@webpresso/agent-kit 3.3.3 → 3.3.4

package/dist/esm/blueprint/markdown/blocked-line.js

@@ -0,0 +1,63 @@
+/**
+ * Single owner of the task-body `**Blocked:** <reason>` line grammar.
+ *
+ * Both sides of the plan-approval contract read this file: `updateBlockedReason`
+ * (`#markdown/helpers.js`) writes the line, and `neutralizeTaskBlockedReason`
+ * (`#review/subject.js`) removes it before the plan-subject digest is taken. That
+ * pairing is exactly the arrangement the Promotion Gates row grammar already uses
+ * (`#trust/gate-row.js`), and for the same reason: when a writer and the
+ * normalizer spell the same grammar twice, they drift, the lifecycle stamp
+ * survives into the digest, and the plan approval the promotion gates on is
+ * silently dismissed.
+ *
+ * Deliberately dependency-free so any module on either side can import it
+ * without risking a cycle.
+ */
+/**
+ * Regex source for a whole `**Blocked:** …` line, anchored to line bounds.
+ *
+ * Anchoring is load-bearing in both directions. Blueprint prose legitimately
+ * mentions the marker mid-sentence ("add a non-empty **Blocked:** line with the
+ * reason") — those mentions are plan substance, and an unanchored pattern would
+ * have the writer overwrite them and the normalizer strip them.
+ */
+export const BLOCKED_LINE_SOURCE = String.raw `^\*\*Blocked:\*\*.*$`;
+/**
+ * Build a matcher for the blocked line. Mirrors the `buildTaskHeadingRegex`
+ * convention in `./task-heading.js`: callers pick the flags they need, but the
+ * pattern itself has exactly one definition.
+ */
+export function buildBlockedLineRegex(flags = "imu") {
+    return new RegExp(BLOCKED_LINE_SOURCE, flags);
+}
+const SINGLE_LINE_MATCHER = buildBlockedLineRegex("iu");
+/** True when `line` IS a blocked-reason line, not merely a line that mentions one. */
+export function isBlockedLine(line) {
+    return SINGLE_LINE_MATCHER.test(line);
+}
+const MARKER_LENGTH = "**Blocked:**".length;
+/**
+ * Serialize the blocked line. The writer-side counterpart to
+ * {@link isBlockedLine}: every emitter goes through here so the written form and
+ * the parsed form cannot diverge.
+ */
+export function formatBlockedLine(reason) {
+    return `**Blocked:** ${reason}`;
+}
+/**
+ * Read the reason off the first blocked line in a task section, or `undefined`
+ * when the section has none.
+ *
+ * The reader counterpart to {@link formatBlockedLine}. Three parsers used to
+ * carry their own unanchored copy of this pattern (`src/blueprint/core/parser.ts`,
+ * `src/blueprint/tracked-document/parser.ts`, `src/docs-linter/blueprint-plan.ts`),
+ * so a task whose prose merely mentioned the marker was read as genuinely
+ * blocked and the lifecycle audit failed the document.
+ */
+export function extractBlockedReason(section) {
+    const match = buildBlockedLineRegex().exec(section);
+    if (!match)
+        return undefined;
+    const reason = match[0].slice(MARKER_LENGTH).trim();
+    return reason === "" ? undefined : reason;
+}

package/dist/esm/blueprint/markdown/helpers.js

@@ -8,6 +8,7 @@
  * produces identical output (for the same inputs).
  */
 import { escapeRegex } from "#utils/string";
