---
type: "ADR"
title: "ADR: the approval stamp bounds what consolidate treats as approved work"
description: "Consolidate refuses a code lane holding a commit made after its work package was approved; an approval with no stamp refuses until re-reviewed or attested."
status: "stable"
generated:
  by: "process:dockitty-export"
  at: "2026-11-10T00:00:00Z"
---

**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](https://github.com/spec-kitty/spec-kitty/issues/5668), Mission `approved-claim-bound-01M444QR`. Reverses two earlier decisions, named under Decision. Related: [#5046](https://github.com/spec-kitty/spec-kitty/issues/5046) and ADR [2026-09-29-1](/adr/3.x/2026-09-29-1-closed-world-refuse-on-mixed-lanes.md).

**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_head` on a work package's latest non-migration approval event. An approval event is an `approved` transition, an unforced transition straight from review into `done` (`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 into `done` is not an approval.
- The run's own `approved -> done` transition 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_stamp` in `src/specify_cli/consolidation/approved_bound.py`. It uses the stamp reader that already served canceled work packages, `stamp_of` in `consolidation/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_APPROVAL` the text names up to three late commits and says to see a commit with `git show <sha>`. The recovery is `spec-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_LANE` the recovery is the same move-back command.
- For `APPROVAL_STAMP_MISSING` the text prints one `spec-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-mission` prints the same text. For `APPROVAL_STAMP_MISSING` only, it adds that it has no attestation flag: attestation is done with `spec-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-task` and `spec-kitty agent status emit` print 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 at `consolidate`. 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:

1. *Covered point.* Every stamped event of a canceled work package covered the commits up to its stamp. A forced `canceled -> canceled`, a re-cancel from `planned` or an attestation after a late commit covered that commit.
2. *Work windows.* The commits inside a canceled work package's closed, stamped work windows were exempt. A work package canceled from `planned` and forced into `blocked` or `for_review` around a late commit had a window; the attribution assigned it nothing, so no check judged the commit.
3. *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 `consolidate` exited 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

1. **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.
2. **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

1. **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.
2. **Require the lane tip to equal the stamp.** Rejected. It refuses every lane with more than one work package and every resume.
3. **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.
4. **Put the reader in the status package.** Rejected. The ancestry check needs git, and the status package stays git-free.
5. **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.
6. **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.
7. **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.
8. **Compare the `done` event's landed-tip stamp with the bound at the gate.** Rejected. It adds a second reader of a different stamp.
9. **Re-run the claim-time check at the gate with live branch names.** Rejected. It passes vacuously, as described above.
10. **Reuse `--attest-canceled-superseded` for approvals.** Rejected. It requires a canceled work package. Storing the attestation outside the status log would create a second authority.
11. **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. `consolidate` names 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 `consolidate` refuses with `APPROVAL_STAMP_MISSING` until 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_code` and `data.preflight_error_codes` are new on its `PREFLIGHT_FAILED` envelope. 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 test `test_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 show` lists 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_branch` missions.** They are not stamped and not bounded by this stamp-based approved bound. `single_branch` missions do, however, now carry a *separate* consolidate backstop (#5939): a strategy-independent implementation-evidence + independent-review axis (`reconciliation._single_branch_evidence_refusal` and `single_branch_evidence_refusal` before #6715; since then the single_branch voice of `consolidation/wp_evidence.py`: `evaluate_evidence`, called by `build_approved_wp_set`, and `mission_evidence_report` for `accept` and `orchestrator-api`) that REFUSES, fail-closed, when an approved single_branch work package has no implementation commit touching its `owned_files` in 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 via `implement --agent <name>`), or an **uncomputable evidence window** (a legacy `lanes.json` with no `planning_commit_sha` — fail-closed, not a no-op). That axis is distinct from this bound — it reads no `lane_head` stamp (single_branch carries none) — and is reinforced by a move-gate layer (`tasks_move_task._mt_require_implementation_evidence`, named `_mt_require_single_branch_implementation` before #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 any `kitty-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 as `CLAIM_REFUSED_FORECAST` naming `LANE_MOVED_AFTER_APPROVAL`, `APPROVAL_STAMP_MISSING` or `APPROVAL_STAMP_NOT_ON_LANE` (pinned by `test_stray_commit_between_two_approvals_forecast_refuses`, `tests/consolidation/test_lane_approval_windows.py`).
- **`orchestrator-api consolidate-mission` has 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. `consolidate` fails 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 -> approved` when 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 into `approved` likewise 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 --force` leaves the canceled state and stamps the tip), and for a sibling that was never reviewed (`in_progress -> approved --force`). A forced `done` of such a work package followed by `consolidate --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.yaml` and a `.gitattributes` line on every lane. `.gitattributes` is not bookkeeping, so on a lane whose work package was approved before that commit, `consolidate` refuses with `LANE_MOVED_AFTER_APPROVAL` and each such work package must be approved again. The bound exempts nothing, a tool-made commit included. The same holds for `spec-kitty upgrade` run 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-task` path for `approved -> approved`, `canceled -> approved` and `in_progress -> approved`: `force: true`, `review_ref: null`, `review_result: null`, and an `evidence.review` whose reviewer is auto-detected (`git config user.name`) and whose reference is the synthetic `auto-approval:<WP>:<date>` token, or the `--approval-ref` the operator typed. With auto-commit on (the default), the approval also writes its own `review-cycle-N.md` and the executor rewrites `evidence.review.reference` to that artifact's `review-cycle://` pointer, so a resolvable reference is no sign of a review either. A forced hop out of `in_review` attaches an approved `review_result`, including when the operator forced the work package into `in_review` first. `--self-review-fallback` records its own evidence in a separate lifecycle event (`emit_reviewer_self_approval`) with no link to the approval event.
- **Rule.** A forced move into `approved` is 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 of `in_review` that carries an approved `review_result`, where the work package's latest move into `in_review` was not forced. A review claim is that unforced move: `agent action review` records `for_review -> in_review` without force. An `evidence.review` reference (a typed `--approval-ref`, a synthetic token, a `review-cycle://` pointer) and a reviewer name never count for a forced move. `_newest_approval` skips every other forced move into `approved`, so the newest review approval stays the bound and a commit made after it still refuses with `LANE_MOVED_AFTER_APPROVAL`; with none left the work package refuses with `APPROVAL_STAMP_MISSING` and `--attest-approved-reviewed` stays 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_attestation` and the reconciliation reader share `approval_stamp` / `approval_is_attested`, so they follow the same selection.
- **Warning.** `move-task` and `agent status emit` print one line on stderr when a forced approval is not a review approval (`approved_bound.forced_approval_warning`).
- **Still open.** An unforced `in_progress -> approved` that supplies review evidence, and a forced `done` followed 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](https://github.com/spec-kitty/spec-kitty/issues/6715), Mission `lane-evidence-independence-01M5YHXF`. It extends the `single_branch` axis of [#5939](https://github.com/spec-kitty/spec-kitty/issues/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>`, with `planning_commit_sha` read from `lanes.json` (or derived from git where none was recorded, Amendment 2026-11-05); for a planning lane, `planning_commit_sha..<target branch>`; for `single_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 is `lanes/for_review_gate.status_only_excluded_prefixes`, which the `for_review` gate reads too. Only when that finds nothing, the window `merge-base(dependency lane tip, lane tip)..lane tip` of each dependency lane is read too. A commit later reverted leaves no change and does not count.
- **Independence.** The #5939 identity `tool:model:profile` of the latest implementer and of the latest approver must be provably different. What changed from #5939, for `single_branch` too: 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_confirmed` applies 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 into `approved` or `done` refuses with `REVIEW_NOT_INDEPENDENT` when the approver is not provably independent of a known implementer of record (ruling 7), or when the approval would be recorded as the placeholder `user`; 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 `--agent` out of `in_review` records the full `tool:model:profile` of the review claim, which is also what the approve command printed by `agent action review` carries. `accept` and `consolidate` are strict: an unknown identity is not independent there. `accept`: a hard preflight, whatever `--lenient` says. `consolidate`: at claim time in `reconciliation.build_approved_wp_set`, before any branch moves, so a refused claim prints no "Reconciliation verified" banner. `orchestrator-api consolidate-mission` answers `PREFLIGHT_FAILED` with `data.preflight_error_code` and `data.preflight_error_codes`; `accept-mission` answers `MISSION_NOT_READY` with `data.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) and `EVIDENCE_WINDOW_UNCOMPUTABLE` (`lanes.json` records no planning commit; remedy: re-run `spec-kitty agent mission finalize-tasks`) on lanes, coordination and planning lanes. `single_branch` Missions keep emitting their `SINGLE_BRANCH_*` codes, which mean the same thing.
- **Attestation.** `accept` and `consolidate` take `--attest-no-implementation <WP> --attest-reason "<why>"`. It records a forced operator self-transition with `policy_metadata.attestation = "no_implementation"` and lifts `IMPLEMENTATION_MISSING` for that work package only. A request for a work package whose evidence verdict is `IMPLEMENTATION_UNREADABLE` or `EVIDENCE_WINDOW_UNCOMPUTABLE` is 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). `consolidate` prints `⚠️ <WP>: IMPLEMENTATION_MISSING lifted by operator attestation (<reason>)`. It never lifts any other code.

