Repository navigation
Conversation
|
Intent: Let Dev Fleet run a shipped release. Each published channel (stable, Not a goal: Changing which channel the user's own install updates from. Nothing |
GPT 5.6 Review — 🔴 changes requested (blocking)GPT 5.6 found at least one blocking issue that must be resolved before merging This comment is updated in place on each push. BLOCKING -- src/kiro_crew/apps/builtins/dev_fleet/worktree_ops.py:3077 -- Mutable git config can redirect or execute during checkout Adjudication (Opus 4.8) — is blocking on each finding proportionate?F1 concerns a TOCTOU residual the code itself documents at Conditions confirmed this run: (a) probes and populate share one The timing window is genuinely narrow, but it is not impossible or contradictory, and a local attacker with config write can retry across staging attempts. On an unbounded code-execution class I cannot complete a rarity record strong enough to say a human would plausibly accept the residual — when torn, UPHOLD-FENCED. [ADJUDICATION] 4daa885 total=0 uphold=0 downgrade=0 False positive or not applicable? A repository writer can comment: |
6ff7f84 to
6b92300
Compare
UX Review (Fable 5) — 🟡 CONCERNSUX-level review of UX-Verdict: CONCERNS Edge-state rows contradict themselves: "ready" beside a fatal git error, and the reserved-name row's recovery steps hide in a tooltip. Watch
Suggestions
[UX-REVIEWED] 4daa885 |
Design Review (Fable 5) — ✅ PASSDesign-level review of Design-Verdict: PASS Verify the Suggestions
[DESIGN-REVIEWED] 4daa885 |
First Principles Review (Fable 5) — ✅ PASSPremise-level review of First-Principles-Verdict: PASS Verify the bundle-ceiling attribution: the 613 KB raise rests on measured numbers (main alone at 12,206 KB, this branch +35 KB) the diff cannot prove. What this change shipsInventory (10 items) — 10 justifiedIntent: let an operator run and click through the newest shipped stable release from Dev Fleet instead of hand-building a checkout — an ADDITION.
The change has more items (spec section, feature-map row, translator context, pluralKeys, tests); these ten are the ones a person would notice, and the doc updates are mandated same-commit by AGENTS.md. [FIRST-PRINCIPLES-REVIEWED] 4daa885 |
Opus 4.8 Review — ✅ no blocking findingsReviewed Verdict parsed from the review's SHA-scoped output markers for commit False positive or not applicable? A repository writer can comment: |
6b92300 to
3d96cf1
Compare
3d96cf1 to
412f682
Compare
|
self-added: yes
|
|
self-added: yes
|
|
|
self-added: yes
|
|
mechanism: removed
|
|
mechanism: removed
|
|
mechanism: removed
|
|
|
|
self-added: no
|
|
self-added: no
|
|
self-added: no
|
|
self-added: no
|
|
self-added: yes
|
|
self-added: no
|
|
self-added: yes
|
|
self-added: no
|
|
self-added: no
|
|
self-added: no
|
|
self-added: no
|
Dev Fleet manages git checkouts, and a git checkout has no release channel —
`platform/update_capability.py` says so outright: "Only the wheel command
carries a channel. A git checkout follows its remote." That leaves no way to
run what stable actually shipped next to unreleased work.
Adds ONE detached worktree pinned to the stable channel, named
`release-channel-stable` as a sibling of the primary checkout, appearing as an
ordinary fleet row that pods and Make Live already drive.
Why not a pin on the primary checkout: sync fast-forwards it (`merge --ff-only`)
and refuses unless HEAD is literally `BASE_BRANCH`. A stable tag is normally
BEHIND main, so pinning that checkout could only work by detaching its HEAD —
which the sync guard rejects, and which repoints every origin/main comparison on
the row — or by resetting main backwards, which destroys work.
Not coupled to the update channel: nothing reads or writes
`$KIROCREW_HOME/channel`. That file says which lane the user's install FOLLOWS
for updates; a pin here says which ref a worktree SITS ON. There is one channel
and it is a single `CHANNEL = "stable"` constant, not a lane vocabulary — an
unpublished lane is a state of that channel, never a second kind of row.
Resolution takes the newest `vX.Y.Z` in SEMVER-DESCENDING order. Tag creation
date is not the ordering: a retagged or backfilled release publishes out of
order, and "newest release" is a claim about version precedence rather than
about when someone pushed the tag.
Resolution is sourced from a private pruned tag mirror
(`refs/dev-fleet/release-tags/`), fetched under a checked refspec, so a local tag
cannot decide what gets checked out — a forged `v9.9.9` in the operator's own
clone resolves nothing. An `ls-remote` provenance check closes the window
between resolving a tag and checking it out, and `repo_supplied_filter` refuses
repo-configured content filters so a fetched repository cannot run its own code
during the checkout; both run inside `_GIT_MUTATION_LOCK`.
`release-channel-*` is reserved, so adoption requires the SHAPE (detached),
never the name — a user's branch checkout under that name keeps ordinary
controls and its ordinary behind-main count, and reports that it is not a
release worktree rather than being silently adopted.
Create only: there is no in-place mutation of a pin. A pinned tree that moved on
its own would shift under a pod being debugged, and an explicit Advance turned
out to be the mechanism forcing every unpleasant tradeoff around it, so moving a
pin is Remove followed by Create — two visible acts on the row that owns them.
Fleet payload gains `release_channel`, its own key rather than extra `worktrees`
rows: a channel with no worktree has no path, and every consumer of a worktrees
entry assumes one. On this row BEHIND measures distance from the CHANNEL TIP (the
behind-main figure is large by construction and names no action) and PR renders
as inapplicable rather than as the no-PR dash. Because the Behind column header
is one shared element above rows with two different denominators, it names both.
Adds `website/capture/devfleet-release-channel.{tsx,html}` and
`website/scripts/capture-devfleet-release-channel.mjs`, the committed harness
that renders the three row states — adopted, placeholder, reserved-name branch —
against the real page with `fetch` stubbed at the network seam.
|
self-added: no
|
|
self-added: yes
|
|
self-added: no
|
|
self-added: no
|
|
self-added: no
|
|
self-added: no
|
|
self-added: no
|
|
self-added: no
|
|
self-added: no
|
|
self-added: no
|
Round 36 — review-ready except one human-only gateHead
The one open finding
Every mitigation this PR can add narrows the gap; none removes it, because the mechanism is probe-then-act. What removes it is a hermetic populate that consults no repository-supplied config, which is a design change across the six probe sites #10691 tracks. That is filed as #12342 with acceptance criteria (a driver planted after the probe does not execute), and both the round-28 and round-31 retrospectives classed it as follow-up work rather than a further patch here. What a maintainer needs to doIf the deferral to #12342 is acceptable, post on this PR: Then PR Readiness re-evaluates green and the PR is ready for the human review that branch protection requires. Auto-merge is not armed and will not be by the author's agent. If the deferral is not acceptable, the alternative is to scope the hermetic checkout into this PR, which reopens the module the last eight rounds converged and is best done as its own PR against the design in #12342. Follow-ups filed from this review (none block merge)#12342 hermetic checkout · #12353 refresher |
|
🤖 Kiro Crew [operator: dwu96#8c08bee0]: This PR has been inactive for 7+ days. I reviewed the blockers but they require your input:
Everything else reads healthy: Design, First Principles, Opus 4.8 and Security Scope all PASS, UX is advisory CONCERNS with its three copy items tracked on #12355, and 91/93 checks are green. It is the one gate above that is holding the PR. When you've addressed these, the pipeline will re-assess on its next cycle. |
|
Closing in favour of #12356, which implements the same change. Evidence. 38 of 40 files are shared (21 after excluding files that 20+ open PRs touch), covering the same dev-fleet channel-pin mechanism: Why this one and not #12356. #12356 is the later and more complete cut of the same mechanism. This is not a judgement on the work -- the two changes were written independently and this one is not the weaker of the pair, it is the one that does not need to land twice. If you disagree, or if #12356 turns out to miss something this branch handles, say so and I will reopen this. From a full relationship audit of every open PR against |
Problem / Motivation
You cannot click through a shipped release from Dev Fleet. The fleet lists feature
worktrees, and every one of them is unreleased code. To see what
stableactuallyshipped you leave the dashboard, find the tag by hand, and make a checkout yourself.
Dev Fleet manages git checkouts, and a git checkout has no release channel.
platform/update_capability.pysays so in as many words: "Only the wheel commandcarries a channel. A git checkout follows its remote."
Why it matters
A bug report says "broken in stable". Answering it means running stable. Today that
is manual work outside the tool that exists to manage checkouts, so it mostly does
not happen — and a fix gets tested against
maininstead of against the build thereporter is on.
What changed (motivation → approach → change)
Dev Fleet grows one row,
release-channel-stable: a real worktree detached at the newestpublished stable release. Pods and Make Live already drive any fleet row, so a shipped
build now boots the same way a feature branch does.
release_channel_pin.pyvX.Y.Ztag by semver, read from a private tag mirror (refs/dev-fleet/release-tags/*), never fromrefs/tags/worktree_ops.pyCreateworktree add --no-checkout --detachat a staging path, probe that staging worktree's own config for a content-filter driver and refuse if one is declared, populate withreset --hard, adopt withworktree movefleet_state.py/fleetpayload: adopted, placeholder, unpublished, taken, errorDevFleetPage.tsxn/alike PR, placeholder with Create, and honest wording when less is knownemptyfor a detached worktree, so the pin cannot be auto-reapedOne channel, on purpose.
nightlytags nothing, so a nightly row would just bemain.insidertags do resolve, but ordering-insider.Nagainst-rc.Nneeds a rule thisrepo does not state.
CHANNELis a single"stable"constant with no channel parameteranywhere; a second channel is a shape change made when that rule exists.
flowchart LR subgraph Before A1[want to run stable]:::ctx --> B1[leave the dashboard]:::removed B1 --> C1[find the tag, clone by hand]:::removed end subgraph After A2[want to run stable]:::ctx --> B2[Create on the stable row]:::added B2 --> C2[detached worktree at v0.5.0]:::added --> D2[Pod / Make live]:::ctx end classDef added fill:#DCFCE7,stroke:#16A34A,color:#14532D,stroke-width:2px classDef removed fill:#FEE2E2,stroke:#DC2626,color:#7F1D1D,stroke-dasharray:4 3 classDef ctx fill:#E0F2FE,stroke:#0284C7,color:#0C4A6E linkStyle 0,1 stroke:#DC2626,stroke-dasharray:4 3 linkStyle 2,3,4 stroke:#16A34A,stroke-width:2px🟩 added · 🟥 removed · 🟦 unchanged
Creating the row is now the whole job; the pod controls were already there.
The mirror is the safety story. The operator writes
refs/tags/too — a localv99.0.0sorts newest and, read from there, became the channel tip.
Resolution reads only the pruned mirror, so "published" is a property of where a ref
lives rather than a claim about how it got there. Create adds two more refusals before it
touches disk: a resolved oid the remote does not advertise, and a
filter.<name>.*driverdeclared in git config, which the checkout would execute. That probe runs from inside the
staging worktree after a
--no-checkoutadd and before the populate, because a[includeIf "gitdir:…"]include is evaluated against the worktree being operated on —probing the primary checkout could miss a driver scoped to the staging path. Before the
populate, git is asked where the working tree is: a
core.worktreein that config wouldsend
reset --hardinto an arbitrary directory, so a redirected answer refuses.The pin never moves in place: a newer release is Remove then Create. Nothing here reads or
writes
$KIROCREW_HOME/channel.The row says less when it knows less, and says it where it is read. A release row's
currency lives on its version badge (its tooltip names the tip, says the tree is at it,
or says the tip could not be resolved); BEHIND on that row reads
n/a, like its PR cell,so the column keeps one meaning — commits behind main — for every row that has one. With
nothing fetched yet the status line says that Create is the fetch; with a version
resolved it says which one Create checks out. When an adopted tree sits on no release tag
its badge reads
not on a release— the tree's condition, never the bare lane word, whichon a row already named
release-channel-stablereads as a version — and a placeholder withnothing resolved shows no version pill at all. A branch checkout holding the reserved name
is told the name is reserved and how to free it. While a placeholder shows, the count beside the filter reads
N worktrees · 1 to create, so it agrees withWorktrees (N)instead of contradicting it.The full reasoning behind each mechanism is under Design notes below.
Every area this diff touches
src/kiro_crew/apps/builtins/dev_fleet/release_channel_pin.pysrc/kiro_crew/apps/builtins/dev_fleet/worktree_ops.pysrc/kiro_crew/apps/builtins/dev_fleet/http_api.pysrc/kiro_crew/apps/builtins/dev_fleet/server.pysrc/kiro_crew/apps/builtins/dev_fleet/fleet_state.pysrc/kiro_crew/security_posture.pyrelease_channel_pinas a non-core-egress redactor — it scrubs git stderr before that text becomes a row'serrorwebsite/src/pages/DevFleetPage.tsxwebsite/src/components/appstore/appManifest.tswebsite/src/i18n/locales/*.json,website/src/i18n/en.context.jsonwebsite/capture/devfleet-release-channel.{html,tsx},website/scripts/capture-devfleet-release-channel.mjs,website/.jscpd.json/fleet, and the by-file duplication exemption every capture entry carrieswebsite/scripts/check-bundle-size.mjsallchunk ceiling re-measured to the file's 5% convention: main alone sat 0.28% under it, this branch's catalogue copy (35 KB across 13 languages, same 14 modules, no library) crossed it by 232 B — see Design notesdocs/system-specs/modules/dev-fleet.mddocs/feature-map/README.mdtest/test_dev_fleet_release_channel_pin.py,test/test_dev_fleet_release_channel_ops.py,test/test_dev_fleet_component_boundaries.py,test/test_dev_fleet_app.py,website/src/test/DevFleetPageReleaseChannels.test.tsxDesign notes
Why each mechanism above has the shape it has. Every paragraph here answers a review round;
none introduces a mechanism the table under What changed does not name.
Dev Fleet grows one more row:
release-channel-stable, a real worktree detached atthe newest stable release. Pods and Make Live already drive an ordinary fleet row, so a
shipped build now boots the same way a feature branch does.
One channel, and the two left out are left out for different reasons.
nightlycannot be resolved from git at all:
nightly.ymlbuilds frommainHEAD on a scheduleand tags nothing, so the newest ref a nightly row could name is
origin/main— which ismain now, not the commit the last nightly published, and is where the primary checkout
already sits after Sync. A row promising "what nightly shipped" while showing neither
duplicates
mainand misleads about which build it is.insideris out by product decision, and its tags do resolve — ranking them is what hasno answer. Ordering
-insider.Nagainst-rc.Nneeds a precedence nothing in this repostates, so a prerelease tip would rest on a rule this feature invented. One channel whose
order is a fact beats two where one is a guess.
The surface is singular, and that is a decision rather than an omission.
release_channel_pin.CHANNELis a single"stable"constant, not a tuple. There is nochannel parameter, no channel key in either request body, no map from channel to resolved
tip, and no list in the payload — each of those would be a shape with exactly one possible
value, and one no caller could vary. The mutation endpoint therefore takes no argument at
all, which is also what retires the validation an earlier shape needed: a value that
cannot be sent cannot be rejected, sanitized, or smuggled into a git ref or a directory
name. It also lets the route declare its SEL audit target statically instead of reading
one out of the request body — and the worktree routes' fallback chain is spelled inline at
its one use site rather than behind a named constant, which was a rider with a single
consumer and identical behaviour. Admitting a second channel is a change to this module's
shape, made when the precedence rule for prerelease tags exists to justify it — not a
parameter carried in advance of it.
Create is not
dashboard/handlers/worktree.py's creator, and that is a differentproblem rather than a duplicate one. That creator solves two races: a branch-ref race
(
_claim_branchwritesrefs/heads/<branch>with an empty old-value, letting git's reflock pick the winner) and a directory race (atomic
os.mkdiras proof-of-creation).Create here checks out a DETACHED worktree at a resolved oid, so there is no branch to
claim and that half has no analog; its destination is a module constant rather than
caller-supplied, so there is no repo allow-list to enforce. What remains is the directory
race alone, which staging decides by construction instead of by inferring ownership from
an
mkdirthat raced. The two now AGREE on content filters, and that agreement replaces adivergence this description previously argued for: both refuse a repo declaring
filter.<name>.process/.smudge/.clean. The earlier argument for allowing it here — thatrefusal would make a legitimately published release un-materializable — does not survive
scrutiny: a filter driver can only be defined in git config, config is never committed and
never travels with a clone or a fetch, so checking out a release tag cannot introduce one and
no tracked
.gitattributesin this repo even names a filter. The refusal can therefore onlyfire when the operator's own checkout already carries a local driver, which is precisely the
hostile case.
release_channel_pin.repo_supplied_filterprobes--localplus--worktree(the latter only when
extensions.worktreeConfigreads true via--bool, and only when theconfig.worktreefile exists), with--includesmandatory so a repo-controlledinclude.pathcannot hide a driver. Global config is deliberately unread:git lfs installwrites
filter.lfs.*there, so probing it would refuse Create on every git-lfs host. Thatprobe runs at the
stricttier — it reads local config and needs no network, so it needs nocredentials — while the two network calls stay at
standard, which is the credential-bearingtier a private remote requires. The git env neutralizers are not bypassed either way: every
git child here goes through
runtime._run_cmd, which applies_GIT_ENV_NEUTRALIZERSto allof them, and content filters are the one class that dict cannot disarm — which is why this
path refuses them outright rather than trying to contain them.
The probe runs inside the mutation lock, from inside the staging worktree, between a
--no-checkoutadd and the populate, with no network call between. It is a point-in-timeread, so its distance from the populate it protects is the whole of what it guarantees — and
its context matters as much as its timing: a
[includeIf "gitdir:**/…staging…"]include isevaluated against the worktree git is operating on, so a driver scoped to the staging path is
invisible to a probe of the primary checkout and visible to exactly the probe that runs there.
A real-git test plants such an include and asserts the primary probe misses it and the staging
probe reports it. A second real-git test sets
core.worktreeunderextensions.worktreeConfigand asserts the working-tree check names the redirect while a clean staging tree answers with
itself; the fake-git sequence test pins add → probe → working-tree check → populate. Measured against git 2.54, a
filter.<name>.smudgedoesexecute during
worktree add --detach, and no by-construction dissolution exists:GIT_CONFIG_NOSYSTEMandGIT_CONFIG_GLOBAL=/dev/nullreach only system and global configwhile the driver lives in local
.git/config, which git always reads;-c filter.<n>.smudge=suppresses only a name known in advance, and the name is attacker-chosen;
--no-checkoutleaves an empty index so the populate runs the filter — which is why the probe sits between the
two; and
git archive | tar -xruns the smudge filter too. Ordering is therefore the available remedy rather than a preference —the window is the gap between two local spawns instead of two network round-trips. The honest
cost is that a filter-declaring repo now pays a fetch it did not need, which is the same fetch
the status refresher already runs every cycle and so writes nothing new.
strictconstrainsthe git child and its descendants, not an independent process writing
.git/config; what itgives is that a filter reaching execution runs credential-free inside the sandbox.
The obvious design does not work, and that is why this one looks the way it does.
Pinning the primary checkout to a release cannot work:
Syncrefuses to run unlessHEAD is
main, and it fast-forwards withgit merge --ff-only. A stable tag isnormally behind main, so that merge is refused. The only ways through are detaching
main's HEAD — which the sync guard rejects, and which silently repoints every
origin/maincomparison on the row — or resettingmainbackwards, which destroyswork. So the channel gets its own tree instead. Nothing existing changes shape.
release_channel_pin.pyresolves the channel to a tag, ordered by semver descending.Creation date is not that order: a backport cut after a newer line (
v0.4.2taggedafter
v0.5.0) is the newest tag by date and an older release by version, and are-pushed tag carries today's date for last year's release. Either would pin the row to a
release stable users are not on. Parts compare numerically, so
v0.10.0beatsv0.9.0,and the key is
apps.version.parse_version— the repo's one version parser, not asecond parse written here. A tag counts as a release only if it is a bare
vX.Y.Z;that shape check is the channel decision, because such a string has no suffix left for
a classifier to read. The resolver never re-checks the tag it just selected, and the
tag LISTING asks git for no order at all:
_release_candidatesre-sorts by semver, so a--sort=-creatordatethere had no consumer — and worse than inert, it read like theorder the tip is chosen by, which is the exact mistake this paragraph exists to prevent.
One mutation sits in
worktree_ops.pybeside the other worktree writers, under thesame
.gitadmin lock. It fetches tags before resolving: the background refresher keepsthe rows current on its own schedule, so a mutation that resolved first would act on
whatever the tag mirror held at that moment and call the result the tip.
The pin never moves in place, and that is a decision. There is no
Advance: a newerrelease is
RemovethenCreate, which the fleet already offers. An in-place checkout ofa tree that already exists has to reason about everything already in it — a branch someone
put it on, a dirty file, a commit stranded on a detached HEAD, build artifacts belonging to
the previous release — and each of those is a guard whose failure mode is silent. Every one
of them was written, reviewed and then deleted with the control they served.
What Remove + Create costs is real and worth naming: the provisioned tree
(
node_modules, builtdist, venv —has_distis a filesystem check inside the worktree,so a re-created channel comes back unprovisioned), the pod (its identity is the worktree
basename, so removal stops the service and drops its port), and the live-target pointer,
which names a path removal deletes. On a control used about once per stable release, that
is the cheaper side of the trade — and it is two clicks the fleet already had.
Prune mergednever offers the channel worktree, and that guard is against a plausibledeletion rather than a theoretical one. A pin is detached (no branch, so no PR), clean,
and holds no commits the base branch lacks — a release tag is an ancestor of main — which
is precisely the
emptyverdict, and past 48hemptyis a candidate the prune previewpreselects. So
_prunablewithholdsemptyfrom any tree with no branch, and itdoes that rather than match the
release-channel-*basename because the name is onelevel above the cause. Matching it got both halves wrong: a tree the operator detached by
hand at a release tag — the workflow this automates — carries no channel name and stayed
preselected, while a branch checkout that merely borrowed the reserved name vanished
from Prune merged entirely. Keying on
branch is Nonecovers every deliberately detachedtree and lets a branch fall through to the ordinary merged logic. The check lives in
_prunablerather than the caller because the removal path re-asks for a fresh verdict —one condition covers both the preview and the execution.
The channel resolves from a private tag mirror, not from
refs/tags/. Every fetch forthis channel carries
+refs/tags/v*:refs/dev-fleet/release-tags/v*, and resolution readsonly that namespace.
refs/tags/cannot be the source of truth because the operator writesto it too — a locally cut release candidate, a bisect marker, a
v99.0.0tagged to test anupgrade path. Each matches the stable shape, sorts newest, and under a plain
git tag --listbecame the channel tip, so the row badged an unpublished commit as a shipped releaseand Create checked it out. Nothing distinguishes a local tag from a fetched one after the
fact, so the separation has to happen where the ref is written: a mirror the operator has no
reason to write to makes "published" a property of WHERE the ref is rather than a claim
about how it got there. The row's own version probe reads the same mirror, because
git tag --points-at HEADwould let a local tag rename the row the same way.--tagsis kept beside the refspec, not replaced by it. The reportedrefis a realrefs/tags/vX.Y.Zthe operator can check out, andrefs/dev-fleet/release-tags/v1.2.3isnot a thing anyone types; because the channel reads only the mirror, keeping
refs/tags/fresh cannot put a local tag back in the running. An empty mirror is a state rather than an
error — a checkout that has not fetched does not know what is published, so it reads as "no
release found" and the next refresher cycle fills it, while
Nonefrom the listing staysreserved for git itself failing.
The mirror is pruned, and the fetch is SPLIT so that pruning is structural rather than
argued. The refresh issues two fetches. The first names the forced mirror refspec and the
base branch and no tags at all, and carries
--prune: a mirror ref the remote does notadvertise is deleted, and
refs/tags/is not among that command's destinations, so anoperator's local tag is not reachable by its pruning even in principle. That is a stronger
statement than the old one, which rested on
--prunenot being--prune-tags. The secondfetch is the
--tagscourtesy that populates ordinary tags for the operator's own use; it isbest-effort and its exit status is deliberately not checked.
Splitting them fixes a real refusal as well as strengthening the guarantee. Mixing a forced
refspec with an unforced
--tagsin one command means a diverged local tag makes the wholefetch exit non-zero —
! [rejected] v1.0.0 -> v1.0.0 (would clobber existing tag)— eventhough the mirror refspec itself succeeded. Because the refresh treats any non-zero as an
error, an operator who ever cut a local tag named like a release could not Create at all.
Without pruning, "the operator has no reason to write here" describes habit and not
enforcement: a ref namespace is writable by anything with repo access, so one
git update-ref refs/dev-fleet/release-tags/v999.0.0 <any-commit>outranks every real release by semver andsurvives an additive fetch. Two things pay for that, and Create's integrity is not one of them.
The FLEET ROWS pay first: the display path resolves out of the same mirror with no provenance
backstop, so the forged ref is badged as stable. Create's AVAILABILITY pays second: every
resolve picks the forgery and every provenance check refuses it, so Create stays refused until
someone hand-runs
git update-ref -d. Create's INTEGRITY is owned by thels-remoteprovenance check below, which refuses any oid the remote does not advertise whether or not the
fetch pruned.
Pruning bounds PERSISTENCE, not timing:
--prunedeletes only refs the remote does notadvertise at fetch time, so a ref planted between the fetch and the resolve is unpruned and
would be checked out. Create therefore asks the configured upstream what it publishes
for exactly the resolved tag (
ls-remote --tags <remote> refs/tags/<tag> 'refs/tags/<tag>^{}')and refuses unless the resolved oid is the one advertised for it, which closes the ref-planting window at every timing rather than
narrowing it. The scope of that guarantee is stated exactly in the docstring and the spec: the
remote is the one named in the repository's own git config and git reads its URL from that
config, so this defends against a writer who can plant a ref, not against one who can
rewrite
remote.<name>.url. A writer with that reach already redirects every fetch this appperforms — including the pre-existing sync that rebases a worktree onto
<remote>/main— so aURL trust anchor would have to be operator-owned state shared by all ten of the app's remote
call sites, which is app-wide hardening rather than this feature's to add (see the deferred
issues below).
The query names the tag's ref AND its
^{}peel pattern explicitly, because an annotatedtag carries its commit only on the peel line; nothing else the remote advertises is asked
for, and nothing else is retained — two hex-validated oids at most, never a map of the
remote's tag population, so a remote with thousands of tags costs the same as one with one.
The mirror listing is bounded the same way, at git:
for-each-ref --countof_MAX_RELEASE_REFSplus one, names capped at_MAX_REF_NAME_LEN, both one named constant.The extra row, or an overlength name, is
MirrorOverflow, raised by the one helper bothlistings share (
_bounded_mirror_rows) on the raw rows before any name is filtered, andsurfaced as the row's error — from the tip listing a truncated tail would otherwise sort and
could name a release that is not the tip; from the
--points-at HEADprobe it would read as"no release" on a tree that may well be on one.
An unadvertised tag is exit 0 with no output rather than an error, so absence is read from
the (empty) answer. A
@requires_gittest builds a throwaway repo, cuts an annotated tag,and asserts the real-git shape rather than the shape this file's fake asserts — with a guard
that the tag object and commit oids differ, or the test would prove nothing about the peel
line.
This hardening is per-path, deliberately. Grepping
ls-remoteacrosssrc/kiro_crewconfirms no other checkout or merge path verifies a local ref against the remote: this path
is the one that resolves a TIP by ranking refs out of a writable namespace, which is what
lets a planted ref decide what gets checked out. The siblings —
worktree_ops._sync's_sync_base_ref()merge and the dashboard creator's checkout — consume a ref the operatornames, so the same check would guard a different threat and needs its own reasoning; both
are deferred rather than silently assumed covered.
--prune-tagsis the flag that would reachrefs/tags/and destroy the operator's tags; itstays refused and a test asserts its absence.
Retraction therefore lands here rather than being deferred: the channel stops resolving a
yanked release on the next fetch, while
refs/tags/stays additive so the operator canstill check such a tag out locally. That closes
#10477.
release-channel-*is a reserved name, so adoption requires the shape: a checkoutis a channel pin only when it is detached. Someone's own branch under that name keeps
ordinary controls and is never adopted as a channel pin, rather than having its HEAD moved
out from under their branch. Its name cell carries a muted sentence, not a pill: On a
branch, so the stable release can't use this name — rename or remove it to free it, with
the tooltip naming the controls that free it (Prune merged once the branch's PR has merged,
or
git worktree move/removein a shell). It was a pill for three rounds — "Not arelease worktree — on a branch", then "Name reserved — on a branch" — and each wording failed
a different blind read: one was mistaken for the off-tag pill two rows away, the next was
not understood at all ("I wouldn't click anything on this row until I understood it"). A
pill holds a verdict; this state needs a what and a what-to-do, and the row's status-line
slot is where the placeholder already says that kind of sentence ("No worktree yet — Create
checks out 0.5.0"), so it moved there. No warn colour: the row is a healthy branch checkout,
and the sentence explains the row's relation to the lane rather than flagging the row.
A third state the backend can emit needed a rendering path, because neither of the other
two covers it: the reserved directory exists and is a registered, selectable worktree, but
its git state could not be read —
worktreeis null,name_taken_by_branchis false, andonly
erroris set. It is therefore neither an adopted pin nor a branch checkout, soneither existing badge fires; and because the row IS selectable, the placeholder path is
suppressed too, which left the backend's error string with no rendering path at all in the
default view. One derivation (
channelErrorFor) now folds this case together with an adoptedrow whose
resolve()failed, and both reach the SAME row-scopedErrorNoticewith the agenthand-off — no error string is carried by a badge tooltip, which is neither keyboard-reachable
nor a hand-off. A test asserts the notice surfaces that error, and nulling either branch of the
derivation fails it.
The placeholder is suppressed whenever a real directory already carries that reserved
basename — tested on the NAME, not on a classification.
worktreeandname_taken_by_branchare both classifications, and a third state exists: an unreadableHEAD resolves to
detached: null, which is neither, so the placeholder rendered besidethe very directory it was describing and one directory became two rows. The name is the
thing that can only belong to one row, so guarding on it holds for classifications added
later too.
The channel rides in a
release_channelkey of its own, not as an extraworktreesrow. A channel with no tree has no path, and every consumer of a
worktreesentry —disk measurement, pod matching, prune candidacy — assumes one. The row carries no
behindcount: the behind-main number on a release worktree is large by construction and names no
action, and three wordings of a tip-denominated count in the BEHIND cell (
↓3 tip,↓3 newer, tooltips) each drew a different misread from a blind reader. So the cell saysthe column does not apply (
n/a, as the PR cell does), the field and therev-listprobethat fed it are gone, and the version badge carries the currency in its text —
0.5.0 · latest 0.5.3when behind, the bare version at the tip — with the tooltip saying which, or that thetip is unknown. "latest", not git's "tip": a blind reader said the word "means nothing to me
otherwise" and guessed; "latest" is the update banner's own word and needs no guess.
It names no control: closing the gap is Remove then Create, two controls on two surfaces,
and naming one would misdirect.
A row's
versionis the release that row is on, and the two row kinds differ: aplaceholder shows what Create would check out (the channel tip), an adopted row shows what
its tree actually holds, read from
git tag --points-at HEADand filtered to the channel'sown tags.
tip_versioncarries the tip alongside it. Publishing the resolved version onan adopted row made the badge rename itself to each new release as it shipped while the
checkout stayed put, so the row claimed a build it did not contain.
versionisnullwhen the tree is detached at no release tag at all — adoption is by shape, not by being
at a release — and the row says that rather than borrowing the tip.
A channel that will not resolve gets a row-scoped
ErrorNoticewith the agenthand-off, on the adopted row and the placeholder alike — one derivation feeds both, so the
notice is the SOLE surface the backend's error string reaches. The placeholder's cell text
states the failure compactly with a short plain label carrying no error string, and the notice
under the row is what makes it keyboard-reachable and hands it to the agent. It is
deliberately NOT the
page-level surface: that error arrives on the fleet poll rather than from a button, so
notifying there fired on every mount for any checkout with no
v*tags (a shallowclone, a fork before its first release), for a feature that operator never used.
The placeholder row reads as muted by dimming its own CELLS, never the grid container.
An
opacity < 1on the container composites the whole subtree as one group and adescendant cannot exceed its ancestor's opacity, so a container opacity dims the Create
button — the one control the row exists to offer — along with the muted text. The muting
therefore sits on the pod-column dash and the worktree cell, which are siblings of the
actions cell, and a test walks the button's ancestors and fails if any of them carries a
reduced opacity.
The fleet table is a DESKTOP-ONLY surface and now says so at its layout root, which is
what the
narrow-viewport-requiredrule's own exemption asks for. The header grid owns afixed 640px seven-column contract that every row matches, and the columns are read across
rows as one aligned diagnostic table — so a lone responsive row would misalign from its own
header, and the placeholder shares the header's grid exactly rather than diverging from it.
Create runs at the
strictgit tier and is drained across cancellation.worktree addmaterializes repo-controlled content and runs whatever content filter that tree
configures, which the env neutralizers do not cover, so the gateway's trusted credential
helpers would otherwise be reachable from a filter defined by the very release tag being
checked out. Draining matters because a cancellation releasing the git mutation lock
mid-write leaves a half-registered worktree behind.
Create builds at
<channel path>.staging.<pid>.<rand>and adopts it withgit worktree move. The destructive cleanup on failure can therefore only ever name a directory thiscall made, and
move— which refuses an existing destination — is what decides a racebetween two gateways. Inferring ownership from an earlier path-exists check could not:
_GIT_MUTATION_LOCKis an asyncio lock, so a second gateway on the same repo can createthat path between the check and the add, and the cleanup would then force-remove its
worktree.
A return is not the only way out, so that cleanup also runs on the unwind. Each git
child is shielded by
_run_uninterruptible, which re-raisesCancelledErroronce itreturns, so a backend shutdown can unwind the frame between a successful
worktree addand the
movethat adopts it — and therc != 0cleanups are only reached by areturning failure. A
BaseExceptionhandler discards the staging tree and re-raises,because swallowing the cancellation would make a shutdown look like a completed Create.
It narrows the window rather than closing it, and what survives is bounded on purpose: a
<path>.staging.<pid>.<rand>directory the operator's owngit worktree removereclaims and thatcannot block a retry, since the guard tests the lane path and every call stages under a
fresh name. The cleanup that runs when Create fails is ONE scoped command,
worktree remove --force <staging>, which drops the staging record whether or not its directory still exists;it used to be followed by a repository-wide
worktree prune, which covered nothing thestaging path needed and would have unregistered any unrelated worktree whose directory was
momentarily absent — an unmounted volume is the ordinary case — with no undo. Gone; a
real-git test keeps both records' directories missing and shows only the staging one leaves.
A channel that will not resolve now gets an
ErrorNoticewith the agent hand-off,scoped to its row. Every other error class on the page already had one; a resolver
failure reached the user only through the version badge's tooltip and the placeholder's
cell text, neither keyboard-reachable and neither offering the hand-off. It is row-scoped
and sits below the grid rather than at page level, because the page-level surface would
fire on every mount for a checkout with no release tags at all — a shallow clone, or a
fork before its first release — which is a normal state and not an incident. The compact
framed sentence stays in the row so the grid still reads at a glance.
The Create success toast names the control it sends the operator to. It used to end
"provision from the row menu", but Provision renders as a standalone row button and is in
no menu — so every success sent the operator somewhere the control is not. The clause is
gone from the string in all 13 catalogues; the code appends the button's own label instead,
prefixed "next:", so it reads as an instruction rather than a bare noun after a dash — and
cannot drift from what the button says.
A Create FAILURE is not a toast. The backend's refusal — a content filter, a redirected
working tree, an ambiguous name — or a transport error is kept in component state and
rendered under the placeholder row through the same
ErrorNoticewith the agent hand-off,until the operator retries or dismisses it; a toast would have carried the diagnosis away
while the worktree stayed uncreated. Four tests pin the notice, its persistence across a
fleet refetch, and its clearing on retry and dismiss.
Presence-based provisioning is a real gap this PR does NOT touch, and deleting Advance is
what took it out of scope.
prov.has_distisdist_dir().is_dir(), so any operation thatrewrites tracked content in place leaves a tree reporting provisioned with artifacts from
before the rewrite —
_rebase_lockedand Sync'sgit merge --ff-onlyboth do. Advancewould have been a third, which is why it carried an artifact-invalidation subsystem
(
_BUILD_INPUTS,_discard_dir,needs_provision) that existed for no other reason. WithAdvance gone, all of it is gone and this PR adds no new in-place writer. The cause is filed
as #10459: build provenance per
artifact, so
has_distcan mean "present AND built from this HEAD", which closes bothexisting siblings.
The background refresher fetches the same two things every cycle, which is load-bearing
rather than tidy. Without it the mirror is refreshed only inside a mutation, so
at_tipreads true against a stale mirror and the version badge and
behindcount both describe atip that has already moved. With no in-place advance, the row's report IS the whole product
of resolution — the operator decides whether to remove and re-create from what it says — so
a stale one is the only failure mode left. Both fetches use the refspec constant rather than
spelling it out, because a drifted second spelling fails silently: the channel would resolve
against a mirror nothing updates, which is indistinguishable from a repo that has published
nothing new.
None of this touches
$KIROCREW_HOME/channel. That file says which channel your installfollows for updates; a pin here says which ref a worktree sits on.
CHANNELis theliteral
"stable"re-declared in this module rather than indexed out ofupdate_layout.RELEASE_CHANNELS— a single constant needs no tuple, and importing one totake
[0]would imply an ordering that tuple does not promise. A test is what keeps thetwo from drifting: it asserts the name is still a channel the update stack knows, and it
is the only place the tuple is imported.
The i18n
allchunk ceiling moves, and the file's rule is that the PR moving it sayswhy.
mainalone builds that chunk at 12,498,868 B against a 12,533,760 B ceiling —0.28% headroom, the same drift the file's own history records five times: a ceiling that
was 5% over a measurement gets eaten by ordinary catalogue copy until the next feature's
strings trip it. This branch adds 35,124 B across 13 catalogues (row states, Create
outcomes, the reserved-name sentence and its tooltip) and crosses by 232 B. Attribution is
measured, not assumed: the chunk holds the same 14 modules on both refs, so no library
reached it, and no lazy
import()boundary can move a catalogue string out ofall. Theceiling goes back to the 5% convention over the measurement that includes this branch.
Tests
test_dev_fleet_release_channel_pin.py(44) covers resolution. The load-bearing oneis that the channel skips newer prerelease tags — this repo's real tag history has
v0.6.0-insider.6newer thanv0.5.0, so a resolver that ignored the shape filterwould hand back a prerelease and look successful. Others pin that the channel name is
still one the update stack knows and that the other two are out; that a release tag is
classified by shape alone and never disagrees with the shared release rule; that a
non-release tag is rejected at the shape check; that the resolver never re-decides a tag
it already picked; that a tag is peeled to a commit; that one broken local ref does not
report the channel as unpublished; that an empty channel is reported rather than guessed;
and that the pruning fetch carries
--prunewhile naming no tag refspec at all, becausepruning the mirror is what bounds a forged ref, and keeping
refs/tags/out of thatcommand's destinations is what keeps the operator's own tags unreachable by it. A further
test pins that a diverged local tag does not fail the refresh, which is the refusal the
split removes. Four cover ordering: a backport tagged after a newer line does
not become the tip, version parts compare numerically (
v0.10.0beatsv0.9.0), aprerelease never becomes the tip even when it is newest, and candidate order is
deterministic under a reordered listing. Seven cover the release a tree is actually on: a
behind row reports its own version and not the tip, a foreign tag sharing the commit
cannot rename the row, an at-tip row takes the version from the already-resolved answer
without spending a second git call, an unreadable HEAD is neither detached nor on a
branch, and — in
worktree_stateand again throughfleet_state— a failed tip lookupleaves the tree's own release on the row with
at_tipunknown rather than relabelling atagged checkout "not on a release" (both fail on the previous early return, which is how
that misreport survived: frame 07 showed a state the backend never produced).
Seven cover the publication boundary the mirror draws, and all four affected code paths were
mutation-checked by reverting the fix and watching the named test fail: a local-only
v99.0.0is never a candidate (asserted by which namespace is queried, since that is thewhole mechanism), the version probe ignores a local tag on the checked-out commit, an
unfetched mirror reads as unpublished while a failed read reads as an error, the fetch
populates the namespace the resolver reads (asserted against the module's own constant,
because a second spelling is what would drift),
--tagsstill refreshes the operator'snamespace, and the payload reports
refs/tags/vX.Y.Zwhile the oid comes from the mirrorref. One more lives in
test_dev_fleet_app.py: the background refresher's fetch carries thesame refspec, which is the copy whose drift would be silent.
test_dev_fleet_release_channel_ops.py(47) covers the mutation, the payload and theroutes. Eleven cover Create: it refuses when the worktree already exists and when the path is
occupied by name, fetches before it resolves, reports a failed fetch instead of resolving
against stale local tags, reports a failed
worktree addwith git's own message, does notleave the channel uncreatable after that failure, builds at a staging path and adopts it
with
worktree moveso the destructive cleanup can only ever name a directory it made,never force-removes the lane path itself, runs without credential helpers, cleans up with
a single scoped
remove --forceand no repository-wide prune (a real-git test registers astaging record and an unrelated worktree, deletes both directories, and shows only the
staging record leaves), and — CANCELLED
between the add and the adoption — still discards its staging tree on the way out while
letting the cancellation propagate. One pins the result's key set exactly, so a field
cannot return as a diagnostic without the reader that justifies it. Eleven cover the
content-filter probe that guards the checkout: Create refuses a repo-declared filter
driver, the refused key name is redacted before it reaches the dashboard (the
<name>infilter.<name>.smudgeis repository-authored, and the refusal lands in the row notice andthe agent hand-off), the probe lands with no network call before the checkout, a driver planted after
the fetch still refuses, the probe follows config includes, it always probes the worktree
scope once the extension is on (a file written after an existence check would otherwise be a
scope the probe never read), it accepts every git boolean spelling of the enabling extension,
git's own "config.worktree: No such file or directory" is the one failure read as an empty
scope while a malformed file still refuses, it never reads
the operator's own machine config, an unreadable scope refuses the Create, and it matches
only executable filter keys. Six cover the provenance the remote supplies: Create refuses
a tag the remote does not publish, refuses a published tag whose local oid was rewritten,
resolves an annotated tag through its peel line, refuses when the remote cannot be asked,
asks for exactly the resolved tag and its peel pattern, retains one oid even when the
remote answers with five thousand unrelated tags, refuses a non-release tag before any
network call, and — against real git rather than the fake — confirms an annotated tag
advertises its commit on that peel line. Two cover credential
scope on either side of that boundary: the filter probe runs without credential helpers,
while the remote-facing calls keep theirs. Ten cover the
payload: an unmaterialized channel publishes as a placeholder, a detached worktree is
adopted and counted behind the tip, an adopted row on no release tag reports no version, a
branch checkout sharing the name is NOT adopted, the row does not claim "on a branch" when
the probe could not read HEAD at all, the worktree basename is published, an unresolvable
channel keeps its row and carries the error, and the key is
Nonewhen resolution raisesor there is no checkout. Three cover the route boundary: the mutation route takes no
request argument, a release-channel route audits the worktree it acts on against a body
carrying a decoy
name, and a worktree route given only a channel field audits againstnothing rather than borrowing it. Three assert the prune guard in the state that would
delete a pin — a detached tree is never offered however it was made, a branch checkout
holding the reserved name still is, and
_prune_candidatesend to end, because a rightverdict that reached the wrong list would still be preselected for removal.
DevFleetPageReleaseChannels.test.tsx(34) covers the rows: the version badge and itstwo states, the placeholder row that carries Create, BEHIND and PR both rendered as
inapplicable on a release row, and a branch checkout sharing the
reserved name keeping its ordinary controls. Three pin the badge's honesty and the
badge's scope: a behind row shows the release it holds with the tip only in the
tooltip, a tree on no release tag says so instead of showing the tip, and a channel whose
resolution failed carries that error on the row. One more covers the
adopted-but-unresolvable channel — worktree present, resolution failed — which reaches the
same shared
ErrorNoticeas the unreadable reserved directory, because an adopted row has noplaceholder to carry the
text. One walks the Create button's ancestor chain and fails if any of them dims it,
which is what keeps the row's muting on cells rather than on the container.
Six pin what the row says when it knows less than usual. An unpublished lane's status
line says that Create is the fetch, and the enabled button carries the same answer as
its tooltip — while a lane with a resolved version gives the button no tooltip, because
the pill beside it already says what Create checks out. A row whose resolver failed
keeps
n/ain BEHIND and its badge tooltip says the tip could not be resolved — neverpresenting the tree's own tag as the tip. The resolved placeholder's status line names the
version Create checks out.
An off-tag adopted badge reads
not on a release— never the bare lane word — and itstooltip carries no
?; a behind badge shows0.5.0 · latest 0.5.3in its text, not only inits colour; the placeholder renders no version pill at all when nothing resolved,
because its status line already says so. While a placeholder shows, the count beside the
filter reads
N worktrees · 1 to create;Worktrees (N)and the stat card count worktrees only.Filtering for the lane row counts it: the row is pinned under main rather than sorted with
the feature rows, and a numerator read off the sorted list alone showed
0 / Nfor a filterwhose one match was on screen — the test fails on that numerator and passes on the fix.
And a filter that hides the unreadable-HEAD lane row conjures no Create placeholder for the
directory that exists: the name check reads the unfiltered fleet, not the filtered rows, and
the test fails when it reads the filtered set.
One test pins the property that decides whether the private mirror may be replaced by the
ls-remoteanswer Create verifies against: it resolves the channel with everyls-remoteand every
fetchfailing, asserts the published version still lands on the row, andasserts the resolver issued no network argv at all. Sourcing row resolution from the
advertisement fails it, which is the point — the fleet is deliberately offline-tolerant
(PR lookups degrade to null on any git or
ghfailure so rows still render), and therelease row participates in that render only because resolution reads
.git.Manual verification
No real-instance run, and the reason is a sandbox fence rather than a shortcut not
taken. This worktree has its own venv whose editable install points at its own
src, so an instance from it is unambiguously this branch's code — that part issettled. What stops it is that a from-source gateway dies at boot under the agent
sandbox:
That path is derived independently of
KIROCREW_HOME, so pointing the data direlsewhere does not avoid it, and pods are fenced separately (
launchctl bootstrapreturns EIO in the same sandbox). Run
bash minimal_install.sh && ./dev-backend.shfrom a native terminal and it comes up; the channel then resolves against this
repo's real tags.
What was verified instead, on this exact head, from a worktree venv carrying the CI-pinned
toolchain. The related-test selection the profile gates use: 1052 backend test files —
37,681 pass, 67 fail, and 66 of those 67 fail identically on
origin/mainin the samesandbox (file-explorer path policy, design-tweak 403s,
doctorhost probes, asymlinked scratch path); the one remaining,
test_cli_doctor.py::…names_the_vault, passesalone on both trees and is order-dependent under xdist. 610 frontend test files (16,283
tests) pass, including the diff-scoped
fr/bnstyle rules, and the 19-check i18nchain plus the i18n render pass diff-scoped against the base. One claim in this PR was
settled by experiment rather than reading: five fresh repos, one per fetch form,
established that
--prune-tagsdoes nothing here and that every form which does prune aretracted tag also deletes local-only tags. That result is what the fetch split acts on:
rather than arguing a flag combination is safe for
refs/tags/, the pruning fetch namesno tag refspec, so the operator's tags are not among its destinations at all. Retraction
still lands, because the resolver ranks refs out of the pruned mirror namespace rather
than out of
refs/tags/.Of the profile's 54 gates, 53 pass. The one failure is
test:electron, which needswebsite/electron/node_modulesthat this worktree does not have; this diff touches nofile under
website/electron/, and CI's own Electron Shell Tests lane passed on theprevious head. The full backend suite is not run at every head — it is roughly an hour
at 16 workers — and CI's shards are the authority on it.
Screenshots / video
Thirteen frames, captured from a committed harness
(
website/scripts/capture-devfleet-release-channel.mjsdrivingwebsite/capture/devfleet-release-channel.tsx) that mounts the realDevFleetPagewith
fetchstubbed at the network seam. Every row state under review is decided bythe
/fleetpayload, so no gateway, no real release tag and no real worktree areneeded for the page to render the state under review — an earlier revision of this
section claimed the opposite and it was wrong. Each scene waits on its headline text
before shooting, the absence claims are asserted as absences, whether Create is live
is asserted as a control state rather than left to the eye, and the run compares
frame byte sizes because two identical frames are what a broken fixture looks like. The
Create trio drives the Create button itself against a stubbed
POST /release-channel/create(never settling, succeeding, failing), so the busy label, the success toast and the failed-
Create notice are evidence rather than described; the last frame opens the release row's menu.
Adopted, behind the tip. The version badge reads
0.5.0 · latest 0.5.3— the newerrelease in its text, not only in its warn colour, and "latest" rather than git's "tip"; BEHIND reads
n/alike PR, directly above a feature rowreading
↓12from main — one column, one meaning.Adopted, at the tip. The steady state a lane spends most of its life in: the badge
takes its ok variant, so "nothing to do here" reads at a glance.
Placeholder. The only surface the feature is discoverable from. The name, version
pill and status are dimmed on their own cells while Create worktree sits outside
any opacity-reduced ancestor at full contrast, which is what makes the row read as an
offer rather than as something disabled.
Nothing fetched yet. A shallow clone or a fork before its first release. Benign
and documented, so it reads as information: the status line says that Create is the
fetch ("No stable release fetched yet — Create fetches the newest one"), the enabled
button repeats that as its tooltip, and there is no version pill: the sentence already
says nothing resolved, and a pill saying it again beside an orange badge on another row
read as two states sharing one label. No
ErrorNotice: this is not an incident.Resolver failure, placeholder variant. A genuine git failure. Create is disabled,
the cell keeps a short label ("The stable release channel could not be resolved") it can
ellipsise without cutting a clause, and the full message reaches the row-scoped
ErrorNoticewith the agent hand-off. Compare theCreate button here against the frame above: same row, opposite control state.
Resolver failure, adopted variant. The row keeps the release its own tree holds
and its ordinary controls; only the tip is unknown, and the row says exactly that: the
badge tooltip says the tip could not be resolved instead of naming one. The failure
routes to the same
ErrorNoticerather than to a Badge title, which is notkeyboard-reachable.
Adopted, on no release tag. Adoption is by shape, so a lane tree an operator
detached at an arbitrary commit is still the lane's row. The version slot reads
not on a release— the tree's condition, so it cannot be confused with the resolver-errorrow above — never the bare lane word, and the tip is named in its tooltip.
Reserved name held by a branch checkout. Not adopted, so no version badge and no
lane controls: the name cell carries the muted sentence
On a branch, so the stable release can't use this name — rename or remove it to free it(no pill, no warn colour — the row is ahealthy branch checkout), and Behind is an ordinary behind-main count.
Create, in flight. The button reads
Creating…and is disabled for the duration, so asecond click cannot start a second fetch-and-checkout of the same reserved name.
Create succeeded. The toast names what was created and the next control by its own
label —
Created stable worktree at 0.5.3 — next: Provision— while the fleet refetchreplaces the placeholder with the fresh row: at the tip (bare
0.5.3, ok variant),not built,and the Provision button the toast points at sitting on the row.
Create failed. Not a toast: the refusal is a persistent
ErrorNoticeunder theplaceholder row, quoting git's own message with the reason it did not happen in front of it,
with Ask the agent and a dismiss control; Create is live again for a retry.
Reserved directory, unreadable HEAD. The third state the backend can emit: the directory
exists but its git state could not be read, so it is neither an adopted pin nor a branch
checkout. One row, not two — no Create placeholder appears beside the very directory it would
describe — no version badge, and the error reaches the row's
ErrorNoticewith the agenthand-off.
Row menu, open. The release row keeps the ordinary controls except Rebase, which has no
meaning for a detached checkout of a tag: Spin up pod, Make live and QA video are there,
Rebase onto main is not.
website/.jscpd.jsongains a by-file exemption for the capture entry plus a sentencenaming the sibling it descends from, following the convention that file already
records for eleven prior harnesses. The shared part is the
/fleetstub pair and thecreateRoot/provider render block every capture entry must spell identically; thesame file states that sharing a runner was considered and rejected, because each
harness is pinned to its own fixture and assertions.
Related Issues
The feature itself came from a direct request, not a filed issue. It does now fix one:
pruning the tag mirror is what stops a retracted release resolving as the channel tip.
Follow-up filed from review, not closed by this PR:
#10459 — per-artifact build
provenance, so
has_distcan mean "present AND built from this HEAD"; it also covers thesame gap in
_rebase_lockedand Sync's--ff-only.#10691 — the config-filter probe
siblings diverge across three components, and
md_notebook's boolean read misses four gitspellings; the consolidation question is recorded there because the match sets and security
tiers are divergent by design. The
files.pyinstance of that bug class is already tracked as#10332.
#10692 — a detached worktree never
ages into the
emptyverdict, so hand-detached trees accumulate and Prune never offers them.#12342 — a hermetic release-channel
checkout that consults no repository-supplied config, retiring the probe-then-populate
sequence and the sub-millisecond config-rewrite residual the security lane fenced; a design
pass across the six probe sites in #10691, not a patch to this one.
#12353 — the status refresher runs the
courtesy
--tagsfetch every cycle on every install; keep it on the Create path only.#12354 — Create's disk cost stated on
the placeholder row before the click.
#12355 — the unresolved-channel notice
says the same thing on a placeholder and on an adopted row; the adopted one should name the
tip check as what failed.
Closes #10477
Checklist