@deftai/directive-core 0.106.0 → 0.107.0

package/dist/lifecycle/completed-write-guard.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Refuse newly added completed/ blobs that bypass runTransition (#3679).
+ *
+ * Historical corpus is advisory (doctor). New work in the change set is hard
+ * (verify:completed-write-guard). Does not read completionProvenance and does
+ * not change verify:completed-tracked.
+ *
+ * Disk reads are capped at COMPLETED_WRITE_GUARD_MAX_BYTES so a huge
+ * contributor-controlled completed/ add fails through the guard instead of
+ * exhausting memory on the required gate path.
+ */
+export type CompletedWriteGuardCode = 0 | 1 | 2;
+export interface CompletedWriteGuardFinding {
+    readonly relPath: string;
+    readonly detail: string;
+}
+export interface CompletedWriteGuardResult {
+    readonly code: CompletedWriteGuardCode;
+    readonly message: string;
+    readonly findings: readonly CompletedWriteGuardFinding[];
+}
+export interface CompletedWriteGuardOptions {
+    readonly baseRef?: string;
+    /** Inject added repo-relative POSIX paths (skips git). */
+    readonly addedFiles?: readonly string[];
+    /** Inject payloads: relPath -> raw JSON. */
+    readonly payloads?: ReadonlyMap<string, string>;
+}
+/**
+ * In-repo completed xBRIEFs average ~5.5 KiB and peak near 44 KiB.
+ * 1 MiB is ~23× that peak and still refuses a multi-hundred-MB add
+ * before the bytes are loaded.
+ */
+export declare const COMPLETED_WRITE_GUARD_MAX_BYTES = 1048576;
+/**
+ * Hard check: newly added completed/ artifacts must show runTransition evidence.
+ */
+export declare function evaluateCompletedWriteGuard(projectRoot: string, options?: CompletedWriteGuardOptions): CompletedWriteGuardResult;
+export interface CompletedWriteCorpusResult {
+    readonly findings: readonly CompletedWriteGuardFinding[];
+    readonly scanned: number;
+}
+/**
+ * Corpus scan for doctor: artifacts without transition evidence.
+ * Caller marks these advisory so historical pre-stamp files do not red doctor.
+ */
+export declare function scanCompletedWriteCorpus(projectRoot: string): CompletedWriteCorpusResult;
+//# sourceMappingURL=completed-write-guard.d.ts.map

package/dist/lifecycle/completed-write-guard.js

@@ -0,0 +1,373 @@
+/**
+ * Refuse newly added completed/ blobs that bypass runTransition (#3679).
+ *
+ * Historical corpus is advisory (doctor). New work in the change set is hard
+ * (verify:completed-write-guard). Does not read completionProvenance and does
+ * not change verify:completed-tracked.
+ *
+ * Disk reads are capped at COMPLETED_WRITE_GUARD_MAX_BYTES so a huge
+ * contributor-controlled completed/ add fails through the guard instead of
+ * exhausting memory on the required gate path.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync, lstatSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { GitCommandError, GitNotFoundError } from "../encoding/git.js";
+import { hasArtifactSuffix, LEGACY_ARTIFACT_DIR, MIGRATED_ARTIFACT_DIR, } from "../layout/resolve.js";
+import { hasTransitionWrite, LEFTOVER_LAND_PR_REMEDIATION } from "../scope/lifecycle-write.js";
+import { resolveDefaultBaseRef, unquoteGitPath } from "../scope-provenance/evaluate.js";
+/**
+ * In-repo completed xBRIEFs average ~5.5 KiB and peak near 44 KiB.
+ * 1 MiB is ~23× that peak and still refuses a multi-hundred-MB add
+ * before the bytes are loaded.
+ */
+export const COMPLETED_WRITE_GUARD_MAX_BYTES = 1_048_576;
+const COMPLETED_REL_RE = /^(?:xbrief|vbrief)\/completed\/[^/]+$/;
+function normalizeRepoRelPath(raw) {
+    return raw.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function isCompletedArtifactRel(relPath) {
+    const n = normalizeRepoRelPath(relPath);
+    if (!COMPLETED_REL_RE.test(n)) {
+        return false;
+    }
+    const base = n.split("/").pop() ?? "";
+    return hasArtifactSuffix(base);
+}
+function parsePlan(raw) {
+    try {
+        const data = JSON.parse(raw);
+        if (typeof data !== "object" || data === null || Array.isArray(data)) {
+            return null;
+        }
+        const plan = data.plan;
+        if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+            return null;
+        }
+        return plan;
+    }
+    catch {
+        return null;
+    }
+}
+function gitEnv(projectRoot) {
+    const env = { ...process.env };
+    delete env.GIT_DIR;
+    delete env.GIT_WORK_TREE;
+    env.GIT_CEILING_DIRECTORIES = dirname(resolve(projectRoot));
+    return env;
+}
+function git(args, projectRoot) {
+    const result = spawnSync("git", args, {
+        cwd: projectRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        env: gitEnv(projectRoot),
+    });
+    if (result.error !== undefined) {
+        const e = result.error;
+        if (e.code === "ENOENT") {
+            throw new GitNotFoundError("'git' executable not found on PATH");
+        }
+        throw new GitCommandError(`git ${args.join(" ")} failed: ${String(e.message)}`);
+    }
+    if (result.signal !== null && result.signal !== undefined) {
+        throw new GitCommandError(`git ${args.join(" ")} killed by signal ${String(result.signal)}`);
+    }
+    const status = result.status ?? 1;
+    const stderr = String(result.stderr ?? "").trim();
+    if (status !== 0 && stderr.length > 0) {
+        return { status, stdout: `${result.stdout ?? ""}\n${stderr}` };
+    }
+    return { status, stdout: result.stdout ?? "" };
+}
+function addedPathsFromNameStatus(stdout) {
+    const out = [];
+    for (const line of stdout.split("\n")) {
+        const t = line.replace(/\r$/, "").trim();
+        if (t.length === 0) {
+            continue;
+        }
+        const parts = t.split("\t");
+        const status = parts[0] ?? "";
+        if (status.startsWith("A")) {
+            const path = parts[1];
+            if (path !== undefined) {
+                out.push(unquoteGitPath(path));
+            }
+        }
+        else if (status.startsWith("R")) {
+            const dest = parts[2] ?? parts[1];
+            if (dest !== undefined) {
+                out.push(unquoteGitPath(dest));
+            }
+        }
+    }
+    return out;
+}
+function discoverAddedFiles(projectRoot, baseRef) {
+    const inside = git(["rev-parse", "--is-inside-work-tree"], projectRoot);
+    if (inside.status !== 0) {
+        throw new GitCommandError("not a git working tree");
+    }
+    let resolved = baseRef;
+    if (baseRef === "HEAD" || baseRef === "") {
+        const upgraded = resolveDefaultBaseRef(projectRoot);
+        if (upgraded === null) {
+            throw new GitCommandError("no merge-base ref (origin/master|main or DEFT_BASE_REF/GITHUB_BASE_REF)");
+        }
+        resolved = upgraded;
+    }
+    const hasBase = git(["rev-parse", "--verify", "-q", resolved], projectRoot).status === 0;
+    if (!hasBase) {
+        throw new GitCommandError(`base ref '${resolved}' not found; pass --base-ref`);
+    }
+    const out = new Set();
+    const range = resolved.includes("...") ? resolved : `${resolved}...HEAD`;
+    const committed = git(["diff", "--name-status", "--diff-filter=AR", range], projectRoot);
+    if (committed.status !== 0) {
+        const detail = committed.stdout.trim() || `git diff ${range} exited ${String(committed.status)}`;
+        throw new GitCommandError(`committed change-set unavailable for '${range}': ${detail}. ` +
+            "Pass --base-ref to a merge-base ancestor of HEAD.");
+    }
+    for (const p of addedPathsFromNameStatus(committed.stdout)) {
+        out.add(normalizeRepoRelPath(p));
+    }
+    const vsHead = git(["diff", "--name-status", "--diff-filter=AR", "HEAD"], projectRoot);
+    if (vsHead.status !== 0) {
+        const detail = vsHead.stdout.trim() || `git diff HEAD exited ${String(vsHead.status)}`;
+        throw new GitCommandError(`working-tree change-set unavailable: ${detail}`);
+    }
+    for (const p of addedPathsFromNameStatus(vsHead.stdout)) {
+        out.add(normalizeRepoRelPath(p));
+    }
+    const untracked = git(["ls-files", "--others", "--exclude-standard"], projectRoot);
+    if (untracked.status !== 0) {
+        const detail = untracked.stdout.trim() || `git ls-files exited ${String(untracked.status)}`;
+        throw new GitCommandError(`untracked change-set unavailable: ${detail}`);
+    }
+    for (const line of untracked.stdout.split("\n")) {
+        const p = normalizeRepoRelPath(unquoteGitPath(line));
+        if (p.length > 0) {
+            out.add(p);
+        }
+    }
+    return [...out];
+}
+function readPayload(projectRoot, relPath, payloads) {
+    const n = normalizeRepoRelPath(relPath);
+    const injected = payloads?.get(n);
+    if (injected !== undefined) {
+        if (injected.length > COMPLETED_WRITE_GUARD_MAX_BYTES) {
+            return {
+                kind: "unsafe",
+                detail: `${n}: completed/ artifact is ${String(injected.length)} bytes; ` +
+                    `exceeds the ${String(COMPLETED_WRITE_GUARD_MAX_BYTES)}-byte read limit`,
+            };
+        }
+        return { kind: "ok", raw: injected };
+    }
+    const parts = n.split("/").filter((part) => part.length > 0 && part !== ".");
+    let abs = resolve(projectRoot);
+    let st;
+    for (const part of parts) {
+        if (part === "..") {
+            return {
+                kind: "unsafe",
+                detail: `${n}: completed/ path escapes project root; refuse without following`,
+            };
+        }
+        abs = join(abs, part);
+        try {
+            st = lstatSync(abs);
+        }
+        catch {
+            return { kind: "missing" };
+        }
+        if (st.isSymbolicLink()) {
+            return {
+                kind: "unsafe",
+                detail: `${n}: completed/ path contains a symlink; refuse without following`,
+            };
+        }
+    }
+    if (st === undefined || !st.isFile()) {
+        return {
+            kind: "unsafe",
+            detail: `${n}: completed/ add is not a regular file; refuse without reading`,
+        };
+    }
+    if (st.size > COMPLETED_WRITE_GUARD_MAX_BYTES) {
+        return {
+            kind: "unsafe",
+            detail: `${n}: completed/ artifact is ${String(st.size)} bytes; ` +
+                `exceeds the ${String(COMPLETED_WRITE_GUARD_MAX_BYTES)}-byte read limit`,
+        };
+    }
+    try {
+        return { kind: "ok", raw: readFileSync(abs, "utf8") };
+    }
+    catch {
+        return { kind: "missing" };
+    }
+}
+/**
+ * Hard check: newly added completed/ artifacts must show runTransition evidence.
+ */
+export function evaluateCompletedWriteGuard(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    let added;
+    try {
+        if (options.addedFiles !== undefined) {
+            added = options.addedFiles.map(normalizeRepoRelPath);
+        }
+        else {
+            const inside = git(["rev-parse", "--is-inside-work-tree"], root);
+            if (inside.status !== 0 || inside.stdout.trim() !== "true") {
+                return {
+                    code: 0,
+                    findings: [],
+                    message: "verify_completed_write_guard: skipped -- not a git working tree.",
+                };
+            }
+            let baseRef = options.baseRef ?? "";
+            if (baseRef.length === 0 || baseRef === "HEAD") {
+                const resolved = resolveDefaultBaseRef(root);
+                if (resolved === null) {
+                    return {
+                        code: 2,
+                        findings: [],
+                        message: "verify_completed_write_guard: no merge-base ref found " +
+                            "(origin/master|main, DEFT_BASE_REF, or GITHUB_BASE_REF). " +
+                            "Pass --base-ref. Unguarded completed/ adds cannot be skipped.",
+                    };
+                }
+                baseRef = resolved;
+            }
+            added = discoverAddedFiles(root, baseRef);
+        }
+    }
+    catch (err) {
+        if (err instanceof GitNotFoundError) {
+            return {
+                code: 2,
+                findings: [],
+                message: "verify_completed_write_guard: 'git' executable not found on PATH.\n" +
+                    "  Recovery: install git or run inside a git working tree.",
+            };
+        }
+        if (err instanceof GitCommandError) {
+            const msg = err.message.toLowerCase();
+            if (msg.includes("not a git repository") ||
+                msg.includes("outside repository") ||
+                msg.includes("not a git working tree")) {
+                return {
+                    code: 0,
+                    findings: [],
+                    message: `verify_completed_write_guard: skipped -- not a git working tree (${err.message}).`,
+                };
+            }
+            return {
+                code: 2,
+                findings: [],
+                message: `verify_completed_write_guard: git failed -- ${err.message}`,
+            };
+        }
+        throw err;
+    }
+    const findings = [];
+    for (const rel of added) {
+        if (!isCompletedArtifactRel(rel)) {
+            continue;
+        }
+        const payload = readPayload(root, rel, options.payloads);
+        if (payload.kind === "missing") {
+            findings.push({
+                relPath: rel,
+                detail: `${rel}: added under completed/ but unreadable`,
+            });
+            continue;
+        }
+        if (payload.kind === "unsafe") {
+            findings.push({
+                relPath: rel,
+                detail: payload.detail,
+            });
+            continue;
+        }
+        const plan = parsePlan(payload.raw);
+        if (plan === null) {
+            findings.push({
+                relPath: rel,
+                detail: `${rel}: added under completed/ with unreadable plan`,
+            });
+            continue;
+        }
+        if (!hasTransitionWrite(plan)) {
+            findings.push({
+                relPath: rel,
+                detail: `${rel}: added under completed/ without a runTransition write`,
+            });
+        }
+    }
+    if (findings.length === 0) {
+        return {
+            code: 0,
+            findings: [],
+            message: "verify_completed_write_guard: clean -- no unguarded completed/ adds",
+        };
+    }
+    return {
+        code: 1,
+        findings,
+        message: `verify_completed_write_guard: ${findings.length} unguarded completed/ add(s) (#3679).\n` +
+            findings.map((f) => `  - ${f.detail}`).join("\n") +
+            `\n${LEFTOVER_LAND_PR_REMEDIATION}`,
+    };
+}
+function listCompletedArtifactRels(projectRoot) {
+    const out = [];
+    for (const dirName of [MIGRATED_ARTIFACT_DIR, LEGACY_ARTIFACT_DIR]) {
+        const completedDir = join(projectRoot, dirName, "completed");
+        if (!existsSync(completedDir)) {
+            continue;
+        }
+        let names = [];
+        try {
+            names = readdirSync(completedDir).filter((n) => hasArtifactSuffix(n));
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            out.push(`${dirName}/completed/${name}`);
+        }
+    }
+    return out.sort();
+}
+/**
+ * Corpus scan for doctor: artifacts without transition evidence.
+ * Caller marks these advisory so historical pre-stamp files do not red doctor.
+ */
+export function scanCompletedWriteCorpus(projectRoot) {
+    const findings = [];
+    const rels = listCompletedArtifactRels(projectRoot);
+    for (const rel of rels) {
+        const payload = readPayload(resolve(projectRoot), rel, undefined);
+        if (payload.kind !== "ok") {
+            continue;
+        }
+        const plan = parsePlan(payload.raw);
+        if (plan === null) {
+            continue;
+        }
+        if (!hasTransitionWrite(plan)) {
+            findings.push({
+                relPath: rel,
+                detail: `${rel}: completed/ artifact has no runTransition write (historical advisory)`,
+            });
+        }
+    }
+    return { findings, scanned: rels.length };
+}
+//# sourceMappingURL=completed-write-guard.js.map

package/dist/lifecycle/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./completed-consistency.js";
 export * from "./completed-tracked-on-delivery.js";
+export * from "./completed-write-guard.js";
 export * from "./event.js";
 export * as eventDetect from "./event-detect.js";
 export * as events from "./events.js";

package/dist/lifecycle/index.js

@@ -1,5 +1,6 @@
 export * from "./completed-consistency.js";
 export * from "./completed-tracked-on-delivery.js";
+export * from "./completed-write-guard.js";
 export * from "./event.js";
 export * as eventDetect from "./event-detect.js";
 export * as events from "./events.js";

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,
@@ -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