Choose how a registered assignment is withdrawn from its source

[fveracoechea]

Question

How is a registered assignment withdrawn from its source, and what happens to its attempt, its landed commit, its dependents, and the gates that wait on every assignment of the source?

Context

Graduated from the fog of Map the integrated pull request workflow.
Choose how a source is registered from a parent issue, decision 15, refuses a recorded item that a new read does not find, and it left withdrawal open.
The branch review of ADR 0017 waits until every executable code assignment of the source is accepted, so an item that is no longer wanted holds the publish of the source for ever.
A withdrawn item can be in any state: registered, claimed, awaiting review, accepted with a landed commit, invalidated, or paused.
Settle who may withdraw (a person, through the tracker or through an approval), which states allow it, how a landed commit leaves the integration branch (the rewrite of ADR 0020), what its dependents do, and how the tracker records it.

[fveracoechea]

Resolution: a person withdraws an item through the tracker, and a landed commit leaves the branch by a rewrite

Resolved in one grilling round and one round of leanings between a grilling sub-agent and the main agent.
The user delegated the human side of this map to the main agent, with the instruction to decide from ~/OPINIONS.md.
These are Operator decisions that quote ~/OPINIONS.md or an ADR where one applies.
They are not human answers.
Round 1 answers: Q1 A, Q2 A, Q3 B, Q4 A, Q5 A, Q6 A, Q7 A.
The round 2 leanings were challenged in five points, and the main agent confirmed each one, including the one new command operator work take-out.

Facts this decision rests on

• Verified: the assignment states are registered, claimed, awaiting-review, rework, paused, invalidated, and accepted, and none of them is a withdrawal (modules/crew-state/assignment.ts:17-25).
• Verified: a claim starts an active attempt in the same change (modules/crew-state/claims.ts:76-88), and an attempt ends only at submission, acceptance, or replacement (submission.ts:279, acceptance.ts:322, acceptance.ts:359, dispatch-replace.ts:254).
• Verified: a pause is released only by the acceptance of the corrected result (modules/crew-state/invalidate.ts:252-287).
• Verified: the frontier treats only accepted as a satisfied dependency (modules/crew-state/frontier.ts:88).
• Verified: the removal gate reads "the assignment is accepted" (modules/crew-state/cleanup-remove.ts:161-165).
• Verified: there is no rewrite command. The rewrite of ADR 0020 runs inside operator work accept, at the acceptance of the correction (docs/adr/0020-...md:36-41).
• Verified: ADR 0011 orders recovery, then conversation, then a pipeline step, then a launch (docs/adr/0011-...md:9).
• Verified: ADR 0006 line 18 puts scope outside delegated authority.
• Decided, not built: the tracker read of ADR 0016, the landing and rewrite of ADR 0020, and the gate of ADR 0021.

Decisions

Who withdraws, and the signal

1. The tracker is the one signal. A person removes the sub-issue from its parent. The next work register --plan reports each recorded item that the read does not find as a withdrawal, with its state and its recorded landing. The approval bound to the registration plan revision covers it, as for decisions 13 and 14 of ADR 0016. No new approval action exists. Source: ADR 0016 "Only a new registration reads the tracker again", and "One concept, one rendering".
2. A closed item is not a signal. A recorded item that the read finds closed, while it is not in accepted completion, refuses and is named, with the hint "remove it from its parent to withdraw it, or reopen it". Source: ADR 0016 line 33 (Operator also closes the issues it completes), and "Two update paths drift".
3. Only a person withdraws. An Operator decision cannot withdraw, because scope is outside delegated authority (ADR 0006 line 18).

When it is allowed

