@deftai/directive-runtime 0.129.6 → 0.129.8

package/Taskfile.yml

@@ -816,7 +816,9 @@ tasks:
     cmds:
       - task: engine:invoke
         vars:
-          ENGINE_CMD: 'release-publish {{.CLI_ARGS}}'
+          # #5805 / #5942: the pin's default project root is its own package dir, so pass the
+          # operator root explicitly (an operator --project-root in CLI_ARGS still wins).
+          ENGINE_CMD: 'release-publish --project-root "{{.USER_WORKING_DIR}}" {{.CLI_ARGS}}'
 
   release:rollback:
     desc: "State-aware release unwind (#716) -- task release:rollback -- <version> [--dry-run] [--allow-low-downloads N] [--allow-data-loss] [--force-strict-0]"
@@ -825,7 +827,9 @@ tasks:
     cmds:
       - task: engine:invoke
         vars:
-          ENGINE_CMD: 'release-rollback {{.CLI_ARGS}}'
+          # #5805 / #5942: the pin's default project root is its own package dir, so pass the
+          # operator root explicitly (an operator --project-root in CLI_ARGS still wins).
+          ENGINE_CMD: 'release-rollback --project-root "{{.USER_WORKING_DIR}}" {{.CLI_ARGS}}'
 
   release:e2e:
     desc: "End-to-end release rehearsal against an auto-created temp repo (#716, #2572 keep+report default) -- task release:e2e [-- --dry-run] [--owner OWNER] [--destroy-repo]"
@@ -834,7 +838,9 @@ tasks:
     cmds:
       - task: engine:invoke
         vars:
-          ENGINE_CMD: 'release-e2e {{.CLI_ARGS}}'
+          # #5805 / #5942: the pin's default project root is its own package dir, so pass the
+          # operator root explicitly (an operator --project-root in CLI_ARGS still wins).
+          ENGINE_CMD: 'release-e2e --project-root "{{.USER_WORKING_DIR}}" {{.CLI_ARGS}}'
 
   release:wait-npm:
     desc: "Phase 7 wait until both public OVPR packages (@deftai/directive + @deftai/directive-runtime) list the cut version (#4267 / #5490) -- task release:wait-npm -- <version>"
@@ -945,10 +951,10 @@ tasks:
             ;;
         esac
         print_deposit_recovery() {
-          echo "Phase 7 local closeout INCOMPLETE (#5953)." >&2
-          echo "Recovery: merge the version-matched agent-hook deposit for $VERSION onto tip, then re-run:" >&2
+          echo "Phase 7 local closeout INCOMPLETE (#5953 / #6163 Prefer-A Bound 6772886751)." >&2
+          echo "Recovery: on the pin candidate, repair/write agent-hook deposit then force-add tip-required Cursor paths (.cursor/hooks.json + .cursor/hooks/deft-hook-<sha8>.mjs) so they co-travel with the pin (preparePinCandidateCursorDeposit / git add -f bounded set); merge that pin+deposit tip, then re-run:" >&2
           echo "  task release:local-update -- $VERSION --checkout $CHECKOUT" >&2
-          echo "Expected managed deposit paths include: .grok/hooks/ .cursor/hooks.json .claude/settings.json .codex/ (and related deposit files)." >&2
+          echo "Expected managed deposit paths include: .grok/hooks/ .cursor/hooks.json .cursor/hooks/deft-hook-<sha8>.mjs .claude/settings.json .codex/ (and related deposit files)." >&2
           echo "Do not auto-commit deposit bytes inside the release flow; do not npm i -g." >&2
         }
         OCC_FILE="$CHECKOUT/.deft/occupancy.json"
@@ -1015,8 +1021,16 @@ tasks:
           git status --short >&2
           exit 1
         fi
-        DEFAULT_BRANCH="$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed "s@^refs/remotes/origin/@@" || true)"
-        if [ -z "$DEFAULT_BRANCH" ]; then DEFAULT_BRANCH=master; fi
+        # #6164: shell parameter expansion strip (zero sed/awk/cut/grep); then git verify.
+        ORIGIN_HEAD="$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null || true)"
+        DEFAULT_BRANCH="${ORIGIN_HEAD#refs/remotes/origin/}"
+        if [ -z "$DEFAULT_BRANCH" ] || [ "$DEFAULT_BRANCH" = "$ORIGIN_HEAD" ]; then
+          DEFAULT_BRANCH=master
+        fi
+        if ! git rev-parse --verify --quiet "refs/remotes/origin/$DEFAULT_BRANCH" >/dev/null; then
+          echo "release:local-update: refuse; cannot verify refs/remotes/origin/$DEFAULT_BRANCH; run: git remote set-head origin -a" >&2
+          exit 1
+        fi
         CURRENT="$(git rev-parse --abbrev-ref HEAD)"
         if [ "$CURRENT" != "$DEFAULT_BRANCH" ]; then
           echo "release:local-update: refuse; checkout must be on default branch $DEFAULT_BRANCH (on $CURRENT)" >&2
@@ -1024,14 +1038,54 @@ tasks:
         fi
         echo "release:local-update: ff-only pull on $DEFAULT_BRANCH at $CHECKOUT"
         git pull --ff-only