+import { BLOCKED_LINE_SOURCE, buildBlockedLineRegex, formatBlockedLine } from "./blocked-line.js";
 import { buildTaskHeaderRegexForId, buildTaskSectionBoundaryRegex, TASK_HEADING_PREFIX_PATTERN, } from "./task-heading.js";
 function buildTaskPattern(taskId) {
     return new RegExp(`(####\\s+${TASK_HEADING_PREFIX_PATTERN}Task\\s+${escapeRegex(taskId)}[:\\s].*?)(?=\\n####|\\n###|$)`, "s");
@@ -65,7 +66,11 @@ export function updateBlockedReason(content, taskId, reason) {
     const taskPattern = buildTaskPattern(taskId);
     return content.replace(taskPattern, (section) => {
         const trimmedReason = reason.trim();
-        const blockedPattern = /\n?\*\*Blocked:\*\*\s*.*(?:\n+)?/i;
+        // Grammar comes from ./blocked-line.js, which the plan-subject normalizer
+        // consumes too. Line-anchored on purpose: a task whose prose mentions
+        // `**Blocked:**` mid-sentence is plan substance, and the previous
+        // unanchored pattern would have overwritten it.
+        const blockedPattern = new RegExp(String.raw `\n?${BLOCKED_LINE_SOURCE}\n*`, "imu");
         if (!trimmedReason) {
             // Preserve the section's trailing whitespace: trimEnd on the whole
             // section would also delete the blank line separating this task from the
@@ -76,9 +81,10 @@ export function updateBlockedReason(content, taskId, reason) {
                 .replace(/\n{3,}/g, "\n\n")
                 .trimEnd() + trailingWhitespace);
         }
-        const blockedLine = `**Blocked:** ${trimmedReason}`;
-        if (/\*\*Blocked:\*\*/i.test(section)) {
-            return section.replace(/\*\*Blocked:\*\*\s*.+/i, blockedLine);
+        const blockedLine = formatBlockedLine(trimmedReason);
+        const existingLine = buildBlockedLineRegex();
+        if (existingLine.test(section)) {
+            return section.replace(existingLine, blockedLine);
         }
         return insertAfterStatusLine(section, blockedLine);
     });

package/dist/esm/blueprint/tracked-document/parser.js

@@ -6,6 +6,7 @@
  *
  * Git-Native SSoT: Checkbox state derives status, no external state.
  */
+import { extractBlockedReason } from "#markdown/blocked-line";
 import { isTaskHeaderLine } from "#markdown/task-heading";
 /**
  * Extract checkbox status from a markdown section and derive task state.
@@ -100,10 +101,9 @@ export function extractDepends(section) {
  * ```
  */
 export function extractBlocked(section) {
-    const blockedMatch = section.match(/\*\*Blocked:\*\*\s*(.+)/i);
-    if (!blockedMatch?.[1])
+    const blockedText = extractBlockedReason(section);
+    if (blockedText === undefined)
         return undefined;
-    const blockedText = blockedMatch[1].trim();
     // Handle missing/empty reason gracefully
     if (blockedText === "" || blockedText.toLowerCase() === "none") {
         return undefined;

package/dist/esm/blueprint/trust/gate-row.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Single owner of the Trust Dossier "Promotion Gates" table row grammar.
+ *
+ * Two callers must agree on this grammar byte-for-byte:
+ *
+ * - the lifecycle WRITER `updateGateLastResult` (`./promotion.ts`), which stamps
+ *   the `Last result` cell during `wp blueprint promote`; and
+ * - the plan-subject digest NORMALIZER `neutralizePromotionGateResults`
+ *   (`#review/subject.js`), which replaces that same cell with a placeholder so
+ *   the stamp is never hashed into a plan approval's subject.
+ *
+ * They each used to implement the grammar independently, and diverged on four
+ * axes at once — cell count (writer 4 or 5, normalizer 4 only), section scope
+ * (writer any table row in the document, normalizer inside `### Promotion Gates`
+ * only), trailing pipe (writer `trim().startsWith("|")` alone, normalizer both
+ * pipes), and trailing whitespace after the closing pipe (writer sliced the
+ * UNTRIMMED line, so it mis-counted a 4-cell row as 5 and appended a spurious
+ * empty cell). Every divergence made `digest(doc) !== digest(writer(doc))`,
+ * which destroys the plan approval the promotion is gating on. One owner,
+ * consumed from both sides, is the only structural fix; anything else lets them
+ * drift again.
+ *
+ * The grammar deliberately matches what `parsePromotionGatesTable` in
+ * `./dossier.ts` already enforces on committed documents: a row is the trimmed
+ * line starting AND ending with a pipe, cells are split on `|` and trimmed, and
+ * the accepted widths are 4 (legacy) and 5 (opt-in `Defer` column). A row this
+ * module rejects is a row the dossier parser reports as `malformed table row`,
+ * so it can never be a live gate — skipping it is the fail-safe direction.
+ */
+/** Zero-based index of the lifecycle-owned `Last result` cell. */
+export declare const LAST_RESULT_CELL_INDEX = 3;
+/**
+ * Cells of one Promotion Gates table row, trimmed, or null when the line is not
+ * a row this grammar owns (no pipes, a single pipe, or an unsupported width).
+ */
+export declare function parsePromotionGateCells(line: string): readonly string[] | null;
+/**
+ * Canonical row bytes. Whitespace around a row (leading indent, padding inside
+ * cells, whitespace after the closing pipe) is not plan substance, so both
+ * callers re-emit this single canonical form. That is what keeps a stamped row
+ * and its normalized counterpart byte-identical, and it is exactly the form the
+ * normalizer has always emitted for a 4-cell row, so committed plan digests are
+ * unaffected.
+ */
+export declare function formatPromotionGateRow(cells: readonly string[]): string;
+/** Copy `cells` with the lifecycle-owned `Last result` cell set to `value`. */
+export declare function setLastResultCell(cells: readonly string[], value: string): readonly string[];
+/**
+ * Rewrite every Promotion Gates table row (header, separator, and data rows
+ * alike) inside the `### Promotion Gates` subsection through `transform`.
+ * Returning the received `cells` reference unchanged leaves the line
+ * byte-identical; returning a new array re-emits the canonical row. Every line
+ * outside the section is always byte-identical.
+ */
+export declare function mapPromotionGateRows(text: string, transform: (cells: readonly string[]) => readonly string[]): string;

package/dist/esm/blueprint/trust/gate-row.js

@@ -0,0 +1,113 @@
+/**
+ * Single owner of the Trust Dossier "Promotion Gates" table row grammar.
+ *
+ * Two callers must agree on this grammar byte-for-byte:
+ *
+ * - the lifecycle WRITER `updateGateLastResult` (`./promotion.ts`), which stamps
+ *   the `Last result` cell during `wp blueprint promote`; and
+ * - the plan-subject digest NORMALIZER `neutralizePromotionGateResults`
+ *   (`#review/subject.js`), which replaces that same cell with a placeholder so
+ *   the stamp is never hashed into a plan approval's subject.
+ *
+ * They each used to implement the grammar independently, and diverged on four
+ * axes at once — cell count (writer 4 or 5, normalizer 4 only), section scope
+ * (writer any table row in the document, normalizer inside `### Promotion Gates`
+ * only), trailing pipe (writer `trim().startsWith("|")` alone, normalizer both
+ * pipes), and trailing whitespace after the closing pipe (writer sliced the
+ * UNTRIMMED line, so it mis-counted a 4-cell row as 5 and appended a spurious
+ * empty cell). Every divergence made `digest(doc) !== digest(writer(doc))`,
+ * which destroys the plan approval the promotion is gating on. One owner,
+ * consumed from both sides, is the only structural fix; anything else lets them
+ * drift again.
+ *
+ * The grammar deliberately matches what `parsePromotionGatesTable` in
+ * `./dossier.ts` already enforces on committed documents: a row is the trimmed
+ * line starting AND ending with a pipe, cells are split on `|` and trimmed, and
+ * the accepted widths are 4 (legacy) and 5 (opt-in `Defer` column). A row this
+ * module rejects is a row the dossier parser reports as `malformed table row`,
+ * so it can never be a live gate — skipping it is the fail-safe direction.
+ */
+/** Zero-based index of the lifecycle-owned `Last result` cell. */
+export const LAST_RESULT_CELL_INDEX = 3;
+/**
+ * Exact end-anchored heading match, mirroring `sectionBlock(markdown, 3, ...)`
+ * in `./dossier.ts` — `### Promotion Gates Notes` is NOT the owned section and
+ * its contents stay plan substance.
+ */
+const PROMOTION_GATES_HEADING = /^###\s+Promotion Gates\s*$/iu;
+/**
+ * The section ends at the next heading of ANY level. `sectionBlock` itself ends
+ * at the next heading of level <= 3, so a table placed after an intervening
+ * `####` heading would be a gate to the parser but not to this walk. The
+ * narrower scope is deliberate: it is the scope every committed plan digest was
+ * computed against (measured: zero tracked blueprint documents put gate rows in
+ * that gap), and the consequence of the mismatch is fail-closed — the writer
+ * leaves such a row unstamped, so `validateBlueprintTrust` rejects the promotion
+ * with a non-passing gate instead of silently leaking the stamp into the digest.
+ */
+const ANY_HEADING = /^#{1,6}\s/u;
+const ACCEPTED_ROW_WIDTHS = [4, 5];
+/**
+ * Cells of one Promotion Gates table row, trimmed, or null when the line is not
+ * a row this grammar owns (no pipes, a single pipe, or an unsupported width).
+ */
+export function parsePromotionGateCells(line) {
+    const body = line.trim();
+    if (body.length < 2 || !body.startsWith("|") || !body.endsWith("|"))
+        return null;
+    const cells = body
+        .slice(1, -1)
+        .split("|")
+        .map((cell) => cell.trim());
+    if (!ACCEPTED_ROW_WIDTHS.includes(cells.length))
+        return null;
+    return cells;
+}
+/**
+ * Canonical row bytes. Whitespace around a row (leading indent, padding inside
+ * cells, whitespace after the closing pipe) is not plan substance, so both
+ * callers re-emit this single canonical form. That is what keeps a stamped row
+ * and its normalized counterpart byte-identical, and it is exactly the form the
+ * normalizer has always emitted for a 4-cell row, so committed plan digests are
+ * unaffected.
+ */
+export function formatPromotionGateRow(cells) {
+    return `| ${cells.join(" | ")} |`;
+}
+/** Copy `cells` with the lifecycle-owned `Last result` cell set to `value`. */
+export function setLastResultCell(cells, value) {
+    const next = [...cells];
+    next[LAST_RESULT_CELL_INDEX] = value;
+    return next;
+}
+/**
+ * Rewrite every Promotion Gates table row (header, separator, and data rows
+ * alike) inside the `### Promotion Gates` subsection through `transform`.
+ * Returning the received `cells` reference unchanged leaves the line
+ * byte-identical; returning a new array re-emits the canonical row. Every line
+ * outside the section is always byte-identical.
+ */
+export function mapPromotionGateRows(text, transform) {
+    const lines = text.split("\n");
+    let inGatesSection = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        if (PROMOTION_GATES_HEADING.test(line)) {
+            inGatesSection = true;
+            continue;
+        }
+        if (inGatesSection && ANY_HEADING.test(line)) {
+            inGatesSection = false;
+            continue;
+        }
+        if (!inGatesSection)
+            continue;
+        const cells = parsePromotionGateCells(line);
+        if (!cells)
+            continue;
+        const next = transform(cells);
+        if (next !== cells)
+            lines[index] = formatPromotionGateRow(next);
+    }
+    return lines.join("\n");
+}

package/dist/esm/blueprint/trust/promotion.d.ts

@@ -19,3 +19,20 @@ export declare function assertPromotionTrustProofCurrent(input: Pick<PromotionTr
 export declare function runPromotionCommand(repoRoot: string, command: string, deps?: {
     spawn?: typeof spawnSync;
 }): void;
+/**
+ * Exported for the plan-subject digest invariance suite
+ * (`src/review/lifecycle-writers.ts`, `src/review/subject-normalize.test.ts`).
+ * Those tests MUST call the production writer, never a hand-written mirror: a
+ * mirror can drift with the very bug under test and stay self-consistent, which
+ * is exactly how the 5-cell Promotion Gates leak survived the suite.
+ */
+export declare function upsertReadinessValue(markdown: string, key: string, value: string): string;
+/**
+ * Stamp the `Last result` cell of the gate named `gate`.
+ *
+ * Exported for the same reason as `upsertReadinessValue` above. The row grammar
+ * and the section scope both come from `./gate-row.js`, which the plan-subject
+ * digest normalizer consumes too — hand-rolling either here is what let the two
+ * sides diverge on four axes and destroy plan approvals on promotion.
+ */
+export declare function updateGateLastResult(markdown: string, gate: string, result: string): string;

package/dist/esm/blueprint/trust/promotion.js

@@ -3,6 +3,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { validateBlueprintTrust } from "./validator.js";
 import { parseTrustDossier } from "./dossier.js";
+import { mapPromotionGateRows, setLastResultCell } from "./gate-row.js";
 import { parseAllowedWpCommand, wpTestFileTargets } from "./gates.js";
 import { ALLOWED_WP_COMMAND_TIMEOUT_MS, executeAllowedWpCommand, tailBounded, } from "./command-runner.js";
 export { parseAllowedWpCommand };
@@ -138,7 +139,14 @@ function formatPromotionGateFailure(result) {
         details.push(`log=${result.logPath}`);
     return `Promotion gate failed (${result.command}): ${details.join("; ")}`;
 }
-function upsertReadinessValue(markdown, key, value) {
+/**
+ * Exported for the plan-subject digest invariance suite
+ * (`src/review/lifecycle-writers.ts`, `src/review/subject-normalize.test.ts`).
+ * Those tests MUST call the production writer, never a hand-written mirror: a
+ * mirror can drift with the very bug under test and stay self-consistent, which
+ * is exactly how the 5-cell Promotion Gates leak survived the suite.
+ */
+export function upsertReadinessValue(markdown, key, value) {
     const re = new RegExp(`^- ${key}: .*$`, "mu");
     if (re.test(markdown))
         return markdown.replace(re, `- ${key}: ${value}`);
@@ -152,22 +160,14 @@ function upsertReadinessValue(markdown, key, value) {
     lines.splice(insertIndex, 0, `- ${key}: ${value}`);
     return lines.join("\n");
 }
-function updateGateLastResult(markdown, gate, result) {
-    const lines = markdown.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] ?? "";
-        const cells = line.trim().startsWith("|")
-            ? line
-                .slice(1, -1)
-                .split("|")
-                .map((c) => c.trim())
-            : [];
-        if (cells[0] === gate && cells.length === 4) {
-            lines[i] = `| ${cells[0]} | ${cells[1]} | ${cells[2]} | ${result} |`;
-        }
-        else if (cells[0] === gate && cells.length === 5) {
-            lines[i] = `| ${cells[0]} | ${cells[1]} | ${cells[2]} | ${result} | ${cells[4]} |`;
-        }
-    }
-    return lines.join("\n");
+/**
+ * Stamp the `Last result` cell of the gate named `gate`.
+ *
+ * Exported for the same reason as `upsertReadinessValue` above. The row grammar
+ * and the section scope both come from `./gate-row.js`, which the plan-subject
+ * digest normalizer consumes too — hand-rolling either here is what let the two
+ * sides diverge on four axes and destroy plan approvals on promotion.
+ */
+export function updateGateLastResult(markdown, gate, result) {
+    return mapPromotionGateRows(markdown, (cells) => cells[0] === gate ? setLastResultCell(cells, result) : cells);
 }

package/dist/esm/build/atomic-file-copy.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Copy `source` to `destination` via copy-to-temp + atomic rename.
+ *
+ * A plain `copyFileSync(source, destination)` opens `destination` directly
+ * for writing. If another process currently has `destination` open for
+ * execution (a running compiled binary, a loaded native addon), POSIX
+ * returns `ETXTBSY` ("text file is busy"). This is not a flake: it is a
+ * deterministic race whenever a staging step runs concurrently with a
+ * process that execs the file being replaced (for example a vitest shard
+ * running the freshly staged `wp` runtime binary while another shard
+ * restages it).
+ *
+ * `rename(2)` is atomic within a filesystem and is legal even onto a file
+ * another process currently has open for execution: the running process
+ * keeps its already-open inode (and keeps running unaffected), while any
+ * new open/exec of `destination` resolves to the new file. Copying to a
+ * unique temp file beside `destination` (same directory) keeps the rename
+ * on the same filesystem so it stays atomic, then renaming over the
+ * destination replaces it without ever truncating a file that may be
+ * actively executing. `copyFileSync` preserves the source file's mode on
+ * the temp file, so there is no non-executable window between the rename
+ * and any later `chmodSync` a caller performs.
+ *
+ * On any failure (source read, temp write, or rename) the temp file is
+ * removed via `rmSync(..., { force: true })` (which tolerates the file not
+ * existing) before the error is rethrown.
+ *
+ * This guarantee is POSIX-only: on Windows, `renameSync` onto a file that
+ * is currently open for execution fails with `EPERM` for the same reason
+ * `copyFileSync` would, so this helper does not remove the race there.
+ */
+export declare function copyFileAtomic(source: string, destination: string): void;

package/dist/esm/build/atomic-file-copy.js

@@ -0,0 +1,44 @@
+import { copyFileSync, renameSync, rmSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+/**
+ * Copy `source` to `destination` via copy-to-temp + atomic rename.
+ *
+ * A plain `copyFileSync(source, destination)` opens `destination` directly
+ * for writing. If another process currently has `destination` open for
+ * execution (a running compiled binary, a loaded native addon), POSIX
+ * returns `ETXTBSY` ("text file is busy"). This is not a flake: it is a
+ * deterministic race whenever a staging step runs concurrently with a
+ * process that execs the file being replaced (for example a vitest shard
+ * running the freshly staged `wp` runtime binary while another shard
+ * restages it).
+ *
+ * `rename(2)` is atomic within a filesystem and is legal even onto a file
+ * another process currently has open for execution: the running process
+ * keeps its already-open inode (and keeps running unaffected), while any
+ * new open/exec of `destination` resolves to the new file. Copying to a
+ * unique temp file beside `destination` (same directory) keeps the rename
+ * on the same filesystem so it stays atomic, then renaming over the
+ * destination replaces it without ever truncating a file that may be
+ * actively executing. `copyFileSync` preserves the source file's mode on
+ * the temp file, so there is no non-executable window between the rename
+ * and any later `chmodSync` a caller performs.
+ *
+ * On any failure (source read, temp write, or rename) the temp file is
+ * removed via `rmSync(..., { force: true })` (which tolerates the file not
+ * existing) before the error is rethrown.
+ *
+ * This guarantee is POSIX-only: on Windows, `renameSync` onto a file that
+ * is currently open for execution fails with `EPERM` for the same reason
+ * `copyFileSync` would, so this helper does not remove the race there.
+ */
+export function copyFileAtomic(source, destination) {
+    const tmpDestination = `${destination}.tmp-${process.pid}-${randomUUID()}`;
+    try {
+        copyFileSync(source, tmpDestination);
+        renameSync(tmpDestination, destination);
+    }
+    catch (error) {
+        rmSync(tmpDestination, { force: true });
+        throw error;
+    }
+}

package/dist/esm/build/vendor-oxlint-plugins.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env bun
+export declare const AGENT_CONFIG_OXLINT_DIST: string;
+export declare const AGENT_KIT_OXLINT_DIST: string;
+/** Plugin basenames that ship as sibling .js next to oxlintrc.json (not path-roles). */
+export declare const VENDOR_PLUGIN_BASENAMES: readonly ["code-safety", "foundation-purity", "graphql-conventions", "import-hygiene", "monorepo-paths", "query-patterns", "testing-quality", "tier-boundaries"];
+export declare function vendorOxlintPlugins(sourceDir?: string, destDir?: string): {
+    copied: string[];
+};

package/dist/esm/build/vendor-oxlint-plugins.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env bun
+/**
+ * Vendor compiled oxlint policy plugins from agent-config into agent-kit dist.
+ *
+ * Consumer SSOT remains @webpresso/agent-config/oxlint/*. agent-kit's inject
+ * oxlintrc uses sibling-relative jsPlugins; we copy the built plugin files so
+ * the published kit has zero runtime dependency on agent-config (no re-export
+ * stubs, no pack chicken-egg).
+ */
+import { cpSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+export const AGENT_CONFIG_OXLINT_DIST = join(process.cwd(), "packages/agent-config/dist/esm/oxlint");
+export const AGENT_KIT_OXLINT_DIST = join(process.cwd(), "dist/esm/config/oxlint");
+/** Plugin basenames that ship as sibling .js next to oxlintrc.json (not path-roles). */
+export const VENDOR_PLUGIN_BASENAMES = [
+    "code-safety",
+    "foundation-purity",
+    "graphql-conventions",
+    "import-hygiene",
+    "monorepo-paths",
+    "query-patterns",
+    "testing-quality",
+    "tier-boundaries",
+];
+export function vendorOxlintPlugins(sourceDir = AGENT_CONFIG_OXLINT_DIST, destDir = AGENT_KIT_OXLINT_DIST) {
+    if (!existsSync(sourceDir)) {
+        throw new Error(`vendor-oxlint-plugins: missing agent-config oxlint dist at ${sourceDir}. Build @webpresso/agent-config first.`);
+    }
+    mkdirSync(destDir, { recursive: true });
+    const copied = [];
+    for (const name of VENDOR_PLUGIN_BASENAMES) {
+        const src = join(sourceDir, `${name}.js`);
+        if (!existsSync(src)) {
+            throw new Error(`vendor-oxlint-plugins: missing compiled plugin ${src}`);
+        }
+        const dest = join(destDir, `${name}.js`);
+        cpSync(src, dest);
+        copied.push(name);
+        // path-roles is imported by several plugins as a sibling — vendor it too.
+    }
+    // Always vendor path-roles (shared classifier used via relative imports inside plugins).
+    const pathRoles = join(sourceDir, "path-roles.js");
+    if (!existsSync(pathRoles)) {
+        throw new Error(`vendor-oxlint-plugins: missing ${pathRoles}`);
+    }
+    cpSync(pathRoles, join(destDir, "path-roles.js"));
+    copied.push("path-roles");
+    return { copied };
+}
+if (import.meta.main) {
+    const { copied } = vendorOxlintPlugins();
+    process.stdout.write(`vendored oxlint plugins: ${copied.join(", ")}\n`);
+}

package/dist/esm/cli/commands/blueprint/mutations.d.ts

@@ -85,6 +85,21 @@ export interface PromoteBlueprintResult {
     readonly newPath: string;
     readonly message: string;
 }
+/**
+ * Update `status:` in YAML frontmatter. Preserves everything else verbatim.
+ *
+ * Exported for the plan-subject digest invariance suite
+ * (`src/review/lifecycle-writers.ts`, `src/review/subject-normalize.test.ts`),
+ * which must exercise the production writer rather than a hand-written mirror.
+ */
+export declare function updateFrontmatterStatus(content: string, newStatus: string): string;
+/**
+ * Add or update `completed_at:` in YAML frontmatter.
+ * Inserts after the `status:` line if not already present.
+ *
+ * Exported for the same reason as `updateFrontmatterStatus` above.
+ */
+export declare function upsertCompletedAt(content: string, isoDate: string): string;
 /**
  * Advance a task's status in its blueprint markdown document, then re-ingest.
  *

package/dist/esm/cli/commands/blueprint/mutations.js

@@ -188,15 +188,21 @@ async function forceReIngestBlueprint(cwd, slug, documentPath) {
 }
 /**
  * Update `status:` in YAML frontmatter. Preserves everything else verbatim.
+ *
+ * Exported for the plan-subject digest invariance suite
+ * (`src/review/lifecycle-writers.ts`, `src/review/subject-normalize.test.ts`),
+ * which must exercise the production writer rather than a hand-written mirror.
  */
-function updateFrontmatterStatus(content, newStatus) {
+export function updateFrontmatterStatus(content, newStatus) {
     return content.replace(/^(status:\s*)(['"]?)[^'"\r\n]+?(['"]?)(\s*)$/m, `$1${newStatus}$4`);
 }
 /**
  * Add or update `completed_at:` in YAML frontmatter.
  * Inserts after the `status:` line if not already present.
+ *
+ * Exported for the same reason as `updateFrontmatterStatus` above.
  */
-function upsertCompletedAt(content, isoDate) {
+export function upsertCompletedAt(content, isoDate) {
     // If already present, update it
     if (/^completed_at:/m.test(content)) {
         return content.replace(/^(completed_at:\s*).*$/m, `$1'${isoDate}'`);

package/dist/esm/cli/commands/compile.d.ts

@@ -1,4 +1,17 @@
 import type { CAC } from "cac";
+import { type ModuleResolver } from "#shared-utils/package-root.js";
+export declare function resolveRulesyncBinFromAgentKit(resolver?: ModuleResolver): string | null;
+/**
+ * The rulesync version agent-kit itself resolves — the only honest baseline to
+ * compare a consumer's install against.
+ *
+ * This used to be a hand-maintained `PINNED_RULESYNC_VERSION` literal, which
+ * drifted five majors behind the declared dependency (9.4.0 vs 14.0.1). The
+ * mismatch warning then fired on every single run, including inside agent-kit
+ * itself, which trains readers to ignore the one warning meant to catch a real
+ * mismatch. Deriving it from the resolved package makes that drift impossible.
+ */
+export declare function resolveBundledRulesyncVersion(resolver?: ModuleResolver): string | null;
 export interface CompileResult {
     readonly ok: boolean;
     readonly targets: readonly string[];