@deftai/directive-core 0.107.0 → 0.108.0

package/dist/architecture/sor-preflight.js

@@ -16,6 +16,7 @@ import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { basename, extname, join, resolve } from "node:path";
 import { hasArtifactSuffix, LIFECYCLE_DIR_NAMES } from "../layout/resolve.js";
+import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
 // ---------------------------------------------------------------------------
 // Classification constants
 // ---------------------------------------------------------------------------
@@ -776,6 +777,7 @@ function gitDiff(projectRoot, baseRef) {
         cwd: resolve(projectRoot),
         encoding: "utf8",
         timeout: 30_000,
+        maxBuffer: SUBPROCESS_MAX_BUFFER,
     });
     if (result.error) {
         return [

package/dist/check/cached-orchestrator.js

@@ -6,6 +6,7 @@ import { readCorePackageVersion } from "../engine-version.js";
 import { applyProductFirstGateMode, EMPTY_AC_CAUSE, EMPTY_AC_REMEDY, isHygieneGate, isProductAcGate, isSoftEmptyAcText, resolveProductFirstCheckMode, } from "../product-first-done-gate/index.js";
 import { RunSummaryEmitter } from "../run-summary/emit.js";
 import { runToolchainPreflight, SKIP_ALL_GATES, } from "../session/toolchain-preflight.js";
+import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
 import { checkGateCliArgv, cliSpawnPlan, resolveGateDispatch, resolveGlobalCliBin, } from "./cli-native-gates.js";
 import { evaluateConsumerGateIntegrity, formatConsumerGateIntegrityFailure, } from "./consumer-gate-integrity.js";
 import { resolveCheckTarget } from "./context.js";
@@ -17,6 +18,7 @@ function captureSpawn(taskBin, args, opts) {
         cwd: opts.cwd,
         encoding: "utf8",
         env: opts.env ?? process.env,
+        maxBuffer: SUBPROCESS_MAX_BUFFER,
     });
     if (result.error !== undefined) {
         return {
@@ -40,6 +42,27 @@ function writeLines(lines, stream = "stderr") {
         write(`${line}\n`);
     }
 }
+function firstImpactingMissingFinding(preflight) {
+    const missing = preflight?.findings.filter((finding) => !finding.present) ?? [];
+    const impacting = missing.filter((finding) => finding.impact !== "none");
+    const priority = [
+        "node",
+        "task",
+        "cli_dist",
+        "package_manager",
+        preflight?.packageManager,
+        "npm",
+        "pnpm",
+    ];
+    for (const tool of priority) {
+        if (tool === null || tool === undefined)
+            continue;
+        const finding = impacting.find((candidate) => candidate.tool === tool);
+        if (finding !== undefined)
+            return finding;
+    }
+    return impacting[0] ?? missing[0];
+}
 /**
  * Run check gates sequentially with content-hash caching (#1713).
  * Falls back to fail-open execution for undeclared / non-cacheable gates.
@@ -135,6 +158,7 @@ export function dispatchCachedTaskCheck(frameworkRoot, projectRoot, options = {}
             composedGates: gates,
             consumerDeposit: target === "check:consumer",
             which,
+            env: options.env,
         })
         : options.preflight;
     const taskPresent = preflight === null || !preflight.findings.some((f) => f.tool === "task" && !f.present);
@@ -165,8 +189,9 @@ export function dispatchCachedTaskCheck(frameworkRoot, projectRoot, options = {}
         if (allSkipped) {
             const skipped = gates.map((g) => {
                 const id = checkGateId(g);
-                const cause = preflight?.findings.find((f) => !f.present)?.cause ?? "toolchain preflight degraded";
-                const remedy = preflight?.findings.find((f) => !f.present)?.remedy ?? remedyForGate(id, cause);
+                const missing = firstImpactingMissingFinding(preflight);
+                const cause = missing?.cause ?? "toolchain preflight degraded";
+                const remedy = missing?.remedy ?? remedyForGate(id, cause);
                 gateOutcomes.push({ id, status: "skipped", cause, remedy });
                 return { id, cause, remedy };
             });
@@ -183,7 +208,7 @@ export function dispatchCachedTaskCheck(frameworkRoot, projectRoot, options = {}
         const gateId = checkGateId(gateSpec);
         // #3282: skip gates that require missing tools (e.g. pnpm-only suite).
         if (skipSet.has(gateId)) {
-            const missing = preflight?.findings.find((f) => !f.present);
+            const missing = firstImpactingMissingFinding(preflight);
             const cause = missing?.cause ?? "toolchain preflight marked gate skippable";
             const remedy = missing?.remedy ?? remedyForGate(gateId, cause);
             process.stderr.write(`check: skipping gate ${gateId} (degraded) — cause: ${cause}; remedy: ${remedy}\n`);

package/dist/check/named-cause.js

@@ -13,7 +13,7 @@ const GATE_REMEDIES = {
     "verify:wip-cap": "Demote stale pending scopes (task scope:demote) or raise plan.policy.wipCap deliberately",
     doctor: "Run task doctor and follow the named recovery steps",
     "toolchain:check": "Install missing maintainer tools reported by the gate (go, uv, git, gh, node, pnpm)",
-    "toolchain:check-consumer": "Install missing consumer tools: go-task, git, gh, node, pnpm (corepack enable && corepack prepare pnpm@latest --activate)",
+    "toolchain:check-consumer": "Install the missing consumer tool reported by the gate; use npm from Node or enable pnpm with Corepack as declared by package.json",
     "ts:check-lane": "Fix lint/type/test failures; re-run task ts:check-lane",
     "vbrief:validate": "Fix xBRIEF/vBRIEF schema errors reported by the gate",
     "verify-strategy-output": "Re-run strategy output or fix non-conformant scope filenames / PROJECT-DEFINITION",
@@ -57,6 +57,12 @@ export function extractGateCause(stdout, stderr, exitCode, spawnError, gateId) {
         useful.push(line);
     }
     const gateHint = gateId?.trim() ?? "";
+    if (gateHint === "toolchain:check" || gateHint === "toolchain:check-consumer") {
+        const toolFailure = useful.find((line) => /^(?:package manager|go|uv|git|gh|node|npm|pnpm|task): (?:NOT FOUND|FAILED|ERROR)\b/i.test(line));
+        if (toolFailure !== undefined) {
+            return sanitizeCauseLine(toolFailure);
+        }
+    }
     if (gateHint.length > 0) {
         const named = useful.find((line) => line.includes(gateHint));
         if (named !== undefined) {
@@ -106,14 +112,23 @@ export function remedyForGate(gateId, cause) {
         return CLI_SPAWN_ERROR_REMEDY;
     }
     if (/task binary not found|cannot spawn go-task/i.test(cause)) {
-        if (gateId.startsWith("verify:") || gateId.startsWith("verify-") || gateId === "doctor") {
+        if (gateId.startsWith("verify:") ||
+            gateId.startsWith("verify-") ||
+            gateId === "doctor" ||
+            gateId === "toolchain:check-consumer") {
             return CLI_SPAWN_ERROR_REMEDY;
         }
         return SPAWN_ERROR_REMEDY;
     }
-    if (/pnpm binary not found|pnpm: NOT FOUND/i.test(cause)) {
+    if (/Unsupported DEFT_PACKAGE_MANAGER value/i.test(cause)) {
+        return "Set DEFT_PACKAGE_MANAGER to npm or pnpm, or unset it to use package.json; then re-run the consumer check";
+    }
+    if (/\bpnpm(?: binary not found|: (?:NOT FOUND|FAILED|ERROR))/i.test(cause)) {
         return "Enable pnpm: corepack enable && corepack prepare pnpm@latest --activate";
     }
+    if (/\bnpm(?: binary not found|: (?:NOT FOUND|FAILED|ERROR))/i.test(cause)) {
+        return "Install or repair Node 20+ (npm is bundled), then re-run the consumer check";
+    }
     return (GATE_REMEDIES[gateId] ??
         `Re-run the gate for details: task ${gateId}  (or task check); fix the reported product/process defect`);
 }

package/dist/codebase/provider.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from "node:url";
 import { contentRoot } from "../content-root.js";
 import { resolveProjectDefinitionPath } from "../layout/resolve.js";
 import { readPlanPolicy } from "../policy/plan-extensions.js";
+import { resolveCaptureFailureStderr, SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
 import { loadJsonFile } from "../verify-source/code-structure-validate.js";
 import { CODEBASE_MAP_SCHEMA_PATH } from "./constants.js";
 import { buildCodebaseMap, CodeStructureConfigError, configErrorToDict, defaultCodeStructurePath, fileSha256, } from "./default-extractor.js";
@@ -547,6 +548,7 @@ function runProviderCommand(command, cwd) {
             cwd,
             encoding: "utf8",
             timeout: 60_000,
+            maxBuffer: SUBPROCESS_MAX_BUFFER,
             stdio: ["ignore", "pipe", "pipe"],
         });
         return { returncode: 0, stdout, stderr: "" };
@@ -556,7 +558,11 @@ function runProviderCommand(command, cwd) {
         return {
             returncode: typeof e.status === "number" ? e.status : 1,
             stdout: typeof e.stdout === "string" ? e.stdout : "",
-            stderr: typeof e.stderr === "string" ? e.stderr : String(e.message ?? err),
+            stderr: resolveCaptureFailureStderr({
+                captured: typeof e.stderr === "string" ? e.stderr : "",
+                status: e.status,
+                message: e.message ?? String(err),
+            }),
         };
     }
 }

package/dist/delivery-attempt/handoff.js

@@ -8,7 +8,7 @@ import { utcIso } from "./types.js";
 export function nextSafeActionFor(decision) {
     switch (decision) {
         case "DENY_DUPLICATE_ACTIVE":
-            return "Wait for the active attempt to finish or cancel it; do not start a duplicate dispatch.";
+            return "A running attempt is not proof the worker is alive. Takeover: swarm:pre-dispatch --action cancel, then begin. REDISPATCH_OK does not lift this deny.";
         case "BLOCK_NON_RETRYABLE":
             return "Fix the deterministic configuration/schema/permission failure, record a relevant material delta, then resume.";
         case "BLOCK_NO_MATERIAL_PROGRESS":

package/dist/design-critique/citation-grammar.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Citation grammar for the design-critique completed-arc record (#3831).
+ *
+ * One parser answers both questions the ingest predicate asks: which comment
+ * ids a synthesis cites, and whether it claims a verified-claims table. The
+ * closed accepted set and the refused positions are published in
+ * `content/contracts/design-critique.md` `## Citation grammar`; this module is
+ * the only implementation of that grammar.
+ *
+ * Which code-span convention governs. The intake cross-ref scanners
+ * (`intake/markdown-scanners.ts`) delete code spans, so for them a backticked
+ * id is an example and never a reference. The citation scan takes the opposite
+ * polarity for the id token only: a balanced single-backtick id is an accepted
+ * citation, because arc comments are hand-written prose and the mandated lean
+ * heading is itself `**Lean:**`. A keyword inside a code span or a fence stays
+ * an example in both layers. Positions are classified, never stripped -- the
+ * strippers delete a span with its contents, which destroys the digits. The
+ * prior art for classify-not-strip is `classifyHit`
+ * (`pr-closing-keywords/detect.ts`).
+ *
+ * The fence scan is local rather than borrowed from that detector because the
+ * detector's opener regex is anchored at column zero, so a CommonMark fence
+ * indented one to three spaces reads as prose. Relaxing it there would move
+ * hits into the #737 false-positive class and change what that gate suppresses,
+ * which is a separate decision from this one.
+ */
+export type CitationKind = "lean" | "table" | "comment";
+export type CitationRejectionClass = "code-fence" | "inline-code" | "blockquote" | "strikethrough" | "negation";
+export type Citation = {
+    readonly id: number;
+    readonly kind: CitationKind;
+};
+export type RejectedCitation = {
+    readonly id: number;
+    readonly reason: CitationRejectionClass;
+};
+export type CitationScan = {
+    /** Accepted citations in document order, deduplicated on (id, kind). */
+    readonly citations: readonly Citation[];
+    /** Keyword-anchored or permalink occurrences refused by position. */
+    readonly rejected: readonly RejectedCitation[];
+    /** Every 8-or-more digit run in the body, for deterministic diagnostics. */
+    readonly idShapedRuns: readonly number[];
+};
+/** The published closed set, in the order the contract lists it. */
+export declare const ACCEPTED_CITATION_FORMS: readonly string[];
+/**
+ * Parse the closed citation grammar out of one comment body. Refused positions
+ * are reported rather than dropped so a block detail can echo the observation
+ * instead of guessing at a cause.
+ */
+export declare function scanCitations(body: string): CitationScan;
+//# sourceMappingURL=citation-grammar.d.ts.map

package/dist/design-critique/citation-grammar.js

@@ -0,0 +1,303 @@
+/**
+ * Citation grammar for the design-critique completed-arc record (#3831).
+ *
+ * One parser answers both questions the ingest predicate asks: which comment
+ * ids a synthesis cites, and whether it claims a verified-claims table. The
+ * closed accepted set and the refused positions are published in
+ * `content/contracts/design-critique.md` `## Citation grammar`; this module is
+ * the only implementation of that grammar.
+ *
+ * Which code-span convention governs. The intake cross-ref scanners
+ * (`intake/markdown-scanners.ts`) delete code spans, so for them a backticked
+ * id is an example and never a reference. The citation scan takes the opposite
+ * polarity for the id token only: a balanced single-backtick id is an accepted
+ * citation, because arc comments are hand-written prose and the mandated lean
+ * heading is itself `**Lean:**`. A keyword inside a code span or a fence stays
+ * an example in both layers. Positions are classified, never stripped -- the
+ * strippers delete a span with its contents, which destroys the digits. The
+ * prior art for classify-not-strip is `classifyHit`
+ * (`pr-closing-keywords/detect.ts`).
+ *
+ * The fence scan is local rather than borrowed from that detector because the
+ * detector's opener regex is anchored at column zero, so a CommonMark fence
+ * indented one to three spaces reads as prose. Relaxing it there would move
+ * hits into the #737 false-positive class and change what that gate suppresses,
+ * which is a separate decision from this one.
+ */
+/** The published closed set, in the order the contract lists it. */
+export const ACCEPTED_CITATION_FORMS = [
+    "successor lean 12345678",
+    "successor lean: 12345678",
+    "successor lean `12345678`",
+    "**successor lean:** 12345678",
+    "#issuecomment-12345678",
+    "/issues/comments/12345678",
+];
+const EMPHASIS = "(?:\\*\\*|\\*)";
+const KEYWORD = "(successor[ \\t]+lean|verified-claims[ \\t]+table|lean|comment)";
+/**
+ * Colon and horizontal whitespace only. One of the three branches must consume
+ * a colon or a space, so `lean12345678` is not a citation.
+ */
+const SEPARATOR = `(?::${EMPHASIS}?[ \\t]*|${EMPHASIS}:?[ \\t]+|[ \\t]+)`;
+/** Bare decimal, or a balanced single-backtick decimal. Nothing else. */
+const ID_TOKEN = "(?:`(\\d{8,})`|(\\d{8,})\\b)";
+const CITATION_RE = new RegExp(`${EMPHASIS}?\\b${KEYWORD}${SEPARATOR}${ID_TOKEN}` +
+    "|#issuecomment-(\\d{8,})" +
+    "|/issues/comments/(\\d{8,})", "gi");
+const ID_RUN_RE = /\d{8,}/g;
+const BLOCKQUOTE_RE = /^ {0,3}>/;
+/** CommonMark fence delimiter: up to three leading spaces, the run, then the rest. */
+const FENCE_LINE_RE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+/** The last sentence break in a slice, and everything after it. */
+const LAST_SENTENCE_RE = /[.!?;][^.!?;]*$/;
+/** Everything up to the first sentence break. */
+const FIRST_SENTENCE_RE = /^[^.!?;]*/;
+/** The closed set of explicit negation markers the class recognises. */
+const NEGATION_MARKER = "\\b(?:cannot|never|no longer" +
+    "|(?:do|does|did|is|are|was|were|has|have|had|will|would|shall|should|must|can|could|may|might)\\s+not" +
+    "|(?:do|does|did|is|are|was|were|has|have|had|wo|would|should|must|ca|could|sha)n['\\u2019]t)\\b";
+/**
+ * Explicit negation of the citation itself, ending within three plain words of
+ * the keyword. A bare marker anywhere in the sentence prefix is not enough: it
+ * reads `without a doubt, successor lean N is accepted` and `not only successor
+ * lean N but also the table` as refusals, which blocks a valid record.
+ */
+const NEGATED_CITATION_RE = new RegExp(`${NEGATION_MARKER}(?:\\s+[A-Za-z][A-Za-z'\\u2019-]*){0,3}\\s*$`, "i");
+/** The same markers, unanchored, for the complement clause after a citation. */
+const NEGATION_ANYWHERE_RE = new RegExp(NEGATION_MARKER, "i");
+/**
+ * A negated verb of denial affirms the citation rather than refusing it, so the
+ * negation belongs to the verb and not to the occurrence: `we cannot deny that
+ * successor lean N binds` cites N. The verb set is closed and published --
+ * negating `deny`, `doubt`, `dispute`, `contest`, or `question` affirms the
+ * complement clause those verbs introduce.
+ *
+ * A trailing `that` alone is not the signal, because `that` is also a
+ * determiner. `do not use that successor lean N` and the cleft `the record is
+ * not that successor lean N` are genuine refusals, and both keep the negation
+ * class. The anchor is the end of the sentence segment, so a second negation
+ * before the keyword still binds: `we do not doubt that this does not bind
+ * successor lean N` is refused.
+ *
+ * The carve-out only suspends a prefix rule that already fired; it never
+ * refuses on its own, so it cannot widen the refused set. It also does not
+ * accept the citation outright. The complement clause is what carries the
+ * claim, so a negation anywhere in the rest of that sentence keeps the refusal:
+ * `we do not doubt that successor lean N does not bind` says the lean does not
+ * bind. That scan runs to the sentence break rather than to a clause boundary,
+ * which refuses more than it strictly must inside this one carve-out -- the
+ * fail-closed direction, and every such body was already refused before it.
+ */
+const DENIAL_COMPLEMENT_RE = /\b(?:den(?:y|ies|ied|ying)|doubt(?:s|ed|ing)?|disput(?:e|es|ed|ing)|contest(?:s|ed|ing)?|question(?:s|ed|ing)?)\s+that\s*$/i;
+function kindForKeyword(keyword) {
+    if (keyword === undefined)
+        return "comment";
+    const normalized = keyword.toLowerCase().replace(/[ \t]+/g, " ");
+    if (normalized.startsWith("verified-claims"))
+        return "table";
+    if (normalized === "comment")
+        return "comment";
+    return "lean";
+}
+function lineBounds(text, offset) {
+    const start = text.lastIndexOf("\n", offset - 1) + 1;
+    const found = text.indexOf("\n", offset);
+    return { start, end: found === -1 ? text.length : found };
+}
+/**
+ * CommonMark inline code: a run of N backticks opens a span that only a run of
+ * exactly N backticks closes. Counting single backticks would read a
+ * double-backtick span as balanced and let documentation prose cite.
+ *
+ * `text` is the whole span from the enclosing block start, not one line: a code
+ * span may carry a newline, so a line-scoped count cannot see the opener.
+ */
+function isInsideInlineCode(text) {
+    let openRun = 0;
+    let i = 0;
+    while (i < text.length) {
+        if (text[i] !== "`") {
+            i += 1;
+            continue;
+        }
+        let run = 0;
+        while (i + run < text.length && text[i + run] === "`")
+            run += 1;
+        if (openRun === 0) {
+            openRun = run;
+        }
+        else if (run === openRun) {
+            openRun = 0;
+        }
+        i += run;
+    }
+    return openRun !== 0;
+}
+function isStruckThrough(text) {
+    let runs = 0;
+    let i = 0;
+    while (i < text.length - 1) {
+        if (text[i] === "~" && text[i + 1] === "~") {
+            runs += 1;
+            i += 2;
+            continue;
+        }
+        i += 1;
+    }
+    return runs % 2 === 1;
+}
+/**
+ * A negation binds the sentence it sits in, not the whole line. Scoping to the
+ * text after the last sentence break keeps `this is not stale. Bound contract
+ * is successor lean N` an affirmative citation.
+ */
+function isNegated(line, column) {
+    const before = line.slice(0, column);
+    const tail = LAST_SENTENCE_RE.exec(before);
+    const segment = tail === null ? before : before.slice(tail.index + 1);
+    if (!NEGATED_CITATION_RE.test(segment))
+        return false;
+    if (!DENIAL_COMPLEMENT_RE.test(segment))
+        return true;
+    const after = line.slice(column);
+    return NEGATION_ANYWHERE_RE.test(FIRST_SENTENCE_RE.exec(after)?.[0] ?? after);
+}
+function fenceDelimiter(line) {
+    const match = FENCE_LINE_RE.exec(line);
+    if (match === null)
+        return null;
+    const run = match[1] ?? "";
+    const info = match[2] ?? "";
+    const char = run.startsWith("~") ? "~" : "`";
+    // A backtick opener's info string may not contain a backtick.
+    if (char === "`" && info.includes("`"))
+        return null;
+    return { char, len: run.length, info };
+}
+/**
+ * Walk the lines up to `offset` once and record both block facts the classifier
+ * needs. The fence stack follows CommonMark: opener and closer share the
+ * character, the closer is at least as long, and a closer carries no info
+ * string, so `` ```ts more text `` inside an open fence is content and not a
+ * closer. Inline scanning restarts after a blank line or a fence delimiter
+ * because neither a code span nor a strikethrough run crosses one. A blockquote
+ * marker carries forward to the blank line that ends the quote, so an unmarked
+ * lazy-continuation line is still quoted text.
+ *
+ * A fence delimiter also ends the quote block, and a line inside an open fence
+ * never opens one: a `>` in a fenced example is example text, so the marker must
+ * not survive the closing fence and refuse the citation that follows it. Lazy
+ * continuation is a paragraph rule, and a fence line is not paragraph text. A
+ * fence marked by `>` on every line is not a fence here -- `fenceDelimiter`
+ * requires the run at the line start -- so the line-level blockquote test still
+ * refuses a citation inside a blockquoted fence.
+ */
+function blockPosition(body, offset) {
+    let open = null;
+    let inlineStart = 0;
+    let quotedBlock = false;
+    let lineStart = 0;
+    while (lineStart < offset) {
+        let lineEnd = body.indexOf("\n", lineStart);
+        const partial = lineEnd === -1 || lineEnd > offset;
+        if (partial) {
+            lineEnd = Math.min(body.length, offset);
+        }
+        const line = body.slice(lineStart, lineEnd);
+        const fence = fenceDelimiter(line);
+        if (fence !== null) {
+            if (open === null) {
+                open = fence;
+            }
+            else if (fence.char === open.char &&
+                fence.len >= open.len &&
+                fence.info.trim().length === 0) {
+                open = null;
+            }
+        }
+        if (!partial) {
+            const blank = line.trim().length === 0;
+            if (blank || fence !== null) {
+                inlineStart = lineEnd + 1;
+                quotedBlock = false;
+            }
+            else if (open === null && BLOCKQUOTE_RE.test(line)) {
+                quotedBlock = true;
+            }
+        }
+        if (lineEnd >= offset) {
+            break;
+        }
+        lineStart = lineEnd + 1;
+    }
+    return { insideFence: open !== null, inlineStart, quotedBlock };
+}
+/**
+ * Refused positions are exactly the five published classes. An indented code
+ * block and an HTML comment are deliberately not classified: a four-space
+ * indent is also ordinary list-continuation content, so refusing it would block
+ * valid records more often than it would catch example text.
+ */
+function classifyPosition(body, offset) {
+    const block = blockPosition(body, offset);
+    if (block.insideFence)
+        return "code-fence";
+    const { start, end } = lineBounds(body, offset);
+    const line = body.slice(start, end);
+    if (BLOCKQUOTE_RE.test(line) || block.quotedBlock)
+        return "blockquote";
+    const preceding = body.slice(block.inlineStart, offset);
+    if (isInsideInlineCode(preceding))
+        return "inline-code";
+    if (isStruckThrough(preceding))
+        return "strikethrough";
+    if (isNegated(line, offset - start))
+        return "negation";
+    return null;
+}
+function idShapedRuns(body) {
+    const runs = [];
+    const seen = new Set();
+    const re = new RegExp(ID_RUN_RE.source, ID_RUN_RE.flags);
+    for (const match of body.matchAll(re)) {
+        const id = Number(match[0]);
+        if (!Number.isSafeInteger(id) || id <= 0 || seen.has(id))
+            continue;
+        seen.add(id);
+        runs.push(id);
+    }
+    return runs;
+}
+/**
+ * Parse the closed citation grammar out of one comment body. Refused positions
+ * are reported rather than dropped so a block detail can echo the observation
+ * instead of guessing at a cause.
+ */
+export function scanCitations(body) {
+    const citations = [];
+    const rejected = [];
+    const seen = new Set();
+    const re = new RegExp(CITATION_RE.source, CITATION_RE.flags);
+    for (const match of body.matchAll(re)) {
+        const raw = match[2] ?? match[3] ?? match[4] ?? match[5];
+        if (raw === undefined)
+            continue;
+        const id = Number(raw);
+        if (!Number.isSafeInteger(id) || id <= 0)
+            continue;
+        const reason = classifyPosition(body, match.index ?? 0);
+        if (reason !== null) {
+            rejected.push({ id, reason });
+            continue;
+        }
+        const kind = kindForKeyword(match[1]);
+        const key = `${id}|${kind}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        citations.push({ id, kind });
+    }
+    return { citations, rejected, idShapedRuns: idShapedRuns(body) };
+}
+//# sourceMappingURL=citation-grammar.js.map

package/dist/design-critique/completed-arc-record.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Completed-arc record for design-critique ingest (#3806).
+ *
+ * Catalog chips are list-visible convenience, not clearance. Ingest waits on
+ * `design-critique: synthesis accepted, because ...` citing an accepted
+ * successor lean (and the verified-claims table when that comment exists).
+ *
+ * Citations are parsed once, by `scanCitations` (#3831). The accepted forms and
+ * the refused positions are published in `content/contracts/design-critique.md`
+ * `## Citation grammar`. Clearance is set membership against the latest
+ * successor lean, not position in the body, so citing the superseded lean --
+ * which `## Successor lean` requires -- cannot block.
+ */
+export type ThreadComment = {
+    readonly id: number;
+    readonly body: string;
+};
+export type CompletedArcBlockReason = "missing-record" | "lone-shape" | "cite-not-lean" | "missing-table-cite";
+export type CompletedArcVerdict = {
+    readonly status: "not-in-arc";
+} | {
+    readonly status: "complete";
+    readonly synthesisCommentId: number;
+    readonly citedLeanId: number;
+    readonly citedTableId: number | null;
+} | {
+    readonly status: "blocked";
+    readonly reason: CompletedArcBlockReason;
+    readonly detail: string;
+};
+export declare class DesignCritiqueIngestBlockedError extends Error {
+    readonly issueNumber: number;
+    readonly reason: CompletedArcBlockReason;
+    constructor(issueNumber: number, reason: CompletedArcBlockReason, detail: string);
+}
+export declare function isSynthesisAcceptedShape(body: string): boolean;
+export declare function isSuccessorLeanBody(body: string): boolean;
+export declare function isVerifiedClaimsTableBody(body: string): boolean;
+/**
+ * Ids cited by one comment body, in document order. Thin projection of the
+ * shared parser -- the grammar itself lives in `citation-grammar.ts`.
+ */
+export declare function extractCitedCommentIds(body: string): number[];
+export declare function hasDesignCritiqueCatalogChip(labels: readonly string[]): boolean;
+export declare function isPanelDepositBody(body: string): boolean;
+export declare function isInFlightCritiqueThread(comments: readonly ThreadComment[]): boolean;
+/**
+ * Ingest clearance from thread structure. Labels and author identity are not
+ * predicates. A lone synthesis-accepted sentence shape is not the record.
+ * Clearance cites the latest successor lean; an older complete record does not
+ * clear a later recut. A panel-deposit is in-flight even before critic posts.
+ */
+export declare function evaluateCompletedArcRecord(input: {
+    readonly labels?: readonly string[];
+    readonly comments: readonly ThreadComment[];
+}): CompletedArcVerdict;
+export declare function assertCompletedArcAllowsIngest(input: {
+    readonly issueNumber: number;
+    readonly labels?: readonly string[];
+    readonly comments: readonly ThreadComment[];
+}): CompletedArcVerdict;
+//# sourceMappingURL=completed-arc-record.d.ts.map