@webpresso/agent-kit 3.3.2 → 3.3.4

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/cli-mcp-parity.js

@@ -52,8 +52,9 @@ export const CLI_MCP_PARITY_CLASSIFICATION = {
     },
     "release-progress": {
         command: "release-progress",
-        classification: "follow-up-candidate",
-        reason: "operator/agent Release workflow phase reporter (detect/native-matrix/publish); CLI-only, uses gh API",
+        classification: "existing-mcp",
+        tools: ["wp_release_progress"],
+        reason: "Release workflow phase reporter (detect/native-matrix/publish) is available as wp_release_progress MCP and CLI",
     },
     cleanup: {
         command: "cleanup",

package/dist/esm/build/package-manifest.js

@@ -1,8 +1,8 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { dirname, join } from "node:path";
 import { parse as parseYaml } from "yaml";
-import { assertBuiltBlueprintMigrationSqlAssets } from "./blueprint-migration-assets.js";
-import { assertBuiltSastRuleAssets } from "./sast-rule-assets.js";
+import { assertBuiltBlueprintMigrationSqlAssets, syncBlueprintMigrationSqlAssets, } from "./blueprint-migration-assets.js";
+import { assertBuiltSastRuleAssets, syncSastRuleAssets } from "./sast-rule-assets.js";
 import { SESSION_MEMORY_NATIVE_TARGETS } from "#session-memory/native-targets.js";
 import { RUNTIME_TARGETS } from "./runtime-targets.js";
 const DEPENDENCY_SECTIONS = [
@@ -304,6 +304,11 @@ export function preparePackedManifest(rootDir, options = {}) {
     // out-of-org consumers cannot resolve.
     const packedManifest = createPackedManifest(manifest, readWorkspaceCatalogs(workspacePath), options);
     if (options.assertBlueprintMigrationAssets ?? true) {
+        // Sync authoring sources into dist before assert so pack/prepack paths
+        // (version dry-run, npm pack) do not require a full `pnpm run build` first.
+        // Assert still fails closed on missing source or content drift.
+        syncBlueprintMigrationSqlAssets(rootDir);
+        syncSastRuleAssets(rootDir);
         assertBuiltBlueprintMigrationSqlAssets(rootDir);
         assertBuiltSastRuleAssets(rootDir);
     }

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/audit-core.js

@@ -79,7 +79,15 @@ export async function runAuditDispatch(auditKind, targets, options, deps) {
         case "blueprint-pr-coverage": {
             const { auditBlueprintPrCoverage } = await import("#audit/blueprint-pr-coverage");
             const root = options.root ?? target ?? deps.root;
-            const baseRef = options.baseRef ?? options.base;
+            const explicitBaseRef = options.baseRef ?? options.base;
+            // Same pinned-base hazard as the branch-scoped audits: CI's
+            // `github.event.pull_request.base.sha` stops being the fork point once the
+            // branch is rebased, and this audit diffs `<baseRef>...HEAD`. Narrow it to
+            // the real fork point so coverage is judged on this PR's own files.
+            const { resolveBranchDiffBase } = await import("#git/changed-files");
+            const baseRef = explicitBaseRef
+                ? resolveBranchDiffBase(root, explicitBaseRef)
+                : explicitBaseRef;
             const result = auditBlueprintPrCoverage(root, { baseRef, headRef: options.headRef });
             return { kind: "repo-result", name: "blueprint-pr-coverage", result };
         }

package/dist/esm/cli/commands/audit.js

@@ -9,7 +9,7 @@ import { STRYKER_COMMAND } from "#audit/run-stryker.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { addAffectedOptions, resolveAffectedTargets } from "#git/affected";
-import { defaultBranchBaseRef, getBranchRemovedFiles, getStagedRemovedFiles, } from "#git/changed-files";
+import { defaultBranchBaseRef, getBranchRemovedFiles, getStagedRemovedFiles, resolveBranchDiffBase, } from "#git/changed-files";
 import { runAuditDispatch } from "#cli/commands/audit-core.js";
 import { createCliLogSink } from "#cli/commands/quality-log-store.js";
 import { emitCliCommandOutput, runLoggedChildCommand } from "#cli/commands/quality-runner.js";
@@ -284,6 +284,17 @@ export function registerAuditCommand(cli) {
         let dispatchOptions = options;
         let auditScope = "full";
         let changeRemovesFile = false;
+        // A caller-supplied `--base` is a PINNED sha (CI passes
+        // `github.event.pull_request.base.sha`, which does not advance with the
+        // base branch). After a rebase it stops being the fork point, so scoping
+        // off it silently absorbs everything merged into the base branch since
+        // the PR opened. Narrow it to the real fork point once, and use that one
+        // value everywhere the branch scope is derived so the affected file set,
+        // the removal probe, and the audit's own base-vs-head range agree.
+        const explicitBaseRef = options.baseRef ?? options.base;
+        const branchBaseRef = branch && explicitBaseRef
+            ? resolveBranchDiffBase(auditRoot, explicitBaseRef)
+            : explicitBaseRef;
         if (affected || branch) {
             if (kind &&
                 AUDIT_KINDS.includes(kind) &&
@@ -309,7 +320,7 @@ export function registerAuditCommand(cli) {
                 cwd: auditRoot,
                 affected,
                 branch,
-                baseRef: options.baseRef ?? options.base,
+                baseRef: branchBaseRef,
                 explicitTargets: [],
                 policy: "fail-closed",
                 mapChangedFiles: (files) => files,
@@ -360,7 +371,7 @@ export function registerAuditCommand(cli) {
             changeRemovesFile = affected
                 ? affectedChangeRemovesFile(auditRoot, {
                     branch,
-                    baseRef: options.baseRef ?? options.base,
+                    baseRef: branchBaseRef,
                 })
                 : false;
             if (resolution.kind === "empty" && !changeRemovesFile) {
@@ -392,7 +403,7 @@ export function registerAuditCommand(cli) {
                     changedOnly: true,
                     affectedFiles: [],
                     root: options.root ?? resolution.cwd,
-                    baseRef: options.baseRef ?? options.base,
+                    baseRef: branchBaseRef,
                 };
             }
             if (resolution.kind === "scoped") {
@@ -404,7 +415,7 @@ export function registerAuditCommand(cli) {
                     changedOnly: true,
                     affectedFiles: [...resolution.targets],
                     root: options.root ?? resolution.cwd,
-                    baseRef: options.baseRef ?? options.base,
+                    baseRef: branchBaseRef,
                 };
             }
         }

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[];