4. Every state, with no active attempt. Withdrawal is allowed in every state. The plan refuses, and names the attempt, while any attempt is active: the producer attempt, a rework or invalidation cycle attempt, an attempt of a result review of the item, or an attempt of a branch review whose snapshot holds its commit. The rule is one test on the recorded attempts, not a list of states. Source: ADR 0010 (closure follows a durable handoff), and "Less is more".
5. No unsettled effect. The plan refuses, and names the effect, while a tracker step, a landing or rewrite intent, or a gate run of the item has no recorded outcome. Source: ADR 0011, "recovery comes before" new work.
6. Dependents. The plan refuses unless each recorded dependent of a withdrawn item, in any source, is withdrawn in the same read or no longer names it as a blocker. Dropping the blocker is a changed item under ADR 0016 decision 14, so only a dependent with no attempt can do it. The refusal names each dependent and each blocking link. A cross-source dependent is settled first, by a registration of its own source.

What is recorded

7. A terminal state withdrawn. It never unblocks a dependent. The attempts, submissions, reviews, findings, invalidations, and planning record stay. The open cycle, the open invalidation, the open direction request, and each review of the item that no attempt holds close in the same change. A registered branch review whose snapshot holds a withdrawn commit, and that no attempt holds, closes too, and it is not a reported round.
8. No tracker write. The person's removal is the tracker record. Crew state records the withdrawal with the registration plan revision that the approval names. Source: "Less is more".
9. A re-added issue refuses. A withdrawn issue that is added to its parent again matches the recorded item by its database id, so it refuses and is named. A new sub-issue carries the work. Source: ADR 0016 decision 14, the same rule for an item that has an attempt.

A landed commit

10. Take-out by the ADR 0020 rewrite, with an empty replacement. The branch is rebuilt in the same order without every withdrawn commit of the source that it still holds. Each later commit lands again if its patch is equal, no result it depends on was taken out, and it passes the project gate at its new place (ADR 0021). The branch moves once, from the recorded tip. A withdrawn commit inside a published range refuses and names the pull request, as every rewrite does.
11. A later commit that fails a test. A later accepted commit is taken out and returns to awaiting-review, not to paused, because no correction will come to release a pause. Its acceptance is taken again as an ordinary landing: an equal patch lands with no new review, and a changed patch or a failed gate becomes an integration cycle. A later commit that is not accepted, such as an invalidated one, keeps its state.
12. The command. operator work take-out <source> performs the take-out. crew next offers it as the pipeline action take_out_commit, ahead of accept_assignment of the same source, so a landing is not gated twice. It uses run_gate for the rebuilt range, and it refuses with the gate blockers of ADR 0021 until the plan passes. An interrupted move is recovered by settle_landing, because it is a rewrite intent.
13. The frontier waits for the take-out. While a take-out of a source waits, the frontier offers no production assignment of that source, with a new blocker take_out_pending that names the withdrawn commits. So no dispatch base holds a commit that no assignment owns.

Effects on other gates

14. Write-path hold. It ends at withdrawal for an item that has no commit on the branch, and when the take-out moves the branch for an item that has one. A later commit that the take-out removes leaves accepted completion, so it holds its paths again under the existing rule.
15. Branch review. The condition is "every executable code assignment that is not withdrawn is accepted". The acceptance, the withdrawal, or the take-out that makes the condition true registers the branch review in the same change. A take-out after a branch review gives a new head, so the next branch review counts toward the limit of three, like any head change.
16. Cleanup. A withdrawn attempt is removed like a superseded one, with no commit proof, because its record stays and its attempt branch survives removal. The removal gate reads "accepted or withdrawn". Closure is unchanged, because decision 4 means every attempt handed over or was replaced.

Scope

17. Withdrawal of a whole source is out of scope. A ticket source is its own parent, and a parent with no sub-issues refuses (ADR 0016 line 29), so this path cannot withdraw every item. The destination runs one approved source to its pull request, so it needs no abandonment.

Points confirmed by the main agent

