@deftai/directive-core 0.105.0 → 0.107.0

package/dist/lifecycle-visible/index.d.ts

@@ -0,0 +1,2 @@
+export { type CheckIgnoreMatch, displayIgnoreSource, evaluateLifecycleVisible, formatLifecycleVisibleSessionLines, indexFlagKind, isSelectiveLifecyclePath, LIFECYCLE_ROOT_PREFIXES, LIFECYCLE_STAGE_DIRS, type LifecycleHideFinding, type LifecycleHideKind, type LifecycleVisibleOptions, type LifecycleVisibleResult, type LsFilesVerboseRecord, lifecycleRootRelPaths, parseCheckIgnoreVerboseLine, parseLsFilesVerboseRecord, } from "./evaluate.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/lifecycle-visible/index.js

@@ -0,0 +1,2 @@
+export { displayIgnoreSource, evaluateLifecycleVisible, formatLifecycleVisibleSessionLines, indexFlagKind, isSelectiveLifecyclePath, LIFECYCLE_ROOT_PREFIXES, LIFECYCLE_STAGE_DIRS, lifecycleRootRelPaths, parseCheckIgnoreVerboseLine, parseLsFilesVerboseRecord, } from "./evaluate.js";
+//# sourceMappingURL=index.js.map

package/dist/literal-acceptance/capture.d.ts

@@ -9,6 +9,17 @@
  * so distinct execution contexts are not collapsed.
  */
 import type { LiteralAcceptanceCommand, RejectedLiteralCommand } from "./types.js";
