@deftai/directive-runtime 0.129.5 → 0.129.7

package/dist/design-critique-ensure-arc-dest.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { type ArcDestInstallMode } from "@deftai/directive-core/dist/design-critique/arc-dest.js";
+export declare const DESIGN_CRITIQUE_ENSURE_ARC_DEST_HELP = "design-critique:ensure-arc-dest \u2014 create/verify arc dest via pin-bin (#6142)\n\nUsage:\n  deft design-critique:ensure-arc-dest --dest-path <path> [--project-root PATH] [--against-implementation SHA] [--install-mode guarded-prep|process-only-no-install] [--json]\n\nOptions:\n  --dest-path PATH          Linked worktree path for the arc dest (required)\n  --project-root PATH       Repo root that owns the worktree (default: cwd)\n  --against-implementation SHA  Fetched PR head SHA (against-implementation pin)\n  --install-mode MODE       guarded-prep (default) or process-only-no-install\n  --json                    Emit structured result\n\nExit codes:\n  0  Dest created or reused with selected install mode\n  1  Operational refuse (prep failed, runtime pin missing, stranger lease, \u2026)\n  2  Config / usage error\n";
+export interface DesignCritiqueEnsureArcDestArgs {
+    destPath: string | null;
+    projectRoot: string;
+    againstImplementationSha: string | null;
+    installMode: ArcDestInstallMode | null;
+    emitJson: boolean;
+    help: boolean;
+    error?: string;
+}
+export declare function parseDesignCritiqueEnsureArcDestArgs(argv: readonly string[]): DesignCritiqueEnsureArcDestArgs;
+export declare function run(argv: readonly string[]): number;
+export declare function main(argv: readonly string[]): number;
+//# sourceMappingURL=design-critique-ensure-arc-dest.d.ts.map

