@deftai/directive-runtime 0.126.0-beta.1 → 0.126.0-beta.3

package/UPGRADING.md

@@ -695,9 +695,10 @@ After Wave 8, live deft gates run through the TypeScript engine. **The consumer
 
 ## From v0.53.0–v0.53.1 → v0.53.2 (vitest no longer discovers vendored framework tests, #1878)
 
-- **Applies when (historical):** projects that used **vitest** on v0.53.0 / v0.53.1 when a copied deposit still vendored framework `*.test.ts` / `*.spec.ts` under a legacy install tree. Detection then: vitest discovered ~80+ framework tests via its default include glob and CI failed with `ERR_MODULE_NOT_FOUND` for `@deftai/core`. Current OVPR installs do **not** copy a `.deft/core/` deposit — this bucket is archaeology for mid-upgrade PRs still on those versions.
-- **Safe to auto-run:** Yes on current tip. Prefer leaving the legacy deposit era entirely:
-- **Commands (current):**
+- **Applies when:** historical — projects that used **vitest** on v0.53.0 / v0.53.1 when a copied deposit still vendored framework `*.test.ts` / `*.spec.ts` under a legacy install tree. Detection then: vitest discovered ~80+ framework tests via its default include glob and CI failed with `ERR_MODULE_NOT_FOUND` for `@deftai/core`. Current OVPR installs do **not** copy a `.deft/core/` deposit — this bucket is archaeology for mid-upgrade PRs still on those versions.
+- **Safe to auto-run:** Yes on current tip. Prefer leaving the legacy deposit era entirely.
+- **Restart required:** No.
+- **Commands:**
   - `npm i -g @deftai/directive@latest` then `directive upgrade` (or `directive install --repair` when the pin should stay)
   - Interim manual workaround **only if you are mid-upgrade on a still-red historical v0.53.0/v0.53.1 PR that still has a copied deposit**: exclude the legacy deposit path from vitest, then re-run CI:
 

package/commands.md

@@ -10,16 +10,18 @@ Legend (from RFC2119): !=MUST, ~=SHOULD, ≉=SHOULD NOT, ⊗=MUST NOT, ?=MAY.
 
 ## Overview
 