+/** Reason stamped when an inline backtick is recorded as a mention, not AC (#3721). */
+export declare const INLINE_PROSE_MENTION_REASON = "inline backtick in prose is a mention, not a stated acceptance command (#3721)";
+/**
+ * True when a capture-only row came from an inline backtick in prose (#3721).
+ * Those mentions are not stated acceptance commands. Labeled, prompt, and fence
+ * spans stay stated.
+ */
+export declare function isInlineProseMention(cmd: {
+    readonly source?: string;
+    readonly sourceSpan?: string | null;
+}): boolean;
 /** Result of capture including the operator-visible rejected ledger. */
 export interface CaptureLiteralAcceptanceResult {
     readonly commands: readonly LiteralAcceptanceCommand[];
@@ -57,6 +68,11 @@ export declare function isProseDerivedRejection(rejected: RejectedLiteralCommand
  * prose-derived rejections no longer depends on this (#3511).
  */
 export declare function hasStructuredAcceptanceCommands(plan: Record<string, unknown> | null | undefined): boolean;
+/**
+ * Command strings the operator recorded as not acceptance commands (#3721).
+ * Listing a string here dispositions a capture without asserting it is AC.
+ */
+export declare function readNotAcceptanceCommands(plan: Record<string, unknown> | null | undefined): ReadonlySet<string>;
 /** Format rejected ledger for CLI / complete-gate messages. */
 export declare function formatRejectedLedger(rejected: readonly RejectedLiteralCommand[]): string;
 //# sourceMappingURL=capture.d.ts.map

package/dist/literal-acceptance/capture.js

@@ -9,7 +9,7 @@
  * so distinct execution contexts are not collapsed.
  */
 import { evaluateCommandSafety } from "./safety.js";
-import { EXECUTABLE_LITERAL_SOURCES, LITERAL_ACCEPTANCE_REJECTED_METADATA_KEY } from "./types.js";
+import { EXECUTABLE_LITERAL_SOURCES, LITERAL_ACCEPTANCE_NOT_COMMANDS_METADATA_KEY, LITERAL_ACCEPTANCE_REJECTED_METADATA_KEY, } from "./types.js";
 /** Labeled keywords (single-token, linear match). */
 const LABELED_KEYWORDS = new Set(["verify", "command", "run", "check", "exec", "shell"]);
 /** Words that look like a CLI invocation start (not prose). */
@@ -85,8 +85,24 @@ function pushCommand(buckets, cmd) {
         return;
     }
     const key = commandDedupeKey(cmd);
-    if (buckets.seen.has(key))
+    if (buckets.seen.has(key)) {
+        const idx = buckets.out.findIndex((row) => commandDedupeKey(row) === key);
+        const existing = idx >= 0 ? buckets.out[idx] : undefined;
+        if (existing !== undefined &&
+            idx >= 0 &&
+            isInlineProseMention(existing) &&
+            isExecutableSource(cmd.source)) {
+            buckets.out[idx] = {
+                command: cmd.command,
+                cwd: cmd.cwd ?? null,
+                expectedStdout: cmd.expectedStdout ?? null,
+                expectedExitCode: cmd.expectedExitCode ?? 0,
+                source: cmd.source,
+                sourceSpan: cmd.sourceSpan ?? null,
+            };
+        }
         return;
+    }
     buckets.seen.add(key);
     buckets.out.push({
         command: cmd.command,
@@ -167,12 +183,12 @@ function matchLabeledCommand(line) {
         return null;
     return line.slice(i).trimEnd();
 }
-/** `$ cmd` or `> cmd` prompt lines. */
+/** `$ cmd` prompt lines. Markdown blockquote `>` is not a prompt (#3572). */
 function matchPromptCommand(line) {
     let i = skipWs(line, 0);
     if (i >= line.length)
         return null;
-    if (line[i] !== "$" && line[i] !== ">")
+    if (line[i] !== "$")
         return null;
     i = skipWs(line, i + 1);
     if (i >= line.length)
@@ -259,7 +275,7 @@ function flushFenceBody(body, fenceLang, fenceStartLine, requireRegion, regionAc
         return;
     if (!isShellFenceLang(fenceLang))
         return;
-    // Transcript lines are skipped. `$`/`>` prompts inside a transcript fence are
+    // Transcript lines are skipped. `$` prompts inside a transcript fence are
     // suggested-fixes (biome migrate), not stated AC (#3511). Comments do not
     // mark a fence as transcript, so a genuine command next to `# Error:` still
     // captures.
@@ -382,8 +398,9 @@ function matchMarkdownHeading(line) {
  * marker). Mid-line label capture is deliberately not attempted (#3484): a
  * `verify:<verb>` token inside ordinary prose has no terminator, so the capture
  * swallowed the rest of the paragraph and the phantom then blocked completion on
- * the safety ledger. Commands stated mid-sentence must live in a fence, a `$`
- * prompt, or an inline backtick span — all of which have real delimiters.
+ * the safety ledger. Commands stated mid-sentence must live in a fence or a `$`
+ * prompt. An inline backtick inside a prose sentence is a reference, not a
+ * stated command (#3721).
  */
 function extractFromLabeledLines(text, buckets) {
     const lines = text.split(/\r?\n/);
@@ -412,9 +429,13 @@ function extractFromLabeledLines(text, buckets) {
         }
     }
 }
+/** Reason stamped when an inline backtick is recorded as a mention, not AC (#3721). */
+export const INLINE_PROSE_MENTION_REASON = "inline backtick in prose is a mention, not a stated acceptance command (#3721)";
 /**
  * Extract inline `` `command` `` spans that follow verify/run language on the same line.
- * Example: `run \`task check\` before done`
+ * These are references, not stated acceptance commands (#3721). Recorded on the
+ * rejected ledger with an `inline@` span so #3511 demotes them to advisory.
+ * They must not enter the stated-command list (that would require promotion).
  */
 function extractInlineVerifySpans(text, buckets) {
     const lines = text.split(/\r?\n/);
@@ -440,10 +461,23 @@ function extractInlineVerifySpans(text, buckets) {
             const normalized = normalizeCommand(inner);
             if (normalized === null || !looksLikeShellCommand(normalized))
                 continue;
-            pushUnique(buckets, normalized, "task_statement", `inline@L${i + 1}`);
+            recordRejected(buckets, normalized, INLINE_PROSE_MENTION_REASON, `inline@L${i + 1}`);
         }
     }
 }
+/**
+ * True when a capture-only row came from an inline backtick in prose (#3721).
+ * Those mentions are not stated acceptance commands. Labeled, prompt, and fence
+ * spans stay stated.
+ */
+export function isInlineProseMention(cmd) {
+    if (cmd.source !== "task_statement")
+        return false;
+    const span = cmd.sourceSpan;
+    if (span === null || span === undefined)
+        return false;
+    return span.startsWith("inline@");
+}
 function emptyBuckets() {
     return {
         out: [],
@@ -519,7 +553,7 @@ export function readStoredLiteralAcceptanceDetailed(plan) {
             // swarm.verify_commands is a string list (legacy). Prefer richer
             // literal_acceptance_commands rows already loaded — do not invent a
             // null-cwd duplicate for the same command text.
-            const alreadyHasCommand = (command) => buckets.out.some((c) => c.command === command);
+            const alreadyHasCommand = (command) => buckets.out.some((c) => c.command === command && !isInlineProseMention(c));
             for (const cmd of coerceCommandList(swarm.verify_commands, "verify_commands", "swarm.verify_commands")) {
                 if (alreadyHasCommand(cmd.command))
                     continue;
@@ -793,6 +827,40 @@ export function hasStructuredAcceptanceCommands(plan) {
         return false;
     return hasNonEmptyCommandList(swarm.verify_commands);
 }
+/**
+ * Command strings the operator recorded as not acceptance commands (#3721).
+ * Listing a string here dispositions a capture without asserting it is AC.
+ */
+export function readNotAcceptanceCommands(plan) {
+    const rec = asRecord(plan);
+    if (rec === null)
+        return new Set();
+    const metadata = asRecord(rec.metadata);
+    if (metadata === null)
+        return new Set();
+    const raw = metadata[LITERAL_ACCEPTANCE_NOT_COMMANDS_METADATA_KEY] ??
+        metadata.literalAcceptanceNotCommands ??
+        null;
+    const out = new Set();
+    if (typeof raw === "string" && raw.trim().length > 0) {
+        out.add(raw.trim());
+        return out;
+    }
+    if (!Array.isArray(raw))
+        return out;
+    for (const entry of raw) {
+        if (typeof entry === "string" && entry.trim().length > 0) {
+            out.add(entry.trim());
+            continue;
+        }
+        const row = asRecord(entry);
+        if (row === null)
+            continue;
+        if (isNonEmptyString(row.command))
+            out.add(row.command.trim());
+    }
+    return out;
+}
 /** Format rejected ledger for CLI / complete-gate messages. */
 export function formatRejectedLedger(rejected) {
     if (rejected.length === 0)

package/dist/literal-acceptance/evaluate.js

@@ -3,7 +3,7 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { captureLiteralAcceptanceCommandsDetailed, formatRejectedLedger, isProseDerivedRejection, readStoredLiteralAcceptanceDetailed, } from "./capture.js";
+import { captureLiteralAcceptanceCommandsDetailed, formatRejectedLedger, INLINE_PROSE_MENTION_REASON, isInlineProseMention, isProseDerivedRejection, readNotAcceptanceCommands, readStoredLiteralAcceptanceDetailed, } from "./capture.js";
 import { runLiteralAcceptanceCommands } from "./run.js";
 function asRecord(value) {
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
@@ -40,11 +40,33 @@ function partitionRejected(rejected) {
  */
 export function resolveLiteralAcceptanceDetailed(plan, options = {}) {
     const raw = resolveRawLiteralAcceptance(plan, options);
+    const notCommands = readNotAcceptanceCommands(plan);
+    const stated = [];
+    const mentionAdvisory = [];
+    for (const c of raw.commands) {
+        if (isInlineProseMention(c)) {
+            mentionAdvisory.push({
+                command: c.command,
+                reason: INLINE_PROSE_MENTION_REASON,
+                sourceSpan: c.sourceSpan ?? null,
+            });
+            continue;
+        }
+        if (c.source === "task_statement" && notCommands.has(c.command)) {
+            mentionAdvisory.push({
+                command: c.command,
+                reason: "operator recorded this capture as not an acceptance command (#3721)",
+                sourceSpan: c.sourceSpan ?? null,
+            });
+            continue;
+        }
+        stated.push(c);
+    }
     const split = partitionRejected(raw.rejected);
     return {
-        commands: raw.commands,
+        commands: stated,
         rejected: split.blocking,
-        advisoryRejected: split.advisory,
+        advisoryRejected: [...split.advisory, ...mentionAdvisory],
         transcriptPromptSkipped: raw.transcriptPromptSkipped,
     };
 }

package/dist/literal-acceptance/index.d.ts

@@ -4,9 +4,9 @@
  * Capture exact stated shell commands at intake; run them verbatim before done.
  * Extends #973; survives ceremony dial rapid/minimal (#3214).
  */
-export { attachLiteralAcceptanceCommands, type CaptureLiteralAcceptanceResult, captureAndAttachLiteralAcceptance, captureLiteralAcceptanceCommands, captureLiteralAcceptanceCommandsDetailed, formatRejectedLedger, hasStructuredAcceptanceCommands, isProseDerivedRejection, readStoredLiteralAcceptanceCommands, readStoredLiteralAcceptanceDetailed, } from "./capture.js";
+export { attachLiteralAcceptanceCommands, type CaptureLiteralAcceptanceResult, captureAndAttachLiteralAcceptance, captureLiteralAcceptanceCommands, captureLiteralAcceptanceCommandsDetailed, formatRejectedLedger, hasStructuredAcceptanceCommands, INLINE_PROSE_MENTION_REASON, isInlineProseMention, isProseDerivedRejection, readNotAcceptanceCommands, readStoredLiteralAcceptanceCommands, readStoredLiteralAcceptanceDetailed, } from "./capture.js";
 export { appendLiteralAcceptanceAdvisory, type EvaluateLiteralAcceptanceOptions, evaluateLiteralAcceptanceFromPath, evaluateLiteralAcceptanceFromPlan, formatLiteralAcceptanceAdvisory, isLiteralAcceptanceRequiredAtCeremonyDepth, LITERAL_ACCEPTANCE_ADVISORY_MARKER, type ResolvedLiteralAcceptance, resolveLiteralAcceptanceCommands, resolveLiteralAcceptanceDetailed, stripLiteralAcceptanceAdvisory, } from "./evaluate.js";
 export { defaultLiteralAcceptanceRunner, runLiteralAcceptanceCommand, runLiteralAcceptanceCommands, } from "./run.js";
 export { type CommandSafetyResult, evaluateCommandSafety, evaluateNoopDenylist, evaluateStampAcceptanceSafety, isExecutableLiteralSource, isNoopRefusalReason, isVerbatimStatementSpan, NOOP_ACCEPTANCE_REMEDIATION, REJECTED_NOOP_OUTCOME, type RejectedNoopOutcome, type StampAcceptanceCommand, type StampAcceptanceSafetyInput, type StampAcceptanceSafetyResult, type StampSourceRung, } from "./safety.js";
-export { EXECUTABLE_LITERAL_SOURCES, LITERAL_ACCEPTANCE_METADATA_KEY, LITERAL_ACCEPTANCE_METADATA_KEY_CAMEL, LITERAL_ACCEPTANCE_REJECTED_METADATA_KEY, type LiteralAcceptanceCommand, type LiteralAcceptanceGateResult, type LiteralAcceptanceRunner, type LiteralAcceptanceRunResult, type LiteralAcceptanceSource, type RejectedLiteralCommand, } from "./types.js";
+export { EXECUTABLE_LITERAL_SOURCES, LITERAL_ACCEPTANCE_METADATA_KEY, LITERAL_ACCEPTANCE_METADATA_KEY_CAMEL, LITERAL_ACCEPTANCE_NOT_COMMANDS_METADATA_KEY, LITERAL_ACCEPTANCE_REJECTED_METADATA_KEY, type LiteralAcceptanceCommand, type LiteralAcceptanceGateResult, type LiteralAcceptanceRunner, type LiteralAcceptanceRunResult, type LiteralAcceptanceSource, type RejectedLiteralCommand, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/literal-acceptance/index.js

@@ -4,9 +4,9 @@
  * Capture exact stated shell commands at intake; run them verbatim before done.
  * Extends #973; survives ceremony dial rapid/minimal (#3214).
  */
-export { attachLiteralAcceptanceCommands, captureAndAttachLiteralAcceptance, captureLiteralAcceptanceCommands, captureLiteralAcceptanceCommandsDetailed, formatRejectedLedger, hasStructuredAcceptanceCommands, isProseDerivedRejection, readStoredLiteralAcceptanceCommands, readStoredLiteralAcceptanceDetailed, } from "./capture.js";
+export { attachLiteralAcceptanceCommands, captureAndAttachLiteralAcceptance, captureLiteralAcceptanceCommands, captureLiteralAcceptanceCommandsDetailed, formatRejectedLedger, hasStructuredAcceptanceCommands, INLINE_PROSE_MENTION_REASON, isInlineProseMention, isProseDerivedRejection, readNotAcceptanceCommands, readStoredLiteralAcceptanceCommands, readStoredLiteralAcceptanceDetailed, } from "./capture.js";
 export { appendLiteralAcceptanceAdvisory, evaluateLiteralAcceptanceFromPath, evaluateLiteralAcceptanceFromPlan, formatLiteralAcceptanceAdvisory, isLiteralAcceptanceRequiredAtCeremonyDepth, LITERAL_ACCEPTANCE_ADVISORY_MARKER, resolveLiteralAcceptanceCommands, resolveLiteralAcceptanceDetailed, stripLiteralAcceptanceAdvisory, } from "./evaluate.js";
 export { defaultLiteralAcceptanceRunner, runLiteralAcceptanceCommand, runLiteralAcceptanceCommands, } from "./run.js";
 export { evaluateCommandSafety, evaluateNoopDenylist, evaluateStampAcceptanceSafety, isExecutableLiteralSource, isNoopRefusalReason, isVerbatimStatementSpan, NOOP_ACCEPTANCE_REMEDIATION, REJECTED_NOOP_OUTCOME, } from "./safety.js";
-export { EXECUTABLE_LITERAL_SOURCES, LITERAL_ACCEPTANCE_METADATA_KEY, LITERAL_ACCEPTANCE_METADATA_KEY_CAMEL, LITERAL_ACCEPTANCE_REJECTED_METADATA_KEY, } from "./types.js";
+export { EXECUTABLE_LITERAL_SOURCES, LITERAL_ACCEPTANCE_METADATA_KEY, LITERAL_ACCEPTANCE_METADATA_KEY_CAMEL, LITERAL_ACCEPTANCE_NOT_COMMANDS_METADATA_KEY, LITERAL_ACCEPTANCE_REJECTED_METADATA_KEY, } from "./types.js";
 //# sourceMappingURL=index.js.map

package/dist/literal-acceptance/run.js

@@ -7,6 +7,7 @@
  */
 import { spawnSync } from "node:child_process";
 import { isAbsolute, resolve } from "node:path";
+import { isInlineProseMention } from "./capture.js";
 import { evaluateCommandSafety, isExecutableLiteralSource } from "./safety.js";
 /** Default shell runner: exact command string via platform shell. */
 export function defaultLiteralAcceptanceRunner(input) {
@@ -95,7 +96,9 @@ export function runLiteralAcceptanceCommands(commands, options) {
             runs: [],
         };
     }
-    const untrusted = commands.filter((c) => c.source === "task_statement" && options.allowTaskStatement !== true);
+    const untrusted = commands.filter((c) => c.source === "task_statement" &&
+        options.allowTaskStatement !== true &&
+        !isInlineProseMention(c));
     const executable = commands.filter((c) => isExecutableLiteralSource(c.source) ||
         (c.source === "task_statement" && options.allowTaskStatement === true));
     // Fail closed: every capture-only stated command must have a matching agent-promoted
@@ -149,8 +152,11 @@ export function runLiteralAcceptanceCommands(commands, options) {
             code: 1,
             message: `Literal acceptance-command gate FAILED (#3267): ${unpromoted.length} stated command(s) ` +
                 `are capture-only (source=task_statement) and have no matching agent-promoted peer.\n` +
-                `Promote the exact command strings (and cwd/expectedStdout/expectedExitCode when stated) ` +
-                `into plan.metadata.swarm.verify_commands (or plan item / explicit metadata), then re-run.\n` +
+                `If the command is this story's acceptance, promote the exact strings ` +
+                `(and cwd/expectedStdout/expectedExitCode when stated) into ` +
+                `plan.metadata.swarm.verify_commands (or plan item / explicit metadata), then re-run.\n` +
+                `If the capture is not an acceptance command, record the exact string in ` +
+                `plan.metadata.literal_acceptance_not_commands without promoting it (#3721).\n` +
                 `Note: an unrelated executable peer or a same-text peer with different context does not waive.\n` +
                 listed,
             commands,

package/dist/literal-acceptance/types.d.ts

@@ -74,6 +74,12 @@ export interface LiteralAcceptanceGateResult {
 }
 /** Metadata key for operator-visible rejected command ledger (#3267). */
 export declare const LITERAL_ACCEPTANCE_REJECTED_METADATA_KEY: "literal_acceptance_rejected";
+/**
+ * Metadata key: command strings the operator recorded as *not* acceptance
+ * commands (#3721). Disposition without promotion — listing a string here does
+ * not assert it is the story's verification.
+ */
+export declare const LITERAL_ACCEPTANCE_NOT_COMMANDS_METADATA_KEY: "literal_acceptance_not_commands";
 /** Injectable shell runner for tests (default: spawnSync shell). */
 export type LiteralAcceptanceRunner = (input: {
     readonly command: string;

package/dist/literal-acceptance/types.js

@@ -19,6 +19,12 @@ export const EXECUTABLE_LITERAL_SOURCES = [
 ];
 /** Metadata key for operator-visible rejected command ledger (#3267). */
 export const LITERAL_ACCEPTANCE_REJECTED_METADATA_KEY = "literal_acceptance_rejected";
+/**
+ * Metadata key: command strings the operator recorded as *not* acceptance
+ * commands (#3721). Disposition without promotion — listing a string here does
+ * not assert it is the story's verification.
+ */
+export const LITERAL_ACCEPTANCE_NOT_COMMANDS_METADATA_KEY = "literal_acceptance_not_commands";
 /** Metadata key on plan.metadata for captured literal commands (#3267). */
 export const LITERAL_ACCEPTANCE_METADATA_KEY = "literal_acceptance_commands";
 /** Alternate camelCase key accepted on read. */

package/dist/orchestration/judgment-policy.d.ts

@@ -2,6 +2,19 @@ export declare const GATE_CLASSES: Set<string>;
 export declare const GATE_TIERS: Set<string>;
 export declare const GATE_MATCH_PREDICATES: Set<string>;
 export declare const GATE_MATCH_STATES: Set<string>;
+/** ADR-005 / #3434 Story 1 -- author-stamped marker vocabulary. */
+export declare const DESIGN_CRITIQUE_GATE_ID = "design-critique";
+/** List-visible mirror; this is what judgmentGates predicates match. */
+export declare const DESIGN_CRITIQUE_MARKER_LABEL = "design-critique:mechanism-shaped";
+/** Authoritative body-text field in the #1423 triage write-back comment. */
+export declare const DESIGN_CRITIQUE_MARKER_FIELD = "mechanism-shaped: true";
+/**
+ * Clearance line shape (ADR-005). Presence and shape only -- a non-empty
+ * because-clause is required; its semantic content is never evaluated.
+ */
+export declare const DESIGN_CRITIQUE_CLEARANCE_SHAPE: RegExp;
+/** True when `line` has clearance presence+shape. Never scores the reason text. */
+export declare function designCritiqueClearanceShapeOk(line: string): boolean;
 export interface JudgmentGate {
     readonly gate_id: string;
     readonly gate_class: string;

package/dist/orchestration/judgment-policy.js

@@ -7,6 +7,21 @@ export const GATE_CLASSES = new Set(["mechanical", "declared"]);
 export const GATE_TIERS = new Set(["auto", "review", "block"]);
 export const GATE_MATCH_PREDICATES = new Set(["labels", "body-text", "paths", "state", "age-days"]);
 export const GATE_MATCH_STATES = new Set(["open", "closed"]);
+/** ADR-005 / #3434 Story 1 -- author-stamped marker vocabulary. */
+export const DESIGN_CRITIQUE_GATE_ID = "design-critique";
+/** List-visible mirror; this is what judgmentGates predicates match. */
+export const DESIGN_CRITIQUE_MARKER_LABEL = "design-critique:mechanism-shaped";
+/** Authoritative body-text field in the #1423 triage write-back comment. */
+export const DESIGN_CRITIQUE_MARKER_FIELD = "mechanism-shaped: true";
+/**
+ * Clearance line shape (ADR-005). Presence and shape only -- a non-empty
+ * because-clause is required; its semantic content is never evaluated.
+ */
+export const DESIGN_CRITIQUE_CLEARANCE_SHAPE = /^design-critique:\s*(warranted|not warranted),\s*because\s+\S/i;
+/** True when `line` has clearance presence+shape. Never scores the reason text. */
+export function designCritiqueClearanceShapeOk(line) {
+    return DESIGN_CRITIQUE_CLEARANCE_SHAPE.test(line.trim());
+}
 function validateStrList(value, prefix, key) {
     if (!Array.isArray(value) || value.length === 0) {
         return [`${prefix}.${key} must be a non-empty list of strings`];

package/dist/orchestration/probe-session.js

@@ -12,6 +12,11 @@ export const SESSION_RELPATH = [".deft", "probe-session.json"];
 export const STATE_INTERROGATE = "interrogate";
 export const STATE_COMPLETE = "complete";
 export const VALID_DECISION_STATUSES = new Set(["locked", "deferred", "risk-accepted"]);
+/** Live CLI teach-string (#3556). The Python helper was deleted. */
+const PROBE_SESSION_START = "`deft probe-session start --target <scope>`";
+const PROBE_SESSION_RECORD = "`deft probe-session record ...`";
+const PROBE_SESSION_COMPLETE = "`deft probe-session complete`";
+const NO_SESSION_START = `No active probe session. Start one with ${PROBE_SESSION_START}.`;
 export class ProbeHandoffBlockedError extends Error {
     session;
     constructor(message, session = null) {
@@ -249,7 +254,7 @@ export function startSession(projectRoot, options) {
 export function recordDecision(projectRoot, options) {
     const session = readSession(projectRoot);
     if (session === null) {
-        throw new ProbeHandoffBlockedError("No active probe session. Start one with `uv run python scripts/probe_session.py start --target <scope>`.");
+        throw new ProbeHandoffBlockedError(NO_SESSION_START);
     }
     if (session.state !== STATE_INTERROGATE) {
         throw new ProbeHandoffBlockedError("Probe session is already complete; decisions cannot be appended.", session);
@@ -275,7 +280,7 @@ export function recordDecision(projectRoot, options) {
 export function setCurrentBranch(projectRoot, branch) {
     const session = readSession(projectRoot);
     if (session === null) {
-        throw new ProbeHandoffBlockedError("No active probe session. Start one with `uv run python scripts/probe_session.py start --target <scope>`.");
+        throw new ProbeHandoffBlockedError(NO_SESSION_START);
     }
     if (session.state !== STATE_INTERROGATE) {
         throw new ProbeHandoffBlockedError("Probe session is already complete; current branch cannot change.", session);
@@ -287,7 +292,7 @@ export function setCurrentBranch(projectRoot, branch) {
 export function markComplete(projectRoot, now) {
     const session = readSession(projectRoot);
     if (session === null) {
-        throw new ProbeHandoffBlockedError("No active probe session. Start one with `uv run python scripts/probe_session.py start --target <scope>`.");
+        throw new ProbeHandoffBlockedError(NO_SESSION_START);
     }
     if (session.state === STATE_COMPLETE) {
         return session;
@@ -307,7 +312,7 @@ function pythonRepr(value) {
 function blockedMessage(session, action) {
     if (session === null) {
         return (`Probe handoff blocked for ${action}: no active probe session. ` +
-            "Start interrogation with `uv run python scripts/probe_session.py start --target <scope>` " +
+            `Start interrogation with ${PROBE_SESSION_START} ` +
             "and finish with `... complete` only after transition criteria are met.");
     }
     return (`Probe handoff blocked for ${action}: session state is ` +
@@ -315,9 +320,9 @@ function blockedMessage(session, action) {
         `currentBranch=${pythonRepr(session.current_branch)}, ` +
         `resolvedDecisions=${session.resolved_decisions.length}). ` +
         "Continue interrogation until transition criteria are met, record decisions " +
-        "with `uv run python scripts/probe_session.py record ...`, then run " +
-        "`uv run python scripts/probe_session.py complete` before writing artifacts " +
-        "or updating completedStrategies.probe in plan.vbrief.json.");
+        `with ${PROBE_SESSION_RECORD}, then run ` +
+        `${PROBE_SESSION_COMPLETE} before writing artifacts ` +
+        "or updating completedStrategies.probe in plan.xbrief.json.");
 }
 export function requireHandoffAllowed(projectRoot, action) {
     const session = readSession(projectRoot);
@@ -330,7 +335,7 @@ export function guardProbeArtifact(projectRoot, artifactPath) {
     return requireHandoffAllowed(projectRoot, `probe artifact write (${artifactPath})`);
 }
 export function guardPlanProbeRegistration(projectRoot) {
-    return requireHandoffAllowed(projectRoot, "completedStrategies.probe registration in plan.vbrief.json");
+    return requireHandoffAllowed(projectRoot, "completedStrategies.probe registration in plan.xbrief.json");
 }
 export function sessionSummary(session) {
     return {

package/dist/orchestration/verify-judgment-gates.d.ts

@@ -2,6 +2,10 @@
  * Risk-tiered judgment-gate engine (#1419 Slice 3). Port of scripts/verify_judgment_gates.py.
  */
 import { type JudgmentGatesPolicy } from "./judgment-policy.js";
+/** Thrown when a design-critique clearance reason fails presence/shape (never content). */
+export declare class JudgmentClearanceShapeError extends Error {
+    constructor(message: string);
+}
 /** Display/back-compat constant; resolution flows through resolveAuditDir (#2109). */
 export declare const AUDIT_DIR_REL = "vbrief/.audit";
 export declare const CLEARANCE_LOG_NAME = "judgment-gate-clearances.jsonl";

package/dist/orchestration/verify-judgment-gates.js

@@ -7,8 +7,15 @@ import { appendFileSync, existsSync, lstatSync, mkdirSync, readFileSync, statSyn
 import { join, resolve } from "node:path";
 import { assertProjectionContained, assertWriteTargetSafe, ProjectionContainmentError, } from "../fs/projection-containment.js";
 import { resolveAuditDir } from "../layout/resolve.js";
-import { resolveJudgmentGates } from "./judgment-policy.js";
+import { DESIGN_CRITIQUE_GATE_ID, designCritiqueClearanceShapeOk, resolveJudgmentGates, } from "./judgment-policy.js";
 import { matchAny } from "./pathspec.js";
+/** Thrown when a design-critique clearance reason fails presence/shape (never content). */
+export class JudgmentClearanceShapeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "JudgmentClearanceShapeError";
+    }
+}
 /** Display/back-compat constant; resolution flows through resolveAuditDir (#2109). */
 export const AUDIT_DIR_REL = "vbrief/.audit";
 export const CLEARANCE_LOG_NAME = "judgment-gate-clearances.jsonl";
@@ -163,6 +170,12 @@ export function readClearances(projectRoot, logPath) {
     return out;
 }
 export function recordClearance(projectRoot, options) {
+    if (options.gate_id === DESIGN_CRITIQUE_GATE_ID &&
+        !designCritiqueClearanceShapeOk(options.reason ?? "")) {
+        throw new JudgmentClearanceShapeError("design-critique clearance reason must match shape " +
+            "'design-critique: warranted | not warranted, because ...' " +
+            "(presence and shape only; the because-clause is not scored)");
+    }
     const path = options.log_path ?? clearanceLogPath(projectRoot);
     const auditDir = resolveAuditDir(projectRoot);
     assertProjectionContained(projectRoot, auditDir);
@@ -202,6 +215,15 @@ export function fingerprintScope(evidence) {
     const payload = JSON.stringify(sorted);
     return createHash("sha256").update(payload, "utf8").digest("hex");
 }
+function acceptClearanceShape(gateId, clearance) {
+    if (clearance === null) {
+        return null;
+    }
+    if (gateId !== DESIGN_CRITIQUE_GATE_ID) {
+        return clearance;
+    }
+    return designCritiqueClearanceShapeOk(String(clearance.reason ?? "")) ? clearance : null;
+}
 function lookupClearance(clearances, gateId, scope) {
     let valid = null;
     let stale = null;
@@ -383,7 +405,8 @@ export function buildReport(projectRoot, candidate, options = {}) {
             continue;
         }
         const scope = fingerprintScope(evidence);
-        const [valid, stale] = lookupClearance(records, String(gate.id), scope);
+        const [validRaw, stale] = lookupClearance(records, String(gate.id), scope);
+        const valid = acceptClearanceShape(String(gate.id), validRaw);
         outcomes.push({
             gate_id: String(gate.id),
             gate_class: String(gate.class),
@@ -605,15 +628,24 @@ function clearMain(argv) {
     if (args.updatedAt !== null)
         evidence["age-days"] = args.updatedAt;
     const scope = fingerprintScope(evidence);
-    const entry = recordClearance(projectRoot, {
-        gate_id: args.gateId,
-        cleared_scope: scope,
-        reviewers: args.reviewers,
-        actor: args.actor,
-        reason: args.reason,
-    });
-    process.stdout.write(`recorded clearance ${String(entry.clearance_id)} for gate ${JSON.stringify(args.gateId)} (cleared_scope=${scope.slice(0, 12)}...)\n`);
-    return 0;
+    try {
+        const entry = recordClearance(projectRoot, {
+            gate_id: args.gateId,
+            cleared_scope: scope,
+            reviewers: args.reviewers,
+            actor: args.actor,
+            reason: args.reason,
+        });
+        process.stdout.write(`recorded clearance ${String(entry.clearance_id)} for gate ${JSON.stringify(args.gateId)} (cleared_scope=${scope.slice(0, 12)}...)\n`);
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof JudgmentClearanceShapeError) {
+            process.stderr.write(`${err.message}\n`);
+            return 1;
+        }
+        throw err;
+    }
 }
 function parseEvalArgs(argv) {
     const parsed = {

package/dist/policy/ceremony-dial.js

@@ -23,7 +23,7 @@ import { RunSummaryEmitter } from "../run-summary/emit.js";
 import { atomicWriteProjectDefinition, projectDefinitionMutationLock, } from "../vbrief-build/project-definition-io.js";
 import { migrateLegacyPolicyKey, PLAN_POLICY_KEY, readPlanPolicy } from "./plan-extensions.js";
 import { policyColonInvocation } from "./policy-invocation.js";
-import { appendAuditLog, loadProjectDefinition, projectDefinitionPath } from "./resolve.js";
+import { appendAuditLog, loadProjectDefinition, POLICY_AUDIT_NOOP_STDOUT, projectDefinitionPath, } from "./resolve.js";
 /** Canonical dotted policy field name. */
 export const FIELD_CEREMONY_DIAL = "plan.policy.ceremonyDial";
 /** Short alias for `policy:show --field=ceremonyDial`. */
@@ -527,7 +527,7 @@ export function setCeremonyDial(projectRoot, options) {
                 }
             }
             const plan = data.plan;
-            migrateLegacyPolicyKey(plan);
+            const legacyKeyMigrated = migrateLegacyPolicyKey(plan);
             const existingPolicy = plan[PLAN_POLICY_KEY];
             if (typeof existingPolicy !== "object" ||
                 existingPolicy === null ||
@@ -564,7 +564,9 @@ export function setCeremonyDial(projectRoot, options) {
                 override: nextOverride,
             };
             const prevParsed = parseConfig(previous).config;
-            const changedFlag = prevParsed.enabled !== nextBlock.enabled || prevParsed.override !== nextBlock.override;
+            const changedFlag = prevParsed.enabled !== nextBlock.enabled ||
+                prevParsed.override !== nextBlock.override ||
+                legacyKeyMigrated;
             policyBlock.ceremonyDial = nextBlock;
             if (changedFlag) {
                 atomicWriteProjectDefinition(path, data);
@@ -580,15 +582,13 @@ export function setCeremonyDial(projectRoot, options) {
             if (note) {
                 parts.push(`note=${note.replace(/\n/g, " ").replace(/\r/g, " ")}`);
             }
-            appendAuditLog(projectRoot, parts.join(" "));
+            appendAuditLog(projectRoot, parts.join(" "), changedFlag);
             return { changed: changedFlag };
         });
         const resolved = resolveCeremonyDial(projectRoot);
         const lines = [
             `\u2713 ${FIELD_CEREMONY_DIAL} updated.`,
-            changed
-                ? "  audit: meta/policy-changes.log updated."
-                : "  no-op: value already matched (audit entry still appended for trail).",
+            changed ? "  audit: meta/policy-changes.log updated." : POLICY_AUDIT_NOOP_STDOUT,
             formatCeremonyDialStatusLine(resolved),
         ];
         return { exitCode: 0, stdout: `${lines.join("\n")}\n`, changed };

package/dist/policy/host-hooks.d.ts

@@ -1,6 +1,12 @@
 import type { HookHost } from "../hooks/dispatcher.js";
+export type { HookHost };
 export declare const FIELD_HOST_HOOKS = "plan.policy.hostHooks";
 export declare const FIELD_HOST_HOOKS_CLI_ALIAS = "hostHooks";
+export declare const DISABLE_HOST_HOOKS_SUBCOMMAND = "disable-host-hooks";
+/** Confirm-gated disable verb for unused-host recovery copy (#3571). CLI form: no go-task `--`. */
+export declare function disableHostHooksInvocation(trailing?: string): string;
+export declare const HOST_HOOKS_DISABLE_CAPABILITY_COST_DISCLOSURE: string;
+export declare const UNUSED_HOST_HOOKS_RECOVERY: string;
 /** Per-host Directive hook deposit toggles (#2752). */
 export type HostHooksPolicy = Record<HookHost, boolean>;
 export declare const DEFAULT_HOST_HOOKS_POLICY: HostHooksPolicy;
@@ -18,4 +24,18 @@ export declare function isHostHookDepositEnabled(host: HookHost, policy?: HostHo
 export declare function inspectHostHooks(data: Record<string, unknown> | null): HostHooksPolicyField;
 /** Resolve host hook deposit policy from PROJECT-DEFINITION on disk. */
 export declare function loadHostHooksPolicyFromProject(projectRoot: string): HostHooksPolicy;
+export declare function parseHookHost(value: string | undefined): HookHost | null;
+export interface DisableHostHooksOptions {
+    readonly host: HookHost;
+    readonly confirm: boolean;
+    readonly actor?: string;
+    readonly note?: string;
+}
+export interface DisableHostHooksResult {
+    readonly exitCode: 0 | 1 | 2;
+    readonly stdout: string;
+    readonly changed: boolean;
+}
+/** Persist `hostHooks.<host>=false` after capability-cost disclosure (#3571). */
+export declare function disableHostHooks(projectRoot: string, options: DisableHostHooksOptions): DisableHostHooksResult;
 //# sourceMappingURL=host-hooks.d.ts.map