**Operator rulings** (binding):

1. 2026-10-27: independence keeps the #5939 identity `tool:model:profile` unchanged on every topology. The recorded role is not compared, because it is stamped from the target lane (`claimed` gives implementer; `in_review`, `approved` and `done` give reviewer) and the role segment of `--agent` is discarded.
2. 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.
3. 2026-10-27 (decision `01M5YHYFRJPTE0SQ9V7SWGK26J`): `move-task --force` keeps bypassing the evidence and independence checks at the move. At the move, independence refuses only a positively-same identity on an unforced move into `approved` or `done` (since ruling 7: an identity not provably different); an unknown implementer does not refuse at the move. `accept` and `consolidate` stay strict regardless of `--force` and `--lenient`.
4. 2026-10-27: planning lanes are covered too.
5. 2026-10-27: an attestation counts only while the work package has stayed in `approved` or `done` since it was recorded.
6. 2026-10-29: a generic placeholder approver (no `--agent`, recorded as `user`) is unknown, hence not independent. `move-task` refuses an unforced approval that would record one.
7. 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. `accept` and `consolidate` stay 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 and `move-task`.
8. 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/` and `checklists/` 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_branch` window 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 -> approved` after a forced move into review is not re-checked for evidence at the move, as ruling 3 implies. `accept` and `consolidate` refuse 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.json` predates `planning_commit_sha` refuses with `EVIDENCE_WINDOW_UNCOMPUTABLE` until `finalize-tasks` is re-run. Settled by the 2026-11-05 amendment below (#7209, #7210): plain `finalize-tasks` now derives the missing pin. An approved lane branch that is gone refuses with `IMPLEMENTATION_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 `claude` can 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 pr` passes 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 --verify` exits 1). A ref that exists but cannot be read (a missing object, a corrupt ref, a git error) refuses `IMPLEMENTATION_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 refuses `IMPLEMENTATION_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_UNREADABLE` with that reason.
- **Overlap refusal.** The window holds every work package of the PR, so a work package whose `owned_files` overlap another approved work package's (glob-aware, conservative) is refused `IMPLEMENTATION_UNREADABLE`: the merge alone cannot say which of them made a change there. The remedy is to restore the lane branch from `refs/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) refuses `OWNERSHIP_UNRESOLVED` (`SINGLE_BRANCH_OWNERSHIP_UNRESOLVED` on `single_branch`). It is decided before `IMPLEMENTATION_MISSING`, so that verdict now means only "ownership resolved, no owned change".
- **Not liftable.** `--attest-no-implementation` refuses 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 keeps `IMPLEMENTATION_MISSING`.
- **Contract.** The orchestrator-api `CONTRACT_VERSION` is `1.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-lanes` Mission with no `lanes.json` (the direct-on-target fallback) runs on a synthesized manifest that never carried a pin (#7209). `finalize-tasks` cannot add one once execution has begun.
- A Mission whose `lanes.json` predates the pin (#7210). The named remedy, re-running `finalize-tasks`, kept the pin empty with a warning; `--refresh-planning-commit` recorded 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-tasks` would 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](https://github.com/spec-kitty/spec-kitty/pull/7238) and moved to `lanes/` for #7210, is the only lookup. It walks `--first-parent` (#7238's review found that a plain `git log` can 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's `planning_commit_sha` anchors 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 action `derived`. On a direct history that is the tip a timely finalize would have recorded. A different anchor from `--skip-lanes`, because a Mission with a `lanes.json` was 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's `kept_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 missing `lanes.json` for a wedged Mission, it records the same task-file base as `finalize-tasks` instead 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, reports `lanes_rebuilt_pin_is_target_tip` beside `lanes_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. The `EVIDENCE_WINDOW_UNCOMPUTABLE` recovery names plain `finalize-tasks` and warns against `--refresh-planning-commit`.
- **No migration.** Older Missions are not rewritten: a derived pin is recorded only when an operator runs `finalize-tasks` or `doctor mission-state --fix`, and a `--skip-lanes` base 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-tasks` still refuses it; `doctor mission-state --fix` records the live target tip, so the gate reports `IMPLEMENTATION_MISSING` rather than `EVIDENCE_WINDOW_UNCOMPUTABLE`. That includes the default `single_branch` Mission 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](/adr/4.x/2026-11-06-3-topology-is-settled-once-at-first-finalize.md) makes `single_branch` the size default for small Missions ([#7282](https://github.com/spec-kitty/spec-kitty/issues/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](https://github.com/spec-kitty/spec-kitty/issues/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_branch` carries the head of the Mission write branch (`write_branch_for`) as `policy_metadata.lane_head`. The decision is keyed on the stored topology, never on `is_planning_lane` or `execution_mode: direct_repo`. The planning lane of a `lanes` Mission stays unstamped. `approval_stamp` and `stamp_of` read the stamp unchanged.
- **Tier 1: after the newest approval.** `check_lane` runs unchanged on the Mission branch at claim time. Content committed after the newest approval stamp refuses `LANE_MOVED_AFTER_APPROVAL`.
- **Tier 2: every content commit inside an approval window.** For each approved work package `k`, `O_k` is the stamp on its first non-migration move into `claimed` or `in_progress` (`wp_attribution.approval_window_open_stamp`; a `blocked` move 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 keeps `first_governed_open_stamp`, which counts `blocked`) and `S_k` the stamp on its newest approval. Every content commit in `claim_base..mission_branch` must be reachable from some `S_k` and not from that work package's `O_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 refuses `LANE_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 in `consolidation/write_branch_bound.py`; `approved_bound.py` gains only the public stamp-refusal split and the warnings.
- **The gate re-check.** It reads the Mission branch through the claim's `lane_id -> branch` map, comparing its live tip with the tip validated at claim time, never through `lane-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 recorded `mission_branch` that differs from the target). A default `single_branch` Mission 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-flight `single_branch` Mission refuses `APPROVAL_STAMP_MISSING` after upgrade; `--attest-approved-reviewed <WP> --attest-reason "..."` lifts it per work package. A Mission branch rebased after approval refuses `APPROVAL_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-task` and `agent status emit` print the existing unstamped-approval and forced-approval warnings for `single_branch` Missions too.
- **No contract change.** The codes are reused. `orchestrator-api consolidate-mission` reports these refusals as today's `PREFLIGHT_FAILED` with the code in `data.preflight_error_codes`; no orchestrator-api code is added for this amendment.

**Residuals.** Each stays open.

- **Commit-to-target and direct-on-target `single_branch` Missions 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 missing `O_k` covers every commit before `S_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 old `O_k` is 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-list` to 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-run` residual is corrected: the dry run reports these refusals as `CLAIM_REFUSED_FORECAST` (corpus cells `forecast|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`](/adr/4.x/2026-11-08-2-work-package-windows-are-recorded-at-the-opening-transition.md).

## 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](https://github.com/spec-kitty/spec-kitty/issues/7159).

**Decision** (operator rulings 2026-11-10).

- **The claim records the dispatch-resolved identity.** Both claim emitters of `agent action implement` record 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. `--model` stays refused (#7013); only `--profile`, an Op's profile and the compact `--agent` segments reach the actor. Without `--agent` the fresh lane's claim keeps the generic `implement-command` placeholder: 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 unforced `in_progress -> for_review` submission 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 a `tool:model:profile` identity, so a submission never overrides a segment the claim recorded. Forced moves, seeds and placeholder actors never refine. `move-task` and 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 into `in_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](https://github.com/spec-kitty/spec-kitty/issues/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 of `in_review` records the hop's actor with role `implementer` instead of `reviewer`; 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 `--agent` is 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 bare `claude` claim, a `claude::rev` review claim and an `--as-implementer --agent claude::impl` re-submission leave the record `claude::`, so `claude::rev` is still refused with `REVIEW_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_identities` walks the work package's events once. An unforced `planned -> claimed` claim starts a new cycle; by a placeholder actor (`implement` without `--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 into `claimed`/`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_identity` is the first of these identities.
- **An approval must be independent of every implementer.** `status.independent_of_implementers` applies `actor_identities_independent` to each identity; `move-task`'s approval check and `consolidation.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`) from `move-task`, `agent status emit` and `agent action implement`, naming the `REVIEW_NOT_INDEPENDENT` refusal and the remedy. It is advisory (an event it cannot classify never fails the move) and is left out of `--json` runs, 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's `latest_implementer_event` / `latest_implementer_actor`.

**Residuals.**

- Identities stay self-asserted. `--as-implementer` by 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 `planned` and 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_state` row stamped 06:21 appended after the 06:54 `done` row) is the union merge of two clones' pushes of `status.events.jsonl`; the reducer orders by `at`, so the fold is correct. The coordination status-write guard (#5572) compares one worktree with its own `HEAD` and cannot see a cross-clone race. Tracked under #1795 and #4955, not a `single_branch` gap 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).