-The active implementation is xBRIEF lifecycle first and Taskfile first:
+The active implementation is xBRIEF lifecycle first and Taskfile first, with `directive` / `deft` as the primary command surface (#4229; Taskfile / `task deft:<verb>` remains an optional parallel include after init):
 
 ```mermaid
 flowchart LR
-    Proposed["proposed scope"] -->|"task scope:promote"| Pending["pending scope"]
-    Pending -->|"task scope:activate"| Active["active scope"]
-    Active -->|"task scope:complete"| Completed["completed scope"]
+    Proposed["proposed scope"] -->|"deft scope:promote"| Pending["pending scope"]
+    Pending -->|"deft scope:activate"| Active["active scope"]
+    Active -->|"deft scope:complete"| Completed["completed scope"]
 ```
 
-`task --list` is the authoritative command index. This file explains the main command families, the agent slash-command surface, and the older `/deft:directive:change` folder workflow that remains as historical/compatibility guidance.
+The CLI commands listing prints every registered verb (see `directive --help`). After an include-only root Taskfile exists, `task --list` also shows `task deft:<verb>` aliases. This file explains the main command families, the agent slash-command surface, and the older `/deft:directive:change` folder workflow that remains as historical/compatibility guidance.
+
+`xbrief:preflight` stays a when-invoked implement lock (not an unconditional host mutation interceptor). Missing go-task stays `#3335` impact=none when gates are CLI-dispatchable; doctor/session may print `status=Taskfile-unavailable; CLI-supported`.
 
 ---
 
@@ -442,7 +444,7 @@ After CLI/deposit upgrade, disk can show the new generation while a long-lived s
 - ! Default interactive sessions to **read-only posture** until mutation or implementation intent (questions, research, Plan Mode, ticket-shaping). Load AGENTS.md / main.md / USER.md / PROJECT-DEFINITION; confirm alignment with addressing-name; ⊗ do not write `.deft/ritual-state.json`, run install/build side effects, or emit triage welcome, branch-policy, default-branch sync, sync-skill lifecycle checks, or eval/value readback writes unless the operator asks or the task is implementation-ready.
 - ! **USER.md path (#2544):** resolve via `deft session:start` output (`USER.md resolved …`); default platform paths: Windows `%APPDATA%\deft\USER.md`, Unix `~/.config/deft/USER.md`; override `$DEFT_USER_PATH`; workspace `<project>/.deft/USER.md`. ⊗ Invent or search `~/.config/deft` on Windows — AppData Roaming is canonical.
 - ! At mutation boundaries (code-writing, scope lifecycle moves, `start_agent`, commits, pushes, PR-from-local-changes, release work): run the mutable quick tier then gated verifier below before proceeding.
-- ! **Identity-only + product mutation (#4544):** on the session-routing else-branch (`else main → USER → PROJECT-DEFINITION; ~ sync` then Mutation → `deft session:start`), when live PROJECT-DEFINITION is identity-only (empty `plan.items` and no convention-valid lifecycle scope) AND the live request has product mutation intent, join existing setup Phase 3 Starting-new / Rapid BEFORE that mutation `session:start`. After Phase 3 confirmation: write confirmed `plan.narratives.Overview` (Light narrative merge or an explicit Overview patch before render; Rapid Strategy Gate STOP must not skip that write) plus one `xbrief/proposed/` draft that carries the live request's requirement list through Rapid Step 3 and #3267 capture. Process-only stays an explicit exit. ⊗ Add `session:start --prompt`. ⊗ Auto-write `xbrief/active/` — promote and activate stay the existing verbs. Unmanaged header one-liner is placeholder-only compare-and-set from user-confirmed Overview (not a prompt interpolator; not identity source of truth). Handback reports the actual lifecycle outcome (`proposed <path>`, Process-only, or product-write-with-no-brief as a gate anomaly). Resolve the rapid compose pointer through `contentRoot` / the consumer deposit path. Under rapid, if this session changed product files and no brief exists, `deft check` reports the verify:ac soft-skip as a named warning.
+- ! **Identity-only + product mutation (#4544):** on the session-routing else-branch (`else main → USER → PROJECT-DEFINITION; ~ sync` then Mutation → `deft session:start`), when live PROJECT-DEFINITION is identity-only (empty `plan.items` and no convention-valid lifecycle scope) AND the live request has product mutation intent, join existing setup Phase 3 Starting-new / Rapid BEFORE that mutation `session:start` (identity-only must not suppress Phase 3 when product mutation is requested; #4229). After Phase 3 confirmation: write confirmed `plan.narratives.Overview` (Light narrative merge or an explicit Overview patch before render; Rapid Strategy Gate STOP must not skip that write) plus one `xbrief/proposed/` draft that carries the live request's requirement list through Rapid Step 3 and #3267 capture. Process-only stays an explicit exit. ⊗ Add `session:start --prompt`. ⊗ Auto-write `xbrief/active/` — promote and activate stay the existing verbs. Unmanaged header one-liner is placeholder-only compare-and-set from user-confirmed Overview (not a prompt interpolator; not identity source of truth). Handback reports the actual lifecycle outcome (`proposed <path>`, Process-only, or product-write-with-no-brief as a gate anomaly). Resolve the rapid compose pointer through `contentRoot` / the consumer deposit path. Under rapid, if this session changed product files and no brief exists, `deft check` reports the verify:ac soft-skip as a named warning.
 - ? Explicit read-only alignment only: `deft session:start --read-only` (no ritual-state write). Task: `task session:start -- --read-only`.
 - ? Tracked docs/requirements without a story xBRIEF: `deft session:start --posture=requirements` (occupancy claimed; no gated ritual). Token is `requirements`; `docs` remains assist/scratch. Unknown --posture tokens refuse and print the closed set (owner: packages/core/src/session/posture.ts). Forge-only (#4020) is no-ingest with dest worktree permitted -- not a tree-write posture.
 - ! **Worktree occupancy contract (#3433 / #3604 / #3611 / #3926):** mutation `session:start` / `session:ready` claim a gitignored `.deft/occupancy.json` lease. Occupancy is cooperative host-session routing between processes that follow the protocol, not authentication against another same-user process: hook JSON and local owner IDs are forgeable. Name it for what it is (#3755): a **cooperative bearer-id boundary, not a lineage** — the lease admits whoever presents an id the record itself names, nothing observes parentage, and a dispatched child is admitted only because a grant records it. A live lease allows only a matching presented owner or member and a ritual state whose exact verified owner agrees; missing, conflicting, or mismatched identity fails closed. `--read-only` does not claim. A stored lease whose `worktree_path` is not this checkout is residue, not a holder: first mutation `session:start` claims over it. Same-tree two-session conflict still fails closed.
@@ -616,6 +618,7 @@ Directive does not guess your mix. Either you name the next units in order (**or
 
 ### Triage Tasks
 
+- **Planning order (#5716):** triage write-back → arc or recorded `design-critique: not warranted, because …` → `issue:ingest` → scope. Sole skip is the recorded not-warranted line; silence is not a skip.
 - `task triage:bootstrap -- [--repo OWNER/NAME] [--limit N] [--state {open|closed|all}] [--batch-size N] [--delay-ms N]` -- seed the local triage cache and audit layer.
 - `task triage:evaluate -- <N...> [--concurrency N] [--repo OWNER/NAME] [--json]` -- Stage A isolated issue-eval (#3648). Detached `origin/master` worktrees own validity; the parent owns WIP census (`xbrief/active`, `xbrief/pending`, `plan-sequence`); GitHub REST owns open PRs/issues. Verdicts land under `.deft-scratch/issue-eval/<sha12>/<invocation-id>/`. No GitHub writes. Fan-out default 4. Value may set `critique-recommend:`; it must not emit `design-critique: warranted | not warranted, because …`. Decisions stay existing `triage:*` verbs.
 - `deft triage:queue --limit=10 [--author LOGIN|@me]` -- show ranked candidate work from cache-backed state. Optional `--author` / `--author-mine` filters to cache `author.login` (exact match; `@me` resolves via authenticated `gh`; comma allow-list; missing author disclosed as unknown) (#3129 / #1318 Layer 1). When the cache is empty, auto-populates from GitHub first (#2575) — do not conclude "nothing to do" from xBRIEF folders or live `gh issue list` alone (#2576).

package/contracts/design-critique.md

@@ -13,6 +13,11 @@ This contract scaffolds the motion. Only the ADR-005 judgment gate and the conte
 - ⊗ Pin this contract or `skills/deft-directive-design-critique` into `templates/agents-entry.md` or the AGENTS.md always-pin list. Discovery is on-demand via the Skills Index.
 - ⊗ Auto-dispatch critics from this contract (#3578 / #1702). Operator (or parent after an operator verb) dispatches the next envelope from the brief template.
 
+### Pre-ingest recommendation (#5716)
+
+Before `issue:ingest` for every GitHub issue, run the design-critique arc or record `design-critique: not warranted, because …`. ADR-005 is unchanged: no auto-dispatch, no engine refusal of unarced work. The ingest advisory is exit 0 and never blocks. This scaffolds the recommendation; content-contract tests lock the skip-form string. Discovery stays on-demand (no always-pin of this skill or contract path). Issue-less scopes use `## No-issue target archive (#5486)` — this GitHub ingest advisory does not extend there.
+
+
 ### The arc
 
 **An arc is one recorded motion over one target revision**, from the Stop 1 write-back (or a voluntary dispatch) through accepted synthesis or the halt line. It holds one or more rounds, and therefore one or more ceilings. An arc is per-target, not per-issue: one issue carries several arcs over time, and one arc can span several issues.
@@ -138,6 +143,15 @@ After Handoff, Stop 2 evaluation does not re-select charter from the issue body
 
 Default motion after a mechanism-shaped stamp: fresh open critique. N=1 (and N≥3 when recommend says so under panel permission) only after a resolved `n=` token, a recorded ask-answer, or a recorded `spend-recommend:` resolve. If residual remains, one reiterating pass with a fresh critic that reads a disagreement map, then verified synthesis. Resume is optional sharpening ("does my prior finding still hold"), not the default reiterating agent. A permitted N≥3 does not change that default; the parent records the spend when it uses the permission after parseOperatorSpend, an ask-answer, or a panel-permission-lawful `spend-recommend: N≥3`.
 
+### Target-kind (#5486)
+
+**Target-kind** is what durable identity the arc binds (`issue` | `xbrief` | `envelope-file`). It is orthogonal to `### Target shape` (set-level / against-implementation) and does not select charter or spend.
+
+- ! Record `Target-kind:` on the lean when the target is not a GitHub issue. Default remains `issue`.
+- ! Target-digest hashes canonical target bytes for that kind (REST issue body, xBRIEF file bytes, or envelope-file bytes). Protocol / gate / chip state stays outside digested bytes.
+- ! Envelope-file targets need durable bytes before Stop 1.
+- ⊗ Treat Target-kind as a Target shape row or a charter/spend row.
+
 ### Target shape
 
 Charter is what the critic is given. **Target shape is what is being critiqued.** The two are independent axes, and target shape selects neither the charter nor the spend, so it is not a row in either table above.
@@ -205,6 +219,21 @@ The three tokens are the blocking, sharpening, and footnote classes `walk all` a
 
 The injection / swarm lens is a triggered MUST: it fires only on those target changes. The reviewer-catch rule is a prohibition, not a required recital. Road-not-taken and steelman are SHOULD, and fire only on a real fork.
 
+### Ceiling-kind (#5486)
+
+**Ceiling-kind** names how same-round isolation is frozen:
+
+| Ceiling-kind | Form |
+|---|---|
+| `comment-id` | GitHub comment id (existing issue path) |
+| `dispatch-sha-outbox-manifest` | dispatch-sha + parent-written outbox manifest (stage-(0) file-path) |
+
+- ! Stage-(0) file-path admits `PostconditionArtifactClass` `file-path` at the panel-handback caller (`panel-handback-acceptance.ts`). Obligation fields bind target-id/path; `issueNumber` is optional/N/A. Verdict returns non-numeric `boundArtifactId` alongside `boundCommentId`.
+- ! Construct the outbox-manifest artifact in stage (0); do not defer to archive stage (b). Parent-collected exclusive-create per-seat outboxes feed the retained archive.
+- ! Comment-id path stays unchanged. Do not weaken the GitHub-issue arc path.
+- ⊗ Use bare file existence or chat-success as dispatch proof.
+- ⊗ Fake 8+ digit local ids that collide with GitHub. Chosen local id-model is composite `arc-post:<n>` (published before parser accept).
+
 ### Envelope and ceiling
 
 The envelope is [`templates/design-critique-brief.md`](../templates/design-critique-brief.md). Fill fields. Do not copy rule bodies from this contract into the envelope.
@@ -733,7 +762,7 @@ Closed cite forms on the successor lean (no third coverage-map type):
 
 - `relieves: P1` / `relieves P1`
 - `does-not-relieve: P1`
-- `operator-deferred: P1 #4377` / `operator-deferred: P1 issue 4377`
+- `operator-deferred: P1 #4377`; leftover brief cites `operator-deferred: P1 plan-id github.issue.123` / `operator-deferred: P1 path xbrief/proposed/example.xbrief.json` / `operator-deferred: P1 issue 4377`
 
 Uncited ids and `does-not-relieve` stay residual headings (`unrelieved-pain`). Unknown ids and conflicting dispositions fail closed as `malformed-pain`. `operator-deferred` must cite a **different** issue id; same-number leftover is `unrelieved-pain`, not yolo-confirmable leftover, and is halt or a later lean that binds relief, without ingest clearance.
 
@@ -801,3 +830,12 @@ This motion ingests untrusted issue threads by design.
 ## Test surface
 
 `packages/core/src/content-contracts/standards/design_critique_contract.test.ts` locks required pointer strings, the scaffolds framing, the comment-lead field as model then role from the closed set (not an issue label), the operator-gated loop (successor lean, operator verbs including walk / walk all, dual stop, halt line, exclusive remaining-set replace of the three catalog chips, #3640 auto-stamp on a non-empty all-accept map and no-stamp on stubs, first-lean recording obligation after this round's siblings are posted), the parent-side substantiation token and independence rules, the Stop 1 exclusion (pre-critic premises outside the trigger) and `refutation-target:` field tokens rather than full body sentences, the composed auto-bind conjunct (all-accept map AND zero unresolved audit markers) at Operator verbs and Bind path 1, the variant-table evaluation rule (charter selection and spend permission evaluated independently), the critic-method heading and distinctive obligation tokens (exact class tokens, citations-are-claims, existing mechanisms, injection / swarm trigger nouns, failed-reviewer phrase, finding anatomy) rather than full body sentences, the brief-template forbidden-inputs list, and the thin router skill (existence, line cap, pointer resolution, no-normative-content). `evaluateParentAudit` locks the omission failure modes. This suite locks the SoT MUST and the thin skill pointer for the first-lean recording obligation, including the auto-stamp operator-confirm conjunct and the no-bind-while-unposted-same-round-siblings rule. `evaluateCompletedArcRecord` locks ingest on the completed-arc record rather than a catalog chip. It does not fail-close live parent turns. `packages/core/src/design-critique/citation-grammar.test.ts` locks the `## Citation grammar` closed set, the refused positions, and the diagnostics surface; `packages/core/src/design-critique/completed-arc-record.test.ts` locks one parser for both questions, set membership against the latest lean, and the observation-echoing block details (#3831). Runtime parent-turn detection only if `evaluateParentAudit` is extended; that extension is not required to ship the recording obligation. Panel completeness is locked as contract text only. No predicate observes it on a live arc (#3850). N≥2 round-1 ceiling is the post-panel-deposit snapshot; Envelope Id ceiling stays authoritative; deposit/envelope mismatch is a finding, never a re-ceiling (#4435). Completeness stays unobservable to round-1 critics even with the deposit in envelope. Decomposition MUST plus multi-pointer forbid are locked as contract text; no new grammar and no new evaluator. `evaluatePanelSeatComposition` locks claimed-family composition and PATH paste-ready-first; it is a fixture over claimed families, not a live sibling-count gate, and it does not observe launchability. `evaluateN3LaunchProbe` locks the N≥3 launch-probe fixture: critic argv class with bypass flags, the existing benign pong, no envelope path, amend-spend or dispatch-fail on miss, and no new halt token (#4432). Does not close #3850. `### The arc` and its derived boundaries, the `### Target shape` axis with its twice-run caveat, and the two bind-path-2 non-empty refusals are locked as contract text (#3797). `## Plain-language summary` is locked the same way: the contract test pins the heading token, the MUST-not-SHOULD reasoning, the ADR-006 exemption and its limit, the non-normative marking, and the per-artifact reserved line-start matrix, and `packages/core/src/design-critique/reserved-line-starts.test.ts` exercises each of the five families on each artifact kind against the exported shape predicates and `evaluateCompletedArcRecord`. `packages/core/src/design-critique/handoff.ts` locks `evaluateHandoffPrint`, `evaluateDualStopReservedSlot`, and `postHandoffStop1Writeback`. Do not add `reframe-needed` to `evaluateCompletedArcRecord`. Do not halt Dual-stop on invariant-set equality. `evaluateCompletedArcRecord` observes presence-only `## In plain English` on `citedLeanId` + `synthesisCommentId` (#5415); closed reason `missing-plain-english`. A pointer-only Bound-remedy or comment-id summary is a published miss and stays unobserved by that presence check; both artifacts state the problem then the accepted solution in ordinary language, including auto-posted synthesis-accepted; the thin skill names `## Plain-language summary` and keeps `Plain English first in main-chat` as the widget surface; ingest-open protocol and "Ingest may proceed" stay off this heading. Content-contract tests lock those sentences. No prose-quality parser (#4309). `### Verified-claims table heading`, the closed reason vocabulary, and the re-measured line-start matrix are locked as contract text, and `completed-arc-record.test.ts` exercises the typed refusal partition: the two states, details that differ by more than the id, the untyped null table id, and the seven recorded live arc table ids (#3942). `### Run posture` and `parseOperatorRunPosture` / `evaluateDirectDispatch` lock the closed-token front door, the missing-token ask including yolo, the `session:start --read-only` start verb, stdin posting, SHA-pinned reads, and the no-worktree direct panel; `run-posture.test.ts` exercises those fixtures. `### Spend` and `parseOperatorSpend` / `evaluateSpendRecord` lock the closed-token spend front door, the missing-token ask including yolo, numeric-only resolved tokens, bare panel as ask, colliding classes as ask, Stop 1 `spend-ask: resolved|asked`, and that grok-bot detect does not default spend; `spend.test.ts` exercises those fixtures. Live parent turns stay unenforced (#4705). Does not close #3846. `evaluateCompletedArcRecord` ignores `arc-mode:` (#4072). Yolo standing confirm of a posted all-accept map, the disagree/defer-set refusal, word-boundary parse on the operator chat utterance, and that yolo-confirm is not ingest are locked as contract text plus content-contract tests; live parent turns stay unenforced (#4308). `evaluateAutoStampPath1Write` locks the lean-cite-only unpublished path-1 candidate, the full pain-coverage reason set, skip of ingest-ready remaining-set when path-1 is refused, and that `autoStamp: true` does not return empty verbs when Handoff applies (#4592). English-heading critic after the bind lean with no operative field refuses `writePath1` as `unresolved-pain-audit` (#4648). `packages/core/src/design-critique/leftover-pain.ts` locks yolo leftover-path recommendation, leftover issue-create recording, remainder continue, finish-still-possible, cite honesty and placement, pain-audit follow-through, Dual-stop posts-not-seats default 6 for spend N=1, and asserted reserved-slot coverage (#4593). Pain-audit dispatch fill of operative `audit-targets:` (ids or none), English Pain-audit headings are not targeting, later-arc critic after the bind lean id, footnote-only follow-through is not clearance, and that `buildPainCoverageDeposit` JSDoc does not recut the asserted-marker conjunct (#4648). Dual stop Fingerprint composition with #3448, the Parallel fingerprint working default that no comparable fingerprint exists for a parallel round, and that marker clearance has no verdict field are locked as contract text plus parent-audit tests (#4442). Yolo first-lean cites under standing (#4811) are locked as contract text plus the thin skill pointer: honest pain cites on the bind-capable first all-accept lean, no free-English intermediate hatch, uncited first map stays Handoff, do not recut evaluateHandoffPrint, pain-audit brief after operative first relieves while Dual-stop numbered or reserved slot remains, and Mid-arc EXIT does not default to operator next-envelope after that lean. Live parent turns may stay unenforced. Dual-stop raise stays a raise.
+
+## No-issue target archive (#5486)
+
+When no GitHub issue exists, the durable arc record is a parent-owned ordered archive under a main-checkout-resolved root (`.deft/design-critique/archive`), keyed by target-id + arc-id. Dest-relative `.deft-scratch` is staging only, not archive root. Sidecar mirrors are optional with published read precedence; never two live SoTs. Machine-local / single-operator is the supported durability tier; cross-machine replication is deferred. Single-machine no-Issues consumers may use the archive.
+
+Write posture (pick one): critics zero in-tree writes and parent collects exclusive-create outboxes into the archive (chosen). Harvest `## Bound remedy` into the same brief via plan-id-keyed idempotent update (`hashBoundRemedyBytes` key); do not use `issue:ingest` as the no-issue harvest path. Promotion keeps the archive authoritative with optional link/mirror and refuses two live arcs over one target.
+
+Gate admission for no-issue targets is `evaluateNoIssueGateAdmission`: target identity + authoritative marker + completed-arc proof + live revision via adapter over `GATE_MATCH_PREDICATES` (paths / body-text). Storage fields alone are insufficient. Discovery/recovery or concrete manual-diagnosis path required. No fake GitHub labels.
+

package/contracts/human-origin-authz.md

@@ -89,17 +89,21 @@ deft authz:uat-suspend
 deft authz:revoke -- grant-…
 ```
 
-## Gate-override hatch (#5542)
+## Gate-override hatch (#5542 / #5674)
 
 Mint + admission APIs for an audited interactive override bound to a coverage-
-applicability refuse. **This release ships grant minting and admission only.**
-Wiring that turns a live admission into a `waived` / exit-4 result on the pre-PR
-`coverage_headroom` / `deft coverage:hotspots` path is a follow-up PR; operators
-minting a grant here will still see the refuse until that consumer lands.
+applicability refuse (#5542). Consumer wiring on pre-PR `coverage_headroom` /
+`deft coverage:hotspots` lands as **exit 4** + distinct waived skip token with
+admission-receipt re-verify (#5674). Measured Istanbul floor/headroom failure
+still dominates when a coverage report exists. Exit 4 never maps to pass /
+exit 0. Residual deposit keep-unknowns (run / hooks / codeql / approved-scope)
+stay open on #5677. Classifier exact-path relief for ordinary managed
+stamps/ledgers is #5665 — not this hatch.
 
 ```bash
 deft authz:grant -- --template gate-override --target <refuseCode> \
   --plan-ref <attemptId> --base-sha <sha> --head-sha <sha> --tree-hash <hash> [--confirm]
+deft coverage:hotspots --attempt-id <attemptId>
 ```
 
 | Rule | Detail |
@@ -107,11 +111,11 @@ deft authz:grant -- --template gate-override --target <refuseCode> \
 | Mint provenance | `origin.kind=operator-cli` only via live `authz:grant` human-presence; `operator-session` non-admitting; refuse chat/parent/fixture consent |
 | Binding | gate id + refuse code + `baseSha+headSha+treeHash` + attempt id (+ optional worktree/evaluator) |
 | Admission | Atomic one-use via claim lock; inspection does **not** consume; same attempt reuses receipt; renew after revoke/expiry replaces under an attempt-id lock |
-| Result arms (follow-up) | Planned `waived` / `overridden` on coverage-applicability + pre-PR evidence — **never** map to pass / exit 0; not wired in this authz-only landing |
+| Result arms (#5674) | Live `waived` on coverage-hotspots + pre-PR evidence via exit 4 + waived skip token — **never** map to pass / exit 0; measured floor dominates when a report exists |
 | Eligible refuse codes | Closed set (`unknown-path`, `dirty-tree`, …); non-overridable authenticity codes (`tree-mismatch`, `invalid-*`) dominate |
 | Deferred peers | Empty list in v1 |
 | Push/merge | Grant is `settings` only — no independent push/merge permission |
-| Keep-outs | Does not fix #5541 classifier correctness; no fabricate green; no UAT silent suspend; no blanket env override |
+| Keep-outs | Does not fix #5541 / #5665 classifier correctness; no fabricate green; no UAT silent suspend; no blanket env override |
 
 Complementary hatches stay separate: `--allow-coverage-debt`, `policy:allow-*`,
 `DEFT_ALLOW_*`, delivery-attempt `recordOperatorOverride`, `spec-drift-override`.
@@ -125,8 +129,10 @@ Complementary hatches stay separate: `--allow-coverage-debt`, `policy:allow-*`,
 | Path write fence schema | #516 / #2443 |
 | AFK session-auth / release verbs | #1095 — see `content/contracts/closed-verb-authz.md` (Wave 4; consumes these grants) |
 | HMAC / hardware-keyed grants | non-goal for MVP |
-| Classifier false-refuse correctness | #5541 (not absorbed by gate-override) |
+| Classifier false-refuse correctness | #5541 / #5665 (not absorbed by gate-override) |
 | Interactive gate waiver audit | #5542 (this hatch) |
+| Pre-PR/hotspots waived-exit consumer + VERSION/lifecycle gitkeep inert | #5674 (leftover #5665/#5542) |
+| Residual deposit keep-unknowns (run / hooks / codeql / approved-scope) | #5677 |
 
 ## Wave 4 consumers
 

package/dist/coverage-hotspots.d.ts

@@ -6,6 +6,9 @@ interface ParsedArgs {
     baseRef: string | null;
     pathFilter: string[];
     useDiffPaths: boolean;
+    attemptId: string | null;
+    worktree: string | null;
+    evaluatorId: string | null;
     json: boolean;
     quiet: boolean;
     error?: string;

package/dist/coverage-hotspots.js

@@ -18,6 +18,9 @@ export function parseArgs(argv) {
         baseRef: null,
         pathFilter: [],
         useDiffPaths: true,
+        attemptId: null,
+        worktree: null,
+        evaluatorId: null,
         json: false,
         quiet: false,
     };
@@ -32,6 +35,39 @@ export function parseArgs(argv) {
         else if (arg === "--no-diff-filter") {
             parsed.useDiffPaths = false;
         }
+        else if (arg === "--attempt-id") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --attempt-id: expected one argument" };
+            }
+            parsed.attemptId = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--attempt-id=")) {
+            parsed.attemptId = arg.slice("--attempt-id=".length);
+        }
+        else if (arg === "--worktree") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --worktree: expected one argument" };
+            }
+            parsed.worktree = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--worktree=")) {
+            parsed.worktree = arg.slice("--worktree=".length);
+        }
+        else if (arg === "--evaluator-id") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...parsed, error: "argument --evaluator-id: expected one argument" };
+            }
+            parsed.evaluatorId = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--evaluator-id=")) {
+            parsed.evaluatorId = arg.slice("--evaluator-id=".length);
+        }
         else if (arg === "--project-root") {
             const value = argv[i + 1];
             if (value === undefined) {
@@ -126,9 +162,13 @@ export function run(argv) {
         baseRef: args.baseRef,
         pathFilter: args.pathFilter.length > 0 ? args.pathFilter : null,
         useDiffPaths: args.useDiffPaths,
+        attemptId: args.attemptId,
+        worktree: args.worktree,
+        evaluatorId: args.evaluatorId,
     });
-    // Exit 3 = authorized coverage N/A (#5421); keep machine-readable artifact on stdout for --json.
-    if (result.exitCode === 3) {
+    // Exit 3 = authorized coverage N/A (#5421); exit 4 = gate-override waived (#5674).
+    // Keep machine-readable artifact on stdout for --json. Never map waived to exit 0.
+    if (result.exitCode === 3 || result.exitCode === 4) {
         if (args.json && result.applicability) {
             process.stdout.write(`${JSON.stringify(result.applicability, null, 2)}\n`);
         }

package/dist/doctor-diagnose.d.ts

@@ -86,6 +86,6 @@ export declare function isNoGitReadinessGap(sync: FullInSyncResult, projectRoot:
  * Full read-only diagnosis. Never creates/updates files or Git config.
  */
 export declare function runDoctorDiagnosis(projectRoot: string, options?: DoctorDiagnosisOptions): DoctorDiagnosis;
-/** Human-readable doctor report (AC12.3 / AC12.5 / F-010). */
+/** Human-readable doctor report (AC12.3 / AC12.5 / F-010 / wave 4g). */
 export declare function formatDoctorReport(diag: DoctorDiagnosis): string;
 //# sourceMappingURL=doctor-diagnose.d.ts.map

package/dist/doctor-diagnose.js

@@ -272,7 +272,7 @@ function line(ok, name, detail) {
     const mark = ok ? "ok" : "FAIL";
     return detail ? `  ${name}: ${mark} — ${detail}` : `  ${name}: ${mark}`;
 }
-/** Human-readable doctor report (AC12.3 / AC12.5 / F-010). */
+/** Human-readable doctor report (AC12.3 / AC12.5 / F-010 / wave 4g). */
 export function formatDoctorReport(diag) {
     const lines = [];
     // Header tracks overall health (exitCode), not install-health inSync alone —
@@ -281,12 +281,29 @@ export function formatDoctorReport(diag) {
     // generic "not in sync" that reads like a broken pin.
     if (diag.exitCode === 0) {
         lines.push("directive doctor: in sync");
+        lines.push("");
+        lines.push("This project's Directive version and wiring look consistent.");
     }
     else if (diag.incompleteInstall === "git-precondition") {
         lines.push("directive doctor: incomplete install (git precondition)");
+        lines.push("");
+        lines.push("This folder is not a git repository yet, so git hooks were not installed.");
+        lines.push("");
+        lines.push("Next:");
+        lines.push("  git init");
+        lines.push("  directive install --repair");
     }
     else {
         lines.push("directive doctor: not in sync");
+        lines.push("");
+        if (!diag.surfaces.installed.ok || !diag.surfaces.pin.ok) {
+            const ver = diag.version ?? "the pinned version";
+            lines.push(`The project asks for Directive ${ver}, but that package is missing or the wrong version is installed.`);
+            lines.push("");
+            lines.push("Next:");
+            lines.push("  npm i -g @deftai/directive");
+            lines.push("  directive install --repair");
+        }
     }
     if (diag.version)
         lines.push(`  version: ${diag.version}`);
@@ -317,8 +334,17 @@ export function formatDoctorReport(diag) {
     if (diag.schemaRemedy) {
         lines.push(`Next: ${diag.schemaRemedy}`);
     }
-    if (diag.remedy) {
-        lines.push(`Recovery: ${diag.remedy}`);
+    if (diag.remedy && diag.incompleteInstall !== "git-precondition") {
+        // Avoid duplicating the plain Next: block when we already printed recovery.
+        if (diag.exitCode !== 0 && (diag.surfaces.installed.ok && diag.surfaces.pin.ok)) {
+            lines.push(`Recovery: ${diag.remedy}`);
+        }
+        else if (diag.exitCode !== 0 && (!diag.surfaces.installed.ok || !diag.surfaces.pin.ok)) {
+            // Plain Next: block already covers AC9.7.
+        }
+        else {
+            lines.push(`Recovery: ${diag.remedy}`);
+        }
     }
     return `${lines.join("\n")}\n`;
 }

package/dist/doctor.js

@@ -71,7 +71,7 @@ function namesUpdatePruneRecovery(result) {
 export function renderDepositFileSetHygieneLine(projectRoot, result = evaluateDepositFileSetHygiene(projectRoot)) {
     const deftDir = join(projectRoot, ".deft", "core");
     if (!existsSync(deftDir)) {
-        return "Deposit hygiene: none -- no .deft/core deposit.";
+        return "Deposit hygiene: none -- package-based layout (no copied .deft/core tree; expected).";
     }
     if (result.skipped) {
         return ("Deposit hygiene: skip -- @deftai/directive-content is not installed " +

package/dist/occupancy-release.d.ts

@@ -5,6 +5,11 @@
  * claim-over and deny-embedded copy-paste remain. host:none / address:none
  * are unset metadata, not the lock cause. Does not reopen anonymous live
  * auto-release (#3954).
+ *
+ * #5544 Prefer-A: pass the supplied --project-root through to releaseOccupancy
+ * so the consumer AGENTS.md header check stays at the project directory.
+ * Lease file / lock resolution stays inside releaseOccupancy (shared with the
+ * Write-hook lease view); denials / already-free print occupancyFile=.
  */
 export declare const ABANDONED_OCCUPANCY_LEASE_RECOVERY: string;
 export declare function formatOccupancyReleaseHelp(): string;

package/dist/occupancy-release.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { resolve } from "node:path";
 import { releaseOccupancy } from "../vendor/directive-core/dist/session/index.js";
 import { occupancyUnrecognizedArgument } from "./occupancy-unrecognized.js";
 /**
@@ -8,17 +7,24 @@ import { occupancyUnrecognizedArgument } from "./occupancy-unrecognized.js";
  * claim-over and deny-embedded copy-paste remain. host:none / address:none
  * are unset metadata, not the lock cause. Does not reopen anonymous live
  * auto-release (#3954).
+ *
+ * #5544 Prefer-A: pass the supplied --project-root through to releaseOccupancy
+ * so the consumer AGENTS.md header check stays at the project directory.
+ * Lease file / lock resolution stays inside releaseOccupancy (shared with the
+ * Write-hook lease view); denials / already-free print occupancyFile=.
  */
 export const ABANDONED_OCCUPANCY_LEASE_RECOVERY = "Abandoned live occupancy lease: bare session:end / occupancy:release without a presented " +
     "session identity refuses while the lease is live. Immediate recovery: " +
     "occupancy:release --session-id=<id from .deft/occupancy.json> " +
     "(read session_id from that file). Or wait for TTL claim-over. " +
-    "host:none / address:none are ordinary unset metadata, not the lock cause.";
+    "host:none / address:none are ordinary unset metadata, not the lock cause. " +
+    "Denials and already-free print occupancyFile= for the lease root this CLI resolved.";
 export function formatOccupancyReleaseHelp() {
     return [
         "Usage: deft occupancy:release [--project-root <path>] [--session-id <id>]",
         "",
         "Release this worktree occupancy lease (owner live, or expired residue).",
+        "Pass the consumer project directory as --project-root (header check uses it; lease file resolves to the Git toplevel when available).",
         "",
         ABANDONED_OCCUPANCY_LEASE_RECOVERY,
         "",
@@ -83,7 +89,9 @@ export function run(argv) {
         process.stdout.write(formatOccupancyReleaseHelp());
         return 0;
     }
-    const result = releaseOccupancy(resolve(args.projectRoot), {
+    // Keep the supplied project directory for the consumer header check; lease
+    // root resolution happens inside releaseOccupancy (#5544 Greptile P1).
+    const result = releaseOccupancy(args.projectRoot, {
         sessionId: args.sessionId,
         env: process.env,
     });

package/dist/policy.d.ts

@@ -23,6 +23,8 @@ interface SetArgs {
     ceremonyEnabled?: boolean;
     /** #5350 driftGuard.enforcement target for set-spec-guard-enforcement. */
     specGuardEnforcement?: SpecGuardEnforcement;
+    /** #4375 audited setter for valueFeedback.upstreamPrompt. */
+    upstreamPrompt?: boolean;
     error?: string;
 }
 /** Parse policy:show flags (mirrors _policy_show_cli.py). */

package/dist/policy.js

@@ -261,11 +261,15 @@ export function parseArgs(argv) {
         let host;
         let ceremonyOverride;
         let ceremonyEnabled;
+        let upstreamPrompt;
         for (let i = 1; i < argv.length; i += 1) {
             const arg = argv[i];
             if (arg === "--confirm") {
                 confirm = true;
             }
+            else if (cmd === "enable-value-feedback" && arg === "--upstream-prompt") {
+                upstreamPrompt = true;
+            }
             else if (arg === "--actor") {
                 const v = argv[i + 1];
                 if (v === undefined)
@@ -377,6 +381,7 @@ export function parseArgs(argv) {
             host,
             ceremonyOverride,
             ceremonyEnabled,
+            upstreamPrompt,
         };
     }
     return makeSetError(`unknown subcommand: ${cmd}`);
@@ -457,6 +462,7 @@ function runEnableValueFeedback(args) {
         confirm: args.confirm,
         actor: args.actor,
         note: args.note,
+        subFlags: args.upstreamPrompt === true ? { upstreamPrompt: true } : undefined,
     });
     process.stdout.write(result.stdout);
     return result.exitCode;

package/dist/session-start.js

@@ -2,7 +2,7 @@
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { CEREMONY_DEPTHS, normalizeCeremonyModelTier, normalizeCeremonyProjectShape, normalizeCeremonyTaskSize, selectCeremonyDepth, } from "../vendor/directive-core/dist/policy/index.js";
-import { COLD_CEREMONY_TIER, PRIMARY_CLAIM_EXCEPTIONS, parseDeferrals, parseSessionPostureToken, READ_ONLY_POSTURE, REARM_CEREMONY_TIER, REQUIREMENTS_POSTURE, resolveProductionHostEffortDescriptor, ritualStatePath, runSessionStart, SESSION_CEREMONY_TIERS, } from "../vendor/directive-core/dist/session/index.js";
+import { COLD_CEREMONY_TIER, PRIMARY_CLAIM_EXCEPTIONS, parseDeferrals, parseSessionPostureToken, publishApplyingHostFromCanonicalSessionId, READ_ONLY_POSTURE, REARM_CEREMONY_TIER, REQUIREMENTS_POSTURE, resolveProductionHostEffortDescriptor, ritualStatePath, runSessionStart, SESSION_CEREMONY_TIERS, } from "../vendor/directive-core/dist/session/index.js";
 function parseCeremonyDepth(raw) {
     const value = raw.trim().toLowerCase();
     if (CEREMONY_DEPTHS.includes(value)) {
@@ -523,6 +523,33 @@ export function run(argv) {
     if (stray) {
         lines.push(stray);
     }
+    // #5676: read-only may bootstrap the applying-host record; mutation/rearm
+    // republishes as reinforcement after a successful ceremony. Skip opt-out /
+    // kill-switch disabled results so .no-deft-directive stays write-free.
+    const disabled = typeof result.payload === "object" &&
+        result.payload !== null &&
+        result.payload.disabled === true;
+    if (result.code === 0 && !disabled) {
+        const owner = args.sessionId?.trim() ||
+            (typeof result.payload.occupancy === "object" &&
+                result.payload.occupancy !== null &&
+                typeof result.payload.occupancy.session_id === "string"
+                ? String(result.payload.occupancy.session_id)
+                : "") ||
+            process.env.DEFT_SESSION_ID?.trim() ||
+            "";
+        if (owner.length > 0) {
+            try {
+                const transport = process.env.GROK_HOOK_EVENT?.trim() ? "grok-hook-event" : "native";
+                publishApplyingHostFromCanonicalSessionId(projectRoot, owner, {
+                    transport: owner.startsWith("host:cursor:") ? "native" : transport,
+                });
+            }
+            catch {
+                /* ceremony success stays authoritative; applying-host is best-effort */
+            }
+        }
+    }
     if (args.emitJson) {
         const sorted = Object.keys(result.payload)
             .sort()

package/dist/triage-actions.js

@@ -152,13 +152,21 @@ export function run(argv) {
     const repo = args.repo;
     try {
         if (args.cmd === "accept") {
-            const decisionId = accept(n, repo, deps, {
+            const outcome = accept(n, repo, deps, {
                 actor: args.actor,
                 projectRoot,
                 autoPromote: args.autoPromote === true,
                 force: args.force === true,
             });
-            process.stdout.write(`${formatAcceptOutput(n, repo, decisionId, { autoPromote: args.autoPromote === true })}\n`);
+            process.stdout.write(`${formatAcceptOutput(n, repo, outcome.decisionId, {
+                autoPromote: args.autoPromote === true,
+                disposition: outcome.disposition,
+                relativePath: outcome.relativePath,
+                ingestMessage: outcome.ingestMessage,
+            })}\n`);
+            if (outcome.disposition === "refused") {
+                return 1;
+            }
         }
         else if (args.cmd === "reject") {
             const decisionId = reject(n, repo, args.reason ?? "", deps, {

package/dist/verify-review-monitor.d.ts

@@ -13,6 +13,13 @@ interface ParsedArgs {
     mergePathArm: boolean;
     liveWait: boolean;
     explicitFinish: boolean;
+    /**
+     * Product mint-gate BLOCKED — refuse --explicit-finish write (#5690).
+     * Pass-through to writeMergePathExplicitFinishAttestation.mintGateBlocked.
+     */
+    mintGateBlocked: boolean;
+    /** Optional attestation reason; mint markers also refuse the write (#5690). */
+    reason: string | null;
     stickyLease: boolean;
     /** DeliveryAttemptRecord.startedAt for Approach 1 arm-startup halt (#5278 P3). */
     dispatchStartedAt: string | null;

package/dist/verify-review-monitor.js

@@ -24,6 +24,8 @@ export function parseVerifyReviewMonitorArgs(argv) {
         mergePathArm: false,
         liveWait: false,
         explicitFinish: false,
+        mintGateBlocked: false,
+        reason: null,
         stickyLease: false,
         dispatchStartedAt: null,
         help: false,
@@ -45,6 +47,20 @@ export function parseVerifyReviewMonitorArgs(argv) {
         else if (arg === "--explicit-finish") {
             acc.explicitFinish = true;
         }
+        else if (arg === "--mint-gate-blocked") {
+            acc.mintGateBlocked = true;
+        }
+        else if (arg === "--reason") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...acc, error: "argument --reason: expected one argument" };
+            }
+            acc.reason = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--reason=")) {
+            acc.reason = arg.slice("--reason=".length);
+        }
         else if (arg === "--sticky-lease") {
             acc.stickyLease = true;
         }
@@ -159,6 +175,9 @@ export function run(argv) {
             "                         pr:watch CLEAN attestation — #5219;\n" +
             "                         parent-shell pr:watch (parent_id=pr-watch) does not arm.\n" +
             "  --explicit-finish      Attest option-C BLOCKED/FAILED finish for this PR\n" +
+            "  --mint-gate-blocked    Refuse --explicit-finish write for product mint-gate\n" +
+            "                         BLOCKED (non-option-C; #5690)\n" +
+            "  --reason TEXT          Attestation reason; mint markers also refuse write (#5690)\n" +
             "  --sticky-lease         Attest a fresh sticky lease (not sufficient alone)\n" +
             "  --dispatch-started-at  DeliveryAttemptRecord.startedAt ISO for Approach 1\n" +
             "                         arm-startup halt (#5278); when merge-path-arm stays\n" +
@@ -202,6 +221,8 @@ export function run(argv) {
             else {
                 const written = writeMergePathExplicitFinishAttestation(resolve(args.projectRoot), args.pr, {
                     source: "verify:review-monitor --explicit-finish",
+                    reason: args.reason ?? undefined,
+                    mintGateBlocked: args.mintGateBlocked,
                 });
                 if (!written.ok) {
                     process.stderr.write(`verify_review_monitor: ${written.reason}