1. There is no rewrite command to reuse. The rewrite runs inside operator work accept. A take-out in that command would record an outcome that is not accepted completion. A take-out in the registration would make the registration move a branch, which ADR 0016 and ADR 0020 forbid. So the take-out needs one new command, operator work take-out <source>. Its parts are all the rewrite of ADR 0020, so the only new code is the command, the action, and the empty replacement.
2. The take-out is a pipeline step, not recovery. ADR 0011 keeps recovery for an unsettled effect, and a pending take-out has none. Order alone does not stop a dispatch, because the frontier is the only dispatch rule (ADR 0004). So decision 13 adds a frontier blocker, and decision 12 puts the action ahead of the landings of the source.
3. A branch review in flight. The leanings did not cover a branch review that is claimed when a landed commit is withdrawn. Its report would name a head that can never be published, and it would use one of the three rounds. So decision 4 refuses while that attempt is active, and decision 7 closes an unclaimed one.
4. A later commit that is not accepted. "Returns to awaiting-review" is right only for an accepted later commit. An invalidated later commit keeps its state, so decision 11 says so.
5. ADR 0010 is a clarifying amendment. Its line 20 asks for a proof only for an accepted result, so no sentence was false. The amendment is kept because the code gate changes and a reader must see why a withdrawn attempt needs no commit proof.

Rejected

• A withdrawal command with no tracker change. The next read still finds the issue, so the tracker and the crew state hold two structures ("Two update paths drift").
• "Closed as not planned" as a second signal. "Closed" has two writers, and one signal is less to keep correct.
• An Operator decision to withdraw. Scope is outside delegated authority (ADR 0006).
• Recording at once and letting the active attempt run to a handoff that registers nothing. It adds a "do nothing" branch to submit and to the review report, and a dead writer leaves an attempt that nothing ends.
• Stopping a writer with no handoff. It widens closure (ADR 0010), and termination belongs to process closure.
• Withdrawal of registered items only. Started work could never be dropped, and the branch review would wait for ever.
• A cascade to every dependent. Operator would withdraw items that the tracker still lists.
• A withdrawn dependency that counts as satisfied. The integration base never holds the commit, and a planning dependent would get no planning record (ADR 0019).
• A new blocker dependency_withdrawn that only a person clears. It is a second clearing path beside the tracker.
• A revert item for a landed commit. The pull request holds a commit and its revert, and every reader reads the change twice.
• A landed commit left on the branch. It breaks "one commit for each accepted code result" (ADR 0015).
• Deleting the rows of a withdrawn assignment. It deletes the history that ADR 0008 keeps.
• A withdrawal record beside the existing state. It is a second place to read, and a reader that forgets it treats a withdrawn item as live.
• A tracker comment, or an Operator close as "not planned". It is a new tracker step that repeats the tracker, or an issue state that the person did not choose.
• A take-out inside work accept, or inside the registration. Point 1 above.
• A take-out ordered as recovery, with no frontier blocker. Point 2 above.
• A production dispatch from a tip that still holds a withdrawn commit. Its result could use code that the take-out removes, and the fault shows only at its gate run.
• A re-added issue that returns to registered. It is a second way back for one item, and decision 14 of ADR 0016 already sends changed work to a new sub-issue.
• Withdrawal of a whole source in this map. The destination does not need it, and it touches the branch, the gate checkout, and cleanup, which other decisions own.

ADR outcome

• No new ADR. Each trade-off has a home: the signal, the refusals, the dependents, the record, the tracker, and the re-add rule go in ADR 0016, and the take-out goes in ADR 0020.
• ADR 0016 is amended, not superseded. Line 53 ("A recorded item that the read no longer finds is refused") reversed into the withdrawal rule. The Consequences sentence about withdrawal is replaced, and seven rejected options are added.
• ADR 0020 is amended. A new paragraph describes the take-out and its command, and two rejected options are added.
• ADR 0004 is amended. The hold ends at withdrawal, a withdrawn commit on the branch holds until the take-out, and the frontier offers no production work of the source while a take-out waits. One rejected option is added.
• ADR 0017 is amended in two sentences: the condition excludes withdrawn work, and a withdrawal or a take-out can register the branch review.
• ADR 0010 is amended in one sentence, as a clarification (point 5).
• Not amended: ADR 0008, 0011, 0015, 0019, 0021. The reasons are in adr.md.
• The amendment passes the three tests:
  • It is hard to reverse, because a new terminal state, a new command, a new action, and a new blocker enter the durable unions of ADR 0011 and the state migration.
  • It is surprising without context, because a removed sub-issue changes the integration branch, and a running Operative is not stopped.
  • It is a real trade-off, against a command with no tracker change, a cascade, a satisfied blocker, a revert item, and a stop with no handoff.