-        if [ -f pnpm-workspace.yaml ]; then
-          if grep -q "minimumReleaseAgeExclude" pnpm-workspace.yaml; then
-            if ! grep -q "@deftai/directive-runtime@$VERSION" pnpm-workspace.yaml; then
-              echo "release:local-update: AgeExclude missing @deftai/directive-runtime@$VERSION before frozen install (#5953 footnote)" >&2
-              exit 1
-            fi
-          fi
-        fi
+        # #6164: unconditional dependency-free AgeExclude gate (exact list-item; fail closed; no soft-skip).
+        node -e '
+          const fs = require("fs");
+          const version = process.argv[1] || "";
+          const want = "@deftai/directive-runtime@" + version;
+          let text;
+          try {
+            text = fs.readFileSync("pnpm-workspace.yaml", "utf8");
+          } catch (err) {
+            const detail = err && err.message ? err.message : String(err);
+            console.error("release:local-update: AgeExclude cannot read pnpm-workspace.yaml before frozen install (#6164): " + detail);
+            process.exit(1);
+          }
+          const lines = text.split(/\r?\n/);
+          const KEY_RE = /^(\s*)minimumReleaseAgeExclude:\s*(#.*)?$/;
+          const ITEM_RE = /^(\s*)-\s+(.*)$/;
+          const keyIdx = lines.findIndex((l) => KEY_RE.test(l));
+          if (keyIdx < 0) process.exit(0);
+          const keyLine = lines[keyIdx];
+          const keyIndent = keyLine.length - keyLine.trimStart().length;
+          const itemValue = (raw) => {
+            let v = String(raw || "").trim();
+            const SQ = String.fromCharCode(39);
+            const DQ = String.fromCharCode(34);
+            if (v.startsWith(SQ) || v.startsWith(DQ)) {
+              const q = v[0];
+              const end = v.indexOf(q, 1);
+              return end > 0 ? v.slice(1, end) : v;
+            }
+            const hash = v.search(/\s#/);
+            if (hash >= 0) v = v.slice(0, hash);
+            return v.trim();
+          };
+          let found = false;
+          for (let i = keyIdx + 1; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+            if (trimmed === "" || trimmed.startsWith("#")) continue;
+            const m = ITEM_RE.exec(line);
+            const indent = line.length - line.trimStart().length;
+            if (m === null || indent < keyIndent) break;
+            if (itemValue(m[2]) === want) { found = true; break; }
+          }
+          if (!found) {
+            console.error("release:local-update: AgeExclude missing " + want + " before frozen install (#5953 footnote / #6164)");
+            process.exit(1);
+          }
+        ' "$VERSION"
         echo "release:local-update: pnpm install --frozen-lockfile"
         pnpm install --frozen-lockfile
         PIN_PKG="$(node -e 'const fs=require("fs"); const p=JSON.parse(fs.readFileSync("package.json","utf8")); const v=(p.dependencies||{})["@deftai/directive-runtime"]||(p.devDependencies||{})["@deftai/directive-runtime"]||""; console.log(String(v).replace(/^[^0-9]*/, ""));')"
@@ -1051,6 +1105,39 @@ tasks:
           print_deposit_recovery
           exit 1
         fi
+        # #6163 Prefer-A Bound 6772886751: committed-byte HEAD association (no repair/staging).
+        echo "release:local-update: require committed Cursor deposit association on HEAD"
+        if ! node --input-type=module -e '
+          import { pathToFileURL } from "node:url";
+          import { join, resolve } from "node:path";
+          const checkout = process.argv[1];
+          const vendor = join(
+            checkout,
+            "node_modules/@deftai/directive-runtime/vendor/directive-core/dist/init-deposit/agent-hooks.js",
+          );
+          let validate;
+          try {
+            ({ validateCursorDepositAssociation: validate } = await import(pathToFileURL(resolve(vendor)).href));
+          } catch (err) {
+            const detail = err && err.message ? err.message : String(err);
+            console.error("release:local-update: cannot load validateCursorDepositAssociation from installed runtime (#6163): " + detail);
+            process.exit(1);
+          }
+          if (typeof validate !== "function") {
+            console.error("release:local-update: installed runtime lacks validateCursorDepositAssociation (#6163); pin must co-travel the Bound helper");
+            process.exit(1);
+          }
+          const result = validate(checkout, { source: "HEAD" });
+          if (!result || result.ok !== true) {
+            console.error("release:local-update: committed Cursor deposit association FAILED on HEAD (#6163)");
+            console.error(result && result.detail ? result.detail : "unknown association failure");
+            process.exit(1);
+          }
+          console.log("release:local-update: committed Cursor deposit association ok (" + result.sha8 + ")");
+        ' "$CHECKOUT"; then
+          print_deposit_recovery
+          exit 1
+        fi
         UPGRADE_BIN=""
         if [ -x "node_modules/.bin/directive" ]; then
           UPGRADE_BIN="node_modules/.bin/directive"

package/commands.md

@@ -149,6 +149,8 @@ Common commands:
   - Bare `evidence` / `disposition` keys are **not** valid (#1620 / Option B #3305). They fail `verify:vbrief-conformance` and are treated as missing by `scope:complete` (no dual-read). Migrate bare keys or narrative-only `Result`/`Verification` workarounds to the namespaced fields above while items are still non-terminal.
   - Already-terminal items (`completed`/`failed`/`cancelled`/…) are not re-checked for typed evidence; pre-marking items complete to skip the gate is unsupported for the typed path.
   - `merge`/`review` alone cannot satisfy smoke/UAT/deploy/observed_behavior criteria (title/Acceptance text or explicit axis).
+  - **Delivery identity (#5710):** with an issue origin, the PR must be associated with the issue as of `merged_at` by one of: (a) a unique sole `deft-story: N` mark in the merge-time PR body (PRs that change only lifecycle briefs, `CHANGELOG.md` and the spec-drift ledger are excluded and never count), (b) a closing keyword (`Closes #N`, `owner/repo#N`, or the issue URL) in the merge-time body, or (c) a Connected issue link at `merged_at`. Brief-in-PR-diff still counts. A mark, keyword or link added after merge does not count, and current `closingIssuesReferences` alone is not enough. Basis (a) scans every merged PR within 20 minutes, `graphql.remaining` ≥ 200 and REST core ≥ 100; any gap refuses. With no issue origin, stamp `plan.metadata.productPullRequest` and complete with `--pr <that number> --merge-commit <sha>`; the repository is the `origin` remote. `--non-delivery` refuses when the stamped PR is merged, and refuses when its merge state cannot be read. `xbrief:preflight` prints one note for a code-bearing brief with no issue origin.
+  - **Lifecycle completion (#680):** completion admission uses the merge-time bases above; there is no separate keyword-only refuse. `swarm:finalize-owed` also lists an active issue-less brief with a stamped `productPullRequest` (shown as `pr #P`, no issue number, no origin-issue check or origin-close); briefs that share a product PR finalize together under one claim. In a batched `swarm:finalize-cohort`, a refused `deft-story` mark is not an error: that story stays pending, unstamped and unswept (`refused_marks`, exit 3 incomplete), and the other stories stamp, sweep, commit and land. A failed changed-file lookup and real delivery errors still fail the batch. `scope:complete` writes the spec-drift ledger as verb output; finalize commits it with the completed briefs, and scope-provenance membership admits exactly `xbrief/.audit/spec-drift-ledger.json` only when the whole change set is a completion move. `verify:changelog-unreleased` needs no new `[Unreleased]` line when the change set versus merge-base (`git diff --name-only --no-renames`) is non-empty and only lifecycle briefs, `CHANGELOG.md` and that ledger, so lifecycle verbs write no CHANGELOG line. Product changes and an empty change set still need one.
 - `task scope:fail -- xbrief/active/<file>.xbrief.json` -- mark running work failed when the scope cannot complete.
 - `task scope:cancel -- <path>` -- move a scope to `cancelled/`.
 - `task scope:restore`, `task scope:block`, `task scope:unblock`, `task scope:demote`, and `task scope:undo:*` -- repair or reverse lifecycle transitions.
@@ -181,6 +183,8 @@ The implementation gate succeeds only for active scope xBRIEFs with `plan.status
 
 **Hotfix classifier (#1193):** Typed `plan.policy.hotfixCriteria` + pure `evaluateHotfixEligibility`. Small fix / pure revert may propose label `hotfix-candidate` only; a human promotes to `hotfix`. Refactors, new exports/handlers, and forbidden paths (Dockerfile, fly.toml, workflows, migrations, auth/secrets) never qualify.
 
+**Small-change lane (#6204):** Under the `rapid` ceremony dial, a scope with stated acceptance commands may use a thin brief: title, issue ref, `file_scope` and acceptance commands only (`emitThinBrief`, `packages/core/src/intake/thin-brief.ts`). The bound defaults to 5 production files and 500 changed lines (added plus deleted, tests included; briefs and CHANGELOG excluded). `plan.policy.ceremonyDial.smallChangeLane` (`maxProductionFiles`, `maxChangedLines`) overrides each field; an invalid value refuses. `scope:promote`, `scope:activate`, `xbrief:preflight`, `verify:ac` and `scope:complete` admit the thin shape, and each one remeasures the cumulative product diff (git, against the lane-admit base in `plan.metadata["x-directive/smallChangeLane"]`; at `scope:complete`, the delivered merge commit against its first parent). A crossed bound, a public-surface change (manifest, entry, task file or export line), an unknown public surface, or a depth other than `rapid` refuses. A crossed bound or public-surface change is recorded on the brief (lane state `crossed`), so every later retry refuses even if the diff shrinks. The public-surface check reads export statements with the TypeScript parser, so a change inside a multi-line export list or exported signature counts. The one remediation is lane exit: convert the scope to the full shape (`escalateThinBriefToFullShape`), which keeps scope identity and acceptance evidence. Raising the dial (#3319) does not clear the refusal. One-PR delivery is not part of this lane; Path B brief-first stays lawful (#6203 / #680).
+
 ```mermaid
 flowchart TD
     Candidate["Scope xBRIEF exists"] --> Promote{"In proposed?"}
@@ -494,13 +498,14 @@ Cross-link: spawn three postures and deny recoveries live under § Agent-host di
 ### Mutable ritual (mutation posture)
 
 - ! On **mutation** session start, run `deft session:start` (or `task session:start` in framework source) after loading AGENTS.md. Records quick-tier ritual in `.deft/ritual-state.json`: alignment confirmation, branch-policy disclosure, `deft verify:tools` guidance, default-branch sync warnings, and `deft triage:welcome` one-liner. State is worktree- and HEAD-bound; stale after `plan.policy.sessionRitualStalenessHours` hours (default 8). Mutation start also claims the worktree occupancy lease (`.deft/occupancy.json`); see Session routing (#3433).
-- ! **Orientation compression Now (#3286):** mutation cold `session:start` composes `doctor` + #3282 toolchain preflight (and deposit-sha fast-paths for `agents:refresh` / `verify:cache-fresh`) as inline sections with per-section status lines — composition of existing steps, not a new monolith. When the deposit fingerprint (payload + templates + engine) is unchanged, refresh surfaces print one-line `unchanged - sha match` no-ops. Opt-in compact output: `deft session:start --compact` or `DEFT_SESSION_COMPACT=1` (verbose remains the default). #2176 read-only default is unchanged. Dual-path Later (orient) stays open until run-summary telemetry shows ritual+gate share ≥ 25% after Now ships (#2899).
+- ! **Quiet-default success stdout (#4966):** mutation `session:start` success human output defaults to one trusted go-signal line with stable prefix `[deft session] ready=…` (ready + branch/HEAD + occupancy). Routine dial/host-surface/effort/orientation/ceremony prose is verbose-only via `deft session:start --verbose` or `DEFT_SESSION_VERBOSE=1`. Non-exhaustive always-on allowlist keeps actionable zero-exit exceptions, non-default policy/bypass and human-merge disclosures, finalize-owed unknown/deferred qualifications, and actionable lifecycle/work-claim notices on the quiet path. Fail/deny/steal/non-zero stay loud. Tip `#3286` `--compact` / `DEFT_SESSION_COMPACT` are deprecated as whole-stdout volume controls (no-op for human stdout selection; `--json` / run-summary unchanged). Exit 0 is not the mutation go-signal — render from structured ready/posture/occupancy state.
+- ! **Orientation compression Now (#3286):** mutation cold `session:start` composes `doctor` + #3282 toolchain preflight (and deposit-sha fast-paths for `agents:refresh` / `verify:cache-fresh`) as inline sections with per-section status lines — composition of existing steps, not a new monolith. When the deposit fingerprint (payload + templates + engine) is unchanged, refresh surfaces print one-line `unchanged - sha match` no-ops. Section formatting may still honor `--compact` / `DEFT_SESSION_COMPACT=1` inside the orientation bundle; whole-stdout volume is `#4966` quiet-default / `--verbose`. #2176 read-only default is unchanged. Dual-path Later (orient) stays open until run-summary telemetry shows ritual+gate share ≥ 25% after Now ships (#2899).
 - ! Cold `session:start` does **not** run the live agent-hook probe. Functional readiness belongs to the gated mutation path so cold ceremony retains the #2990/#2991 latency profile.
 - ! **Hot path latency (#2991):** by default, mutation `session:start` does **not** block ritual-state write on optional network. It skips the npm release-availability probe and triage cache empty-hydrate / self-heal (`ensureTriageCacheHydrated` / `maybeSelfHealCache`). Targets (operator-facing, not CI-hard): warm hot path typically under a few seconds once tools are on PATH; cold path dominated by local `verify:tools` and git, usually well under ~30s when optional network is off. Empty-cache GitHub fetch-all and npm `view` previously accounted for multi-minute hangs in the WWYSYDH pilot — those stay off the critical path unless opted in.
 - ! **Cold vs re-arm ceremony tiers (#2992):** default `session:start` is the **cold** (full) path. After age staleness or compact re-arm (#2113) on the **same worktree** with continuous HEAD and previously-passing quick steps, prefer `deft session:start --rearm` (alias `--tier=rearm`) to refresh the ritual clock + HEAD/worktree bind without `verify:tools`, triage welcome, release probe, or staleness tickler. Full cold remains required for missing/invalid state, worktree change, discontinuous HEAD, first install, or failed/missing quick steps. Compact marks `rearm_needed`; PreToolUse denial and inspect/verify messages prefer re-arm recovery when cold is unnecessary.
 - ? Opt into optional network: `deft session:start --with-network` or `DEFT_SESSION_START_NETWORK=1`. When enabled, the bounded release-availability probe runs against the public npm registry (skips framework source checkouts, non-release pins, and `DEFT_NO_NETWORK=1`; identical latest-version notices throttle for 24 hours in `xbrief/.triage-cache/release-availability-state.json`). Default-mode triage welcome then also hydrates/self-heals the triage cache. This is separate from `deft doctor`, whose bare and gated invocations remain offline by default (#2182). Refs #1692 / #2991. Re-arm never runs optional network.
 - ~ `session:start --json` includes `steps[]` with `name` + `duration_ms` for major phases (`alignment`, `branch_policy`, `verify_tools`, `triage_welcome`, `release_probe`, `ritual_write`), plus total `duration_ms`, `optional_network`, and `ceremony_tier` (`cold` | `rearm`). Skipped optional steps report `skipped: true` and `duration_ms: 0`. Use this for attribution when investigating ceremony wall-clock.
-- ~ **Process-cost events (#2994 / #3508):** on mutation `session:start` completion (cold or re-arm), Directive appends a local `session:start` behavioral event to `.deft-cache/events.jsonl` with `ceremony_tier`, `duration_ms`, `exit_code`, and optional `steps[]` (same labels as `--json`). Mutation `session:start` also prints one operator-visible `ceremony <tier> <ms>` line (hidden under `--compact` / `DEFT_SESSION_COMPACT`). When PreToolUse denies for `ritual-not-ready`, a local `session:ritual-blocked` event records `tool_name`, `code`, and optional `recovery_tier` / `detail`. Always-on best-effort (never blocks ceremony or deny path); not gated on `valueFeedback`; **no remote upload** (Product Insights #2603 is a separate opt-in). Pull the rollup with `task value:show` (composed reader; CLI process time, not agent-turn wall clock). See § Process-cost events below. ⊗ Do not use the printed CLI duration as #3286 Later graduation input.
+- ~ **Process-cost events (#2994 / #3508):** on mutation `session:start` completion (cold or re-arm), Directive appends a local `session:start` behavioral event to `.deft-cache/events.jsonl` with `ceremony_tier`, `duration_ms`, `exit_code`, and optional `steps[]` (same labels as `--json`). Mutation `session:start` also emits one operator-visible `ceremony <tier> <ms>` line on the verbose human path (`--verbose` / `DEFT_SESSION_VERBOSE`; quiet-default hides it per #4966). When PreToolUse denies for `ritual-not-ready`, a local `session:ritual-blocked` event records `tool_name`, `code`, and optional `recovery_tier` / `detail`. Always-on best-effort (never blocks ceremony or deny path); not gated on `valueFeedback`; **no remote upload** (Product Insights #2603 is a separate opt-in). Pull the rollup with `task value:show` (composed reader; CLI process time, not agent-turn wall clock). See § Process-cost events below. ⊗ Do not use the printed CLI duration as #3286 Later graduation input.
 - ~ At safe idle points (clean tree, no in-flight story), mutation session start and `deft scope:complete` may also run the staleness tickler: an interactive, consent-based offer to upgrade Directive (`npm i -g @deftai/directive@latest`) and/or migrate xBRIEF (`deft migrate:xbrief`). Escalation tiers, snooze windows, and opt-out live under `plan.policy.stalenessTickler` — inspect with `deft policy:show --field=stalenessTickler`. State persists in `xbrief/.triage-cache/staleness-tickler-state.json`. Skips framework source checkouts, dirty trees, CI/headless (`DEFT_SESSION_RITUAL_SKIP=1`), and typed opt-out. Refs #2488 / #2489.
 - ! Before any code-writing tool call or `start_agent` implementation dispatch, run `deft verify:session-ritual -- --tier=gated`. Gated tier fails closed unless quick-tier state is fresh; lazily records the non-deferrable `agent_hooks` readiness gate plus `deft doctor` and `task verify:cache-fresh` entrypoints. Agent-hook correctness is independent of doctor warnings and throttling. Step 0 of the pre-`start_agent` gate stack.
 - ! **One-shot recovery (#2993 / #3100 / #4399):** when PreToolUse denies writes for a stale/missing gated ritual, run `deft session:ready` (or `task session:ready`). It composes `session:start` (only when quick-tier is not green) + `verify:session-ritual -- --tier=gated` with check-class `cache_fresh` (age + live drift, no `--skip-drift-probe`) + `cache fetch-all --force` when `cache_fresh` is the remaining blocker, then re-verifies. Skip-drift ritual argv is not the ready bar — that is the `task check` / FRAMEWORK_CHECK_GATES evaluate, so stale-by-drift can still fire fetch-all. Even when gated inspect is already fresh, the fast path forces one live `agent_hooks` check and the same check-class `cache_fresh`; it still avoids unnecessary fetch-all when that evaluate is green. Flags: `--json`, `--repo OWNER/NAME`, `--with-network` (forwarded to session:start). Prefer this over juggling the multi-step recovery sequence under hook pressure.
@@ -550,7 +555,7 @@ Local ceremony cost signal for WWYSYDH / weekly process rollups. Emits to `.deft
 | PreToolUse ritual deny | `session:ritual-blocked` | Hook blocks write/spawn because gated ritual is not ready | `tool_name`, `code=ritual-not-ready`, `recovery_tier` (`cold`\|`rearm`) |
 | Per-step wall-clock | (field on `session:start`) | Same emit as session start | `steps[].name` + `steps[].duration_ms` (`alignment`, `scm_readiness`, `branch_policy`, `verify_tools`, `triage_welcome`, `release_probe`, `ritual_write`) |
 
-CLI mirror (no JSONL required): `deft session:start --json` already exposes the same `steps` / `duration_ms` / `ceremony_tier` fields for one-shot inspection. Human mutation output adds one `ceremony <tier> <ms>` line unless compact hides it (#3508).
+CLI mirror (no JSONL required): `deft session:start --json` already exposes the same `steps` / `duration_ms` / `ceremony_tier` fields for one-shot inspection. Human mutation output adds one `ceremony <tier> <ms>` line on the verbose path (#3508 / #4966).
 
 Composed reader (no new verb): `task value:show` / `deft value:show` prints last cold vs re-arm duration, last per-step breakdown, blocked-ritual count, and recovery-tier distribution from the same ledger. This is **CLI process time**, not agent-turn wall clock (#3500). ⊗ Do not feed the printed CLI duration into #3286 Later graduation.
 

package/dist/session-start.d.ts

@@ -30,10 +30,16 @@ export interface ParsedSessionStartArgs {
         hardBudget?: boolean;
     };
     /**
-     * #3286: compact orientation output (terse machine format). Verbose remains
-     * the default; also settable via DEFT_SESSION_COMPACT=1.
+     * #3286 / #4966: tip `--compact` retained for argv compatibility; deprecated
+     * as whole-stdout volume gate (no-op for human stdout selection). Orientation
+     * section formatting may still honor it inside core.
      */
     compact: boolean;
+    /**
+     * #4966: restore full ceremony human stdout. Quiet success is the default.
+     * Also settable via DEFT_SESSION_VERBOSE=1.
+     */
+    verbose: boolean;
     /** #3433: steal the worktree occupancy lease. */
     steal: boolean;
     confirm: boolean;

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, publishApplyingHostFromCanonicalSessionId, 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, resolveSessionVerbose, ritualStatePath, runSessionStart, SESSION_CEREMONY_TIERS, selectSessionStartHumanLines, } from "../vendor/directive-core/dist/session/index.js";
 function parseCeremonyDepth(raw) {
     const value = raw.trim().toLowerCase();
     if (CEREMONY_DEPTHS.includes(value)) {
@@ -40,6 +40,7 @@ export function parseArgs(argv) {
         ceremonyDepthOverride: null,
         effortBudgetHost: {},
         compact: false,
+        verbose: false,
         steal: false,
         confirm: false,
         occupant: null,
@@ -311,9 +312,14 @@ export function parseArgs(argv) {
             parsed.effortBudgetHost.hardBudget = true;
         }
         else if (arg === "--compact") {
-            // #3286: terse machine orientation output (opt-in; verbose remains default)
+            // #3286 / #4966: deprecated as whole-stdout volume gate (parsed; no-op for
+            // human stdout selection). Prefer --verbose / DEFT_SESSION_VERBOSE.
             parsed.compact = true;
         }
+        else if (arg === "--verbose") {
+            // #4966: restore full ceremony dump (quiet success is the default).
+            parsed.verbose = true;
+        }
         else if (arg === "--steal") {
             parsed.steal = true;
         }
@@ -496,8 +502,10 @@ export function run(argv) {
             ceremonyTier: args.ceremonyTier,
             ceremonyDialInputs: args.ceremonyDialInputs,
             effortBudgetSeams: { hostDescriptor, environ: process.env },
-            // #3286: --compact flag; DEFT_SESSION_COMPACT still resolved inside core.
+            // #3286 / #4966: --compact retained for orientation formatting; not volume.
             compact: args.compact ? true : undefined,
+            // #4966: --verbose / DEFT_SESSION_VERBOSE restores ceremony dump.
+            verbose: args.verbose ? true : undefined,
             steal: args.steal ? true : undefined,
             confirm: args.confirm ? true : undefined,
             occupant: args.occupant ?? undefined,
@@ -586,27 +594,40 @@ export function run(argv) {
         process.stdout.write(`${JSON.stringify(sorted)}\n`);
         return result.code;
     }
-    const sink = result.code === 0 ? process.stdout : process.stderr;
-    for (const line of lines) {
-        sink.write(`${line}\n`);
-    }
+    // #4966: one final human-output selection point (core lines + stray + trailer).
+    const trailer = [];
     if (result.code === 0) {
         const posture = result.payload.posture;
         if (posture === READ_ONLY_POSTURE || posture === REQUIREMENTS_POSTURE) {
-            process.stdout.write(`[deft] ${String(result.payload.message)}\n`);
+            trailer.push(`[deft] ${String(result.payload.message)}`);
         }
         else {
-            process.stdout.write(`[deft] session ritual recorded at ${ritualStatePath(projectRoot)} (diagnostic-only; not posture authority)\n`);
+            trailer.push(`[deft] session ritual recorded at ${ritualStatePath(projectRoot)} (diagnostic-only; not posture authority)`);
         }
         if (applyingHostPublish.status === "deferred") {
-            process.stdout.write(`[deft] applying-host publish deferred: live occupant ${applyingHostPublish.liveSessionId} ` +
+            trailer.push(`[deft] applying-host publish deferred: live occupant ${applyingHostPublish.liveSessionId} ` +
                 `still holds this worktree (attempted ${applyingHostPublish.attemptedSessionId}); ` +
-                "not a conflict recovery — that owner must release/end or wait for lease TTL.\n");
+                "not a conflict recovery — that owner must release/end or wait for lease TTL.");
         }
         else if (applyingHostPublish.status === "failed") {
-            process.stdout.write(`[deft] applying-host publish failed: ${applyingHostPublish.message}\n`);
+            trailer.push(`[deft] applying-host publish failed: ${applyingHostPublish.message}`);
         }
     }
+    const verbose = resolveSessionVerbose({
+        verbose: args.verbose ? true : undefined,
+        env: process.env,
+    });
+    const humanLines = selectSessionStartHumanLines({
+        code: result.code,
+        payload: payloadWithPublish,
+        lines: [...lines, ...trailer],
+        verbose,
+        env: process.env,
+    });
+    const sink = result.code === 0 ? process.stdout : process.stderr;
+    for (const line of humanLines) {
+        sink.write(`${line}\n`);
+    }
     return result.code;
 }
 if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {

package/dist/vbrief-preflight.d.ts

@@ -1,4 +1,8 @@
 #!/usr/bin/env node
+/** One remediation line for a code-bearing brief with no issue origin (#5710 P2). */
+export declare const ISSUELESS_CODE_BEARING_REMEDIATION: string;
+/** The P2 remediation line when the brief is code-bearing with no issue origin, else null. */
+export declare function issuelessCodeBearingNote(briefPath: string): string | null;
 interface ParsedArgs {
     vbriefPath: string | null;
     emitJson: boolean;

package/dist/vbrief-preflight.js

@@ -1,9 +1,38 @@
 #!/usr/bin/env node
+import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { emitJson, evaluate, PREFLIGHT_USAGE_HINT } from "../vendor/directive-core/dist/preflight/index.js";
 import { scanWorkClaimForBriefPath } from "../vendor/directive-core/dist/scm/index.js";
+import { isCodeBearingScope, resolvePlanGithubIssueRef } from "../vendor/directive-core/dist/scope/index.js";
 import { refuseIfWslOwnershipBlocked } from "./wsl-ownership-guard.js";
+/** One remediation line for a code-bearing brief with no issue origin (#5710 P2). */
+export const ISSUELESS_CODE_BEARING_REMEDIATION = "[deft preflight] note: code-bearing brief has no x-xbrief/github-issue origin (#5710). " +
+    "PR-only complete: stamp plan.metadata.productPullRequest, then " +
+    "scope:complete -- --pr <that PR> --merge-commit <sha>. " +
+    "Issue-first: add an x-xbrief/github-issue reference before the product PR.";
+/** The P2 remediation line when the brief is code-bearing with no issue origin, else null. */
+export function issuelessCodeBearingNote(briefPath) {
+    let plan;
+    try {
+        const raw = JSON.parse(readFileSync(briefPath, "utf8"));
+        plan =
+            raw !== null && typeof raw === "object" && !Array.isArray(raw)
+                ? raw.plan
+                : null;
+    }
+    catch {
+        return null;
+    }
+    if (plan === null || typeof plan !== "object" || Array.isArray(plan)) {
+        return null;
+    }
+    const record = plan;
+    if (!isCodeBearingScope(record) || resolvePlanGithubIssueRef(record) !== null) {
+        return null;
+    }
+    return ISSUELESS_CODE_BEARING_REMEDIATION;
+}
 const HELP_TEXT = `usage: xbrief:preflight [--vbrief-path PATH | PATH] [--json] [--help]
 
 Implementation-intent gate (#810): exits 0 only when the xBRIEF is in
@@ -117,6 +146,11 @@ export function run(argv, scan = scanWorkClaimForBriefPath) {
             `[deft work-claim] warning: scan failed (${message}). Warn is success; this is not a GitHub lock.`,
         ];
     }
+    // #5710 P2: advisory only; the exit code is unchanged.
+    const issuelessNote = issuelessCodeBearingNote(vbriefPath);
+    if (issuelessNote !== null) {
+        scanLines = [issuelessNote, ...scanLines];
+    }
     if (args.emitJson) {
         const message = scanLines.length > 0 ? `${result.message}\n${scanLines.join("\n")}` : result.message;
         process.stdout.write(`${emitJson(vbriefPath, result.exitCode, message)}\n`);

package/dist/verify-scope-provenance.d.ts

@@ -8,9 +8,21 @@ interface ParsedArgs {
     /** Raw `--enforce` token present, even when a later `--warn` wins `enforce`. */
     enforcePresent: boolean;
     quiet: boolean;
+    /** PR number for the forge-approval admit (#6203); null when absent. */
+    prNumber: number | null;
+    /** OWNER/NAME for the forge-approval admit; empty means resolve. */
+    repo: string;
     error?: string;
 }
 export declare function parseArgs(argv: string[]): ParsedArgs;
-export declare function run(argv: string[]): number;
+/**
+ * PR context for the forge-approval admit (#6203): flags win, then
+ * GITHUB_PR_NUMBER (digits only) / GITHUB_REPOSITORY. Null without a PR.
+ */
+export declare function resolveForgeContext(args: Pick<ParsedArgs, "prNumber" | "repo">, env: NodeJS.ProcessEnv): {
+    prNumber: number;
+    repo: string | null;
+} | null;
+export declare function run(argv: string[], env?: NodeJS.ProcessEnv): number;
 export {};
 //# sourceMappingURL=verify-scope-provenance.d.ts.map

package/dist/verify-scope-provenance.js

@@ -6,12 +6,21 @@
  * evaluated inside evaluateScopeProvenance. This CLI forwards --base-ref.
  * `--enforce` / `--warn` stay parsed for compatibility; `--enforce` is a
  * no-op after #4956 / #5002 and prints a stderr notice when present.
+ *
+ * `--pr N` / `--repo OWNER/NAME` (env fallback GITHUB_PR_NUMBER /
+ * GITHUB_REPOSITORY) supply PR context for the forge-approved head-brief
+ * membership admit (#6203). Without a PR number the admit is never consulted.
  */
 import { resolve } from "node:path";
 import { scopeProvenance } from "../vendor/directive-core/dist/index.js";
 import { isDirectEntrypoint } from "./entrypoint.js";
 /** Stderr line when argv includes `--enforce`. Exit code is unchanged. */
 export const ENFORCE_NOOP_NOTICE = "verify_scope_provenance: --enforce has no effect after #4956 / #5002";
+const PR_DIGITS = /^[1-9][0-9]*$/;
+function parsePr(value) {
+    const t = value.trim();
+    return PR_DIGITS.test(t) ? Number(t) : null;
+}
 export function parseArgs(argv) {
     const parsed = {
         projectRoot: ".",
@@ -20,6 +29,8 @@ export function parseArgs(argv) {
         enforce: false,
         enforcePresent: false,
         quiet: false,
+        prNumber: null,
+        repo: "",
     };
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -55,22 +66,54 @@ export function parseArgs(argv) {
         else if (arg?.startsWith("--base-ref=")) {
             parsed.baseRef = arg.slice("--base-ref=".length);
         }
+        else if (arg === "--pr" || arg?.startsWith("--pr=")) {
+            const value = arg === "--pr" ? argv[i + 1] : arg.slice("--pr=".length);
+            if (arg === "--pr")
+                i += 1;
+            const pr = value === undefined ? null : parsePr(value);
+            if (pr === null) {
+                return { ...parsed, error: "argument --pr: expected a positive PR number" };
+            }
+            parsed.prNumber = pr;
+        }
+        else if (arg === "--repo" || arg?.startsWith("--repo=")) {
+            const value = arg === "--repo" ? argv[i + 1] : arg.slice("--repo=".length);
+            if (arg === "--repo")
+                i += 1;
+            if (value === undefined || value.trim().length === 0) {
+                return { ...parsed, error: "argument --repo: expected OWNER/NAME" };
+            }
+            parsed.repo = value.trim();
+        }
         else {
             return { ...parsed, error: `unrecognized argument: ${arg}` };
         }
     }
     return parsed;
 }
-export function run(argv) {
+/**
+ * PR context for the forge-approval admit (#6203): flags win, then
+ * GITHUB_PR_NUMBER (digits only) / GITHUB_REPOSITORY. Null without a PR.
+ */
+export function resolveForgeContext(args, env) {
+    const prNumber = args.prNumber ?? parsePr(env.GITHUB_PR_NUMBER ?? "");
+    if (prNumber === null)
+        return null;
+    const repo = args.repo.length > 0 ? args.repo : (env.GITHUB_REPOSITORY ?? "").trim();
+    return { prNumber, repo: repo.length > 0 ? repo : null };
+}
+export function run(argv, env = process.env) {
     const args = parseArgs(argv);
     if (args.error !== undefined) {
         process.stderr.write(`verify_scope_provenance: ${args.error}\n`);
         return 2;
     }
     const projectRoot = resolve(args.projectRoot);
+    const forgeApproval = resolveForgeContext(args, env);
     const result = scopeProvenance.evaluateScopeProvenance(projectRoot, {
         ...(args.baseRef.length > 0 ? { baseRef: args.baseRef } : {}),
         enforce: args.enforce,
+        ...(forgeApproval !== null ? { forgeApproval } : {}),
     });
     if (args.enforcePresent) {
         process.stderr.write(`${ENFORCE_NOOP_NOTICE}\n`);

package/docs/getting-started.md

@@ -58,6 +58,8 @@ directive doctor
 
 After clone or a new worktree: run the project package manager (`npm install` / `pnpm install`), then the first eligible runtime command or registered hook completes local activation.
 
+**Dependabot / pin-only bumps (AC14.10):** a PR that changes only the `@deftai/directive-runtime` pin + lockfile is valid. After `pnpm install` / `npm install` brings `node_modules` to the new pin, the first eligible skill, hook, or ordinary runtime command runs local automatic setup (wiring / `GENERATION` / readiness). `directive doctor` stays read-only — dirty doctor output before that eligible invocation is expected. CI may either rely on that first eligible command or run explicit `directive install --repair --yes`. Do not treat "deposit bytes must land in the same pin PR" as product law. Human-test mirror: HT-17 in `docs/installer-refactor-ovpr/install-ovpr-human-test-plan.md`. Schema/data behind the new pin still needs `directive upgrade` (AC14.11), not repair alone.
+
 **Repair (pin unchanged):** `npm i -g @deftai/directive`, then `directive install --repair`.
 
 **Upgrade version or migrate data:** `directive upgrade` (alias: `update`).

package/docs/scope-provenance.md

@@ -45,10 +45,24 @@ Allowance = clamp(count of **concrete** production files on the merge-base `file
 When the bound story is in the change set:
 
 1. A human-stamped merge-base mint for the **continuity-resolved** story is the allowlist when present (planId match ignores stale `xbriefRelPath`; no-`plan.id` is path-first + basename-keyed mint with matching `xbriefRelPath`).
-2. Otherwise membership evaluates against the merge-base brief's **concrete** `file_scope` as agent precommitment. Head brief cannot widen.
+2. Otherwise membership evaluates against the merge-base brief's **concrete** `file_scope` as agent precommitment. Head brief cannot widen, except under a qualifying forge approval (#6203, below).
 3. Free paths: bound brief, verified peer briefs, `CHANGELOG.md`, and continuity lifecycle paths of the bound identity. An xBRIEF-only change set may omit a mint.
 4. Empty / invalid / unreadable mint records fail closed (they are not absence).
 
+#### Forge-approved head brief (#6203)
+
+A PR can carry a new or widened brief plus its code when a human approves it on GitHub. With PR context (`--pr N` / `--repo OWNER/NAME`, or `GITHUB_PR_NUMBER` / `GITHUB_REPOSITORY` in CI), a failing membership check under precommitment or missing authority consults the forge. When a qualifying approval exists, membership evaluates against the **head** brief's concrete `file_scope` instead of the merge-base brief.
+
+- **Mint wins.** A present mint keeps the mint path. The forge is never consulted.
+- **Auth-hash v1** (`sha256:` over canonical JSON; strings byte-exact, no Unicode normalization) covers `plan.id`, the xbrief path, the concrete `file_scope`, and the acceptanceCriteria array: `plan.acceptance`, `plan.narratives.AcceptanceCriteria`, and each item's `narrative.Acceptance`, in document order. `productPullRequest` and other delivery metadata stay out, so a PPR stamp keeps the approval. Any change to the covered fields drops it.
+- **Qualifying approval:** the reviewer's latest deciding review (APPROVED / CHANGES_REQUESTED / DISMISSED) is APPROVED; the reviewer is a `User` (not Bot or App), not the PR author, and has `write`, `maintain` or `admin` on the repo; the repo is the checkout's `origin` (a `--repo` value may only confirm it, so a fork's approval never counts) and is the PR's base repo; the evaluated HEAD is the PR head (or GitHub's merge commit whose second parent is the PR head); and the brief at the reviewed commit hashes the same as the head brief.
+- **Fallback:** missing PR context, no qualifying approval, a hash mismatch, or an unavailable forge keeps today's Path B or mint finding unchanged. The result message adds one `forge approval (#6203)` line with the reason.
+- **Membership only.** The production fence still reads the merge-base brief. A widened brief can pass membership and still fail `production-scope-over-budget`. A brand-new brief has no production fence (as today).
+- **Re-run after approval.** Approval does not re-trigger CI. Re-run the merge gate (or push) after the approval lands.
+- **Residual (#6207):** an agent that holds a second human forge token can satisfy every predicate above. The hash binds the approved bytes; it does not prove independent human intent and does not close that confused-deputy risk. That posture stays open on #6207.
+
+Code: `packages/core/src/scope-provenance/forge-approval.ts`.
+
 #### Path A planning split (#5551)
 
 When an active implementation brief is **outside** the change set, membership is a no-op for that identity (Path A). Supported planning publication is two change sets, not one:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-runtime",
-  "version": "0.129.6",
+  "version": "0.129.8",
   "description": "Directive runtime — pinned product commands, hooks, content, and engine.",
   "license": "MIT",
   "homepage": "https://deftai.github.io/directive/",