ADR: the approval stamp bounds what consolidate treats as approved work
Status: Accepted
Date: 2026-10-04
Deciders: Stijn Dejongh (owner). The operator brief for issue #5668 settled the refusal, the attestation and the scope.
Technical Story: #5668, Mission approved-claim-bound-01M444QR. Reverses two earlier decisions, named under Decision. Related: #5046 and ADR 2026-09-29-1.
Reader: a maintainer who needs to know why spec-kitty consolidate refuses with LANE_MOVED_AFTER_APPROVAL, APPROVAL_STAMP_MISSING or APPROVAL_STAMP_NOT_ON_LANE, and what the rule does not cover. An operator who is looking at one of those refusals should start from the recovery command in the message, and from the changelog entry for #5668.
Context and Problem Statement
spec-kitty consolidate landed commits that were made on a lane after the lane’s work package was approved, and it printed “Reconciliation verified”. Nobody had reviewed those commits.
The issue’s reproducer was run before the fix in four combinations: the lanes topology and a coordination topology, each with the default squash strategy and with --strategy merge. All four exited 0, put the late file on the target and printed the banner.
The cause is how the approved claim is built. The claim builder asks the status snapshot only whether a work package is approved or done. It then reads the commits of the lane branch as they are at that moment, and treats all of them as approved authorship. The recorded decision was: approved commit SHAs come from lane-branch git tips, never from status rows. A commit added after approval is therefore approved on every axis the reconciliation gate checks.
The information needed to tell the two apart was already recorded. Since 4.0.0rc5 every persisted transition of a lane-mapped work package carries the lane head in policy_metadata.lane_head. On the approved transition that value is the commit review saw. In the reproducer, WP01’s approved event named d0d8b2c6 and the lane tip was 8fc7fb8c, one commit later. No consumer read the stamp for this purpose.
The closed-world check from ADR 2026-09-29-1 did not catch it either. It runs only on a lane that mixes an approved and a canceled work package, and it returns early for every other lane.
Decision
The approval stamp is the one reference for what review approved. A code lane that holds a commit after its approval stamps is refused, and so is an approval that has no stamp.
What the stamp is
- The approval stamp is
policy_metadata.lane_headon a work package’s latest non-migration approval event. An approval event is anapprovedtransition, an unforced transition straight from review intodone(in_review -> done, which the state machine allows and which carries the reviewed tip), or an operator attestation of an approval (see Attestation). A forced move intodoneis not an approval. - The run’s own
approved -> donetransition is never read. The consolidation records it before the gate, stamped with the tip that is about to land, so reading it would make the landed tip its own bound. - One reader resolves the stamp:
approval_stampinsrc/specify_cli/consolidation/approved_bound.py. It uses the stamp reader that already served canceled work packages,stamp_ofinconsolidation/wp_attribution.py. The status package stays free of git access. - An approval recorded by a release before 4.0.0rc5 carries no stamp.
The lane check
approved_bound.check_lane applies to every code lane that has an approved work package in the claim and is not fully canceled. The commits it examines are those reachable from the lane tip and from none of the approval stamps of the lane’s approved work packages.
A lane that also holds a canceled work package is checked the same way. Nothing that work package does covers a commit: no commit of its own, no status move while it stays canceled, no attestation. Forcing it into approved is a forced approval, not a covering move, and it restamps the lane (see Residuals). check_lane reads no event of a canceled work package. A commit that a canceled work package made after the approval, inside its own stamped work window or outside it, refuses until the approved work package is approved again (see Mixed lanes).
Commits reachable from the claim base or from an anchor are not examined. Merge commits are dropped. Commits that touch only bookkeeping paths are dropped, using the gate’s existing definition (_is_bookkeeping), so there is one definition. Any other commit that is left refuses with LANE_MOVED_AFTER_APPROVAL, naming the lane, the approved work packages, up to three short SHAs and one path.
The walk covers the full commit range, not the first-parent spine. A late commit that arrives through a merge from a branch that is not an anchor is found.
The claim base is the target branch’s tip as it was before the run mutated anything; on a resume it is the persisted value. When that value does not resolve, the claim base is the coordination base. check_lane itself raises when the claim base or the lane tip does not resolve, and every caller turns that into a refusal; only the claim builder keeps its older tolerance of an unresolvable coordination base, which reads as an empty lane. Anchors are:
- the dependency-lane tips of lanes that are not fully canceled;
- the target’s pre-consolidation tip;
- every bounded lane’s approval stamps.
Because every bounded lane’s approval stamps are anchors, a commit that review approved as part of another lane is not refused on the lane it was first made on. Example: a commit is added to lane A after WP01 was approved. Lane B merges lane A. WP02 on lane B is sent back, reworked and approved again, so its new approval stamp reaches that commit. Lane A is then no longer refused: the commit is inside what review approved for lane B. The dependency-lane tip anchor has the same property for a lane that depends on lane A; lane A itself is still checked against its own stamps in the same run. This is deliberate. Content inside an approval stamp was in a reviewed tip, and the tool’s own merge of the mission branch into a stale lane brings in other lanes’ reviewed commits, which must not refuse. It also means a fresh run can give a different verdict than the first implementation of this rule did.
No live branch is a reference. An earlier version used the live mission branch as an anchor. A post-approval commit that had already been merged into the mission branch, for example after an interrupted run that was resumed, then passed. That was found in review and fixed before release. The landing review found the same defect one step away: a code lane that depends on the planning lane had the live target branch as an anchor, so on a resume after the target had advanced a late commit passed. Planning lanes are no longer anchors; the target tip recorded before the run already covers what they contribute.
Two more refusals come from the same check:
APPROVAL_STAMP_MISSING: an approved work package in the claim has no approval stamp. The stamp is never replaced by the lane tip. There is no fallback, in product code or behind a test switch.APPROVAL_STAMP_NOT_ON_LANE: an approval stamp is neither the lane tip nor one of its ancestors. The lane was rewritten after approval.
A lane with no commit beyond the claim base is not checked, because nothing can land from it. A done work package with no approved event on such a lane is therefore not refused. This differs from the letter of the Mission’s FR-005 and is deliberate.
A commit added to a lane after that lane was already consolidated is also refused, although it never landed. The check cannot tell the two cases apart from the lane alone, and refusing is the safe reading.
Where it runs
| Entry point | When | Result |
|---|---|---|
spec-kitty consolidate | At claim time, before the pre-mutation snapshot | Exit 1 under the existing claim-time refusal header. No branch or worktree has moved, so there is nothing to roll back. An attestation requested on the same command is already recorded in the status log. |
spec-kitty consolidate | At the reconciliation gate, before “Reconciliation verified” can print | Compares each live lane tip with the tip validated at claim time. The references are the lane tips validated at claim time, plus the mission branch, the target and the coordination base as resolved at claim time. A refusal rolls back through the existing rollback authority. No new restore path exists. |
spec-kitty orchestrator-api consolidate-mission | Before its first lane is consolidated | PREFLIGHT_FAILED envelope; the code is in data.preflight_error_code. Contract version 1.10.0. This path has no gate re-check because it has no rollback door. |
What the gate re-check adds is narrower than it might look. A commit added to a lane during a run was already failed by the existing content checks as un-attributable, and rolled back, in the plain case. There the re-check replaces a generic failure with the named refusal: the commit, the work package and the remedy. The case it closes is a mission with no coordination branch. There, a late commit on one lane that writes another lane’s approved content (same path, identical blob) passed the old gate with exit 0 and the banner.
The re-check never uses a live branch name as a reference. Lanes are consolidated into the mission branch with a no-ff merge, so at gate time the live mission branch reaches every consolidated lane commit. A check against it would pass vacuously.
Attestation
spec-kitty consolidate --attest-approved-reviewed <WP> --attest-reason "<why>" lets an operator who has checked a lane by hand bound an unstamped approval.
- It records a forced operator self-transition in the status log, with
policy_metadata.attestation = "approved_reviewed". The lane head at that moment becomes the bound. - It is accepted only for a work package in the approved claim whose newest approval is not a stamped review approval: an approval with no stamp, or an earlier attestation (see the repeat rule below).
- It never lifts
LANE_MOVED_AFTER_APPROVAL. A commit made after an attestation is refused like any other post-approval commit, and the only way to approve content is review. No attestation lifts that refusal, the canceled-superseded attestation of a mixed lane included (see Mixed lanes). - A repeat attestation is accepted, and recorded again, only while the lane has not moved past the earlier one. Otherwise it is refused and nothing is recorded.
- It is not a review. The hollow-review warning never reads it as the approving review, so it cannot satisfy the independent-review check. It is a forced transition and each attestation adds one to the work package’s forced-transition count, which that warning counts, so an attestation can itself bring a work package to the count at which the warning prints.
Operator guidance
Each refusal prints one short line per refused lane or work package, then one recovery block. The commands in it carry the Mission slug, and both refusal prints keep each command on one line, so they run as printed. The text names the approval stamp once, as the lane commit recorded when review approved the work package.
- For
LANE_MOVED_AFTER_APPROVALthe text names up to three late commits and says to see a commit withgit show <sha>. The recovery isspec-kitty agent tasks move-task <WP> --to in_progress --mission <slug>for each work package of the lane, then rework, review and approve again. - For
APPROVAL_STAMP_NOT_ON_LANEthe recovery is the same move-back command. - For
APPROVAL_STAMP_MISSINGthe text prints onespec-kitty consolidate --mission <slug> --attest-approved-reviewed <WP> ... --attest-reason "<what you checked>"command that lists every unstamped work package, and the move-back command for each of them. - A fix committed to a lane after approval, including a fix folded in after a late review, needs the work package approved again. The refusal does not distinguish a fix from any other late commit.
orchestrator-api consolidate-missionprints the same text. ForAPPROVAL_STAMP_MISSINGonly, it adds that it has no attestation flag: attestation is done withspec-kitty consolidate(CLI only). The other two refusals offer no attestation, so they carry no such note.- When a mixed-lane or canceled-dependency refusal stops the claim, the first message also names the refusals of this ADR that apply, so the operator does not fix one problem to meet the next on the following run. The first refusal is printed unchanged. A blank line,
This Mission also has:and the refusal block(s) of this ADR follow, then one sentence saying that both parts need their own fix, in either order. Every canceled work package that refuses is named in the first part, one per line. The bound is evaluated as it stands once the first recovery is followed: neither a canceled-superseded attestation nor a canceled work package’s own commit counts as covered, so every content commit made after the approval is named there. A missing approved lane branch, an unreadable canceled dependency lane, an unmaterializable status surface and an unreadable event log stand alone, because the later checks cannot be computed without them. The gate stops at its first refusal and rolls back, so it never prints two. A canceled dependency refusal is shown with the approval-stamp refusals; a mixed-lane refusal on the same Mission is shown on the next run. When the dependency resolution refuses, the claim builder stops there and does not resolve the mixed lanes: the mixed-lane closed world takes the dependency resolution’s commit set as its never-exempt input, and a refusing dependency resolution returns none. - Only the claim-time refusals are compounded. Refusals of different phases are still shown one per run. Before the claim: flag validation, review-artifact consistency, merge-state and resume checks, terminal readiness, the merge gates, the hollow-review prompt, and the dirty-checkout and protected-branch preflights. After it: one gate verdict per run, with rollback.
spec-kitty agent tasks move-taskandspec-kitty agent status emitprint a one-line warning on stderr when an approval was persisted with no stamp for a work package of a code lane, so the operator learns it at approval time and not atconsolidate. The status pipeline stays free of git access; the shells read the persisted event.
Mixed lanes
The closed-world refusals of ADR 2026-09-29-1 keep their precedence, codes and texts on a mixed lane. The bound check applies on a mixed lane exactly as on any other code lane: every content commit after the approval stamps refuses, a canceled work package’s own commit included. When a closed-world refusal fires, the claim names the bound’s refusals after it, in the same message. When the only problem is a canceled work package’s commit made after the approval, the message is the approval-stamp refusal alone.
The order the bound imposes on a mixed lane: the approved work package is approved after the canceled work package’s last commit. The reviewer then sees the lane as it stands, canceled work included, and the canceled-content checks of ADR 2026-09-29-1 judge that lane. They still fail the run when canceled work would ship; the new approval does not lift that.
A canceled-superseded attestation (--attest-canceled-superseded) records a forced operator transition that carries its own lane head. ADR 2026-09-29-1 decided (FR-012) that this stamp exempts lane commits up to it from the closed-world refusal. That stays true. The bound check does not read the attestation, so a commit made after an approved work package’s approval is refused with LANE_MOVED_AFTER_APPROVAL whether or not the attestation is supplied. Nor does it read any other event of a canceled work package (a forced canceled -> canceled, a re-cancel from planned, a forced move into blocked, for_review or in_progress). When an attestation lifts an attribution refusal (the whole-lane fallback of FR-012), that work package’s commits made after the approval still need the approved work package approved again.
Decision (#5720): the bound wins. The first version of this ADR let the attestation’s stamp cover such a commit and listed that as a residual. The owner ruled otherwise. The operator who attests says that the canceled work is absent or superseded. That is not a statement that the new content was reviewed, and only an approval records a review. A commit made after an approved work package’s approval therefore needs that work package approved again. The attestation keeps its one job, lifting the closed-world refusal.
Decision (#5720, final): no exemption. Three designs tried to leave “the canceled work package’s own commits” out of the bound, on the ground that the canceled-content checks judge them. Each left a way to land a commit made after the approval without the approved work package being approved again:
- Covered point. Every stamped event of a canceled work package covered the commits up to its stamp. A forced
canceled -> canceled, a re-cancel fromplannedor an attestation after a late commit covered that commit. - Work windows. The commits inside a canceled work package’s closed, stamped work windows were exempt. A work package canceled from
plannedand forced intoblockedorfor_reviewaround a late commit had a window; the attribution assigned it nothing, so no check judged the commit. - Attribution-assigned commits. Only the commits the mixed-lane attribution assigned to a canceled work package were exempt. The canceled-content checks then passed two shapes. A reopened canceled work package deleted a file that it had first written and that the approved work package had rewritten and been approved for: the deletion restored the canceled work package’s own pre-state, read as a net-zero change, and
consolidateexited 0 without the approved file. Two canceled work packages on one lane superseded each other (the second overwrote the first one’s late file and wrote the same bytes back): each was resolved alone, and the claim had no refusal and no canceled content.
The owner ruled that the bound exempts nothing. An exemption makes the bound as strong as the checks it defers to, and those checks answer a different question (is canceled work on the target), not whether review saw the lane. With no exemption both shapes, and every variant that depends on which work package a commit is assigned to, refuse by construction.
The cost: a mixed lane where a canceled work package committed after the approval needs the approved work package approved again, even when that work was reverted on the lane or will be failed by the canceled-content checks anyway. A canceled work package that worked and was canceled before the approval costs nothing.
On a mixed lane both refusals can apply to the same commit, and neither lifts the other. Approving the work package again does not clear the closed-world refusal: the commit lies in no work package’s window, because the new approval’s window starts after it. The attestation does not clear the bound. The operator does both, in either order, and the first message says so (see Operator guidance).
Reversed decisions
- The claim builder’s rule that approved commit SHAs come from lane-branch git tips, never status rows. The commits are still read from git. A status row, the approval stamp, now decides which of them are approved work.
- Decision 1 of ADR 2026-09-29-1, “applies only to mixed lanes”. The closed-world check itself still applies only to mixed lanes. What changes is the premise that a lane that is not mixed needs no bound. Every code lane with an approved work package is now bounded. A short dated pointer to this ADR has been added to that ADR.
Evidence
The reproducer from the issue was run after the fix in the same four combinations. All four refuse at claim time with LANE_MOVED_AFTER_APPROVAL, print no banner and leave the late file off the target.
The #5720 review found the first version of the attestation fix still open to a forced canceled -> canceled (or a re-cancel from planned, or a reopen) followed by the attestation, which restamped the canceled work package’s point at the lane tip. A second version exempted the commits inside every closed, stamped work window of the canceled work package. A second review found that this was a second definition of a canceled work package’s own commits and that it was wider than the attribution’s: a work package canceled from planned and then forced into blocked or for_review around a late commit had a window, but the attribution assigned it nothing, so the bound skipped the commit, no canceled-content check judged it, and the attestation lifted the closed world. A third version took the exemption from the attribution itself, and two more shapes passed (see the final decision under Mixed lanes). The exemption was then dropped. The sequences through the real CLI (move-task WP02 --to canceled --force, or --to blocked --force or --to in_progress --force, a commit, --to canceled --force, then consolidate --attest-canceled-superseded WP02) now refuse at claim time with LANE_MOVED_AFTER_APPROVAL and leave the target unchanged. So does the reopened canceled work package that deletes an approved file, attested or not, and the claim of the two canceled work packages that supersede each other.
Considered Options
- Land the approved stamp and drop the later commit. Rejected. Dropping a commit silently hides work from its author, and no other gate verdict does that. Merging the stamp instead of the branch name would also change the physical consolidation for every mission and discard the tool-made merges a lane needs.
- Require the lane tip to equal the stamp. Rejected. It refuses every lane with more than one work package and every resume.
- Require tree or blob equality between the lane and the stamp. Rejected. It refuses any overlapped automatic merge, the “blob equal to neither parent” class already known from #5013.
- Put the reader in the status package. Rejected. The ancestry check needs git, and the status package stays git-free.
- Extend the canceled work package resolver. Rejected. It is scoped to one canceled work package on one mixed lane, and extending it would push it past the complexity ceiling.
- Per-work-package windows on every lane (the closed world everywhere). Deferred. It brings every closed-world anchor hazard to missions with no canceled work package, with unknown real refusals. It would close the first residual below.
- Treat a missing stamp as the lane tip. Rejected. It is fail-open, and it would keep the defect for every mission approved before the stamp existed. Backfill stamps with an upgrade migration, or exempt approvals older than the stamp. Rejected for the same reason. A backfill would assert that whatever sat on the lane at upgrade time had been reviewed, with no human act. The reader ignores migration events by design. Attestation is the same assertion made by a named operator with a reason.
- Compare the
doneevent’s landed-tip stamp with the bound at the gate. Rejected. It adds a second reader of a different stamp. - Re-run the claim-time check at the gate with live branch names. Rejected. It passes vacuously, as described above.
- Reuse
--attest-canceled-supersededfor approvals. Rejected. It requires a canceled work package. Storing the attestation outside the status log would create a second authority. - Route the orchestrator code-lane path through the executor. Out of scope. It is a larger behaviour change with its own rollback questions.
Consequences
- A mixed lane where a canceled work package committed after the approval refuses until the approved work package is approved again. This holds when the canceled work was reverted on the lane too.
- A post-approval commit goes back for review before it can land.
consolidatenames the commit, the work package and the recovery command, and leaves the target unchanged. - Upgrade impact. A Mission approved by a release before 4.0.0rc5 has no stamps. Its
consolidaterefuses withAPPROVAL_STAMP_MISSINGuntil each work package is re-reviewed or attested. - A claim reads the status event log once, now also for a mission that has no mixed lane. An unreadable log refuses.
- Existing refusal codes and texts are unchanged. The three new codes and texts are additions.
- The orchestrator API contract version is 1.10.0, and
data.preflight_error_codeanddata.preflight_error_codesare new on itsPREFLIGHT_FAILEDenvelope. The first is the first code of the text, the second lists every distinct code it names. That command only raises this ADR’s codes and never a mixed-lane refusal, so it never carries a compound message. - A fixture-honesty change came with the rule: the shared consolidation fixtures now record approvals after the lane work exists, with real stamps, so the suite can express “after approval”.
Residuals
Each stays open.
- A commit between two approvals on one lane. A commit made after WP01’s approval and before WP02 is claimed sits under WP02’s later bound. Closed on a lane where at least one approved work package has a recorded window (Amendment 2026-11-08 below); it stays open on a lane where every approved work package has a window gap, for example a Mission started before #7403.
- (Amendment 2026-11-08) Parallel claims on one lane. Two work packages claimed in parallel on one lane, or one claimed early and parked without returning to
planned, get a window that opens early and also covers the other’s commits and any stray commit between them. Pinned as the strict expected-failure testtest_parallel_claims_window_is_not_over_wide(tests/consolidation/test_lane_approval_windows.py). - Content inside a merge commit. A merge commit that carries new content of its own is not seen. It is pinned as a strict expected-failure test. The skip cannot simply be removed:
git showlists a merge commit’s paths that differ from every parent, and the lane auto-rebase resolves source-file conflicts in a merge commit it makes itself, so counting merge commits would refuse a legitimate lane. A sound check has to tell a tool-made resolution from an operator-made one. - A commit made during review. The stamp is the lane head when the approval was recorded, not the commit the reviewer read.
- Planning lanes and
single_branchmissions. They are not stamped and not bounded by this stamp-based approved bound.single_branchmissions do, however, now carry a separate consolidate backstop (#5939): a strategy-independent implementation-evidence + independent-review axis (reconciliation._single_branch_evidence_refusalandsingle_branch_evidence_refusalbefore #6715; since then the single_branch voice ofconsolidation/wp_evidence.py:evaluate_evidence, called bybuild_approved_wp_set, andmission_evidence_reportforacceptandorchestrator-api) that REFUSES, fail-closed, when an approved single_branch work package has no implementation commit touching itsowned_filesin the evidence window (planning_commit..mission_branch, covering both a minted-branch and a commit-to-target single_branch), no confirmable independent review (STRICT: the implementer of record and the approving actor are the same identity, or either identity is not recorded — a legitimate mission records a real implementer viaimplement --agent <name>), or an uncomputable evidence window (a legacylanes.jsonwith noplanning_commit_sha— fail-closed, not a no-op). That axis is distinct from this bound — it reads nolane_headstamp (single_branch carries none) — and is reinforced by a move-gate layer (tasks_move_task._mt_require_implementation_evidence, named_mt_require_single_branch_implementationbefore #6715) that enforces the same evidence/uncomputable-window checks. Genuine planning lanes (non-single_branch missions) stay unbounded. - The width of the bookkeeping definition. It covers the repository’s
.kittify/tree and anykitty-specs/<slug>/path segment. A post-approval commit confined to those paths is not refused. The bound reuses the gate’s definition so there is one authority; narrowing it is a separate change to the existing content checks. consolidate --dry-run. Corrected 2026-11-09: this residual no longer holds. Since #6771 the dry run builds the full claim, so it reports these refusals asCLAIM_REFUSED_FORECASTnamingLANE_MOVED_AFTER_APPROVAL,APPROVAL_STAMP_MISSINGorAPPROVAL_STAMP_NOT_ON_LANE(pinned bytest_stray_commit_between_two_approvals_forecast_refuses,tests/consolidation/test_lane_approval_windows.py).orchestrator-api consolidate-missionhas only the up-front check. A commit hand-merged into the mission branch with the lane reset to its stamp, or a commit that lands between its check and its lane consolidation, is not caught there.consolidatefails both.- Any new approval of a work package of the lane restamps the lane, forced or not. The bound proves that an approval was recorded after the commit. It does not prove that a second person read it: the state machine allows
in_progress -> approvedwhen review evidence is supplied, and it does not check that the reviewer differs from the implementer. So one actor can send a work package back and approve it again in two commands, and the late commit then lands. Any forced transition intoapprovedlikewise records a new approval stamp for that work package at the current lane head, and a commit made after the earlier approval then lands with no refusal and no warning. This holds for the approved work package itself (approved -> approved --force), for a canceled work package (move-task WP02 --to approved --forceleaves the canceled state and stamps the tip), and for a sibling that was never reviewed (in_progress -> approved --force). A forceddoneof such a work package followed byconsolidate --attest-approved-reviewed <WP>has the same effect, and the hollow-review warning prints in that case. The bound is as strong as the review model: these are recorded operator acts, tracked in issue #5721. - A Mission damaged by an upgrade before the fix for #5457. That upgrade committed
.kittify/metadata.yamland a.gitattributesline on every lane..gitattributesis not bookkeeping, so on a lane whose work package was approved before that commit,consolidaterefuses withLANE_MOVED_AFTER_APPROVALand each such work package must be approved again. The bound exempts nothing, a tool-made commit included. The same holds forspec-kitty upgraderun from inside a lane worktree (#5747). - A refusal with no code. When the commit the lanes are measured from does not resolve, the claim refuses in plain text and names that commit. Neither command reaches this today, because both resolve the base first.
- An approval recorded while the lane branch is missing has no stamp. It can then be attested, which leaves two recorded operator acts in the log.
- A repeat attestation on a resume. If the target already advanced, the repeat attestation measures from the live target tip. The claim check still refuses afterwards.
Follow-up 2026-10-07 — a forced approval is a review only when a review claim, an arbiter override or an attestation backs it (#5721)
This follow-up supersedes, for forced moves into approved, the residual above that says any forced transition into approved restamps the lane. The residual’s text is kept as history.
- What a forced move writes. Through the real
move-taskpath forapproved -> approved,canceled -> approvedandin_progress -> approved:force: true,review_ref: null,review_result: null, and anevidence.reviewwhose reviewer is auto-detected (git config user.name) and whose reference is the syntheticauto-approval:<WP>:<date>token, or the--approval-refthe operator typed. With auto-commit on (the default), the approval also writes its ownreview-cycle-N.mdand the executor rewritesevidence.review.referenceto that artifact’sreview-cycle://pointer, so a resolvable reference is no sign of a review either. A forced hop out ofin_reviewattaches an approvedreview_result, including when the operator forced the work package intoin_reviewfirst.--self-review-fallbackrecords its own evidence in a separate lifecycle event (emit_reviewer_self_approval) with no link to the approval event. - Rule. A forced move into
approvedis a review approval only when it is (1) an approved-reviewed attestation, (2) an arbiter override (review.arbiter.is_arbiter_override_history, over the events strictly before it), or (3) a hop out ofin_reviewthat carries an approvedreview_result, where the work package’s latest move intoin_reviewwas not forced. A review claim is that unforced move:agent action reviewrecordsfor_review -> in_reviewwithout force. Anevidence.reviewreference (a typed--approval-ref, a synthetic token, areview-cycle://pointer) and a reviewer name never count for a forced move._newest_approvalskips every other forced move intoapproved, so the newest review approval stays the bound and a commit made after it still refuses withLANE_MOVED_AFTER_APPROVAL; with none left the work package refuses withAPPROVAL_STAMP_MISSINGand--attest-approved-reviewedstays the route. When a stamped review approval precedes the forced one, that attestation is refused; the route is to rework and approve again. Unforced approvals count as before.approved_attestationand the reconciliation reader shareapproval_stamp/approval_is_attested, so they follow the same selection. - Warning.
move-taskandagent status emitprint one line on stderr when a forced approval is not a review approval (approved_bound.forced_approval_warning). - Still open. An unforced
in_progress -> approvedthat supplies review evidence, and a forceddonefollowed by--attest-approved-reviewed.
Amendment 2026-10-29 — owned-file evidence and review independence are a separate axis on every topology (#6715)
Reader: a maintainer who needs to know why move-task, accept, consolidate or orchestrator-api refuses with IMPLEMENTATION_MISSING, REVIEW_NOT_INDEPENDENT, IMPLEMENTATION_UNREADABLE or EVIDENCE_WINDOW_UNCOMPUTABLE, and how that check relates to the approval bound above. Technical story: #6715, Mission lane-evidence-independence-01M5YHXF. It extends the single_branch axis of #5939 to every topology.
Problem. On a lanes or coordination Mission, an agent could claim a work package, commit nothing to its owned files, tick its subtask and move it to approved under its own name. Every command exited 0, consolidate printed its “Reconciliation verified” banner, and the deliverable was missing from the target. The approval bound did not catch it, and is not meant to: it refuses content added to a lane after an approval, not the absence of content, and it does not compare the reviewer with the implementer. #5939 closed the gap for single_branch Missions only.
Decision.
- A separate axis, beside the bound. One topology-neutral predicate,
consolidation/wp_evidence.py, asks two questions of every approved work package: does a committed change touch its owned files (evidence), and did someone other than its implementer approve it (independence)? The approval bound of this ADR (approved_bound.py) is unchanged: it reads no evidence, and the evidence axis reads no approval stamp. A work package lands only when both pass. - The evidence window. For a code lane, the tree diff
planning_commit_sha..<lane branch>, withplanning_commit_sharead fromlanes.json(or derived from git where none was recorded, Amendment 2026-11-05); for a planning lane,planning_commit_sha..<target branch>; forsingle_branch, the #5939 window, unchanged. The diff is restricted to the work package’s owned files, and Mission bookkeeping paths never count: the status log,meta.json,.kittify/, and every other Mission file the CLI writes itself (tasks/,lanes.json,acceptance-matrix.json,analysis-report.md,decisions/,decisions.events.jsonl,traces/), so only author-written Mission content counts (ruling 8). The one list islanes/for_review_gate.status_only_excluded_prefixes, which thefor_reviewgate reads too. Only when that finds nothing, the windowmerge-base(dependency lane tip, lane tip)..lane tipof each dependency lane is read too. A commit later reverted leaves no change and does not count. - Independence. The #5939 identity
tool:model:profileof the latest implementer and of the latest approver must be provably different. What changed from #5939, forsingle_branchtoo: the inputs and the comparison. A generic placeholder approver (user,unknown,implement-command) projects to unknown (ruling 6); the latest approval decides, so a newer approval with a blank actor also leaves the approver unknown instead of falling back to an older reviewer; and the two identities compare segment-wise (status.actor_identities_independent, ruling 7) instead of as whole strings.preflight._independent_reviewer_confirmedapplies all three, so the hollow-review warning, which reads it, changes the same way. - Where it runs.
move-task: an unforced move into a review lane needs evidence. An unforced move intoapprovedordonerefuses withREVIEW_NOT_INDEPENDENTwhen the approver is not provably independent of a known implementer of record (ruling 7), or when the approval would be recorded as the placeholderuser; an unknown implementer passes at the move. The move predicts the approver with the executor’s own hop helpers (tasks_move_task_hops._mt_hop_actor/_mt_hop_structured_actor), and an approval without--agentout ofin_reviewrecords the fulltool:model:profileof the review claim, which is also what the approve command printed byagent action reviewcarries.acceptandconsolidateare strict: an unknown identity is not independent there.accept: a hard preflight, whatever--lenientsays.consolidate: at claim time inreconciliation.build_approved_wp_set, before any branch moves, so a refused claim prints no “Reconciliation verified” banner.orchestrator-api consolidate-missionanswersPREFLIGHT_FAILEDwithdata.preflight_error_codeanddata.preflight_error_codes;accept-missionanswersMISSION_NOT_READYwithdata.evidence_error_codes. The orchestrator API contract version is 1.21.0. - Codes.
IMPLEMENTATION_MISSING(no owned-file change in the window),REVIEW_NOT_INDEPENDENT(an identity not provably different, or one that is not known),IMPLEMENTATION_UNREADABLE(the window cannot be read, for example a lane branch that is gone) andEVIDENCE_WINDOW_UNCOMPUTABLE(lanes.jsonrecords no planning commit; remedy: re-runspec-kitty agent mission finalize-tasks) on lanes, coordination and planning lanes.single_branchMissions keep emitting theirSINGLE_BRANCH_*codes, which mean the same thing. - Attestation.
acceptandconsolidatetake--attest-no-implementation <WP> --attest-reason "<why>". It records a forced operator self-transition withpolicy_metadata.attestation = "no_implementation"and liftsIMPLEMENTATION_MISSINGfor that work package only. A request for a work package whose evidence verdict isIMPLEMENTATION_UNREADABLEorEVIDENCE_WINDOW_UNCOMPUTABLEis refused before anything is recorded, since it could not lift that verdict; one for a work package that already shows evidence is still accepted (a no-op).consolidateprints⚠️ <WP>: IMPLEMENTATION_MISSING lifted by operator attestation (<reason>). It never lifts any other code.
Operator rulings (binding):
- 2026-10-27: independence keeps the #5939 identity
tool:model:profileunchanged on every topology. The recorded role is not compared, because it is stamped from the target lane (claimedgives implementer;in_review,approvedanddonegive reviewer) and the role segment of--agentis discarded. - 2026-10-27:
IMPLEMENTATION_MISSING(no commit touching the work package’s owned files in its window) refuses by default. An operator attestation may lift it for a docs-only or no-deliverable work package. It never lifts independence. - 2026-10-27 (decision
01M5YHYFRJPTE0SQ9V7SWGK26J):move-task --forcekeeps bypassing the evidence and independence checks at the move. At the move, independence refuses only a positively-same identity on an unforced move intoapprovedordone(since ruling 7: an identity not provably different); an unknown implementer does not refuse at the move.acceptandconsolidatestay strict regardless of--forceand--lenient. - 2026-10-27: planning lanes are covered too.
- 2026-10-27: an attestation counts only while the work package has stayed in
approvedordonesince it was recorded. - 2026-10-29: a generic placeholder approver (no
--agent, recorded asuser) is unknown, hence not independent.move-taskrefuses an unforced approval that would record one. - 2026-10-29 (R1): identities compare segment-wise. Two recorded identities are independent only if their tools differ, or a segment (model, profile) recorded on both sides differs. A segment missing on one side never proves independence (“unknown = same”); the role is still never compared.
acceptandconsolidatestay strict (an unknown or placeholder identity is not independent); at the move, an identity not provably independent of a known implementer refuses, a placeholder approver refuses, and an unknown implementer passes. One function compares,status.actor_identities_independent, used by the evidence axis andmove-task. - 2026-10-29 (R2): only author-written Mission content counts as evidence. The Mission’s own tool-written planning and lifecycle files are added to the one exclusion list;
spec.md,plan.md,research.md,data-model.md,quickstart.md,contracts/andchecklists/still count.
Effect on the follow-up of 2026-10-07. Its “still open” unforced in_progress -> approved now also passes through the evidence and independence checks at the move, so it refuses with no owned-file commit or under the implementer’s own identity. It still restamps the lane when it passes.
Residuals. Each stays open.
- Content merged into a lane counts. The window is a tree diff, so a hollow work package passes when its lane merges in content someone else committed to its owned paths. That needs an edit outside the ownership map. The #5939
single_branchwindow has the same limit. A candidate follow-up is to read only the lane’s own non-merge commits. - A forced move into review, then an unforced approval. An unforced
in_review -> approvedafter a forced move into review is not re-checked for evidence at the move, as ruling 3 implies.acceptandconsolidaterefuse it. consolidate --dry-run. Corrected 2026-11-09: the dry run builds the full claim since #6771, and the evidence check runs inside that claim build, so it reaches these refusals too. No test pins the forecast verdict for them yet; the approval-stamp refusals are pinned (see the 2026-11-08 amendment).- Older Missions. A Mission whose
lanes.jsonpredatesplanning_commit_sharefuses withEVIDENCE_WINDOW_UNCOMPUTABLEuntilfinalize-tasksis re-run. Settled by the 2026-11-05 amendment below (#7209, #7210): plainfinalize-tasksnow derives the missing pin. An approved lane branch that is gone refuses withIMPLEMENTATION_UNREADABLE. - Attestations are not atomic. If writing several attestations fails partway, the earlier ones stay recorded. An attestation recorded before a claim that then refuses for another reason also stays.
- Owned files carry the check. On every topology the verdict is only as accurate as each work package’s
owned_files. - Same-tool review needs full identities. Under ruling 7 an implementer recorded as bare
claudecan only be independently reviewed by another tool; a same-tool review needs a model or profile recorded on both sides (--agent <tool>:<model>:<profile>on implement and review). - PR-mode accept on pruned lane branches. Settled by the 2026-10-31 amendment below (#6780).
Amendment 2026-10-31 — a pruned lane is judged on the pull request’s own side of the landing merge (#6780)
Reader: a maintainer who needs to know why accept --mode pr --merge-commit <sha> accepts, or refuses, a Mission whose lane branches were deleted after the pull request merged.
Problem. accept --mode pr never runs consolidate, and the lane branches are normally pruned once the landing is on the target, so the window planning_commit..<lane branch> could not be read and every approved work package refused with IMPLEMENTATION_UNREADABLE, which no attestation lifts.
Decision.
- A stand-in, narrowly. Only
accept --mode prpasses a landing commit, and only after it verified it as the Mission’s PR landing commit. It stands in only for a lane whose branch ref is truly absent (git show-ref --verifyexits 1). A ref that exists but cannot be read (a missing object, a corrupt ref, a git error) refusesIMPLEMENTATION_UNREADABLE; it never falls back. - The PR’s own side. The window is
landing^1..landing, the net change the merge brought onto the target, so unrelated work that reached the target before the merge is never evidence. Every other rule (owned-files matcher, bookkeeping exclusion, independence) is unchanged, and a work package with no owned change there still refusesIMPLEMENTATION_MISSING. - Ancestry precondition. The planning commit must be an ancestor of the landing and sit on a non-first-parent side of it, and the landing must be a merge commit. A squash or fast-forward landing, or a merge that did not carry the planning commit, refuses
IMPLEMENTATION_UNREADABLEwith that reason. - Overlap refusal. The window holds every work package of the PR, so a work package whose
owned_filesoverlap another approved work package’s (glob-aware, conservative) is refusedIMPLEMENTATION_UNREADABLE: the merge alone cannot say which of them made a change there. The remedy is to restore the lane branch fromrefs/spec-kitty/lane-tip/<branch>or the PR’s head and re-run.
Residuals. Each stays open.
- Rebased stacks. A Mission whose corpus was rebased first sees only changes up to the corpus commit on the PR side, so its work packages refuse
IMPLEMENTATION_MISSING(fail closed). - Squash landings cannot use the stand-in; the lane branch must be restored.
- Overlap is approximate. The glob comparison errs toward refusing, so disjoint-in-practice globs that look nested also refuse.
Amendment 2026-11-03 — unresolved ownership is its own verdict, not a missing implementation (#7149)
Reader: a maintainer who needs to know why an approved work package with an unreadable task file no longer refuses IMPLEMENTATION_MISSING.
Problem. The evidence axis read an absent ownership declaration as an empty one, so a work package whose task file, or whole tasks/ directory, could not be read refused IMPLEMENTATION_MISSING. Its recovery (commit more work, or --attest-no-implementation) could not help, and the attestation could lift the refusal on evidence that was never judged.
Decision.
- A fifth verdict. A work package absent from the resolved ownership map (missing
tasks/, an absent or unreadable task file) refusesOWNERSHIP_UNRESOLVED(SINGLE_BRANCH_OWNERSHIP_UNRESOLVEDonsingle_branch). It is decided beforeIMPLEMENTATION_MISSING, so that verdict now means only “ownership resolved, no owned change”. - Not liftable.
--attest-no-implementationrefuses it; no attestation lifts it. The recovery is to restore the task file or run from the owning checkout. - Authored stays resolved. An authored
owned_files, an empty list or an omitted key (which reads as an empty list) included, is a resolved declaration and keepsIMPLEMENTATION_MISSING. - Contract. The orchestrator-api
CONTRACT_VERSIONis1.23.0(additive code).
Diagnostic clarification 2026-11-05 — #7146 / #7120 option 1 only. A failed window whose tip Git reports absent now names only local ref facts. Sibling presence does not establish that the missing lane ever existed; restore only its actual history, never fabricate a lane window from target-branch work. A nonexistent lane window cannot be retried into existence. The existing verified PR-merge stand-in remains subject to every ancestry, merge-shape, ownership and independence check above; absent that landing or restorable history, escalate #7120. No evidence window, topology, verdict or operator ruling changes; #7120’s target-branch fallback remains unruled.
Amendment 2026-11-05 — a base derived from git stands in for a planning commit finalize never recorded (#7209, #7210)
Reader: a maintainer who needs to know where the evidence window starts when lanes.json records no planning_commit_sha, or when there is no lanes.json at all.
Problem. The evidence window opens at planning_commit_sha. Two kinds of Mission had none, and both refused EVIDENCE_WINDOW_UNCOMPUTABLE with no working remedy:
- A
consolidate --skip-lanesMission with nolanes.json(the direct-on-target fallback) runs on a synthesized manifest that never carried a pin (#7209).finalize-taskscannot add one once execution has begun. - A Mission whose
lanes.jsonpredates the pin (#7210). The named remedy, re-runningfinalize-tasks, kept the pin empty with a warning;--refresh-planning-commitrecorded the live target tip, an empty window for a planning lane or a lane already merged.
Decision (operator ruling 2026-11-05).
- A derived base is a fact read from git. Where no planning commit was recorded, the base is the target-branch commit immediately before a Mission path first appeared on the target’s first-parent line. It claims nothing about review, unlike the approval-stamp backfill this ADR rejected, so it may stand in. The window can be wider than one a timely
finalize-taskswould have recorded; that is accepted, and listed under Residuals. - One resolver, two anchors.
lanes/planning_base.resolve_planning_base_commit, introduced for #7209 by #7238 and moved tolanes/for #7210, is the only lookup. It walks--first-parent(#7238’s review found that a plaingit logcan anchor on an old side branch and widen the window past unrelated target work), takes the introducing commit’s first parent, and treats a root introducing commit as its own base.--skip-lanes(#7209, #7238). The synthesized manifest’splanning_commit_shaanchors on the Mission directory,kitty-specs/<slug>/. With no resolvable base the pin stays empty and the refusal tells the operator to commit the Mission’s planning artifacts on the target branch.finalize-tasks(#7210). With no pin recorded and a resolvable target tip, a plain run anchors on the work package task files,kitty-specs/<slug>/tasks/WP*.md, and records the result, reported as the actionderived. On a direct history that is the tip a timely finalize would have recorded. A different anchor from--skip-lanes, because a Mission with alanes.jsonwas finalized after its task files existed, so their first appearance bounds its planning start more tightly than the directory does. The base is accepted only when every lane branch of the Mission contains it: the window is a tree diff, so a base holding content the lane never had reads that content as the lane’s implementation, and a work package with no commits would land. That happens when the tasks reach the target by a merge or a rebase after the lane was cut. A shallow repository derives nothing. When none can be derived, the run keeps today’skept_with_warning. Derivation never writes over a recorded pin, though the existing auto-refresh can later replace a derived one (#7297).
doctor mission-state --fix(#7210, ruling 2026-11-05). When it rebuilds a missinglanes.jsonfor a wedged Mission, it records the same task-file base asfinalize-tasksinstead of the live target tip, which gave an empty window for work already committed there. When none can be derived it keeps the live tip, reportslanes_rebuilt_pin_is_target_tipbesidelanes_rebuilt_from_event_log, and prints a warning.- One window authority. The window is still computed only in
consolidation/wp_evidence.py, which does not know whether its base was recorded or derived. TheEVIDENCE_WINDOW_UNCOMPUTABLErecovery names plainfinalize-tasksand warns against--refresh-planning-commit. - No migration. Older Missions are not rewritten: a derived pin is recorded only when an operator runs
finalize-tasksordoctor mission-state --fix, and a--skip-lanesbase is derived per run and never persisted.
Residuals. Each stays open.
- A wider window. Content committed on the target between the derived base and the Mission’s real planning start counts as evidence when it touches a work package’s
owned_files. The widening is not bounded: tasks removed and re-added, or WP files committed before unrelated work, widen it further (#7297). - A fast-forwarded Mission branch (#7229). When a Mission branch merges the target in and the target is then fast-forwarded onto it, the base lands below the Mission’s artifacts.
- History without the Mission. A Mission whose files never reached the target’s history has no derivable base.
finalize-tasksstill refuses it;doctor mission-state --fixrecords the live target tip, so the gate reportsIMPLEMENTATION_MISSINGrather thanEVIDENCE_WINDOW_UNCOMPUTABLE. That includes the defaultsingle_branchMission on a protected primary, whose tasks live on its mission branch (#7297).
Amendment 2026-11-06: per-WP approval windows for single_branch (#7283)
Reader: a maintainer who needs to know why consolidate now refuses a single_branch Mission with LANE_MOVED_AFTER_APPROVAL, APPROVAL_STAMP_MISSING or APPROVAL_STAMP_NOT_ON_LANE, and which single_branch Missions it still does not bound.
Problem. The residual “Planning lanes and single_branch missions” above left single_branch Missions unbounded: their work packages were not stamped, so a commit made on the Mission branch after an approval landed under the “Reconciliation verified” banner. ADR 2026-11-06-3 makes single_branch the size default for small Missions (#7282), so that residual would cover most of them. Its constraint C-010: this amendment ships before or with that decision. Mission lane-worktree-model-hardening-01M6QY1M, #7283.
Decision. This amendment narrows that residual. For a single_branch Mission with a minted Mission branch, the residual is replaced by per-WP windows; its text is kept as history.
- The stamp. Every lifecycle transition of a work package in a Mission whose stored topology is
single_branchcarries the head of the Mission write branch (write_branch_for) aspolicy_metadata.lane_head. The decision is keyed on the stored topology, never onis_planning_laneorexecution_mode: direct_repo. The planning lane of alanesMission stays unstamped.approval_stampandstamp_ofread the stamp unchanged. - Tier 1: after the newest approval.
check_laneruns unchanged on the Mission branch at claim time. Content committed after the newest approval stamp refusesLANE_MOVED_AFTER_APPROVAL. - Tier 2: every content commit inside an approval window. For each approved work package
k,O_kis the stamp on its first non-migration move intoclaimedorin_progress(wp_attribution.approval_window_open_stamp; ablockedmove opens nothing, so a work package blocked at the start cannot widen its window over commits made before it was claimed. The mixed-lane closed world keepsfirst_governed_open_stamp, which countsblocked) andS_kthe stamp on its newest approval. Every content commit inclaim_base..mission_branchmust be reachable from someS_kand not from that work package’sO_k, that is lie in some window(O_k, S_k]. Git merge commits and bookkeeping paths (_is_bookkeeping) are excluded, and commits reachable from the claim base or an anchor are exempt, as in the lane check. A commit outside every window refusesLANE_MOVED_AFTER_APPROVAL, naming the commit and the work package approved before it. Overlapping windows are accepted: a work package committed while another was under review passes when both are approved. The window is cumulative from the first claim because the reviewer’s diff runs from the work package’s base. Tier 2 lives inconsolidation/write_branch_bound.py;approved_bound.pygains only the public stamp-refusal split and the warnings. - The gate re-check. It reads the Mission branch through the claim’s
lane_id -> branchmap, comparing its live tip with the tip validated at claim time, never throughlane-planning’s alias, which resolves to the target. A refusal restores through the one rollback authority (consolidation/rollback.py). The run’s own bookkeeping commits never refuse. - Scope. The bound applies only when the Mission lands its Mission branch (
lands_mission_branch: a recordedmission_branchthat differs from the target). A defaultsingle_branchMission always does. - Back-compat: refuse plus attest (operator ruling, DM
01M6QY42BBA8GZ3R4FPGCYY3F5), the lanes precedent of “Upgrade impact” above, unchanged. Every unstamped approval on an in-flightsingle_branchMission refusesAPPROVAL_STAMP_MISSINGafter upgrade;--attest-approved-reviewed <WP> --attest-reason "..."lifts it per work package. A Mission branch rebased after approval refusesAPPROVAL_STAMP_NOT_ON_LANE, and attestation is the remedy. No marker key scopes the bound to newly stamped Missions; that alternative was rejected. - Warnings.
move-taskandagent status emitprint the existing unstamped-approval and forced-approval warnings forsingle_branchMissions too. - No contract change. The codes are reused.
orchestrator-api consolidate-missionreports these refusals as today’sPREFLIGHT_FAILEDwith the code indata.preflight_error_codes; no orchestrator-api code is added for this amendment.
Residuals. Each stays open.
- Commit-to-target and direct-on-target
single_branchMissions are unbounded. A Mission whose write branch is its target (--commit-to-target, which needs an explicit--topology single_branch) keeps today’s behaviour. It is pinned by a strict expected-failure test that names the residual, so the gap stays visible. - A missing open stamp
O_k. A work package whose first claim carries no stamp degrades to the window(claim_base, S_k], even when a later rework entry is stamped (a Mission upgraded in flight), and the degrade is logged, at INFO only. It is not a new refusal, but it hides a commit: a missingO_kcovers every commit beforeS_k, including one made between the preceding approval and that work package’s claim (WP01 claimed with a stamp and approved, commit X, WP02 claimed without a stamp and approved: X passes). A rebase has the same effect: the oldO_kis no longer on the branch, so its reachable set holds only pre-rebase SHAs and the window widens to(claim_base, S_k]. Tier 1 forces re-approval or attestation first, a recorded operator act. An attestation on an unstamped claim likewise covers the whole branch before the attestation tip. - Refusal-path cost. The pass path is batched (one reachability set per boundary); each refused commit costs one extra
git rev-listto name the work package approved before it, so a branch with many out-of-window commits costs O(n) subprocesses on the refusal path only. - A commit made during review. As for lanes, the stamp is the Mission branch head when the approval was recorded, not the commit the reviewer read.
- A contested window. Because overlapping windows are accepted, a commit inside one approved work package’s window is covered even when it belongs to another work package’s scope. Exact per-commit attribution is deferred.
- The lanes residuals above (content inside a git merge commit, the width of the bookkeeping definition and forced approvals) apply to the Mission branch unchanged. The
--dry-runresidual is corrected: the dry run reports these refusals asCLAIM_REFUSED_FORECAST(corpus cellsforecast|single_branch|...).
Confirmation. tests/status/test_lane_head_single_branch.py (the stamp, with a lanes planning-lane control that stays unstamped); tests/consolidation/test_write_branch_bound.py (tier 2); tests/integration/test_single_branch_approval_windows.py (the window scenarios through consolidate: a late commit after the last approval, a commit between two approvals, overlapping review, rework after a later approval, refuse plus attest, a mid-run commit at the gate re-check, and the strict expected-failure test_commit_to_target_unbounded_residual); tests/orchestrator_api/test_single_branch_bound_preflight.py (the reused codes on PREFLIGHT_FAILED).
Amendment 2026-11-08: lane approvals are judged by recorded work-package windows (#7403)
Every non-migration move of a lane-mapped work package into claimed or in_progress now records its window-open SHA (policy_metadata.wp_window), and on every code lane with at least one recorded window each approved work package covers only (window-open SHA, newest approval stamp]. This is the per-work-package window model of the single_branch amendment above, applied to lanes. The bound in this record runs unchanged first (tier 1); a second tier then refuses a commit outside every window with LANE_MOVED_AFTER_APPROVAL, naming the commit and the work package approved before it. On that path the exemption anchors are the closed-world anchors plus the approval stamps of other lanes, never the lane’s own (operator ruling, Decision Moment 01M6YAFYHT0RMVZB03THW1WWSE), and a canceled work package’s own attributed commits are exempt from the second tier (operator ruling 2026-11-09). A work package without a usable window falls back to this record’s approval-stamp bound, is never refused for the gap alone, and is listed in a gap report; a lane where every window is a gap is judged exactly as before. single_branch approval windows read the recorded window-open SHA when present. The detail, the residuals and the evidence live in 2026-11-08-2-work-package-windows-are-recorded-at-the-opening-transition.
Amendment 2026-11-10: the implement claim records its dispatch identity, and a submission refines it (#7159)
Reader: a maintainer who needs to know why a same-tool reviewer under another --profile now approves where it was refused REVIEW_NOT_INDEPENDENT, and which recorded event names the implementer.
Problem. Ruling 7 compares tool:model:profile segment-wise, so a same-tool reviewer is independent only when a profile or model is recorded on both sides. agent action implement --agent claude --profile python-pedro on a fresh code lane recorded its claim with the bare actor claude: the lane was created through the top-level implement command, which emitted the claim with the --agent string, and the structured claim then found the work package in_progress and emitted nothing. The implementer read as claude::, and recording the full identity later did not help: a rework into in_progress carries a review_ref (a reviewer verdict by construction), and a for_review submission was not an implementer event. #7159.
Decision (operator rulings 2026-11-10).
- The claim records the dispatch-resolved identity. Both claim emitters of
agent action implementrecord the structured implementer actor and binding annotation built once (workflow_executor.implementer_claim_identity). The dispatch binding is resolved before any lane or claim exists.--modelstays refused (#7013); only--profile, an Op’s profile and the compact--agentsegments reach the actor. Without--agentthe fresh lane’s claim keeps the genericimplement-commandplaceholder: the frontmatter agent is planned, not proven, and never names the implementer (#6400). - A submission refines the claim’s identity. The implementer of record is the identity of the latest qualifying claim (
latest_implementer_event, unchanged), refined by every later unforcedin_progress -> for_reviewsubmission of the work package (status.latest_implementer_identity,status.models.refine_actor_identity). A submission by the claim’s tool fills a model or profile the claim did not record. It is ignored when it names another tool, contradicts a recorded segment or is not atool:model:profileidentity, so a submission never overrides a segment the claim recorded. Forced moves, seeds and placeholder actors never refine.move-taskand the accept/consolidate evidence axis read this one projection. - Unchanged. The comparison (
actor_identities_independent), the refusal codes and their text, and the reviewer-verdict reading of a rework intoin_progress.
Residuals. Identities stay self-asserted.
- Any same-tool submitter, not only the implementer, fills what a bare claim left empty: a bare claim followed by an unforced submission under another profile records that profile, as a claim under that profile already would.
- A submission can fill the model a claim never records (#7013), so a later approver under the same profile and another model is independent of it, as it would be of a claim that recorded the model (ruling 7).
- The refusal text of the review-lane exit (
work_package_lifecycle) still names the unrefined claim.
Confirmation. tests/integration/test_7159_implement_claim_profile.py (the fresh-lane claim on coord and lanes; the agent-less placeholder; a refusal before any lane exists; a bare claim refined by a submission), tests/cli/commands/test_dispatched_claim_identity_7159.py (the seam) and the latest_implementer_identity truth table in tests/unit/status/test_review_roles.py.
Amendment 2026-11-18: a forced or foreign claim never replaces the implementer of record, and an explicit re-submission completes a bare claim (#7712)
Reader: a maintainer who needs to know how an implementer whose claim recorded only its tool can complete its identity, and why a forced rewind no longer changes who the implementer of record is.
Problem. #7712, WP03 of an open-packs single_branch Mission. The claim recorded the bare actor claude, so under ruling 7 no claude::<profile> reviewer was independent of it. The implementer re-submitted out of in_review with its profile, but that hop (in_review -> for_review, forced: the matrix has no unforced edge) was stamped role reviewer and was neither a claim nor a #7159 submission, so its identity was ignored. What worked was a forced for_review -> in_progress rewind, and latest_implementer_event read it as a new claim: its identity replaced the implementer of record. Anyone who forced a rewind (or unblocked, or took over) under a new identity became the implementer, and independence was judged against them, not against the agent that did the work.
Decision (operator ruling 2026-11-18: accepted as designed: WP03’s recorded log fails closed, the explicit move-task --as-implementer re-submission is the repair, and forced or foreign claims join an implementer set without replacing the record).
- An explicit re-submission completes a bare claim (option chosen: an identity-annotation act carried by the re-submission).
move-task --to for_review --as-implementer --agent <tool>:<model>:<profile>out ofin_reviewrecords the hop’s actor with roleimplementerinstead ofreviewer; only such a hop refines the implementer of record under the #7159 rule (fill only, never another tool, never a contradicted segment). The flag is refused (AS_IMPLEMENTER_HOP_INVALID) on any other move, without--agent, and when the review claim recorded a model or profile and--agentis not provably another identity (status.resubmitter_may_be_implementer). The re-submission also completes nothing when the cycle’s review claimant recorded a model or profile and is not provably independent of the implementer of record (landing fold: a bareclaudeclaim, aclaude::revreview claim and an--as-implementer --agent claude::implre-submission leave the recordclaude::, soclaude::revis still refused withREVIEW_NOT_INDEPENDENT): the claimant may be the implementer, and a self-asserted identity that completed the record would only make it look independent of its own work. Under a claimant that is provably another identity (codex::rev) the re-submission completes the bare claim; the projection applies the same predicate, and reads only a structured actor’s role, so an older log’s compact fourth segment never counts. The plain hop is not used: on it the actor is normally the reviewer handing the review back, and filling a bare claim with the reviewer’s profile would make the real implementer look independent of it (adversarial squad finding; the issue’s “re-submission whatever lane it starts from” option was tried and rejected for that reason). No new event field: the role is already recorded on every actor. - Only a fresh claim names a new implementer of record.
status.implementer_identitieswalks the work package’s events once. An unforcedplanned -> claimedclaim starts a new cycle; by a placeholder actor (implementwithout--agent), the previous record stands until the cycle’s first unforced real claim names the new one. A claim that adds nothing to the record (the record itself, or a less specific spelling of it) changes nothing. The claim’s own unforced hops that agree with it (not provably independent, ruling 7) refine it. Every other claim intoclaimed/in_progress(forced, or by another identity: a forced rewind, a takeover, an unblock) never changes the record; its identity is kept beside it as a further implementer. A submission never completes the record when its submitter is not provably independent of an identity kept beside it: whoever rewound or took over must not fill the original claim with its own identity.latest_implementer_identityis the first of these identities. - An approval must be independent of every implementer.
status.independent_of_implementersappliesactor_identities_independentto each identity;move-task’s approval check andconsolidation.preflight._independent_reviewer_confirmed(the accept/consolidate evidence axis and the hollow-review warning) read it. So the original implementer cannot approve after someone else forced a rewind, and the identity that forced it, who may have reworked the work package, cannot approve either (#6955). - Claim-time warning. A claim whose identity is the tool alone prints one line on stderr (
status.profileless_claim_warning) frommove-task,agent status emitandagent action implement, naming theREVIEW_NOT_INDEPENDENTrefusal and the remedy. It is advisory (an event it cannot classify never fails the move) and is left out of--jsonruns, whose output must stay one JSON document;agent action implement, the canonical claim path, always prints it. - Unchanged.
actor_identities_independent(one-sided segments still prove nothing), the refusal codes and their text, and the ownership guard’slatest_implementer_event/latest_implementer_actor.
Residuals.
- Identities stay self-asserted.
--as-implementerby a reviewer is a deliberate, recorded misattribution, not an incidental one; so is the #7159 residual that any same-tool unforced submitter fills what a bare claim left empty. - The ownership guard (
latest_implementer_actor, #5196) still names the latest claimant, while the hand-back target (_mt_returning_implementer) and the independence checks read the implementer of record: after a forced rework by another identity the two can differ. - A WP03 log recorded before this change stays refused (fail closed): its 06:44:25 hop is stamped
reviewer, and its later submission came from the identity that forced the rewind. A reviewer under another tool, or a fresh cycle, approves it. - Returning a work package to
plannedand claiming it again starts a new cycle, so an earlier implementer of that work package may approve the next cycle’s work. - A bare review claim proves nothing about who re-submits with
--as-implementer, so a reviewer who claimed the review without a profile can still assert the implementer’s identity; it is a recorded act. - The status-log race seen in the same run (a
migration:backfill_runtime_staterow stamped 06:21 appended after the 06:54donerow) is the union merge of two clones’ pushes ofstatus.events.jsonl; the reducer orders byat, so the fold is correct. The coordination status-write guard (#5572) compares one worktree with its ownHEADand cannot see a cross-clone race. Tracked under #1795 and #4955, not asingle_branchgap of that guard.
Confirmation. tests/unit/status/test_review_roles_7712.py (WP03’s sequence, the reviewer hand-back, the third-identity rewind, takeover and unblock, the claim-time warning) and tests/specify_cli/cli/commands/agent/test_move_task_evidence_gate.py (a forced re-opener refused at the move; --as-implementer role and refusals; the review claimant re-submitting under another profile still refused, and the control where another implementer completes the bare claim).