Build system thoughts

[Bill Barry]

I was thinking about CI and was wondering what everyone here thought 
about the following working practice designed for small to medium teams 
(probably around 8 to 30 people):

1 outgoing repo (call it stable)
1 "centralized" repo (call it central)
developers maintain their own copies of the central repo, all have push 
access

each dev does the following to start working on anything (they would all 
have central set up as the default pull/push location):
hg pull
hg up -C default
hg branch "featurename"
begin work

each commit would be to this feature, if the dev needed to switch to 
some other feature (perhaps not one they started) to do work to it they 
would do:
hg pull
hg up -C "otherfeaturebranchname"

in order to commit the dev would do:
hg ci -m "some message stating work for featurename"
hg push -f
(or just hg push if mercurial was fixed so that it didn't complain as 
long as there was only one head per branch)

any time the dev would want to update what version their feature is 
built off of (suppose for example a bug fix was committed elsewhere that 
he needed before the feature works properly), they would do:
hg pull
hg up -C "featurename"
hg merge -r default
hg ci -m "pulling updates from trunk"

there would be a stable repository maintainer role who would:
hg pull
hg up -C default
hg merge -r "featurename"
(possibly dealing with conflicts)
hg ci -m "merging in featurename message"
hg push
hg push -r default stable

in the meantime the central repo would be monitored by a CI process 
which would pull and build every incoming revision to find failing 
builds and successful builds and creating a page that looks somewhat 
like tinderbox (http://tinderbox.mozilla.org/Firefox/ as an example) 
except that each column would simply be a named branch. As an iteration 
draws to a close, the stable maintainer could merge together completed 
features that test successfully (and pass whatever other imposed 
conditions) into the main branch and push just that branch to stable.

The central repo would likely wind up with many heads active at a time 
(all on seperate branches). The default branch would remain stable, but 
the other branches could fluctuate in stability.

So what are your thoughts? And is there any tools either already in 
existence or under current development which could fulfill this CI 
process role (everything else appears doable right now)?