@deftai/directive-core 0.106.0 → 0.108.0

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,
@@ -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/orphan-active/evaluate.d.ts

@@ -6,11 +6,28 @@ export interface OrphanActiveBrief {
     readonly reason: string;
     readonly kind: OrphanKind;
 }
+/**
+ * How the run's issue-state verdicts were reached (#3767). A pass with
+ * `unverified > 0` is not evidence that the tree is clean.
+ */
+export interface OrphanActiveBasis {
+    readonly inventory: number;
+    readonly live: number;
+    readonly cache: number;
+    readonly unverified: number;
+    /** Oldest cache entry that produced a verdict, in ms. */
+    readonly maxCacheAgeMs: number | null;
+    /** True when reads resolved through `ghx`, a cached GET proxy. */
+    readonly proxied: boolean;
+    readonly elapsedMs: number;
+    readonly budgetMs: number;
+}
 export interface EvaluateResult {
     readonly code: 0 | 1 | 2;
     readonly message: string;
     readonly stream: OutputStream;
     readonly orphans: readonly OrphanActiveBrief[];
+    readonly basis: OrphanActiveBasis;
 }
 export interface EvaluateOptions {
     readonly quiet?: boolean;
@@ -19,6 +36,8 @@ export interface EvaluateOptions {
     readonly skipGh?: boolean;
     /** When set, scan only active/running briefs that reference this issue (#3429). */
     readonly issue?: number | null;
+    /** Monotonic clock seam so basis ages and budget checks are testable. */
+    readonly nowMs?: () => number;
 }
 /**
  * Pure evaluator for orphaned active/running xBRIEF detection (#2321 / #3429).
@@ -26,6 +45,12 @@ export interface EvaluateOptions {
  * issues and/or a merged PR — the stop-at:pr-open orphan signature.
  * Pass `issue` to scan one origin after merge. Confirmed shipped prints
  * scope:complete; unresolved lookup still exits 1 with a retry remediation.
+ *
+ * Issue state resolves by query shape (#3767): scoped `--issue N` takes an
+ * authoritative read and stays fail-closed on unknown; the unscoped sweep uses
+ * one complete, fail-closed open-issue inventory and stays fail-open on
+ * unknown so offline work is not network-authorized. A cache hit is honoured
+ * only inside `ISSUE_CACHE_MAX_AGE_MS`, and every verdict reports its basis.
  */
 export declare function evaluate(projectRoot: string, options?: EvaluateOptions): EvaluateResult;
 //# sourceMappingURL=evaluate.d.ts.map