@deftai/directive-core 0.104.0 → 0.106.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

@@ -13,6 +13,8 @@ import type { LiteralAcceptanceCommand, RejectedLiteralCommand } from "./types.j
 export interface CaptureLiteralAcceptanceResult {
     readonly commands: readonly LiteralAcceptanceCommand[];
     readonly rejected: readonly RejectedLiteralCommand[];
+    /** Prompt lines skipped inside a transcript-shaped fence (#3511). */
+    readonly transcriptPromptSkipped: number;
 }
 /**
  * Capture literal acceptance commands from free-form task statement text.
@@ -47,6 +49,14 @@ export declare function captureAndAttachLiteralAcceptance(plan: Record<string, u
     readonly commands: readonly LiteralAcceptanceCommand[];
     readonly rejected: readonly RejectedLiteralCommand[];
 };
+/** True when a rejected ledger entry was scraped from narrative prose (#3484). */
+export declare function isProseDerivedRejection(rejected: RejectedLiteralCommand): boolean;
+/**
+ * True when the author stated acceptance commands structurally — `swarm.verify_commands`
+ * or `plan.acceptance.commands` (#3484). Still used by intake/tests; demotion of
+ * prose-derived rejections no longer depends on this (#3511).
+ */
+export declare function hasStructuredAcceptanceCommands(plan: Record<string, unknown> | null | undefined): boolean;
 /** 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

@@ -167,88 +167,156 @@ function matchLabeledCommand(line) {
         return null;
     return line.slice(i).trimEnd();
 }
-/** Mid-line `verify: cmd` (e.g. "Also run: verify: task check"). */
-function matchMidlineLabeled(line) {
-    const low = line.toLowerCase();
-    for (const kw of LABELED_KEYWORDS) {
-        if (kw === "run" || kw === "check")
-            continue; // too ambiguous mid-line
-        const needle = `${kw}:`;
-        const idx = low.indexOf(needle);
-        if (idx < 0)
-            continue;
-        const rest = line.slice(idx + needle.length).trim();
-        if (rest.length > 0)
-            return rest;
-    }
-    return null;
-}
-/** `$ 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)
         return null;
     return line.slice(i).trimEnd();
 }
+/** Box-drawing / block elements used in terminal UIs (━, │, …). */
+const BOX_DRAWING_RE = /[\u2500-\u257F\u2580-\u259F]/;
+/**
+ * Drop GNU-style long flags and their following value so `--filter fail`
+ * is not classified as FAIL transcript output (#3511).
+ * Covers `--flag`, `--flag=value`, and `--flag value` (value not another flag).
+ */
+function stripLongFlags(line) {
+    return line.replace(/(^|\s)--[\w-]+(?:=[^\s]+|\s+(?!-)[^\s]+)?/g, "$1");
+}
+/**
+ * True when a fence line is log/transcript, not a stated command (#3511).
+ * `[1/13]` / `[ts:check-lane]`, box drawing, or FAIL/FAILED/Error:.
+ * Flag tokens (--fail-fast, --failOnError, --no-fail) and flag values
+ * (`--filter fail`, `--grep FAIL`) are not FAIL output: `\bFAIL` matches
+ * between `-` and `f`, and leftover values still match after name-only strip.
+ */
+function isTranscriptOutputLine(line) {
+    const t = line.trim();
+    if (t.length === 0)
+        return false;
+    if (t.startsWith("#") || t.startsWith("//"))
+        return false;
+    if (/^\[[^\]]{1,80}\]/.test(t))
+        return true;
+    if (BOX_DRAWING_RE.test(t))
+        return true;
+    const withoutFlags = stripLongFlags(t);
+    if (/\b(?:FAILED|FAIL|Error:)/i.test(withoutFlags))
+        return true;
+    return false;
+}
+function isFenceCommentOrBlank(line) {
+    const t = line.trim();
+    return t.length === 0 || t.startsWith("#") || t.startsWith("//");
+}
+function isPromptLine(line) {
+    const t = line.trim();
+    return t.startsWith("$ ") || t.startsWith("> ");
+}
+/** Per-line mask: true for body lines inside ``` / ~~~ fences (not the markers). */
+function fenceBodyMask(lines) {
+    const mask = Array.from({ length: lines.length }, () => false);
+    let open = null;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        if (open === null) {
+            open = matchFenceOpen(line);
+            continue;
+        }
+        if (matchFenceClose(line, open)) {
+            open = null;
+            continue;
+        }
+        mask[i] = true;
+    }
+    return mask;
+}
+function captureFenceBodyLine(line, fenceLang, fenceStartLine, buckets) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith("#") || trimmed.startsWith("//")) {
+        return;
+    }
+    let body = trimmed;
+    if (body.startsWith("$ ") || body.startsWith("> ")) {
+        body = body.slice(2).trim();
+    }
+    const normalized = normalizeCommand(body);
+    if (normalized === null)
+        return;
+    const langOk = isShellFenceLang(fenceLang);
+    if (!looksLikeShellCommand(normalized) && (fenceLang === "" || !langOk))
+        return;
+    pushUnique(buckets, normalized, "task_statement", `fence@L${fenceStartLine}${fenceLang ? `:${fenceLang}` : ""}`);
+}
+function flushFenceBody(body, fenceLang, fenceStartLine, requireRegion, regionActive, buckets) {
+    if (requireRegion && !regionActive)
+        return;
+    if (!isShellFenceLang(fenceLang))
+        return;
+    // 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.
+    const transcript = body.some((line) => isTranscriptOutputLine(line));
+    for (const line of body) {
+        if (isFenceCommentOrBlank(line))
+            continue;
+        if (transcript && isPromptLine(line)) {
+            buckets.transcriptPromptSkipped += 1;
+            continue;
+        }
+        if (isTranscriptOutputLine(line))
+            continue;
+        captureFenceBodyLine(line, fenceLang, fenceStartLine, buckets);
+    }
+}
 /**
  * Walk fenced ``` / ~~~ blocks; keep fence body lines that look like shell.
  * When `requireRegion` is true, only fences under an acceptance/verify heading.
+ * Output-shaped fences (progress tags, box drawing, FAIL/Error:) are skipped (#3511).
  */
 function extractFromFences(text, requireRegion, buckets) {
     const lines = text.split(/\r?\n/);
-    let inFence = false;
-    let fenceLang = "";
+    let open = null;
     let regionActive = !requireRegion;
     let fenceStartLine = 0;
+    let fenceBody = [];
+    const flush = () => {
+        if (open === null)
+            return;
+        flushFenceBody(fenceBody, open.lang, fenceStartLine, requireRegion, regionActive, buckets);
+        open = null;
+        fenceBody = [];
+    };
     for (let i = 0; i < lines.length; i += 1) {
         const line = lines[i] ?? "";
         const heading = matchMarkdownHeading(line);
-        if (heading !== null && !inFence) {
+        if (heading !== null && open === null) {
             regionActive = requireRegion ? isRegionHeading(heading.text) : true;
             continue;
         }
         const fenceOpen = matchFenceOpen(line);
-        if (fenceOpen !== null && !inFence) {
-            inFence = true;
-            fenceLang = fenceOpen.lang;
+        if (fenceOpen !== null && open === null) {
+            open = fenceOpen;
             fenceStartLine = i + 1;
+            fenceBody = [];
             continue;
         }
-        if (inFence && matchFenceClose(line)) {
-            inFence = false;
-            fenceLang = "";
+        if (open !== null && matchFenceClose(line, open)) {
+            flush();
             continue;
         }
-        if (!inFence)
+        if (open === null)
             continue;
-        if (requireRegion && !regionActive)
-            continue;
-        // Skip comment-only fence lines.
-        const trimmed = line.trim();
-        if (trimmed.length === 0 || trimmed.startsWith("#") || trimmed.startsWith("//")) {
-            continue;
-        }
-        // Shell-ish langs always accepted; unknown langs need CLI shape.
-        const langOk = isShellFenceLang(fenceLang);
-        if (!langOk && fenceLang !== "")
-            continue;
-        // Strip leading prompt markers inside fences.
-        let body = trimmed;
-        if (body.startsWith("$ ") || body.startsWith("> ")) {
-            body = body.slice(2).trim();
-        }
-        const normalized = normalizeCommand(body);
-        if (normalized === null)
-            continue;
-        if (!looksLikeShellCommand(normalized) && (fenceLang === "" || !langOk))
-            continue;
-        pushUnique(buckets, normalized, "task_statement", `fence@L${fenceStartLine}${fenceLang ? `:${fenceLang}` : ""}`);
+        fenceBody.push(line);
     }
+    flush();
 }
 function isShellFenceLang(lang) {
     return (lang === "" ||
@@ -262,26 +330,38 @@ function isShellFenceLang(lang) {
         lang === "cmd" ||
         lang === "text");
 }
-/** Linear fence open: ```lang or ~~~lang */
+/**
+ * CommonMark fence open: 3+ backticks or tildes, then an optional info string.
+ * Longer openers (````) must close with the same marker at >= that length (#3511 P1).
+ */
 function matchFenceOpen(line) {
-    const t = line.trimEnd();
-    if (t.startsWith("```")) {
-        const rest = t.slice(3).trim().toLowerCase();
-        if (rest.includes(" ") || rest.includes("\t"))
-            return null;
-        return { lang: rest };
-    }
-    if (t.startsWith("~~~")) {
-        const rest = t.slice(3).trim().toLowerCase();
-        if (rest.includes(" ") || rest.includes("\t"))
-            return null;
-        return { lang: rest };
-    }
-    return null;
+    const body = line.trimEnd().trimStart();
+    if (body.length < 3)
+        return null;
+    const first = body[0];
+    if (first !== "`" && first !== "~")
+        return null;
+    const marker = first;
+    let length = 0;
+    while (length < body.length && body[length] === marker)
+        length += 1;
+    if (length < 3)
+        return null;
+    const rest = body.slice(length).trim().toLowerCase();
+    if (rest.includes(" ") || rest.includes("\t"))
+        return null;
+    if (rest.includes(marker))
+        return null;
+    return { lang: rest, marker, length };
 }
-function matchFenceClose(line) {
+function matchFenceClose(line, open) {
     const t = line.trim();
-    return t === "```" || t === "~~~";
+    let length = 0;
+    while (length < t.length && t[length] === open.marker)
+        length += 1;
+    if (length < open.length)
+        return false;
+    return t.slice(length).trim().length === 0;
 }
 function matchMarkdownHeading(line) {
     if (!line.startsWith("#"))
@@ -295,17 +375,25 @@ function matchMarkdownHeading(line) {
         return null;
     return { level, text: line.slice(level + 1).trim() };
 }
-/** Extract from labeled lines and `$` prompts anywhere in the statement. */
+/**
+ * Extract from labeled lines and `$` prompts anywhere in the statement.
+ *
+ * A labeled command MUST start its own line (after an optional bullet / number
+ * 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.
+ */
 function extractFromLabeledLines(text, buckets) {
     const lines = text.split(/\r?\n/);
+    const inFence = fenceBodyMask(lines);
     for (let i = 0; i < lines.length; i += 1) {
+        if (inFence[i] === true)
+            continue;
         const line = lines[i] ?? "";
         let capturedLabeled = false;
-        let labeledBody = matchLabeledCommand(line);
-        if (labeledBody === null && matchPromptCommand(line) === null) {
-            // Avoid treating `$ task verify:branch` as labeled "branch".
-            labeledBody = matchMidlineLabeled(line);
-        }
+        const labeledBody = matchLabeledCommand(line);
         if (labeledBody !== null) {
             const normalized = normalizeCommand(labeledBody);
             if (normalized !== null && looksLikeShellCommand(normalized)) {
@@ -330,7 +418,10 @@ function extractFromLabeledLines(text, buckets) {
  */
 function extractInlineVerifySpans(text, buckets) {
     const lines = text.split(/\r?\n/);
+    const inFence = fenceBodyMask(lines);
     for (let i = 0; i < lines.length; i += 1) {
+        if (inFence[i] === true)
+            continue;
         const line = lines[i] ?? "";
         if (!/\b(verify|run|execute|acceptance)\b/i.test(line))
             continue;
@@ -359,6 +450,7 @@ function emptyBuckets() {
         seen: new Set(),
         rejected: [],
         rejectedSeen: new Set(),
+        transcriptPromptSkipped: 0,
     };
 }
 /**
@@ -367,7 +459,7 @@ function emptyBuckets() {
  */
 export function captureLiteralAcceptanceCommandsDetailed(taskStatement) {
     if (!isNonEmptyString(taskStatement)) {
-        return { commands: [], rejected: [] };
+        return { commands: [], rejected: [], transcriptPromptSkipped: 0 };
     }
     const buckets = emptyBuckets();
     // Prefer fences under acceptance/verify headings first.
@@ -376,7 +468,11 @@ export function captureLiteralAcceptanceCommandsDetailed(taskStatement) {
     extractFromFences(taskStatement, false, buckets);
     extractFromLabeledLines(taskStatement, buckets);
     extractInlineVerifySpans(taskStatement, buckets);
-    return { commands: buckets.out, rejected: buckets.rejected };
+    return {
+        commands: buckets.out,
+        rejected: buckets.rejected,
+        transcriptPromptSkipped: buckets.transcriptPromptSkipped,
+    };
 }
 /**
  * Capture literal acceptance commands from free-form task statement text.
@@ -395,7 +491,7 @@ export function readStoredLiteralAcceptanceCommands(plan) {
 /** Read stored commands plus any persisted rejected ledger. */
 export function readStoredLiteralAcceptanceDetailed(plan) {
     if (plan === null || plan === undefined || typeof plan !== "object") {
-        return { commands: [], rejected: [] };
+        return { commands: [], rejected: [], transcriptPromptSkipped: 0 };
     }
     const buckets = emptyBuckets();
     const metadata = asRecord(plan.metadata);
@@ -435,7 +531,11 @@ export function readStoredLiteralAcceptanceDetailed(plan) {
         }
     }
     walkPlanItems(plan.items, "items", buckets);
-    return { commands: buckets.out, rejected: buckets.rejected };
+    return {
+        commands: buckets.out,
+        rejected: buckets.rejected,
+        transcriptPromptSkipped: buckets.transcriptPromptSkipped,
+    };
 }
 function walkPlanItems(items, pathPrefix, buckets) {
     if (!Array.isArray(items))
@@ -644,6 +744,55 @@ function toSerializable(cmd) {
     }
     return row;
 }
+/**
+ * Provenance prefixes stamped by the free-text scrapers in this module.
+ * Anything carrying one of these spans came from prose, not from a structured
+ * acceptance field the author wrote on purpose (#3484).
+ */
+const PROSE_SPAN_PREFIXES = ["labeled@", "prompt@", "inline@", "fence@"];
+/** True when a rejected ledger entry was scraped from narrative prose (#3484). */
+export function isProseDerivedRejection(rejected) {
+    const span = rejected.sourceSpan;
+    if (span === null || span === undefined)
+        return false;
+    return PROSE_SPAN_PREFIXES.some((prefix) => span.startsWith(prefix));
+}
+function hasNonEmptyCommandList(raw) {
+    if (typeof raw === "string")
+        return raw.trim().length > 0;
+    if (!Array.isArray(raw))
+        return false;
+    for (const entry of raw) {
+        if (typeof entry === "string" && entry.trim().length > 0)
+            return true;
+        const rec = asRecord(entry);
+        if (rec === null)
+            continue;
+        if (isNonEmptyString(rec.command ?? rec.cmd ?? rec.shell))
+            return true;
+    }
+    return false;
+}
+/**
+ * True when the author stated acceptance commands structurally — `swarm.verify_commands`
+ * or `plan.acceptance.commands` (#3484). Still used by intake/tests; demotion of
+ * prose-derived rejections no longer depends on this (#3511).
+ */
+export function hasStructuredAcceptanceCommands(plan) {
+    const rec = asRecord(plan);
+    if (rec === null)
+        return false;
+    const acceptance = asRecord(rec.acceptance);
+    if (acceptance !== null && hasNonEmptyCommandList(acceptance.commands))
+        return true;
+    const metadata = asRecord(rec.metadata);
+    if (metadata === null)
+        return false;
+    const swarm = asRecord(metadata.swarm);
+    if (swarm === null)
+        return false;
+    return hasNonEmptyCommandList(swarm.verify_commands);
+}
 /** Format rejected ledger for CLI / complete-gate messages. */
 export function formatRejectedLedger(rejected) {
     if (rejected.length === 0)

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

@@ -13,6 +13,19 @@ export interface EvaluateLiteralAcceptanceOptions {
     /** Quiet success (empty message on pass). */
     readonly quiet?: boolean;
 }
+/** Resolved literal-AC view: executable commands plus the blocking / advisory ledgers. */
+export interface ResolvedLiteralAcceptance {
+    readonly commands: readonly LiteralAcceptanceCommand[];
+    /** Safety-rejected entries that block completion. */
+    readonly rejected: readonly RejectedLiteralCommand[];
+    /**
+     * Prose/fence/inline-derived rejections demoted to advisory (#3484 / #3511).
+     * Reported, never blocking. Structured-field rejections stay on `rejected`.
+     */
+    readonly advisoryRejected: readonly RejectedLiteralCommand[];
+    /** Prompt lines skipped inside a transcript-shaped fence (#3511). */
+    readonly transcriptPromptSkipped: number;
+}
 /**
  * Resolve commands + rejected ledger.
  * Stored first; when captureFromNarratives is true (default), also re-scan narratives
@@ -21,16 +34,28 @@ export interface EvaluateLiteralAcceptanceOptions {
  */
 export declare function resolveLiteralAcceptanceDetailed(plan: Record<string, unknown>, options?: {
     readonly captureFromNarratives?: boolean;
-}): {
-    readonly commands: readonly LiteralAcceptanceCommand[];
-    readonly rejected: readonly RejectedLiteralCommand[];
-};
+}): ResolvedLiteralAcceptance;
 /**
  * Resolve commands: stored first; optional narrative re-capture when empty.
  */
 export declare function resolveLiteralAcceptanceCommands(plan: Record<string, unknown>, options?: {
     readonly captureFromNarratives?: boolean;
 }): LiteralAcceptanceCommand[];
+/**
+ * Marker that opens the #3484 advisory block. Consumers strip from here to the end
+ * before any free-text inspection of a literal-AC message: the block quotes refusal
+ * reasons that were explicitly demoted and must not be read back as blocking (#3497).
+ */
+export declare const LITERAL_ACCEPTANCE_ADVISORY_MARKER = "Literal acceptance advisory (#3484):";
+/** Render the #3484 advisory block (reported, never blocking). */
+export declare function formatLiteralAcceptanceAdvisory(advisory: readonly RejectedLiteralCommand[]): string;
+/** Append the #3484 advisory block to a message tail. */
+export declare function appendLiteralAcceptanceAdvisory(message: string, advisory: readonly RejectedLiteralCommand[]): string;
+/**
+ * Drop the #3484 advisory block from a rendered message.
+ * The block is always the tail, so an index cut is exact.
+ */
+export declare function stripLiteralAcceptanceAdvisory(message: string): string;
 /**
  * Evaluate from an in-memory plan object.
  */

package/dist/literal-acceptance/evaluate.js

@@ -3,7 +3,7 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { captureLiteralAcceptanceCommandsDetailed, formatRejectedLedger, readStoredLiteralAcceptanceDetailed, } from "./capture.js";
+import { captureLiteralAcceptanceCommandsDetailed, formatRejectedLedger, isProseDerivedRejection, readStoredLiteralAcceptanceDetailed, } from "./capture.js";
 import { runLiteralAcceptanceCommands } from "./run.js";
 function asRecord(value) {
     if (typeof value === "object" && value !== null && !Array.isArray(value)) {
@@ -14,6 +14,24 @@ function asRecord(value) {
 function planOf(data) {
     return asRecord(data.plan);
 }
+/**
+ * Prose-derived rejections are advisory (#3484 / #3511). A scraper misread must
+ * not block completion, whether or not the plan states structured commands —
+ * blocking on a capture the extractor itself rejected is backwards. Rejections
+ * from structured fields (`swarm.verify_commands`, plan items, explicit metadata)
+ * keep blocking — those are real commands the author asked for.
+ */
+function partitionRejected(rejected) {
+    const blocking = [];
+    const advisory = [];
+    for (const r of rejected) {
+        if (isProseDerivedRejection(r))
+            advisory.push(r);
+        else
+            blocking.push(r);
+    }
+    return { blocking, advisory };
+}
 /**
  * Resolve commands + rejected ledger.
  * Stored first; when captureFromNarratives is true (default), also re-scan narratives
@@ -21,6 +39,16 @@ function planOf(data) {
  * (Greptile conf residual).
  */
 export function resolveLiteralAcceptanceDetailed(plan, options = {}) {
+    const raw = resolveRawLiteralAcceptance(plan, options);
+    const split = partitionRejected(raw.rejected);
+    return {
+        commands: raw.commands,
+        rejected: split.blocking,
+        advisoryRejected: split.advisory,
+        transcriptPromptSkipped: raw.transcriptPromptSkipped,
+    };
+}
+function resolveRawLiteralAcceptance(plan, options = {}) {
     const stored = readStoredLiteralAcceptanceDetailed(plan);
     if (options.captureFromNarratives === false) {
         return stored;
@@ -74,7 +102,11 @@ export function resolveLiteralAcceptanceDetailed(plan, options = {}) {
         rejectedSeen.add(k);
         rejected.push(r);
     }
-    return { commands, rejected };
+    return {
+        commands,
+        rejected,
+        transcriptPromptSkipped: captured.transcriptPromptSkipped,
+    };
 }
 /**
  * Resolve commands: stored first; optional narrative re-capture when empty.
@@ -82,6 +114,36 @@ export function resolveLiteralAcceptanceDetailed(plan, options = {}) {
 export function resolveLiteralAcceptanceCommands(plan, options = {}) {
     return [...resolveLiteralAcceptanceDetailed(plan, options).commands];
 }
+/**
+ * Marker that opens the #3484 advisory block. Consumers strip from here to the end
+ * before any free-text inspection of a literal-AC message: the block quotes refusal
+ * reasons that were explicitly demoted and must not be read back as blocking (#3497).
+ */
+export const LITERAL_ACCEPTANCE_ADVISORY_MARKER = "Literal acceptance advisory (#3484):";
+/** Render the #3484 advisory block (reported, never blocking). */
+export function formatLiteralAcceptanceAdvisory(advisory) {
+    if (advisory.length === 0)
+        return "";
+    return (`${LITERAL_ACCEPTANCE_ADVISORY_MARKER} ${advisory.length} ` +
+        `prose/fence-derived capture(s) were safety-rejected but do NOT block — ` +
+        `the extractor is not confident these are stated acceptance commands (#3511).\n` +
+        formatRejectedLedger(advisory));
+}
+/** Append the #3484 advisory block to a message tail. */
+export function appendLiteralAcceptanceAdvisory(message, advisory) {
+    const block = formatLiteralAcceptanceAdvisory(advisory);
+    if (block.length === 0)
+        return message;
+    return message.length > 0 ? `${message}\n${block}` : block;
+}
+/**
+ * Drop the #3484 advisory block from a rendered message.
+ * The block is always the tail, so an index cut is exact.
+ */
+export function stripLiteralAcceptanceAdvisory(message) {
+    const at = message.indexOf(LITERAL_ACCEPTANCE_ADVISORY_MARKER);
+    return at === -1 ? message : message.slice(0, at);
+}
 function appendRejectedNote(message, rejected) {
     const ledger = formatRejectedLedger(rejected);
     if (ledger.length === 0)
@@ -120,11 +182,17 @@ export function evaluateLiteralAcceptanceFromPlan(plan, options = {}) {
                 ledger +
                 (result.message.length > 0 ? `\n${result.message}` : "");
     }
+    // Prose/fence-derived rejections (#3484 / #3511) are reported, never blocking.
+    if (resolved.advisoryRejected.length > 0) {
+        message = appendLiteralAcceptanceAdvisory(message, resolved.advisoryRejected);
+    }
     const withRejected = {
         ...result,
         ok,
         code,
         rejected: resolved.rejected,
+        advisoryRejected: resolved.advisoryRejected,
+        transcriptPromptSkipped: resolved.transcriptPromptSkipped,
         message,
     };
     if (options.quiet === true && withRejected.ok) {

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, readStoredLiteralAcceptanceCommands, readStoredLiteralAcceptanceDetailed, } from "./capture.js";
-export { type EvaluateLiteralAcceptanceOptions, evaluateLiteralAcceptanceFromPath, evaluateLiteralAcceptanceFromPlan, isLiteralAcceptanceRequiredAtCeremonyDepth, resolveLiteralAcceptanceCommands, resolveLiteralAcceptanceDetailed, } from "./evaluate.js";
+export { attachLiteralAcceptanceCommands, type CaptureLiteralAcceptanceResult, captureAndAttachLiteralAcceptance, captureLiteralAcceptanceCommands, captureLiteralAcceptanceCommandsDetailed, formatRejectedLedger, hasStructuredAcceptanceCommands, isProseDerivedRejection, 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, isExecutableLiteralSource, } from "./safety.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";
 //# 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, readStoredLiteralAcceptanceCommands, readStoredLiteralAcceptanceDetailed, } from "./capture.js";
-export { evaluateLiteralAcceptanceFromPath, evaluateLiteralAcceptanceFromPlan, isLiteralAcceptanceRequiredAtCeremonyDepth, resolveLiteralAcceptanceCommands, resolveLiteralAcceptanceDetailed, } from "./evaluate.js";
+export { attachLiteralAcceptanceCommands, captureAndAttachLiteralAcceptance, captureLiteralAcceptanceCommands, captureLiteralAcceptanceCommandsDetailed, formatRejectedLedger, hasStructuredAcceptanceCommands, isProseDerivedRejection, 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, isExecutableLiteralSource, } from "./safety.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";
 //# sourceMappingURL=index.js.map