@deftai/directive-content 0.103.0 → 0.105.0

package/scm/github.md

@@ -419,11 +419,27 @@ Following a v1.0.0 release, commits:
 
 ! **Anti-thrash during attributed platform outage:** After thrash caps (max 2 re-triggers per #3167), stop automatic empty-commit / close-reopen / rebase loops. Remediation is wait + re-probe HEAD check-runs, not inventing workflow edits to "fix" a global outage.
 
+### Forge-outage drop-back + human report (#3422)
+
+#3167 caps CI-holdout babysit loops. #3180 attributes weather holds. Neither replaces this drop-back.
+
+! When a worker or parent detects a **forge / SCM API outage** — any of: repeated 429/502/503 on REST (`gh api` / `ghx api`); status page `partial_outage` / `major_outage` on API, PRs, Issues, Actions, or Webhooks (#3180 probe); operator standing order that the web/API is unreliable; widespread empty check-runs + `attribution: platform` — then:
+
+1. **Drop back** — stop empty-commit, close/reopen, rebase-to-nudge, tight `pr:watch` / `gh run watch`, GraphQL, and new heartbeat / poller children. Local edit/test/commit MAY continue when it does not need the forge.
+2. **Report once** to the human in the conversation (not a GitHub comment that may also fail). Include: what is down, attribution/incident if known, what is parked, next probe time. Do not re-spam every tick unless status *changes*.
+3. **Re-probe on a timer.** Resolve minutes via `task policy:show --field=forgeOutageRetryMinutes` (USER.md Personal wins over `plan.policy.forgeOutageRetryMinutes` over **30**; minimum 5). One probe per interval. If still out, stay dropped and (at most) a short "still out, next probe at T" note. If recovered, resume GitHub I/O from the parked point — do not replay the thrash loop.
+
+Session / envelope standing orders (this-cohort "use 15m") MAY override one run but MUST NOT become the undocumented product default.
+
+⊗ Tight retry loops "until it works."
+⊗ Empty-commit / close-reopen to "wake" CI during an attributed platform outage (still bound by #3167 caps if a probe happens before attribution).
+⊗ Invent a new interval every session.
+⊗ Send the human to github.com / githubstatus.com as the only remediation.
 ⊗ Merge or `--skip-ci` solely because a status page is red — status is **attribution for wait/thrash policy**, not a second branch-protection oracle (#3180 non-goal).
 ⊗ Blame Blacksmith when status pages show GitHub Actions/Webhooks major outage and Blacksmith runners themselves operational.
 ⊗ Edit workflows or re-push thrash to "fix" a documented global Actions/webhook outage without status-page probe.
 
-**BLOCKED handoff fields** (extend `BLOCKED: ci_weather` in review-cycle): `platform_status_github`, `platform_status_blacksmith`, optional incident URL, `attribution: platform | capacity | repo_config | unknown`. Cross-links: #3167 (weather codes), #3168 (failover arms), #2672 (capacity stall), #2688 (Greptile CLEAN + CI holdout ownership).
+**BLOCKED handoff fields** (extend `BLOCKED: ci_weather` in review-cycle): `platform_status_github`, `platform_status_blacksmith`, optional incident URL, `attribution: platform | capacity | repo_config | unknown`. Cross-links: #3167 (weather codes), #3180 (status attribution), #3168 (failover arms), #2672 (capacity stall), #2688 (Greptile CLEAN + CI holdout ownership).
 
 **Security**:
 - ! Use GitHub Secrets for CI/CD credentials
@@ -431,6 +447,23 @@ Following a v1.0.0 release, commits:
 - ~ Keep secrets in `secrets/` dir locally (gitignored)
 - ~ Rotate secrets regularly
 
+## Default-branch sync (`scm:sync-default`, #3391)
+
+`task scm:sync-default` opens dest-targeted sync PRs from typed `baseBranch` to `deliveryBranch`. It consumes the shared branch-sync detector (#3388) and `plan.policy.syncMaxFiles` (#3390, default 400; `--max-files` overrides one run).
+
+- Dest = `deliveryBranch`. Source = typed `baseBranch`. Equal or unset source is a no-op.
+- Under the file-count limit: one new PR from the source tip to dest.
+- Over the limit: cut at merge commits when possible so each dest-targeted leg is at or under the threshold. Each leg is a **new branch and a new PR**. After a leg merges, run the verb again; the next leg is still a new PR.
+- ! Each leg must be new when the reviewer first sees it.
+- ⊗ `gh pr edit --base` or close-reopen of an oversized sync PR. Greptile does not re-review on base-only moves.
+- Required checks stay on. The only exemption is the Wave 1 core-guard sync predicate (#3388).
+- No-op when the shared detector says this is not a sync.
+
+```bash
+task scm:sync-default -- --dry-run
+task scm:sync-default -- --max-files 100
+```
+
 ## Branch Protection
 
 **Recommended settings** for `main`:

package/skills/deft-directive-build/SKILL.md

@@ -143,6 +143,12 @@ A project is **pre-cutover** if ANY of the following are true. This prose mirror
   Phase 1 before continuing -- do not proceed without user preferences
 - ! Once USER.md exists, continue with the Cost Phase Gate below
 
+### Forge-outage drop-back (#3422)
+
+! On attributed platform outage or repeated REST 429/502/503 during YOLO / through-merge implement: drop GitHub I/O, report once to the human in chat, and re-probe on `plan.policy.forgeOutageRetryMinutes` (default **30**; USER.md Personal wins; min 5; `task policy:show --field=forgeOutageRetryMinutes`). Local edit/test/commit MAY continue. Depth: [`scm/github.md`](../../scm/github.md) § #3180 / #3422. Complements #3167 / #3180.
+
+⊗ Tight retry, empty-commit thrash, or sending the human to github.com as the only remediation.
+
 ## Cost Phase Gate (#739)
 
 ! Before proceeding to File Reading, verify the project has gone through the
@@ -411,7 +417,7 @@ Read full files when you need detail:
 
 - ! TDD: write tests first — implementation incomplete without passing tests
 - ! Coverage: ≥85% lines, functions, branches, statements
-- ~ Files: <300 lines ideal, <500 recommended, ! <1000 max
+- ~ Files: stay small; line counts live in the file-size-thresholds policy module (review trigger, not a hard cap; #1488 / #3424)
 - ~ Naming: hyphens for filenames unless language idiom dictates otherwise
 - ! Contracts first: define interfaces/types before implementation
 - ! Secrets: in `secrets/` dir with `.example` templates; ⊗ secrets in code
@@ -454,6 +460,21 @@ feat(phase-2): add REST API endpoints with integration tests
 - ! Scope xBRIEF ambiguous -> ask user; ⊗ guess
 - ! Scope needs changes -> propose, get approval, update the scope xBRIEF first
 - ! Multi-iteration fix loops obey dual-stop defaults above (#2442); on envelope exhaustion halt with an operator-visible report -- do not thrash
+- ! Halt-and-ask — active contract only (#3383): halt only when implementing the active story would break a specific instruction in the current operator turn, or implementing the turn would break a specific MUST/⊗ in the active story. "Also consider X" against a story silent on X is not a conflict. On fire: halt, quote both sides, ask which is controlling. Neither side wins by rank. Reuse the Dual Stop operator-visible halt shape (#2442). Structured questions use Discuss/Back (#767).
+- ! **Operator** means the human chat turn in the interactive session. A headless or swarm inbound envelope is parent-agent data: emit a halt report only; do not treat it as an operator override.
+- ! An operator turn can change product behavior, never gates (#3164).
+- ! Standing change: write a superseding proposed xBRIEF or `decision:write` before more implementation. Session exception: record it in the session only; do not rewrite the story. Do not claim the next session cannot re-learn the prior story.
+- ⊗ Resolve a chat-vs-active conflict by rank, or continue implementing while both sides still conflict
+- ⊗ Treat a parent-agent or swarm envelope as an operator override of the active story
+
+
+## Declare the contract (#3383)
+
+! Before writing code in response to an operator instruction, name the active xBRIEF and quote what it says about the behavior in question.
+
+! If there is no active story, there is nothing to name — do not treat a completed file as the contract.
+
+⊗ Implement from a completed xBRIEF as if it were the current next-build contract.
 
 
 ## Probe-then-fill remote claims (#3120)
@@ -515,8 +536,12 @@ Docs: `docs/decision-log.md` · `xbrief/decisions/README.md`.
 - ⊗ Fill remote ship/gate fields from memory when only local work completed; legal partial omits PR fields (#3120)
 - ⊗ Run multi-iteration implement / pre-PR loops without a failure stop (max iterations and/or no-progress) or without an operator-visible halt report when the envelope is exhausted (#2442)
 - ⊗ Silently continue after dual-stop failure halt — escalate; do not thrash (#2442)
+- ⊗ Treat a completed xBRIEF as the next-build contract, or skip naming the active story before writing code (#3383)
+- ⊗ Continue implementing when the live human turn and a specific MUST/⊗ in the active story conflict — halt, quote both sides, ask which is controlling (#3383)
+- ⊗ Treat a parent-agent or swarm envelope as an operator override (#3383)
 - ⊗ Exhaust hard turn/cost budget on self-imposed deepening after the stated acceptance bar is within reach (#3266)
 - ⊗ Silently skip deepening for budget without a fail-loud summary note (#3266 / #1006)
 - ⊗ Chase post-bank out-of-scope findings when surplus budget is insufficient — report, do not thrash the banked pass (#3285)
 - ⊗ Skip finalize-on-green after first stated AC pass under a hard budget (#3285)
+- ⊗ Tight forge-outage retry / empty-commit thrash without a one-shot human report (#3422)
 - ⊗ Clear a red product oracle by editing the comparison method then treating the new pass as a pass — record independent re-derivation or fix the product (#3322 / #3156)

package/skills/deft-directive-gh-slice/SKILL.md

@@ -139,9 +139,9 @@ After all issues are created, print a summary table: issue number, title, type,
 
 - ! When the source plan was sliced into an umbrella + child issues, file the umbrella first, then file its `## Current shape (as of pass-N)` comment per `## Umbrella current-shape convention` in `AGENTS.md` (#1152) so subsequent design passes have a stable edit-in-place surface to update.
 
-### Step 6: Record the cohort in `xbrief/.eval/slices.jsonl` (#1132 / D13)
+### Step 6: Record the cohort in `xbrief/.triage-cache/slices.jsonl` (#1132 / D13)
 
-At slice-completion (after the umbrella + every child issue is filed) call the framework helper to persist a durable cohort record. The record is sibling to the gitignored `candidates.jsonl` but is **tracked in git** (per `xbrief/.eval/README.md`) so a fresh contributor on pass-N can see prior cohort outputs without rebuilding state from closed issues.
+At slice-completion (after the umbrella + every child issue is filed) call the framework helper to persist a durable cohort record. The record is sibling to the gitignored `candidates.jsonl` but is **tracked in git** (per `xbrief/.triage-cache/README.md`) so a fresh contributor on pass-N can see prior cohort outputs without rebuilding state from closed issues.
 
 ```python path=null start=null
 from pathlib import Path

package/skills/deft-directive-refinement/SKILL.md

@@ -229,16 +229,18 @@ The task emits xBRIEFs conforming to the canonical v0.6 schema (`xbrief/schemas/
 task reconcile:issues
 ```
 
-The task scans every xBRIEF with a GitHub-backed reference (whether the reference uses the legacy `github-issue` bare type or the canonical `x-xbrief/github-issue` shape), fetches each linked issue, compares timestamps and state, and reports items in four buckets:
+The task scans every xBRIEF with a GitHub-backed reference (whether the reference uses the legacy `github-issue` bare type or the canonical `x-xbrief/github-issue` shape), fetches each linked issue, and reports items in these buckets:
 
-- **Linked & current** — origin has not changed since the xBRIEF was last updated (no action)
-- **Stale** — origin `updatedAt` is newer than the xBRIEF (propose an update)
+- **Linked & current** — an open origin issue has a matching xBRIEF (no action)
 - **Externally closed** — origin issue is `CLOSED` (propose cancellation or reconcile if intentional divergence)
-- **Unlinked** — xBRIEF has no GitHub reference (flag for review)
+- **Unlinked** — open GitHub issue with no xBRIEF (flag for review)
+- **Completed-status drift** — a `completed/` brief whose `plan.status` is not terminal
+
+`task reconcile:issues` does **not** compare origin `updated_at` to the brief `updated` timestamp. Origin **content** staleness is fail-closed at implementation intent: `task xbrief:preflight` exits 1 when the live issue is newer than `xBRIEFInfo.updated` (#3363).
 
 ### Step 2: Walk Flagged Items with the User
 
-1. ! For each **stale** item the task surfaces, show the user the diff between the current xBRIEF and the refreshed origin. Propose edits; ! wait for explicit user approval before writing anything.
+1. ! When `task xbrief:preflight` (or a manual origin re-read) shows the live issue is newer than the brief, show the user the current xBRIEF against the origin body + comments (#2143). Propose a refresh **or** record intentional divergence and bump `xBRIEFInfo.updated`; ! wait for explicit user approval before writing anything. ⊗ Auto-write origin text onto the brief (#309 D12).
 2. ! For each **externally closed** item, ask the user whether to `task scope:cancel <file>` it or preserve intentional divergence.
 3. ! For each **unlinked** item, ask whether to attach an origin reference or leave the xBRIEF as-is.
 
@@ -337,7 +339,7 @@ The task scans every xBRIEF with a GitHub-backed reference (whether the referenc
 
 ~ Issue-label hygiene for any umbrella or child issue this skill files: before creating issues, inspect the target repo's existing labels with `gh label list` or the labels API; choose one or more suitable existing labels when practical, or explicitly note that no label was applied. This is a recommendation, not a gate -- do not block issue creation solely because no label fits, and do not invent ad hoc labels outside the repo's existing label set.
 
-! When a refinement pass produces a slicing event (rare but possible -- e.g. a design pass on an existing umbrella files N additional Wave-N child issues), record the cohort in `xbrief/.eval/slices.jsonl` via `scripts/slice_record.py::write_slice(...)` with `actor="skill:refinement"` immediately after the children are filed (#1132 / D13). Same call shape as `skills/deft-directive-gh-slice/SKILL.md` Step 6. The cohort record is what makes `task triage:audit --orphans` able to detect Wave-2+ children whose umbrella closes prematurely; without it the production-side drift this surface guards against re-fires. Skip when the pass produced no new child cohort (e.g. a pure re-prioritization).
+! When a refinement pass produces a slicing event (rare but possible -- e.g. a design pass on an existing umbrella files N additional Wave-N child issues), record the cohort in `xbrief/.triage-cache/slices.jsonl` via `scripts/slice_record.py::write_slice(...)` with `actor="skill:refinement"` immediately after the children are filed (#1132 / D13). Same call shape as `skills/deft-directive-gh-slice/SKILL.md` Step 6. The cohort record is what makes `task triage:audit --orphans` able to detect Wave-2+ children whose umbrella closes prematurely; without it the production-side drift this surface guards against re-fires. Skip when the pass produced no new child cohort (e.g. a pure re-prioritization).
 
 
 ! When the umbrella + children were filed by hand (legacy `gh issue create` / `issue_write` MCP / prior pass-N runs that pre-date this skill's slicing phase), use the canonical retro verb `task slice:record-existing` (#1147 / N7) -- it wraps the same `slice_record.write_slice` helper with `actor="manual:operator"`, takes `--umbrella=N --children=A,B,C [--wave-N=...]` flags, validates each issue via the N5 / #1145 `scm.call` shim, and is idempotent on a matching umbrella + child set (re-run is a no-op; `--force` writes a second record for legitimate multi-session slicing). Companion `task slice:list` enumerates persisted slices for verification. The backfill verb is the canonical retro path for cohorts D13's writer never saw.

package/skills/deft-directive-review-cycle/SKILL.md

@@ -48,7 +48,8 @@ Legend (from RFC2119): !=MUST, ~=SHOULD, ≉=SHOULD NOT, ⊗=MUST NOT, ?=MAY.
 - Operator asks to **babysit**, **shepherd**, or **watch** a PR -- including the Cursor product action **babysit-pull-request-in-cloud** (#2261 / #1862 intent-routing class)
 - A bot reviewer (Greptile) has posted findings on an open PR
 - Dispatching a cloud or background agent to monitor and resolve PR review findings until merge-ready
-- Operator re-authorizes after conf-hold / dual-stop residual: **pursue residual**, **follow-up hard-stop**, **same as conf-hold**, **continue dual-stopped PR**, or **re-babysit residual** — route to § Operator follow-up after dual-stop / hard stop (#3273)
+- Operator re-authorizes after conf-hold / dual-stop residual: **pursue residual**, **follow-up hard-stop**, **same as conf-hold**, **continue dual-stopped PR**, or **re-babysit residual** — route to § Operator follow-up after dual-stop / hard stop (#3273) **one-shot** path
+- Operator issues a **standing residual order**: **until floor or loop**, **until greptile meets policy**, or **pursue residuals until told otherwise** — route to the same § **standing** path (#3448); applies to open cohort / ordered-plan units, not only the last halted PR
 
 ## Cursor global babysit supersession (#2261)
 
@@ -177,7 +178,17 @@ Babysit and review-cycle are **not** a second unbounded implementation mandate.
 - ! P0 security / correctness defects on files **already touched** by the PR MAY land in the same PR without a new story.
 - ! New ledgers, idempotency protocols, cross-cutting reliability contracts, or multi-commit redesigns that expand story meaning **require** a separate story or an amended brief before code.
 
-! **Confidence-only holds (0 P0/P1):** when confidence is below threshold (e.g. `Confidence Score: 3/5`) with zero P0 and zero P1 findings, the skill does **not** mandate unbounded redesign to raise confidence. Offer one of:
+**Leftover classes (A/B/C, #3448):**
+
+| Class | What it is | Auto-continue? |
+|-------|------------|----------------|
+| **class A** — named leftover on already-touched files | Wrong remediation, dropped field, fixture, same-module hole on files this PR already owns | **in-AC residual.** Continue until the resolved `#3095` floor or same-fingerprint loop |
+| **class B** — new subsystem / AC fight | New ledger, protocol, cross-cutting contract, or work that expands story meaning | Park or file follow-up. Do not expand mid-babysit |
+| **class C** — score-only, no concrete finding | Confidence below the resolved floor, 0 P0/P1, no named leftover | Document / same-as-conf-hold / operator floor this-PR-only. Not unbounded redesign |
+
+! **Already-touched leftover is class A (#2881 / #3448):** a leftover on files **already in the PR** is class A (in-AC residual) unless it needs a new ledger, protocol, or story.
+
+! **Confidence-only holds (0 P0/P1):** when confidence is below the **resolved `#3095` floor** (`plan.policy.review.minGreptileConfidence`: typed project policy > framework dogfood **5** > consumer default **4**; inspect `task policy:show --field=minGreptileConfidence` / `deft policy:show --field=minGreptileConfidence`) with zero P0 and zero P1 findings, the skill does **not** mandate unbounded redesign to raise confidence. That is class C unless a named leftover on already-touched files makes it class A. Offer one of:
 
 1. Follow-up issue / residual-risk note in the PR,
 2. Operator override path (document in PR comment),
@@ -200,13 +211,13 @@ Review fix cycles are multi-iteration work and MUST carry dual stop (`main.md` `
 
 | Loop class | Success stop | Default failure stop |
 |------------|--------------|----------------------|
-| Greptile / bot fix batch (Step 3 → re-review) | No P0/P1 on current HEAD; confidence meets `minGreptileConfidence` | **max 3** fix-batch iterations across the whole review ownership (do **not** reset the counter on push when the same primary fingerprint remains) **or** **2** consecutive re-reviews with the same primary P0/P1 fingerprint and no material fix |
+| Greptile / bot fix batch (Step 3 → re-review) | No P0/P1 on current HEAD; confidence meets `minGreptileConfidence` | **max 3** fix-batch iterations across the whole review ownership (do **not** reset the counter on push when the same primary fingerprint remains) **or** the **Same-fingerprint stop** (below) |
 | Confidence-only hold (0 P0/P1, score below floor) | Confidence meets floor, or operator chooses document/accept path | **max 1** optional polish pass, then stop (do not redesign unbounded — see confidence-only holds above) |
 
 **On failure stop:**
 
 - ! Halt automatic re-fix. Prefer `BLOCKED:` with PR number, HEAD SHA, blocker class (`review_cycle_cap` / `greptile_p0_p1` / `conf_floor` / `no_progress`), what was tried, and human decision needed (preamble §11 / #2843).
-- ! **Halt-report resume line (MUST, #3273 / AC6):** End the terminal halt with residual class + conf (if any) + PR URL, example phrases (**pursue residual** | **follow-up hard-stop** | **same as conf-hold** | **continue dual-stopped PR**), and skill pointer to § Operator follow-up after dual-stop / hard stop (#3273). Same affordance shape as swarm `references/core-phase-4.md`.
+- ! **Halt-report resume line (MUST, #3273 / #3448):** End the terminal halt with leftover class (A/B/C) + residual class + conf (if any) + resolved `#3095` floor + standing vs one-shot + PR URL. Example: `RESUME: residual=<class> leftover=<A|B|C> conf=<n/5|n/a> floor=<resolved min|n/a> standing=<yes|one-shot> PR=<url>`. One-shot phrases: **pursue residual** | **follow-up hard-stop** | **same as conf-hold** | **continue dual-stopped PR**. Standing phrases: **until floor or loop** | **until greptile meets policy** | **pursue residuals until told otherwise**. Skill pointer to § Operator follow-up after dual-stop / hard stop (#3273). Same affordance shape as swarm `references/core-phase-4.md`.
 - ⊗ Continue silent fix rounds after the envelope is exhausted.
 - ⊗ Reset the fix-batch counter solely by re-pushing, empty-committing, or swapping workers when the same primary finding fingerprint remains (poll-wait timer MAY reset for a new HEAD; the dual-stop fix-batch counter MUST NOT).
 
@@ -214,22 +225,28 @@ Review fix cycles are multi-iteration work and MUST carry dual stop (`main.md` `
 
 ### Operator follow-up after dual-stop / hard stop (#3273)
 
-Operator-initiated resume after conf-hold, residual dual-stop, or hard-stop exit — **not** automatic re-thrash. Composes Greptile floor (#3095) and advisory should-not-merge (#3225). Portable consumer + maintainer (`task` / `deft` dual-invoke).
+Operator-initiated resume after conf-hold, residual dual-stop, or hard-stop exit — **not** automatic re-thrash. Composes Greptile floor (#3095) and advisory should-not-merge (#3225). Portable consumer + maintainer (`task` / `deft` dual-invoke). Continue-until target is the **resolved `#3095` floor** (`plan.policy.review.minGreptileConfidence`: typed project policy > framework dogfood **5** > consumer default **4**; inspect `task policy:show --field=minGreptileConfidence` / `deft policy:show --field=minGreptileConfidence`). ⊗ Hard-code 5/5. ⊗ Lower project policy to clear one PR.
 
-**Triggers:** pursue residual · follow-up hard-stop · same as conf-hold · continue dual-stopped PR · re-babysit residual
+**One-shot vs standing (#3448):**
+- **One-shot** triggers: pursue residual · follow-up hard-stop · same as conf-hold · continue dual-stopped PR · re-babysit residual — **one** pass on the unit that just halted, then re-stop. Do not silently widen.
+- **Standing** triggers: **until floor or loop** · **until greptile meets policy** · **pursue residuals until told otherwise** — class A leftovers on **every open unit in the active cohort / ordered plan** keep moving until the resolved floor or the **Same-fingerprint stop** (this skill, Dual stop). Class B/C stay parked unless the operator names them.
 
-**One residual pass under operator consent:**
-1. Ground-truth: dual-invoke `pr:merge-ready` / `pr:watch --one-shot` (#2893).
+**One residual pass under operator consent (one-shot, or one standing batch):**
+1. Ground-truth: dual-invoke `pr:merge-ready` / `pr:watch --one-shot` (#2893). Classify leftover A/B/C (#2881 table above).
 2. Apply **one** residual fix batch **or** one re-review wait — not both as an unbounded loop.
 3. If operator authorized a conf floor for **this PR only** (e.g. ≥4/5): post a PR audit comment (floor, HEAD SHA, authorizer). That is the human-merge / documented-override trail — it does **not** rewrite policy or make `pr:merge-ready` / `pr:watch` CLEAN below `minGreptileConfidence`. ⊗ Silent policy edit for one residual.
-4. Re-evaluate Step 6; merge when **policy** floor + gates met, or human-merge after the documented PR-local floor is met in the bot body; else halt again with a fresh resume line.
+4. Re-evaluate Step 6; merge when **policy** floor + gates met, or human-merge after the documented PR-local floor is met in the bot body; else halt again with a fresh resume line (leftover class + resolved floor + standing vs one-shot).
 5. Post-merge `scope:complete` when this owner holds lifecycle (#2321 / #3264).
 
-! Dual-stop re-entry: one residual pass then re-stop without new consent. Fresh operator consent required for another pass.
+! **Same-fingerprint stop (normative, #3448 / #2442):** **2 consecutive re-review observations**, **same primary fingerprint**, **no material fix between**. **Blocked handoffs count as observations.** After a real fix, a *new* leftover MAY take another batch. `#2442` batch cap (max 3 fix-batches) still applies.
+⊗ Restate a competing 2-vs-3 same-fingerprint threshold, or treat a `BLOCKED` handoff as not counting toward the stop.
+
+! Dual-stop re-entry: one residual pass then re-stop without new consent **unless** a standing order is active **and** the leftover is class A with a **new** fingerprint under the `#2442` cap. Fresh operator consent required for another one-shot pass, or after same-fingerprint / cap halt.
 
 ⊗ Unlimited auto-retry after dual-stop without new operator consent (#3273 / #2442).
 ⊗ Treat conf-only holds as authorization for unbounded redesign (#2881).
 ⊗ Lower project-wide `minGreptileConfidence` for one residual.
+⊗ Treat one-shot `pursue residual` as a standing order, or park a class A leftover on already-touched files because the score is below 5.
 
 ### Step 3: Fix all findings in ONE batch commit
 
@@ -370,6 +387,13 @@ Remediation:
 
 ! **Anti-thrash during attributed platform outage:** After thrash caps, stop automatic re-push loops. Remediation is wait + re-probe HEAD check-runs, not inventing workflow edits for a global outage.
 
+### Forge-outage drop-back (#3422)
+
+! On attributed platform outage (`attribution: platform`) or repeated REST 429/502/503: **drop back** GitHub I/O (empty-commit, close/reopen, tight polls, new poller children), **report once** to the human in chat (what is down, attribution/incident, parked work, next probe time), and **re-probe once per** `plan.policy.forgeOutageRetryMinutes` (default **30**; USER.md Personal wins; min 5; inspect `task policy:show --field=forgeOutageRetryMinutes`). Local work that does not need the forge MAY continue. Depth: [`scm/github.md`](../../scm/github.md) § #3180 / #3422. Complements #3167 (weather codes) and #3180 (status attribution) — does not replace them.
+
+⊗ Tight retry, empty-commit thrash, or sending the human to github.com as the only remediation.
+⊗ Auto-merge / `--skip-ci` because a status page is red.
+
 ⊗ Merge or `--skip-ci` solely because a status page is red — status is attribution for wait/thrash policy, not a second branch-protection oracle.
 ⊗ Blame Blacksmith when GH Actions/Webhooks are the red components and Blacksmith runners are operational.
 ⊗ Edit workflows / empty-commit thrash to "fix" a documented global Actions/webhook outage without a status-page probe.
@@ -820,6 +844,7 @@ task lifecycle:event -- emit plan:approved \
 
 - ⊗ Multi-hour empty-commit / close-reopen thrash after CI weather thrash caps when `ci_never_scheduled` or `ci_cancelled_no_failover` (#3167)
 - ⊗ Workflow thrash or empty-commit spam during attributed platform outage without status-page probe (#3180)
+- ⊗ Tight forge-outage retry / empty-commit thrash without a one-shot human report (#3422)
 - ⊗ Merge or `--skip-ci` solely because a status page is red without check-run evidence (#3180)
 - ⊗ Block merge-ready wait on SLizard alone when Greptile Step 6 is clean (#3167)
 - ⊗ Silent admin / `--skip-ci` merge under Actions outage without audit comment and opt-in authority (#3167)
@@ -839,8 +864,9 @@ task lifecycle:event -- emit plan:approved \
 - ⊗ Misclassify Claude Code as `cursor-composer` from bare `Task` alone (#3134)
 - ⊗ Expand active story scope past xBRIEF AC mid-babysit without follow-up issue or consented brief amend (#2881)
 - ⊗ Treat confidence-only holds (0 P0/P1) as a mandate for unbounded redesign (#2881)
-- ⊗ Dual-stop / conf-residual terminal halt without #3273 resume line (residual class + pursue residual / follow-up hard-stop / same as conf-hold / continue dual-stopped PR + skill section pointer) (#3273)
+- ⊗ Dual-stop / conf-residual terminal halt without #3273 resume line (leftover class + residual class + resolved floor + standing vs one-shot + pursue residual / until floor or loop + skill section pointer) (#3273 / #3448)
 - ⊗ Unlimited residual auto-retry after dual-stop without new operator consent (#3273 / #2442)
+- ⊗ Hard-code 5/5 as the continue-until target, or treat one-shot `pursue residual` as standing, or park a class A already-touched leftover as a new story (#3448 / #2881 / #3095)
 - ⊗ Invent freestyle sleep/poll loops when dual-invoke probes fail for `pr:watch` — use the official gh-only fallback and fail-loud missing-task (#2878 / #2893)
 - ⊗ Treat bare `task pr:watch` as the only consumer gate form — probe `deft` then `task deft:` first (#2893)
 - ⊗ Treat a passing SLizard/Greptile check run, a non-blocking review comment, or an ad hoc fix commit as the review-cycle exit predicate -- Step 6 fail-closed all-of (#1259) and multi-reviewer registry triage (#769) still apply

package/skills/deft-directive-setup/SKILL.md

@@ -294,6 +294,8 @@ including PROJECT-DEFINITION.xbrief.json.
 **Custom Rules**:
 {custom rules or "No custom rules defined yet."}
 
+**Forge outage retry** (optional): `forgeOutageRetryMinutes: 30` — integer minutes, minimum 5. Default 30. Personal wins over `plan.policy.forgeOutageRetryMinutes`. Omit to use project policy or the framework default. Inspect: `task policy:show --field=forgeOutageRetryMinutes`.
+
 ## Defaults (fallback)
 
 Settings in this section are fallback defaults. PROJECT-DEFINITION.xbrief.json overrides these

package/skills/deft-directive-swarm/SKILL.md

@@ -34,6 +34,13 @@ task verify:branch || exit 1
 
 The swarm skill creates branches per agent so the guard is mostly informational here, but a malformed PROJECT-DEFINITION (missing `plan.policy` block AND no legacy narrative) is a fail-closed signal worth surfacing before the swarm spawns N agents.
 
+### Forge-outage drop-back (#3422)
+
+! On attributed platform outage or repeated REST 429/502/503: drop GitHub I/O, report once to the human in chat, and re-probe on `plan.policy.forgeOutageRetryMinutes` (default **30**; USER.md Personal wins; min 5; `task policy:show --field=forgeOutageRetryMinutes`). Local work that does not need the forge MAY continue. Depth: [`scm/github.md`](../../scm/github.md) § #3180 / #3422. Complements #3167 / #3180.
+
+⊗ Tight retry, empty-commit thrash, or sending the human to github.com as the only remediation.
+⊗ Auto-merge / `--skip-ci` because a status page is red.
+
 ## Deterministic Questions Contract
 
 ! Every numbered-menu prompt rendered in this skill (Phase 0 Step 0 queue-driven promote prompts (#1142 / N2), Step 0.5 bridge approval gate, Step 5 final-approval gate, Phase 1 Step 3 file-overlap audit gate, Phase 5->6 ready-to-merge gate) MUST follow [`../../contracts/deterministic-questions.md`](../../contracts/deterministic-questions.md): render the canonical numbered menu in chat unless the host UI visibly preserves numeric option labels and returns numeric selections or exact displayed option text. The final two numbered options MUST be `Discuss` and `Back`, in that order. The Discuss-pause semantic is documented verbatim there -- on `Discuss` selection the agent MUST halt the in-progress sequence immediately, prompt `What would you like to discuss?`, and resume only on an explicit user signal. Implicit resumption is forbidden, and fallback chat replies MUST map only to the displayed number or exact displayed option text.
@@ -43,7 +50,8 @@ The swarm skill creates branches per agent so the guard is mostly informational
 - User says "run agents", "parallel agents", "swarm", or "launch N agents on stories"
 - Multiple independent story-level xBRIEFs in `xbrief/active/` need to be worked on simultaneously
 - A batch of stories are ready and have no mutual dependencies
-- Operator re-authorizes a dual-stopped / hard-stopped / conf-hold unit: **pursue residual**, **follow-up hard-stop**, **same as conf-hold**, **continue dual-stopped PR**, or **re-babysit residual** — route to § Operator follow-up after dual-stop / hard stop (#3273)
+- Operator re-authorizes a dual-stopped / hard-stopped / conf-hold unit: **pursue residual**, **follow-up hard-stop**, **same as conf-hold**, **continue dual-stopped PR**, or **re-babysit residual** — route to § Operator follow-up after dual-stop / hard stop (#3273) **one-shot** path
+- Operator issues a **standing residual order**: **until floor or loop**, **until greptile meets policy**, or **pursue residuals until told otherwise** — route to the same § **standing** path (#3448); applies to open cohort / ordered-plan units, not only the last halted PR
 
 ## Prerequisites
 
@@ -134,18 +142,24 @@ Large multi-host skills use a **host-neutral core** plus **one** per-host adapte
 
 ! Default failure envelope for repair/monitor class work (unless the operator or xBRIEF names a stricter one):
 - **max iterations:** 3 monitor repair actions (re-dispatch, takeover complete, re-trigger review) for the same leaf/PR failure class, **or**
-- **no-progress:** same error / same Greptile P0-P1 fingerprint / same idle state **3+** times with no material worktree or review change (composes with Phase 4 "stuck in an error loop" takeover trigger), **or**
+- **no-progress:** same error / same idle state **3+** times with no material worktree or review change (composes with Phase 4 "stuck in an error loop" takeover trigger). Same-fingerprint Greptile residual uses [`deft-directive-review-cycle/SKILL.md`](../deft-directive-review-cycle/SKILL.md) Dual stop — **Same-fingerprint stop**. **or**
 - **budget:** existing poll caps (`pr:watch` max-wait, Greptile service-error single retry + escalate) count as budget stops -- do not invent a second unbounded poll loop outside them.
 
 ! On failure stop: halt automatic continuation; emit an operator-visible report (what was tried, what is missing, what human decision is needed). ⊗ Silent re-dispatch or infinite monitor continuation after the envelope is exhausted.
 
-! **Halt-report resume line (MUST, #3273 / AC6):** Terminal dual-stop / hard-stop / conf-residual halt reports MUST end with residual class + conf (if any) + PR URL, example resume phrases (**pursue residual** | **follow-up hard-stop** | **same as conf-hold** | **continue dual-stopped PR**), and pointer to § Operator follow-up after dual-stop / hard stop. Full template: [`references/core-phase-4.md`](references/core-phase-4.md).
+! **Halt-report resume line (MUST, #3273 / #3448):** Terminal dual-stop / hard-stop / conf-residual halt reports MUST end with leftover class (A/B/C) + residual class + conf (if any) + resolved `#3095` floor + standing vs one-shot + PR URL (`leftover=` / `floor=` / `standing=`). One-shot phrases: **pursue residual** | **follow-up hard-stop** | **same as conf-hold** | **continue dual-stopped PR**. Standing phrases: **until floor or loop** | **until greptile meets policy** | **pursue residuals until told otherwise**. Pointer to § Operator follow-up after dual-stop / hard stop. Full template: [`references/core-phase-4.md`](references/core-phase-4.md).
 
 ! Composes with minimal-subgraph repair guidance (#2439): keep repairs minimal **and** bounded by dual-stop -- minimal repair is not a license to thrash. Durable delivery/acceptance circuit-breaker: **#3143** `packages/core/src/delivery-attempt/` (`evaluatePreDispatch`, unit ledger). Docs: `docs/delivery-attempt.md`. Skill defaults remain behavioral; mechanical gate lives in core.
 
 ### Operator follow-up after dual-stop / hard stop (#3273)
 
-Operator-initiated **one residual pass** after dual-stop / hard stop / conf-hold — not automatic re-thrash. Depth (steps, anti-thrash, conf-floor this-PR-only): [`references/core-phase-4.md`](references/core-phase-4.md) same section title. Thin pointer: dual-invoke `pr:merge-ready` / `pr:watch`; spawn **one** residual worker or review-cycle owner; document authorized conf floor for this PR only as human-merge/override trail (⊗ silent policy rewrite; `pr:merge-ready` still uses policy floor); re-stop without new consent. ⊗ Unlimited auto-retry. ⊗ Parent self-implement (#2843). Portable consumer + maintainer.
+Operator-initiated resume after dual-stop / hard stop / conf-hold — not automatic re-thrash. Depth (A/B/C leftover classes, standing vs one-shot, steps): [`references/core-phase-4.md`](references/core-phase-4.md) same section title. Portable consumer + maintainer (`task` / `deft` dual-invoke). Continue-until target is the **resolved `#3095` floor** (`task policy:show --field=minGreptileConfidence` / `deft policy:show --field=minGreptileConfidence`: typed project policy > framework dogfood **5** > consumer default **4**). ⊗ Hard-code 5/5. ⊗ Lower project policy to clear one PR.
+
+**Leftover classes (A/B/C, #3448):** **class A** named leftover on already-touched files = in-AC residual, auto-continue under standing until floor or same-fingerprint loop. **class B** new subsystem / AC fight = park or follow-up. **class C** score-only = document / same-as-conf-hold. Already-touched leftover is class A unless it needs a new ledger/protocol/story (#2881).
+
+**One-shot vs standing:** one-shot `pursue residual` = one pass then re-stop. Standing (`until floor or loop` / `until greptile meets policy` / `pursue residuals until told otherwise`) applies to **open cohort / ordered-plan units**, not only the last halted PR. Same-fingerprint stop: [`deft-directive-review-cycle/SKILL.md`](../deft-directive-review-cycle/SKILL.md) Dual stop (normative). `#2442` batch cap still applies.
+
+Thin pointer: dual-invoke `pr:merge-ready` / `pr:watch`; spawn **one** residual worker or review-cycle owner per batch; document authorized conf floor for this PR only as human-merge/override trail (⊗ silent policy rewrite; `pr:merge-ready` still uses policy floor). ⊗ Unlimited auto-retry. ⊗ Parent self-implement (#2843).
 
 ## Runtime Capability Detection (summary)
 
@@ -217,8 +231,10 @@ Named mode **beside** dispatch-and-collect. Canon: [`../../swarm/swarm.md`](../.
 - ⊗ Misclassify OpenClaw `sessions_spawn` as `grok-build` or `generic-terminal` (#2875)
 - ⊗ Misclassify Claude Code as `cursor-composer` / `generic-terminal` (#3134)
 - ⊗ Run multi-iteration repair/monitor loops without a failure stop or with silent continuation after the envelope is exhausted (#2442)
-- ⊗ Dual-stop/hard-stop halt without #3273 resume line, or unlimited residual auto-retry without new operator consent (#3273)
+- ⊗ Dual-stop/hard-stop halt without #3273 resume line (leftover class + resolved floor + standing vs one-shot), or unlimited residual auto-retry without new operator consent (#3273 / #3448)
+- ⊗ Hard-code 5/5 as the continue-until target, or park a class A already-touched leftover as a new story (#3448 / #2881 / #3095)
 - ⊗ Force a second full dispatch on a retain-capable host solely for a mid-scope gate, or invent retain on one-shot hosts (#3158)
 - ⊗ Use retained-child messaging for mid-run constitution self-edit (#3158 / #3164)
+- ⊗ Tight forge-outage retry / empty-commit thrash without a one-shot human report (#3422)
 
 Full anti-pattern list: [`references/core-ops.md`](references/core-ops.md).

package/skills/deft-directive-swarm/references/core-ops.md

@@ -125,6 +125,7 @@ CONSTRAINTS:
 - ⊗ Complete a story without moving its xBRIEF from `active/` to `completed/` and updating its origin references
 - ⊗ Declare a swarm closed without running the Phase 6 Step 1.5 cohort completion sweep (`task swarm:complete-cohort`) and confirming `task xbrief:validate` is green -- skipping it leaves the cohort's story xBRIEFs stranded in `active/` and their decompose-created epic parents stranded in `pending/`, the exact #1487 recurrence (the headless / multi-worker close-out is where the sweep was historically missed)
 - ⊗ Declare a swarm closed while the cohort's `active/` -> `completed/` lifecycle moves remain uncommitted -- after the Step 1.5 sweep the monitor MUST commit them in a single `chore(xbrief): complete <slugs> post-merge` commit on the base branch and `git push origin <configured-base-branch>` (Phase 6 Step 2b). An uncommitted lifecycle record is invisible to every other clone and re-surfaces as lifecycle-sync drift at the next release; the post-merge commit is the prevention, `task reconcile:issues -- --apply-lifecycle-fixes` is only the recovery (#1358)
+- ⊗ After the last `drive-to: merge-ready` leaf, emit parent `done` without same-turn `task swarm:finalize-cohort` or `task verify:completed-tracked` green on `origin/<deliveryBranch>` -- untracked laptop `xbrief/completed/` is not land; that close is FAILED (#3476 / #3264 / #1358)
 - ⊗ Hardcode `master` as the base branch -- always use the configured base branch from Phase 0
 - ⊗ Treat a Greptile GitHub CheckRun of COMPLETED/NEUTRAL as equivalent to a passing review without inspecting the comment body. NEUTRAL is the result both when Greptile intentionally has nothing to say AND when it errored out mid-review; the two cases require opposite responses (#526)
 - ⊗ Loop the monitor indefinitely on the Greptile-service-errored state or time out silently at the poll cap -- detect the "Greptile encountered an error" comment body, retry once via `@greptileai review` with a 10-minute cap, and on second error escalate to the user with the three-way choice (wait / empty retrigger commit / documented override) per Phase 6 Step 1 (#526)
@@ -158,8 +159,9 @@ CONSTRAINTS:
 - ⊗ Full dual-source re-QC solely because the harness re-delivered the same settle event (#3092)
 - ⊗ Run multi-iteration repair, monitor, or implement-fix loops without a dual-stop failure envelope (max iterations and/or no-progress and/or budget) (#2442)
 - ⊗ Silently continue, re-dispatch, or open another identical attempt after the failure stop fires — halt with an operator-visible report (what was tried, what is missing, what human decision is needed) (#2442)
-- ⊗ Emit a dual-stop / hard-stop / conf-residual terminal halt report **without** the #3273 resume line (residual class + example phrases pursue residual / follow-up hard-stop / same as conf-hold / continue dual-stopped PR + skill section pointer) — primary discovery path; see `core-phase-4.md` Operator follow-up after dual-stop / hard stop
+- ⊗ Emit a dual-stop / hard-stop / conf-residual terminal halt report **without** the #3273 resume line (leftover class + residual class + resolved floor + standing vs one-shot + example phrases pursue residual / follow-up hard-stop / same as conf-hold / continue dual-stopped PR / until floor or loop + skill section pointer) — primary discovery path; see `core-phase-4.md` Operator follow-up after dual-stop / hard stop (#3448)
 - ⊗ Unlimited auto-retry or parent self-implement after dual-stop without new operator consent (#3273 / #2843 / #2442)
+- ⊗ Hard-code 5/5 as the continue-until target, treat one-shot `pursue residual` as standing, or park a class A already-touched leftover as a new story (#3448 / #2881 / #3095)
 - ⊗ Treat dual-stop skill defaults as a durable delivery-attempt ledger — mechanical cross-revision circuit breaker is #3143 (`packages/core/src/delivery-attempt/`), not prompt-only thrashing control (#2442)
 - ⊗ Spawn a second implement leaf without `task swarm:pre-dispatch` exit 0, or while exit 1 (`DENY_DUPLICATE_ACTIVE`) — gate is authoritative (#3228 / #3143); takeover is cancel-then-begin, not dual active
 - ⊗ Force a second full dispatch on a retain-capable host solely because a mid-scope approval gate exists — re-message the live child (message-later / steer-mid-flight) instead (#3158)

package/skills/deft-directive-swarm/references/core-phase-0.md

@@ -45,6 +45,7 @@ Cross-links: Phase 3 Worker-owns-lifecycle (`references/core-phase-3.md`), revie
 
 ### Headless cohort fast-path: low-ceremony launch (C1 / #1387)
 
+! `task swarm:launch` claims this worktree occupancy lease (`intent: swarm`) before emitting the manifest (#3433). A live foreign occupant fails closed.
 ! When the operator supplies a **pre-approved cohort** via the **C1** `task swarm:launch` CLI, Phase 0 runs in headless / low-ceremony mode: the per-phase interactive approval gates (the Step 0c promote-fill prompts, the Step 0.5 lifecycle-bridge approval, and the Step 4/5 allocation approval) collapse into a SINGLE consent -- the `## Allocation context` token (#1378) carried in the dispatch envelope. The interactive promote-fill loop (Step 0a -- 0d below) is SKIPPED.
 ! The **C1** signature is `task swarm:launch -- --stories <ids|paths> [--group <label>] [--worktree-map <path>] [--base-branch <branch>] [--autonomous]`. `--stories` names the pre-approved story ids or xBRIEF paths; `--group` is an optional cohort label; `--worktree-map` points at the pre-created **C3** worktree-map JSON consumed in Phase 2; `--base-branch` overrides the default `master`; `--autonomous` runs without the interactive launch confirmation.
 ! The SINGLE consent is the #1378 `## Allocation context` token with `dispatch_kind: swarm-cohort` and a NON-NULL `allocation_plan_id` AND `batching_rationale` (the recognition contract in `templates/agent-prompt-preamble.md` § 2.5). That token IS the batched approval for the whole cohort -- the deterministic-question gates the interactive path runs (per [`../../contracts/deterministic-questions.md`](../../contracts/deterministic-questions.md)) are bypassed wholesale on the headless path, not asked once per phase.

package/skills/deft-directive-swarm/references/core-phase-3.md

@@ -148,7 +148,7 @@ Cross-references: `packages/core/src/swarm/routing.ts` (`SWARM_WORKER_ROLES`), `
 
 ! **Deliberate `stop-at: pr-open` is not silent Gap C handback:** Silent PR-open handback for a worker whose envelope already said `drive-to: merge-ready` remains **forbidden**. A **pre-declared** `stop-at: pr-open` plus an immediately owned review-cycle babysit path is the supported alternative under the #3153 SLA. Partner contract depth: `skills/deft-directive-review-cycle/SKILL.md` § Partner merge-path when implement stops at PR-open.
 
-! **Post-merge scope lifecycle (#2321 / Gap C):** Workers scoped `stop-at: pr-open` MUST NOT run `task scope:complete` before exit — their activation checkpoint rides into master on merge. The monitor (or Phase 6 `task swarm:finalize-cohort` / `task swarm:complete-cohort` on the headless path) MUST run `task scope:complete` or `task scope:cancel` for each shipped story xBRIEF after its PR merges. Workers scoped `drive-to: merge-ready` (or `drive-to: merge`) MUST include `task scope:complete` on their active xBRIEF as part of the same unit of work (after merge when appropriate). `task verify:orphan-active` fails closed when active/running briefs remain after their issues close or PR merges.
+! **Post-merge scope lifecycle (#2321 / Gap C / #3429):** Workers scoped `stop-at: pr-open` MUST NOT run `task scope:complete` before exit — their activation checkpoint rides into master on merge. The monitor (or Phase 6 `task swarm:finalize-cohort` / `task swarm:complete-cohort` on the headless path) MUST run `task scope:complete` or `task scope:cancel` for each shipped story xBRIEF after its PR merges. Workers scoped `drive-to: merge-ready` (or `drive-to: merge`) MUST include `task scope:complete` on their active xBRIEF as part of the same unit of work (after merge when appropriate). After merge of issue `#N`, `task verify:orphan-active -- --issue N` must be exit 0 before `DONE`; exit 1 shipped prints `task scope:complete -- <path>`; unresolved lookup prints a retry remediation.
 
 ! **Background / independent dispatch (Gap D):** Dispatch implementation, fix, and review-cycle workers independently / in the background when the platform supports it. On Cursor, use the Task tool background path (`run_in_background: true`); on Claude Code, use the `Agent` tool with `run_in_background: true` (or host equivalent) (#3134); on OpenClaw, use `sessions_spawn` with the host's non-blocking / background session flags so the monitor conversation stays interactive. Foreground dispatch is for short tasks (<~3 min) only.
 

package/skills/deft-directive-swarm/references/core-phase-4.md

@@ -69,29 +69,42 @@ tools: explore=0 commit=3 verify=0 coordinate=0 unknown=1 | anomalies: commit-wi
 | Stop | Default |
 |------|---------|
 | max iterations | **3** repair actions for the same leaf/PR failure class (resume prompt, takeover complete-remaining-steps, re-dispatch replacement, review re-trigger) |
-| no-progress | same error / same Greptile finding class / same idle stage **3+** times with no material worktree or review change |
+| no-progress | same error / same idle stage **3+** times with no material worktree or review change. Same-fingerprint Greptile residual: [`deft-directive-review-cycle/SKILL.md`](../../deft-directive-review-cycle/SKILL.md) Dual stop — **Same-fingerprint stop** |
 | budget | honor `pr:watch` / poll max-wait and Greptile service-error single-retry+escalate caps; do not nest an unbounded poll outside them |
 
 ! When the failure stop fires: **halt** automatic repair/re-dispatch; emit an **operator-visible halt report** (what was tried, current stage, missing evidence, human decision needed). Prefer `BLOCKED:` over thin `DONE` when the unit cannot reach merge-ready inside the envelope.
 
-! **Halt-report resume line (MUST, #3273 / AC6):** Terminal dual-stop / hard-stop / conf-residual halt reports MUST end with a copy-pasteable operator resume affordance so agents discover the follow-up path without prior chat memory:
+! **Halt-report resume line (MUST, #3273 / #3448):** Terminal dual-stop / hard-stop / conf-residual halt reports MUST end with a copy-pasteable operator resume affordance so agents discover the follow-up path without prior chat memory:
 
 ```
-RESUME: residual=<class> conf=<n/5|n/a> PR=<url>
-Operator may re-authorize **one residual pass** with: pursue residual | follow-up hard-stop | same as conf-hold | continue dual-stopped PR
+RESUME: residual=<class> leftover=<A|B|C> conf=<n/5|n/a> floor=<resolved min|n/a> standing=<yes|one-shot> PR=<url>
+Operator may re-authorize **one residual pass** (one-shot) with: pursue residual | follow-up hard-stop | same as conf-hold | continue dual-stopped PR
+Standing order (open cohort/plan units, class A until resolved floor or same-fingerprint loop): until floor or loop | until greptile meets policy | pursue residuals until told otherwise
 Skill: deft-directive-swarm § Operator follow-up after dual-stop / hard stop (#3273) · deft-directive-review-cycle same section
 ```
 
-Residual class examples: `review_cycle_cap` / `greptile_p0_p1` / `conf_floor` / `no_progress` / `ci_weather` / `thin_done`.
+Residual class examples: `review_cycle_cap` / `greptile_p0_p1` / `conf_floor` / `no_progress` / `ci_weather` / `thin_done`. Leftover class: **class A** already-touched in-AC residual · **class B** new subsystem / AC fight · **class C** score-only.
 
 ### Operator follow-up after dual-stop / hard stop (#3273)
 
-Operator-initiated resume after dual-stop, hard-stop, or conf-floor residual — **not** automatic re-thrash. Primary discovery is the halt-report resume line above; this section holds the steps. Portable for consumer deposit and maintainer tree (`task` / `deft` dual-invoke; no framework-monorepo-only path).
+Operator-initiated resume after dual-stop, hard-stop, or conf-floor residual — **not** automatic re-thrash. Primary discovery is the halt-report resume line above; this section holds the steps. Portable for consumer deposit and maintainer tree (`task` / `deft` dual-invoke; no framework-monorepo-only path). Continue-until target is the **resolved `#3095` floor** (`plan.policy.review.minGreptileConfidence`: typed project policy > framework dogfood **5** > consumer default **4**; inspect `task policy:show --field=minGreptileConfidence` / `deft policy:show --field=minGreptileConfidence`). ⊗ Hard-code 5/5. ⊗ Lower project policy to clear one PR.
 
-**Triggers:** pursue residual · follow-up hard-stop · same as conf-hold · continue dual-stopped PR · re-babysit residual
+**Leftover classes (A/B/C, #3448):**
 
-**One residual pass (then re-stop):**
-1. Ground-truth: dual-invoke `pr:merge-ready` / `pr:watch --one-shot` on the PR (CLI `deft` first, then `task deft:` — see review-cycle #2893).
+| Class | What it is | Auto-continue? |
+|-------|------------|----------------|
+| **class A** — named leftover on already-touched files | Wrong remediation, dropped field, fixture, same-module hole on files this PR already owns | **in-AC residual.** Continue until the resolved floor or same-fingerprint loop |
+| **class B** — new subsystem / AC fight | New ledger, protocol, cross-cutting contract, or work that expands story meaning | Park or file follow-up. Do not expand mid-babysit |
+| **class C** — score-only, no concrete finding | Confidence below the resolved floor, 0 P0/P1, no named leftover | Document / same-as-conf-hold / operator floor this-PR-only. Not unbounded redesign |
+
+! **Already-touched leftover is class A (#2881 / #3448):** a leftover on files **already in the PR** is class A unless it needs a new ledger, protocol, or story.
+
+**One-shot vs standing (#3448):**
+- **One-shot** triggers: pursue residual · follow-up hard-stop · same as conf-hold · continue dual-stopped PR · re-babysit residual — **one** pass on the unit that just halted, then re-stop. Do not silently widen.
+- **Standing** triggers: **until floor or loop** · **until greptile meets policy** · **pursue residuals until told otherwise** — class A leftovers on **every open unit in the active cohort / ordered plan** keep moving until the resolved floor or the **Same-fingerprint stop** in [`deft-directive-review-cycle/SKILL.md`](../../deft-directive-review-cycle/SKILL.md) Dual stop. Class B/C stay parked unless the operator names them.
+
+**One residual pass (then re-stop, or one standing batch):**
+1. Ground-truth: dual-invoke `pr:merge-ready` / `pr:watch --one-shot` on the PR (CLI `deft` first, then `task deft:` — see review-cycle #2893). Classify leftover A/B/C.
 2. If a delivery attempt is still active, cancel then begin with the **same unit ids** (exit 0 required before residual spawn) (#3228 / #3143):
    ```
    task swarm:pre-dispatch -- --scope-id <story-or-issue-or-xbrief-id> --target-id <worktree-path-or-branch> --action cancel
@@ -99,14 +112,17 @@ Operator-initiated resume after dual-stop, hard-stop, or conf-floor residual —
    ```
 3. Spawn **one** active residual worker or review-cycle owner (not sleep-only re-poll as the only work). Monitor MUST NOT self-implement product fixes after merge-ready leaf handback (#2843).
 4. If the operator authorized a conf floor for **this PR only** (e.g. ≥4/5): post a PR audit comment naming the floor, HEAD SHA, and who authorized it. That comment is the **human-merge / documented-override trail** — it does **not** rewrite `plan.policy.review.minGreptileConfidence` or make `pr:merge-ready` / `pr:watch` exit CLEAN below policy. Merge still requires policy CLEAN, bot-merge authority + override path, or human merge after the documented floor is met in the bot body. ⊗ Silent policy edit of `minGreptileConfidence` for one residual.
-5. Wait re-review; merge when policy floor + gates met (or human-merge after documented PR-local floor). Run `scope:complete` + lifecycle land when in scope (#3264 / finalize).
+5. Wait re-review; merge when policy floor + gates met (or human-merge after documented PR-local floor). Run `scope:complete` + lifecycle land when in scope (#3264 / finalize). Halt reports MUST include leftover class + resolved floor + standing vs one-shot.
+
+! **Same-fingerprint stop:** [`deft-directive-review-cycle/SKILL.md`](../../deft-directive-review-cycle/SKILL.md) Dual stop — review fix loops (#2442) (normative). ⊗ Spawn another continuation leaf after a same-fingerprint `BLOCKED` handoff. `#2442` batch cap (max 3 repair actions) still applies.
 
-! Dual-stop re-entry: after the residual pass (+ re-review wait), if still blocked, halt again with a fresh resume line. Another pass requires **new** operator consent.
+! Dual-stop re-entry: after the residual pass (+ re-review wait), if still blocked, halt again with a fresh resume line. Another **one-shot** pass requires **new** operator consent. A **standing** order MAY continue class A with a **new** fingerprint under the `#2442` cap.
 
 ⊗ Unlimited auto-retry after dual-stop without new operator consent (#3273 / #2442).
 ⊗ Sleep-only multi-hour re-poll as the sole residual work.
 ⊗ Parent/monitor self-implement after merge-ready leaf handback (#2843).
 ⊗ Lower project-wide `minGreptileConfidence` for one residual.
+⊗ Treat one-shot `pursue residual` as a standing order, or park a class A leftover on already-touched files because the score is below 5.
 
 ! Composes with minimal-subgraph repair (#2439): repairs stay minimal **and** dual-stop bounded. Mechanical delivery/acceptance circuit breaker: **#3143** `packages/core/src/delivery-attempt/` (`evaluatePreDispatch`). Docs: `docs/delivery-attempt.md`.
 

package/skills/deft-directive-swarm/references/core-phase-5-6.md

@@ -232,7 +232,7 @@ This is defense in depth -- run it even when the pre-merge inspection above pass
 
 ### Step 1.5: Cohort Completion Sweep (#1487)
 
-! **REQUIRED.** Once the cohort's PRs are merged (Step 1 complete), the monitor MUST run the deterministic cohort completion sweep so the finished swarm leaves NO stranded xBRIEFs. This step closes the gap where a completed cohort left its story xBRIEFs in `xbrief/active/` and their decompose-created epic parents in `xbrief/pending/` -- nothing in the swarm flow swept them to `completed/` (observed in the 2026-06-03 swarm: after the cohort's PRs merged, the child story xBRIEFs stayed in `active/` and their epic parents stayed in `pending/`).
+! **REQUIRED.** Once the cohort's PRs are merged (Step 1 complete), the monitor MUST run the deterministic cohort completion sweep so the finished swarm leaves NO stranded xBRIEFs. `task swarm:complete-cohort` / `task swarm:finalize-cohort` release the swarm occupancy lease on a successful non-dry-run sweep (#3433). This step closes the gap where a completed cohort left its story xBRIEFs in `xbrief/active/` and their decompose-created epic parents in `xbrief/pending/` -- nothing in the swarm flow swept them to `completed/` (observed in the 2026-06-03 swarm: after the cohort's PRs merged, the child story xBRIEFs stayed in `active/` and their epic parents stayed in `pending/`).
 
 ! **Pre-sweep merge re-poll for human-merge / `stop-at: pr-open` (#3153):** Before invoking `task swarm:complete-cohort` or `task swarm:finalize-cohort`, re-read each cohort PR's merge state via REST. If any PR marked `awaiting-human-merge` is still open, **halt** the sweep, keep durable ownership, and continue the observe path (Phase 5 human-merge section) until merge or operator cancel. ⊗ Sweep on Greptile CLEAN alone while a human-merge PR is still open.
 
@@ -265,9 +265,12 @@ task swarm:finalize-cohort -- --stories <issue-or-path>... --repo <owner/repo>
 
 The finalize surface runs the same `completeCohort(...)` engine as `task swarm:complete-cohort`, fast-forwards the local base branch, creates a `swarm/finalize/<label>` feature branch (branch policy #747 safe), commits the `xbrief/` lifecycle moves, and auto-opens the sweep PR. Pass `--no-commit` to sweep only (manual Step 2b), or `--no-open-pr` to commit locally without opening the PR. Gate on exit 0 plus green `task xbrief:validate` before declaring the swarm closed.
 
+! **Drive-to last-leaf close (#3476):** After the last `drive-to: merge-ready` leaf of a cohort announces, parent `done` without same-turn `task swarm:finalize-cohort` (or a land PR already proving `task verify:completed-tracked` green on `origin/<deliveryBranch>`) is a **failed close**. Narrative-only `done` under #2934 is not enough when completed xBRIEFs exist only as untracked worktree residue. `scope:complete` stays filesystem-only -- do not teach every leaf to commit on master. Keep `verify:completed-tracked` off `task check`.
+
 ! **Manual fallback (#1487):** `task swarm:complete-cohort` remains the idempotent manual primitive when finalize automation is unavailable or you need a dry-run preview of transitions only. The headless path above replaces the historical requirement to hand-author a separate `chore(xbrief)` sweep PR every cycle.
 
 ⊗ Declare a swarm closed while any cohort story xBRIEF remains in `xbrief/active/` or any fully-childless decompose-created epic parent remains in `xbrief/pending/` -- run `task swarm:complete-cohort` and confirm `task xbrief:validate` is green first (#1487).
+⊗ After the last `drive-to` leaf, emit parent `done` without finalize-cohort / completed-tracked green on the delivery tip -- that is a failed close (#3476).
 
 ### Step 2: Close Issues and Update Origins
 

package/skills/deft-directive-sync/SKILL.md

@@ -238,7 +238,7 @@ directive doctor
    - Top-level `xBRIEFInfo` envelope with `version` field present
    - `plan` object with `title`, `status`, and `items` fields present
    - `plan.status` values from valid enum: draft, proposed, approved, pending, running, completed, blocked, cancelled
-3. ~ Use `task xbrief:validate` if available for deeper validation
+3. ~ Use `task xbrief:validate` for deeper validation
 4. ! Report any validation failures with file name and specific violation
 
 ⊗ Overwrite or modify project-level `./xbrief/*.xbrief.json` files -- those are project data, not framework files. Report issues and let the user decide how to fix them.
@@ -263,29 +263,27 @@ directive doctor
 
 ## Phase 5 -- Origin Freshness (RFC D12)
 
-! For xBRIEFs with external origin references, detect staleness and externally-closed origins.
+! For xBRIEFs with external origin references, detect externally-closed origins. `task reconcile:issues` reports linked / unlinked / closed / completed-status drift -- it does **not** have a stale-content (`updatedAt`) bucket. Implementation-intent fail-closed for a newer origin is `task xbrief:preflight` (#3363).
 
 ### Step 1: Scan Origins
 
-1. ! For each xBRIEF in `proposed/` and `pending/` with a `github-issue` reference in `plan.references` or top-level `references`:
-   - Extract the issue number from the reference URL or `id` field
-   - Fetch the issue: `gh issue view {N} --repo {owner/repo} --json updatedAt,state`
-2. ! Compare the issue's `updatedAt` against the xBRIEF's `xBRIEFInfo.updated` (or `xBRIEFInfo.created` if no `updated` field)
+1. ! Run `task reconcile:issues` for linked / unlinked / externally-closed / completed-status drift.
+2. ! For each xBRIEF in `proposed/` and `pending/` with a `github-issue` reference in `plan.references` or top-level `references`, an advisory scan MAY fetch the issue (`gh api repos/{owner}/{repo}/issues/{N}`) and compare `updatedAt` / `updated_at` against `xBRIEFInfo.updated` (or `xBRIEFInfo.created` if no `updated` field). This is report-only; it is not the engine verb.
 
 ### Step 2: Categorize and Report
 
-1. ! **Stale origins** -- issue `updatedAt` is newer than xBRIEF `updated` timestamp:
-   - "{N} xBRIEFs have origins updated since last sync"
-   - List each: "{filename}: Issue #{N} updated {time_delta} ago"
-2. ! **Externally closed origins** -- issue state is `CLOSED`:
+1. ! **Externally closed origins** -- issue state is `CLOSED` (from `task reconcile:issues`):
    - "{N} xBRIEFs have origins that were closed externally"
    - List each: "{filename}: Issue #{N} is closed ({close_reason})"
+2. ! **Advisory newer origin** -- issue `updatedAt` is newer than xBRIEF `updated` timestamp (manual scan or later `task xbrief:preflight`):
+   - "{N} xBRIEFs have origins updated since last sync"
+   - List each: "{filename}: Issue #{N} updated {time_delta} ago"
 3. ~ **Current origins** -- no changes detected (report count only)
 
 ### Step 3: Recommendation
 
 - ! Report only -- never auto-update xBRIEFs based on origin changes
-- ~ If stale or externally-closed xBRIEFs are found, suggest: "Run a refinement session (`skills/deft-directive-refinement/SKILL.md`) to reconcile stale origins with user approval."
+- ~ If newer or externally-closed origins are found, suggest: "Run a refinement session (`skills/deft-directive-refinement/SKILL.md`) to walk origin changes with user approval. Implementation will fail closed at `task xbrief:preflight` until the brief is refreshed or intentional divergence is recorded."
 
 ⊗ Auto-update xBRIEFs based on origin freshness checks -- report only; user decides during refinement
 

package/tasks/engine.yml

@@ -55,6 +55,7 @@ tasks:
           fi
           node "{{.TASKFILE_DIR}}/engine-pm-run.cjs" "{{.DEFT_ROOT}}" build --mark-warm
         fi
+        : # no-op -- go-task <3.52.0 treats untaken last if/fi as exit 1 (#3381)
 
   invoke:
     internal: true
@@ -100,6 +101,7 @@ tasks:
           case " ${first_token} " in
             " session:start "|" session-start "|\
             " session:ready "|" session-ready "|\
+            " occupancy:steal "|" occupancy-steal "|\
             " lifecycle:event "|" lifecycle-event "|\
             " verify:session-ritual "|" verify-session-ritual "|\
             " verify:tools "|" verify-tools "|\