package/dist/design-critique-ensure-arc-dest.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+/**
+ * design-critique:ensure-arc-dest — sanctioned pin-bin arc dest create/verify (#6142).
+ * Defaults to guarded-prep; explicit process-only-no-install for pin-read callers.
+ * Never treat gitignored packages/core/dist as SoT — call this verb instead.
+ */
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { ensureArcDest, } from "../vendor/directive-core/dist/design-critique/arc-dest.js";
+export const DESIGN_CRITIQUE_ENSURE_ARC_DEST_HELP = `design-critique:ensure-arc-dest — create/verify arc dest via pin-bin (#6142)
+
+Usage:
+  deft design-critique:ensure-arc-dest --dest-path <path> [--project-root PATH] [--against-implementation SHA] [--install-mode guarded-prep|process-only-no-install] [--json]
+
+Options:
+  --dest-path PATH          Linked worktree path for the arc dest (required)
+  --project-root PATH       Repo root that owns the worktree (default: cwd)
+  --against-implementation SHA  Fetched PR head SHA (against-implementation pin)
+  --install-mode MODE       guarded-prep (default) or process-only-no-install
+  --json                    Emit structured result
+
+Exit codes:
+  0  Dest created or reused with selected install mode
+  1  Operational refuse (prep failed, runtime pin missing, stranger lease, …)
+  2  Config / usage error
+`;
+export function parseDesignCritiqueEnsureArcDestArgs(argv) {
+    const acc = {
+        destPath: null,
+        projectRoot: ".",
+        againstImplementationSha: null,
+        installMode: null,
+        emitJson: false,
+        help: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--")
+            continue;
+        if (arg === "--help" || arg === "-h")
+            return { ...acc, help: true };
+        if (arg === "--json") {
+            acc.emitJson = true;
+            continue;
+        }
+        if (arg === "--dest-path") {
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return { ...acc, error: "argument --dest-path: expected one argument" };
+            }
+            acc.destPath = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--dest-path=")) {
+            acc.destPath = arg.slice("--dest-path=".length);
+            continue;
+        }
+        if (arg === "--project-root") {
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return { ...acc, error: "argument --project-root: expected one argument" };
+            }
+            acc.projectRoot = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--project-root=")) {
+            acc.projectRoot = arg.slice("--project-root=".length);
+            continue;
+        }
+        if (arg === "--against-implementation") {
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return { ...acc, error: "argument --against-implementation: expected one argument" };
+            }
+            acc.againstImplementationSha = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--against-implementation=")) {
+            acc.againstImplementationSha = arg.slice("--against-implementation=".length);
+            continue;
+        }
+        if (arg === "--install-mode") {
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return { ...acc, error: "argument --install-mode: expected one argument" };
+            }
+            if (value !== "guarded-prep" && value !== "process-only-no-install") {
+                return {
+                    ...acc,
+                    error: "argument --install-mode: expected guarded-prep|process-only-no-install",
+                };
+            }
+            acc.installMode = value;
+            i += 1;
+            continue;
+        }
+        if (arg?.startsWith("--install-mode=")) {
+            const value = arg.slice("--install-mode=".length);
+            if (value !== "guarded-prep" && value !== "process-only-no-install") {
+                return {
+                    ...acc,
+                    error: "argument --install-mode: expected guarded-prep|process-only-no-install",
+                };
+            }
+            acc.installMode = value;
+            continue;
+        }
+        return { ...acc, error: `unknown argument: ${arg}` };
+    }
+    return acc;
+}
+export function run(argv) {
+    const args = parseDesignCritiqueEnsureArcDestArgs(argv);
+    if (args.help) {
+        process.stdout.write(`${DESIGN_CRITIQUE_ENSURE_ARC_DEST_HELP}\n`);
+        return 0;
+    }
+    if (args.error !== undefined) {
+        process.stderr.write(`design-critique:ensure-arc-dest: ${args.error}\n`);
+        return 2;
+    }
+    if (args.destPath === null || args.destPath.trim().length === 0) {
+        process.stderr.write("design-critique:ensure-arc-dest: --dest-path is required\n" +
+            "Remediation: deft design-critique:ensure-arc-dest --dest-path .deft-scratch/worktrees/arc-<N>\n");
+        return 2;
+    }
+    const projectRoot = resolve(args.projectRoot);
+    const destPath = resolve(projectRoot, args.destPath);
+    let result;
+    try {
+        result = ensureArcDest({
+            repoRoot: projectRoot,
+            destPath,
+            againstImplementationSha: args.againstImplementationSha ?? undefined,
+            installMode: args.installMode ?? "guarded-prep",
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (args.emitJson) {
+            process.stdout.write(`${JSON.stringify({ ok: false, code: "ensure-failed", message }, null, 2)}\n`);
+        }
+        else {
+            process.stderr.write(`design-critique:ensure-arc-dest: ${message}\n`);
+        }
+        return 1;
+    }
+    if (args.emitJson) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    }
+    else if (result.ok) {
+        process.stdout.write(`design-critique:ensure-arc-dest: ok dest=${result.destPath} sha=${result.dispatchSha} pin=${result.pinKind} reused=${result.reused}\n`);
+    }
+    else {
+        process.stderr.write(`design-critique:ensure-arc-dest: ${result.code}: ${result.message}\n`);
+    }
+    return result.ok ? 0 : 1;
+}
+export function main(argv) {
+    return run(argv);
+}
+if (process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(run(process.argv.slice(2)));
+}
+//# sourceMappingURL=design-critique-ensure-arc-dest.js.map

package/dist/dispatch.d.ts

@@ -10,7 +10,7 @@ export interface DispatchIo {
     writeErr: (text: string) => void;
 }
 /** CLI modules in packages/cli/src (excluding parity harnesses and bin/index). */
-export declare const CLI_MODULE_VERBS: readonly ["agents-refresh", "cache", "check", "capacity-backfill", "capacity-show", "codebase-default-extractor", "codebase-map", "codebase-map-fresh", "codebase-projection-registry", "codebase-provider", "doctor", "ownership-doctor", "ownership-fix", "verify-ownership", "install-upgrade", "install-uninstall", "migrate-preflight", "migrate-xbrief", "migrate-category-b", "framework-check-updates", "hook-dispatch", "umbrella-current-shape", "changelog-check", "change-init", "commit-lint", "coverage-hotspots", "policy", "authz", "escalation-cli", "pr-closing-keywords", "pr-merge-readiness", "pr-monitor", "pr-protected-issues", "pr-wait-mergeable", "pr-watch", "pr-finish-loop", "directive-finish-loop", "pre-pr-run", "preflight-cache", "preflight-gh", "probe-session", "release", "release-e2e", "release-publish", "release-rollback", "release-wait-npm", "scope-lifecycle", "scope-record-approved-scope", "scope-record-observable-scope", "scope-record-intent-constraint", "scm-sync-default", "lifecycle-event", "lifecycle-stats", "session-start", "session-ready", "occupancy-steal", "occupancy-release", "occupancy-heartbeat", "occupancy-grant", "plan-sequence", "slice", "subagent-monitor", "toolchain-check", "triage-actions", "triage-bootstrap", "triage-bulk", "triage-classify", "triage-strip-withdrawn", "triage-evaluate", "triage-help", "triage-queue", "triage-reconcile", "triage-refresh", "triage-scope", "triage-scope-drift", "triage-smoketest", "triage-subscribe", "triage-summary", "triage-welcome", "ts-check-lane", "vbrief-activate", "vbrief-build", "vbrief-preflight", "vbrief-reconcile", "vbrief-validate", "vbrief-validation", "xbrief-create", "xbrief-verify", "xbrief-adopt-stored-plan-id", "verify-branch", "verify-encoding", "verify-forward-coverage", "verify-test-boundary", "verify-class-checks", "verify-presentation-coverage", "verify-scope-provenance", "verify-consumer-check-contract", "verify-hooks-installed", "verify-investigation", "verify-judgment-gates", "verify-no-task-runtime", "validate-links", "validate-strategy-output", "verify-biome-config", "verify-bridge-drift", "verify-capacity", "verify-contained-writes", "verify-telemetry-coverage", "verify-content-manifest", "verify-deposit-closure", "verify-consumer-hard-stops", "verify-closing-keywords", "verify-skill-external-fetch-gate", "verify-semantic-single-source", "verify-contract-drift", "verify-cursor-tier1", "verify-openclaw-tier1", "verify-go-freeze", "verify-scm-boundary", "verify-session-ritual", "verify-plan-sequence", "verify-stubs", "verify-xbrief-drift", "verify-spec-prd-fresh", "verify-spec-drift", "rule-ownership-lint", "verify-story-ready", "verify-review-monitor", "verify-cohort-review-monitors", "verify-l4-owner", "verify-subagent-alive", "verify-subagent-steer", "subagent-pre-cancel", "subagent-steer-write", "design-critique-spend-resolve", "review-monitor-register", "review-monitor-release", "verify-tools", "verify-wip-cap", "verify-orphan-active", "verify-pr-closeout-attestable", "verify-lifecycle-visible", "verify-completed-tracked", "verify-completed-write-guard", "verify-literal-ac", "verify-ac", "verify-agents-md-budget", "verify-consumer-header-placeholder", "verify-agents-md-advisory", "verify-persisted-planning-narratives", "verify-eval-health-relocation", "verify-eval-triggers-relocation", "verify-evaluator-surface", "verify-observable-scope", "verify-operator-scope-limit", "verify-presentation-ceiling", "verify-intent-constraint", "verify-durable-effect-acquisition", "verify-consumer-test-lane", "eval-health", "eval-run", "eval-report", "eval-triggers"];
+export declare const CLI_MODULE_VERBS: readonly ["agents-refresh", "cache", "check", "capacity-backfill", "capacity-show", "codebase-default-extractor", "codebase-map", "codebase-map-fresh", "codebase-projection-registry", "codebase-provider", "doctor", "ownership-doctor", "ownership-fix", "verify-ownership", "install-upgrade", "install-uninstall", "migrate-preflight", "migrate-xbrief", "migrate-category-b", "framework-check-updates", "hook-dispatch", "umbrella-current-shape", "changelog-check", "change-init", "commit-lint", "coverage-hotspots", "policy", "authz", "escalation-cli", "pr-closing-keywords", "pr-merge-readiness", "pr-monitor", "pr-protected-issues", "pr-wait-mergeable", "pr-watch", "pr-finish-loop", "directive-finish-loop", "pre-pr-run", "preflight-cache", "preflight-gh", "probe-session", "release", "release-e2e", "release-publish", "release-rollback", "release-wait-npm", "scope-lifecycle", "scope-record-approved-scope", "scope-record-observable-scope", "scope-record-intent-constraint", "scm-sync-default", "lifecycle-event", "lifecycle-stats", "session-start", "session-ready", "occupancy-steal", "occupancy-release", "occupancy-heartbeat", "occupancy-grant", "applying-host-release", "plan-sequence", "slice", "subagent-monitor", "toolchain-check", "triage-actions", "triage-bootstrap", "triage-bulk", "triage-classify", "triage-strip-withdrawn", "triage-evaluate", "triage-help", "triage-queue", "triage-reconcile", "triage-refresh", "triage-scope", "triage-scope-drift", "triage-smoketest", "triage-subscribe", "triage-summary", "triage-welcome", "ts-check-lane", "vbrief-activate", "vbrief-build", "vbrief-preflight", "vbrief-reconcile", "vbrief-validate", "vbrief-validation", "xbrief-create", "xbrief-verify", "xbrief-adopt-stored-plan-id", "verify-branch", "verify-encoding", "verify-forward-coverage", "verify-test-boundary", "verify-class-checks", "verify-presentation-coverage", "verify-scope-provenance", "verify-consumer-check-contract", "verify-hooks-installed", "verify-investigation", "verify-judgment-gates", "verify-no-task-runtime", "validate-links", "validate-strategy-output", "verify-biome-config", "verify-bridge-drift", "verify-capacity", "verify-contained-writes", "verify-telemetry-coverage", "verify-content-manifest", "verify-deposit-closure", "verify-consumer-hard-stops", "verify-closing-keywords", "verify-skill-external-fetch-gate", "verify-semantic-single-source", "verify-contract-drift", "verify-cursor-tier1", "verify-openclaw-tier1", "verify-go-freeze", "verify-scm-boundary", "verify-session-ritual", "verify-plan-sequence", "verify-stubs", "verify-xbrief-drift", "verify-spec-prd-fresh", "verify-spec-drift", "rule-ownership-lint", "verify-story-ready", "verify-review-monitor", "verify-cohort-review-monitors", "verify-l4-owner", "verify-subagent-alive", "verify-subagent-steer", "subagent-pre-cancel", "subagent-steer-write", "design-critique-spend-resolve", "design-critique-ensure-arc-dest", "review-monitor-register", "review-monitor-release", "verify-tools", "verify-wip-cap", "verify-orphan-active", "verify-pr-closeout-attestable", "verify-lifecycle-visible", "verify-completed-tracked", "verify-completed-write-guard", "verify-literal-ac", "verify-ac", "verify-agents-md-budget", "verify-consumer-header-placeholder", "verify-agents-md-advisory", "verify-persisted-planning-narratives", "verify-eval-health-relocation", "verify-eval-triggers-relocation", "verify-evaluator-surface", "verify-observable-scope", "verify-operator-scope-limit", "verify-presentation-ceiling", "verify-intent-constraint", "verify-durable-effect-acquisition", "verify-consumer-test-lane", "eval-health", "eval-run", "eval-report", "eval-triggers"];
 /** Core-only CLI entrypoints without a packages/cli wrapper. */
 export declare const CORE_MODULE_VERBS: readonly ["scm", "scm-readiness", "github-auth-modes", "github-body", "issue-emit", "issue-ingest", "issue-sync-from-xbrief", "reconcile-issues", "swarm-launch", "swarm-complete-cohort", "swarm-finalize-cohort", "swarm-finalize-owed", "swarm-pre-dispatch", "swarm-readiness", "swarm-routing-verify", "swarm-routing-set", "swarm-verify-review-clean", "swarm-worktrees", "framework-commands", "pack-render", "packs-slice", "prd-render", "export-spec", "project-render", "project-write-narratives", "roadmap-render", "rule-map", "capability-map", "spec-render", "spec-reconstruct", "spec-validate", "code-structure-validate", "pack-migrate-skills", "pack-migrate-rules", "pack-migrate-strategies", "pack-migrate-patterns", "pack-migrate-swarm-spec", "policy-set", "setup-ghx", "scope-undo", "scope-demote", "scope-decompose", "changelog-resolve-unreleased", "architecture-preflight-sor", "feedback-file", "value-readback", "product-signal", "freshness-report", "decision-write", "decision-list", "docs-impact", "tutorial", "migrate-clause-ids", "migrate-confidence", "rule-to-verb-parity"];
 /** Colon aliases for triage-actions (mirrors cli-router SUBCOMMAND_ROUTES). */

package/dist/dispatch.js

@@ -86,6 +86,7 @@ export const CLI_MODULE_VERBS = [
     "occupancy-release",
     "occupancy-heartbeat",
     "occupancy-grant",
+    "applying-host-release",
     "plan-sequence",
     "slice",
     "subagent-monitor",
@@ -162,6 +163,7 @@ export const CLI_MODULE_VERBS = [
     "subagent-pre-cancel",
     "subagent-steer-write",
     "design-critique-spend-resolve",
+    "design-critique-ensure-arc-dest",
     "review-monitor-register",
     "review-monitor-release",
     "verify-tools",
@@ -398,6 +400,7 @@ export const VERB_ALIASES = {
     "subagent:pre-cancel": "subagent-pre-cancel",
     "subagent:steer": "subagent-steer-write",
     "design-critique:spend-resolve": "design-critique-spend-resolve",
+    "design-critique:ensure-arc-dest": "design-critique-ensure-arc-dest",
     "agent:monitor": "subagent-monitor",
     "review-monitor:register": "review-monitor-register",
     "review-monitor:release": "review-monitor-release",
@@ -465,6 +468,7 @@ export const VERB_ALIASES = {
     "occupancy:release": "occupancy-release",
     "occupancy:heartbeat": "occupancy-heartbeat",
     "occupancy:grant": "occupancy-grant",
+    "applying-host:release": "applying-host-release",
     "session:end": "occupancy-release",
     ...FRESHNESS_COLON_ALIASES,
     "lifecycle:event": "lifecycle-event",
@@ -2839,6 +2843,10 @@ const CURATED_HELP_GROUPS = [
                 name: "session:end",
                 summary: "End this mutation session by releasing occupancy (same as occupancy:release)",
             },
+            {
+                name: "applying-host:release",
+                summary: "Clear the worktree applying-host soft claim (owner or abandoned no-lease)",
+            },
             {
                 name: "freshness:report",
                 summary: "Bound vs live deposit generation (current|stale_soft|stale_hard)",

package/dist/hook-dispatch.js

@@ -3,7 +3,7 @@ import { readFileSync, realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { checkCheapInSync } from "../vendor/directive-core/dist/install-health/cheap.js";
-import { INSTALLATION_RECOVERY_GUIDANCE } from "../vendor/directive-core/dist/install-health/constants.js";
+import { HOOK_ROOT_MISMATCH_RECOVERY_GUIDANCE, INSTALLATION_RECOVERY_GUIDANCE, } from "../vendor/directive-core/dist/install-health/constants.js";
 import { decideHook, hookPayloadTopLevelKeys, isHookEvent, isHookHost, mergeHookDispatchEnviron, normalizeHookProjectRoot, parseHookStdin, projectRootFromHookPayload, renderHostDecision, } from "../vendor/directive-core/dist/hooks/index.js";
 import { readProjectDataStatus } from "./data-status.js";
 import { maybeSelfCompleteSetup } from "./self-complete.js";
@@ -216,7 +216,7 @@ export function run(argv, seams = {}) {
     // owns the running hook-bin. Mismatch → fail closed (no setup, no policy).
     const launchRoot = (seams.launchingCheckoutRoot ?? resolveLaunchingCheckoutRoot)();
     if (launchRoot !== null && !rootsMatch(launchRoot, projectRoot)) {
-        const guidance = INSTALLATION_RECOVERY_GUIDANCE;
+        const guidance = HOOK_ROOT_MISMATCH_RECOVERY_GUIDANCE;
         const decision = installationIdentityDeny(args.host, args.event, projectRoot, `Directive hook refuse: payload project root does not match the launching checkout ` +
             `(payloadRoot=${normalizeHookProjectRoot(projectRoot)} ` +
             `launchRoot=${normalizeHookProjectRoot(launchRoot)}). Recovery: ${guidance}`);
@@ -226,6 +226,7 @@ export function run(argv, seams = {}) {
         return 0;
     }
     // Wave 2k / AC9.4+AC14.8: pin≠installed → fail closed before policy.
+    // #6013/#5893: pin≠installed recovery names project PM install (not AC9.7).
     // #5910: overlay-present also fail-closes (even when versions match); recovery
     // names frozen-lockfile restore then overlay retirement.
     const cheap = (seams.cheapInSync ?? checkCheapInSync)(projectRoot);

package/dist/human-presence-mint.d.ts

@@ -3,7 +3,7 @@
  * (pseudo-terminal residual; #3110 Greptile). Presence refuses mint.
  * Expanded for dogfood conf 5/5 — markers are fail-closed (any non-empty value).
  */
-export declare const AUTHZ_AGENT_SHELL_ENV_MARKERS: readonly ["CLAUDECODE", "CLAUDE_CODE", "CLAUDE_CODE_ENTRYPOINT", "CURSOR_AGENT", "CURSOR_TRACE_ID", "CURSOR_SESSION_ID", "AIDER", "CONTINUE_CLI", "CODEX_SANDBOX", "CODEX_CI", "OPENAI_CODEX", "OPENCLAW", "OPENCLAW_STATE_DIR", "DEFT_PROBE_OPENCLAW", "DEFT_HOOK_HOST", "DEFT_AGENT_SHELL", "DEFT_AGENT_RUNTIME", "WARP_SESSION_ID", "WARP_HARNESS", "WARP_RUN_ID", "GEMINI_CLI", "AMP_CLI", "SWARM_AGENT", "AI_AGENT", "CI", "CONTINUOUS_INTEGRATION", "GITHUB_ACTIONS", "GITLAB_CI", "CIRCLECI", "BUILDKITE", "TRAVIS", "JENKINS_URL", "TEAMCITY_VERSION", "TF_BUILD", "APPVEYOR", "BITBUCKET_BUILD_NUMBER", "CODEBUILD_BUILD_ID"];
+export declare const AUTHZ_AGENT_SHELL_ENV_MARKERS: readonly ["CLAUDECODE", "CLAUDE_CODE", "CLAUDE_CODE_ENTRYPOINT", "CURSOR_AGENT", "CURSOR_TRACE_ID", "CURSOR_SESSION_ID", "AIDER", "CONTINUE_CLI", "CODEX_SANDBOX", "CODEX_CI", "OPENAI_CODEX", "GROK_AGENT", "GROK_SESSION_ID", "OPENCLAW", "OPENCLAW_STATE_DIR", "DEFT_PROBE_OPENCLAW", "DEFT_HOOK_HOST", "DEFT_AGENT_SHELL", "DEFT_AGENT_RUNTIME", "WARP_SESSION_ID", "WARP_HARNESS", "WARP_RUN_ID", "GEMINI_CLI", "AMP_CLI", "SWARM_AGENT", "AI_AGENT", "CI", "CONTINUOUS_INTEGRATION", "GITHUB_ACTIONS", "GITLAB_CI", "CIRCLECI", "BUILDKITE", "TRAVIS", "JENKINS_URL", "TEAMCITY_VERSION", "TF_BUILD", "APPVEYOR", "BITBUCKET_BUILD_NUMBER", "CODEBUILD_BUILD_ID"];
 /** Phrase an operator must type on the controlling TTY after --confirm (#3110). */
 export declare const AUTHZ_INTERACTIVE_CONFIRM_PHRASE = "mint";
 /** Testable seams for TTY / agent-shell detection (#3110 / #3384). */
@@ -26,6 +26,11 @@ export interface HumanPresenceMintSeams {
      */
     readonly readInteractiveConfirm?: () => string | null;
 }
+/**
+ * Matching agent/CI shell marker keys in AUTHZ_AGENT_SHELL_ENV_MARKERS order.
+ * Blank or whitespace-only values do not match (return []).
+ */
+export declare function detectedAgentShellMarkers(environ: NodeJS.ProcessEnv): string[];
 export declare function looksLikeAgentShell(environ: NodeJS.ProcessEnv): boolean;
 /** Platform controlling-terminal path (`\\.\CONIN$` on win32, `/dev/tty` elsewhere). */
 export declare function controllingTerminalPath(platform?: NodeJS.Platform): string;

package/dist/human-presence-mint.js

@@ -26,6 +26,9 @@ export const AUTHZ_AGENT_SHELL_ENV_MARKERS = [
     "CODEX_SANDBOX",
     "CODEX_CI",
     "OPENAI_CODEX",
+    // Grok Build shell markers (#5983 Prefer-A Recut-2): exact names only, both unconditional.
+    "GROK_AGENT",
+    "GROK_SESSION_ID",
     "OPENCLAW",
     "OPENCLAW_STATE_DIR",
     "DEFT_PROBE_OPENCLAW",
@@ -56,13 +59,21 @@ export const AUTHZ_AGENT_SHELL_ENV_MARKERS = [
 ];
 /** Phrase an operator must type on the controlling TTY after --confirm (#3110). */
 export const AUTHZ_INTERACTIVE_CONFIRM_PHRASE = "mint";
-export function looksLikeAgentShell(environ) {
+/**
+ * Matching agent/CI shell marker keys in AUTHZ_AGENT_SHELL_ENV_MARKERS order.
+ * Blank or whitespace-only values do not match (return []).
+ */
+export function detectedAgentShellMarkers(environ) {
+    const matched = [];
     for (const key of AUTHZ_AGENT_SHELL_ENV_MARKERS) {
         const v = environ[key];
         if (v !== undefined && String(v).trim().length > 0)
-            return true;
+            matched.push(key);
     }
-    return false;
+    return matched;
+}
+export function looksLikeAgentShell(environ) {
+    return detectedAgentShellMarkers(environ).length > 0;
 }
 function defaultIsTty() {
     return process.stdin.isTTY === true && process.stdout.isTTY === true;
@@ -163,10 +174,13 @@ export function refuseMintWhileUatActive(verb, projectRoot) {
  */
 export function refuseNonInteractiveMint(input) {
     const { verb, confirm } = input;
-    if (looksLikeAgentShell(input.environ)) {
+    const matchedMarkers = detectedAgentShellMarkers(input.environ);
+    if (matchedMarkers.length > 0) {
+        const named = matchedMarkers.join(", ");
         process.stderr.write(`${verb}: refusing operator-cli stamp from an agent/host/CI shell ` +
-            `(detected agent or CI env marker). Mint requires a human interactive ` +
-            "TTY without agent-shell markers, plus --confirm and typed phrase (#3110).\n");
+            `(matched agent-shell env markers: ${named}). Unset ${named} and retry ` +
+            "from a human interactive TTY without agent-shell markers, plus --confirm " +
+            "and typed phrase (#3110 / #5983).\n");
         return 2;
     }
     const tty = input.isTty();

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,
@@ -523,12 +531,15 @@ export function run(argv) {
     if (stray) {
         lines.push(stray);
     }
-    // #5676: read-only may bootstrap the applying-host record; mutation/rearm
+    // #5676 / #6101: 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.
+    // Helper owns the live-occupant skip; CLI surfaces published / deferred / failed
+    // (deferred distinct from non-canonical null) without claiming conflict recovery.
     const disabled = typeof result.payload === "object" &&
         result.payload !== null &&
         result.payload.disabled === true;
+    let applyingHostPublish = { status: "skipped" };
     if (result.code === 0 && !disabled) {
         const owner = args.sessionId?.trim() ||
             (typeof result.payload.occupancy === "object" &&
@@ -541,37 +552,81 @@ export function run(argv) {
         if (owner.length > 0) {
             try {
                 const transport = process.env.GROK_HOOK_EVENT?.trim() ? "grok-hook-event" : "native";
-                publishApplyingHostFromCanonicalSessionId(projectRoot, owner, {
+                const published = publishApplyingHostFromCanonicalSessionId(projectRoot, owner, {
                     transport: owner.startsWith("host:cursor:") ? "native" : transport,
                 });
+                if (published === null) {
+                    applyingHostPublish = { status: "non-canonical" };
+                }
+                else if (published.status === "published") {
+                    applyingHostPublish = {
+                        status: "published",
+                        applyingHostSessionId: published.record.applyingHostSessionId,
+                    };
+                }
+                else {
+                    applyingHostPublish = {
+                        status: "deferred",
+                        reason: published.reason,
+                        liveSessionId: published.liveSessionId,
+                        attemptedSessionId: published.attemptedSessionId,
+                    };
+                }
             }
-            catch {
-                /* ceremony success stays authoritative; applying-host is best-effort */
+            catch (err) {
+                applyingHostPublish = {
+                    status: "failed",
+                    message: err instanceof Error ? err.message : String(err),
+                };
             }
         }
     }
+    const payloadWithPublish = applyingHostPublish.status === "skipped"
+        ? result.payload
+        : { ...result.payload, applyingHostPublish };
     if (args.emitJson) {
-        const sorted = Object.keys(result.payload)
+        const sorted = Object.keys(payloadWithPublish)
             .sort()
             .reduce((acc, key) => {
-            acc[key] = result.payload[key];
+            acc[key] = payloadWithPublish[key];
             return acc;
         }, {});
         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") {
+            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.");
+        }
+        else if (applyingHostPublish.status === "failed") {
+            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;
 }

package/dist/setup-wiring.d.ts

@@ -14,6 +14,15 @@ export type TrackResult = {
     conflict?: boolean;
     conflictReason?: string;
 };
+/** Normalize CRLF/CR to LF for ownership/wrapper equality (#5995). */
+export declare function normalizeEol(text: string): string;
+/** True when two texts differ only by end-of-line convention (#5995). */
+export declare function contentsEqualIgnoringEol(a: string, b: string): boolean;
+/**
+ * `.githooks` shell entrypoints must be LF on disk for `sh` (#5995 / PR #6151 P1).
+ * Ownership stays EOL-insensitive; these paths still rewrite CRLF-only drift.
+ */
+export declare function isShellHookEntrypoint(rel: string): boolean;
 /**
  * Resolve deft skill pointer target (AC9.6). Prefer skills/deft/SKILL.md when
  * present in this runtime package; otherwise keep working package-root SKILL.md.
@@ -48,6 +57,32 @@ export declare function ensureSkillPointers(projectRoot: string): {
 };
 /** All wholly owned skill pointer paths (host roots × inventory). */
 export declare function listSkillPointerPaths(): string[];
+/**
+ * True when `rel` has unstaged worktree edits vs the index (#6151 P1).
+ * No repo / no git / clean path → false (safe to report modified for staging).
+ */
+export declare function pathHasUnstagedChanges(projectRoot: string, rel: string): boolean;
+/** Left-unstaged disclosure when LF pins land on a dirty `.gitattributes` (#6151 P1). */
+export declare const GITATTRIBUTES_STAGING_SKIPPED_DIRTY = ".gitattributes had unstaged local edits; LF pins were written but left unstaged so install/upgrade does not git add unrelated user changes (#6151 P1)";
+/**
+ * True when every attribute line is a known Directive core/managed marker (or
+ * Deft deposit comment). Foreign rules mean the file is not pure Directive-owned
+ * (#6151 P1 dirty-skip heuristic).
+ */
+export declare function isDirectiveManagedGitattributes(content: string): boolean;
+/**
+ * Deposit narrow LF .gitattributes for managed wiring paths (#5995).
+ * Reuses scaffold ensureGitattributes (core markers + managed wiring lines).
+ * Reports created/modified so install/upgrade staging commits the pins (#6151 P1).
+ * When the path already has unstaged user edits (or an untracked foreign file),
+ * still appends missing pins but does not report modified (avoids staging WIP).
+ */
+export declare function ensureManagedPathGitattributes(projectRoot: string): {
+    created: boolean;
+    modified: boolean;
+    wrote: boolean;
+    stagingSkippedNotice?: string;
+};
 /**
  * Deposit host slash/prompt thin wrappers with package-relative targets (AC8.1 / AC8.10).
  * Reuses emitter inventory; does not revive .deft/core teaching.
@@ -57,6 +92,7 @@ export declare function ensureSlashCommands(projectRoot: string): {
     created: string[];
     modified: string[];
     conflicts: string[];
+    notices: string[];
 };
 /**
  * Verified managed slash/prompt paths from the emitter inventory (AC8.1 / AC11.10).