• The exact old and new text is in adr.md.

Glossary

• Add Withdrawal, after Invalidated result.
• Sharpen Integration branch (a rewrite can take a withdrawn commit out), Crew frontier (no production work while a withdrawn commit is on the branch), and Worktree removal (a commit of a withdrawn assignment needs no proof).
• Avoid "cancel", "drop", "descope", "abandon", and "revert" for a withdrawal.
• Do not add "Take-out" or "Withdrawn assignment".
• The exact text is in context.md.

Consequences for other tickets

• Choose how the integrated pull request is opened and linked:
  • A withdrawn commit inside a published range refuses, as every rewrite in a published range does. That ticket owns what follows.
  • A source whose executable code items are all withdrawn has an integration branch with no commit. Publish must refuse it, or report that there is nothing to publish.
  • The pull request body lists only accepted commits, so a withdrawn item does not appear.
  • Decision 8 depends on the precondition that a code ticket completes only after its commit reaches the target branch. Then a closed code ticket is always inside a published range, and its withdrawal refuses. If that ticket closes a code ticket at acceptance, a closed ticket can name a commit that a take-out removed, and that ticket must decide what the tracker then says.
  • The publish half of the new crew next actions must keep take_out_commit ahead of publish, because publish reads the branch review of the exact head.
• Choose who integrates accepted commits (closed, recorded in ADR 0020): the IntegrationBranch.plan change kind rewrite takes an empty correction. This is a build note, and no decision changes.
• Choose the gate at every commit of the integration branch (closed, recorded in ADR 0021): a take-out is a gate run subject of the kind "one place in a rewrite". No decision changes.
• Choose where review looks (closed, recorded in ADR 0017): the branch review condition and its registration change as decision 15 records.
• Choose the preservation proof for cleanup after integration (closed, recorded in ADR 0010): a withdrawn attempt is removed like a superseded one.
• Choose how the frontier holds overlapping write paths (closed, recorded in ADR 0004): the hold ends at withdrawal, and the frontier gets the blocker take_out_pending.
• Choose how a source is registered from a parent issue (closed, recorded in ADR 0016): decision 15 is now the withdrawal rule.

Map changes

• No new ticket.
• Fog: nothing in "Not yet specified" is cleared or added. The fog item "The new crew next actions for publish" stays. The integration half now also has take_out_commit and the blocker take_out_pending, both settled here.
• Out of scope: withdrawal of a whole source. A ticket source is its own parent, and a parent with no sub-issues refuses, so the path of this decision cannot withdraw every item. The destination runs one approved source to its pull request and needs no abandonment.

Assets

The ADR and glossary text are in the draft pull request docs: record the decisions of the integrated pull request map, commit dab5edc.

Build notes for the specification

• The build starts with a reproduction, per the user's instructions: register a map source, remove one sub-issue from the parent, and show that the next registration refuses the source for ever and that the branch review never registers.
• modules/crew-state/assignment.ts:17-25 gains withdrawn. Each reader that switches on the state must handle it. The frontier (frontier.ts:163), the dependency gate (frontier.ts:88), and the removal gate (cleanup-remove.ts:161-165) are the first three.
• The registration plan lists each withdrawal with its state, its recorded landing, and the later commits that a take-out will rebuild, read from crew state with no Git read.
• take_out_commit, take_out_pending, and the refusal names of decisions 2, 4, 5, 6, and 9 are new members of the durable unions of ADR 0011.
• skills/operator/REGISTRATION.md says how to withdraw an item: remove the sub-issue from its parent, and wait until no attempt of it runs. skills/operator/ names operator work take-out in the topic that covers landings.
• Each test must fail when its rule is deleted ("Confirm a test can fail"): an active attempt refuses, a dependent with an attempt refuses, a closed unaccepted item refuses, a re-added issue refuses, a take-out moves the branch once, a later accepted commit with a changed patch returns to awaiting-review, and the frontier withholds production work of a source whose take-out waits.