@webpresso/agent-kit 3.3.3 → 3.3.5

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,11 @@
+#!/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).
+ * SSOT: `@webpresso/agent-config/oxlint/basenames`.
+ */
+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,48 @@
+#!/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";
+import { OXLINT_PATH_ROLES_BASENAME, OXLINT_POLICY_PLUGIN_BASENAMES, } from "@webpresso/agent-config/oxlint/basenames";
+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).
+ * SSOT: `@webpresso/agent-config/oxlint/basenames`.
+ */
+export const VENDOR_PLUGIN_BASENAMES = OXLINT_POLICY_PLUGIN_BASENAMES;
+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, `${OXLINT_PATH_ROLES_BASENAME}.js`);
+    if (!existsSync(pathRoles)) {
+        throw new Error(`vendor-oxlint-plugins: missing ${pathRoles}`);
+    }
+    cpSync(pathRoles, join(destDir, `${OXLINT_PATH_ROLES_BASENAME}.js`));
+    copied.push(OXLINT_PATH_ROLES_BASENAME);
+    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[];

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

@@ -1,35 +1,125 @@
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { createRequire } from "node:module";
 import { z } from "zod";
 import { flattenAgentDir, writeFlattenedAssets } from "#compiler/flatten";
-const PINNED_RULESYNC_VERSION = "9.4.0";
+import { findPackageAsset } from "#utils/package-assets.js";
+import { readPackageManifest, resolvePackageRoot, resolvePackageVersion, } from "#shared-utils/package-root.js";
 const SUPPORTED_TARGETS = ["claude", "codex", "opencode"];
 const DEFAULT_TARGETS = SUPPORTED_TARGETS.join(",");
 const COMPILE_MANIFEST_VERSION = 1;
+/**
+ * wp's target names are the stable CLI contract; rulesync's own ids differ for
+ * two of the three. rulesync does not reject an unknown target — it logs a skip
+ * and exits 0 — so passing wp's names straight through generated nothing for
+ * `claude` and `codex` while still reporting success.
+ */
+const RULESYNC_TARGET_IDS = {
+    claude: "claudecode",
+    codex: "codexcli",
+    opencode: "opencode",
+};
+/**
+ * rulesync defaults `--features` to `rules`, which agent-kit never emits — so
+ * omitting the flag guaranteed an empty generate. This is the set agent-kit
+ * actually flattens.
+ *
+ * Deliberately not `*`: that also enables `rules`, whose output writes
+ * `AGENTS.md`/`CLAUDE.md` at the repo root and collides with the mergeAgentsMd
+ * step below, plus `ignore`/`mcp`/`hooks`/`permissions`, whose loaders print
+ * ENOENT lines straight to the user's terminal through the inherited stdio.
+ */
+const RULESYNC_FEATURES = "skills,commands,subagents";
+const ASSET_KINDS = ["skills", "commands", "agents"];
+/**
+ * Where rulesync writes each asset kind, per wp target.
+ *
+ * A kind omitted from a target's entry is one rulesync does not emit in project
+ * scope — notably codexcli commands, which it supports only under `--global`
+ * and otherwise skips with a warning. Omitting it keeps the check below honest
+ * rather than demanding a file rulesync was never going to write.
+ */
+const RULESYNC_OUTPUT_PATHS = {
+    claude: {
+        skills: (name) => join(".claude", "skills", name, "SKILL.md"),
+        commands: (name) => join(".claude", "commands", `${name}.md`),
+        agents: (name) => join(".claude", "agents", `${name}.md`),
+    },
+    codex: {
+        skills: (name) => join(".agents", "skills", name, "SKILL.md"),
+        // Codex subagents are TOML, not markdown — every other target emits .md.
+        agents: (name) => join(".codex", "agents", `${name}.toml`),
+    },
+    opencode: {
+        skills: (name) => join(".opencode", "skills", name, "SKILL.md"),
+        commands: (name) => join(".opencode", "commands", `${name}.md`),
+        agents: (name) => join(".opencode", "agents", `${name}.md`),
+    },
+};
+/** Every output path a target is expected to produce for the given assets. */
+function expectedOutputsForTarget(target, assets) {
+    const paths = RULESYNC_OUTPUT_PATHS[target];
+    const expected = [];
+    for (const kind of ASSET_KINDS) {
+        const toPath = paths[kind];
+        if (!toPath)
+            continue;
+        for (const name of Object.keys(assets[kind]))
+            expected.push(toPath(name));
+    }
+    return expected;
+}
+function expectedOutputs(targets, assets) {
+    return targets.flatMap((target) => expectedOutputsForTarget(target, assets));
+}
 // Resolve rulesync bin — checks consumer's node_modules first,
 // then falls back to webpresso's own bundled rulesync.
+// rulesync's `exports` map declares only ".", so its package.json is not
+// resolvable by subpath — see #shared-utils/package-root for the full trap.
 const _require = createRequire(import.meta.url);
-function resolveRulesyncBinFromAgentKit() {
-    try {
-        const pkgPath = _require.resolve("rulesync/package.json");
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        const binField = pkg.bin;
-        const rel = typeof binField === "string"
-            ? binField
-            : typeof binField === "object" && binField !== null && "rulesync" in binField
-                ? String(binField["rulesync"])
-                : null;
-        if (!rel)
-            return null;
-        return join(dirname(pkgPath), rel);
-    }
-    catch {
+/**
+ * Resolve rulesync relative to agent-kit's installed location rather than to
+ * this module's URL.
+ *
+ * In a bundled-Bun single-file binary `import.meta.url` is a `/$bunfs/root/...`
+ * virtual path, so a require anchored on it resolves nothing — and that is
+ * exactly the globally-installed case where the consumer has no local rulesync
+ * and this fallback is the only copy available.
+ */
+function agentKitAnchoredRequire() {
+    const manifestPath = findPackageAsset("package.json");
+    if (manifestPath === null)
+        return _require;
+    return createRequire(join(dirname(manifestPath), "noop.cjs"));
+}
+export function resolveRulesyncBinFromAgentKit(resolver = agentKitAnchoredRequire()) {
+    const root = resolvePackageRoot("rulesync", resolver);
+    if (!root)
         return null;
-    }
+    const binField = readPackageManifest(root)?.bin;
+    const rel = typeof binField === "string"
+        ? binField
+        : typeof binField === "object" && binField !== null && "rulesync" in binField
+            ? String(binField["rulesync"])
+            : null;
+    if (!rel)
+        return null;
+    return join(root, rel);
+}
+/**
+ * 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 function resolveBundledRulesyncVersion(resolver = agentKitAnchoredRequire()) {
+    return resolvePackageVersion("rulesync", resolver);
 }
 const CompileManifestSchema = z.object({
     version: z.number(),
@@ -56,25 +146,6 @@ function readRulesyncVersion(cwd) {
         return null;
     }
 }
-function contentHash(assets) {
-    const entries = [
-        ...Object.entries(assets.skills).map(([k, v]) => `s:${k}:${v}`),
-        ...Object.entries(assets.commands).map(([k, v]) => `c:${k}:${v}`),
-        ...Object.entries(assets.agents).map(([k, v]) => `a:${k}:${v}`),
-    ];
-    entries.sort();
-    return entries.join("\0");
-}
-function readHashFile(p) {
-    if (!existsSync(p))
-        return null;
-    try {
-        return readFileSync(p, "utf-8").trim();
-    }
-    catch {
-        return null;
-    }
-}
 /** SHA-256 hash of all .md files under agentDir, recursively (content only). */
 export function hashAgentDir(agentDir) {
     const h = createHash("sha256");
@@ -144,20 +215,26 @@ export async function runCompile(options) {
     }
     const agentDir = join(cwd, ".agent");
     const lockPath = join(agentDir, ".compile.lock");
-    const hashPath = join(agentDir, ".compile.hash");
     const manifestPath = join(agentDir, ".compile-manifest.json");
     const rulesyncBin = resolveRulesyncBin(cwd);
+    const expectedVersion = resolveBundledRulesyncVersion();
     if (!rulesyncBin || !existsSync(rulesyncBin)) {
+        const installHint = expectedVersion ? `rulesync@${expectedVersion}` : "rulesync";
         return {
             ok: false,
             targets: targetList,
             noOp: false,
-            message: "rulesync is not installed — run `vp add -w rulesync@9.4.0`",
+            message: `rulesync is not installed — run \`vp add -w ${installHint}\``,
         };
     }
     const installedVersion = readRulesyncVersion(cwd);
-    if (installedVersion !== null && installedVersion !== PINNED_RULESYNC_VERSION) {
-        process.stderr.write(`wp compile: warning — installed rulesync@${installedVersion} does not match pinned @${PINNED_RULESYNC_VERSION}\n`);
+    // Only compare against a version we actually resolved: with no baseline there
+    // is nothing to assert, and a fabricated one is what produced the old
+    // permanently-firing warning.
+    if (expectedVersion !== null &&
+        installedVersion !== null &&
+        installedVersion !== expectedVersion) {
+        process.stderr.write(`wp compile: warning — installed rulesync@${installedVersion} does not match the rulesync@${expectedVersion} agent-kit resolves\n`);
     }
     // Atomic lock via O_EXCL — fails if another compile is running
     try {
@@ -171,31 +248,48 @@ export async function runCompile(options) {
             message: `wp compile: lock file exists at ${lockPath} — another compile is running`,
         };
     }
+    // Staging dir lives in cwd (see the rename below), so an interrupted compile
+    // would strand a `.rulesync.tmp-*` directory inside the user's repo that no
+    // later run reaps. Tracked here so the signal path clears it too.
+    let stagingDir = null;
     const cleanup = () => {
         try {
             if (existsSync(lockPath))
                 unlinkSync(lockPath);
+            if (stagingDir !== null)
+                rmSync(stagingDir, { recursive: true, force: true });
         }
         catch {
             /* best-effort */
         }
     };
-    process.on("exit", cleanup);
-    process.on("SIGINT", () => {
+    // Held as named refs so `finally` can detach them: runCompile is called
+    // repeatedly within one process (the test suites do exactly this), and
+    // anonymous handlers would stack up a MaxListenersExceededWarning plus N
+    // SIGINT handlers each racing to call process.exit.
+    const onSigint = () => {
         cleanup();
         process.exit(130);
-    });
-    process.on("SIGTERM", () => {
+    };
+    const onSigterm = () => {
         cleanup();
         process.exit(143);
-    });
+    };
+    process.on("exit", cleanup);
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
     try {
         const assets = flattenAgentDir(agentDir);
-        const hash = contentHash(assets);
         const sourceHash = hashAgentDir(agentDir);
-        // Check compile manifest for idempotent no-op
+        // An unchanged source hash only proves the *input* is the same; it says
+        // nothing about whether the generated surfaces still exist. Deleting
+        // .claude/skills/ would otherwise leave compile reporting "no changes"
+        // forever while the files it exists to produce stay missing — the very
+        // silent-zero-output failure this command was repaired to eliminate.
+        const expected = expectedOutputs(targetList, assets);
+        const outputsPresent = expected.every((rel) => existsSync(join(cwd, rel)));
         const existingManifest = readCompileManifest(manifestPath);
-        if (existingManifest !== null && existingManifest.sourceHash === sourceHash) {
+        if (outputsPresent && existingManifest !== null && existingManifest.sourceHash === sourceHash) {
             return {
                 ok: true,
                 targets: targetList,
@@ -203,30 +297,35 @@ export async function runCompile(options) {
                 message: "No changes (manifest matches)",
             };
         }
-        // Legacy hash file check (pre-manifest path)
-        if (existingManifest === null && readHashFile(hashPath) === hash) {
-            return {
-                ok: true,
-                targets: targetList,
-                noOp: true,
-                message: "wp compile: no-op (content unchanged)",
-            };
-        }
-        // Step 1+2: Write flattened assets to tmpdir then atomically rename to .rulesync/
-        const tmpOut = mkdtempSync(join(tmpdir(), "wp-compile-"));
+        // Step 1+2: Stage the flattened assets, then atomically rename to .rulesync/.
+        //
+        // The staging dir must live inside `cwd`, not in os.tmpdir(): renameSync
+        // cannot cross filesystems, and on any host where /tmp is its own mount
+        // (tmpfs on most systemd Linux distros, Docker --tmpfs, many CI runners)
+        // the swap below would throw EXDEV and take the whole command down. The
+        // test suites cannot catch that on their own, because their cwd is itself
+        // under tmpdir() and so always lands on the same filesystem.
+        const tmpOut = mkdtempSync(join(cwd, ".rulesync.tmp-"));
+        stagingDir = tmpOut;
         try {
             await writeFlattenedAssets(assets, tmpOut);
             const rulesyncInputDir = join(cwd, ".rulesync");
             if (existsSync(rulesyncInputDir))
                 rmSync(rulesyncInputDir, { recursive: true, force: true });
             renameSync(tmpOut, rulesyncInputDir);
+            // Renamed away: nothing left at the staging path for cleanup to remove.
+            stagingDir = null;
         }
         catch (err) {
             rmSync(tmpOut, { recursive: true, force: true });
+            stagingDir = null;
             throw err;
         }
         // Step 3: Run rulesync generate
-        const result = spawnSync(rulesyncBin, ["generate", "--targets", targets], {
+        const rulesyncTargets = targetList
+            .map((target) => RULESYNC_TARGET_IDS[target])
+            .join(",");
+        const result = spawnSync(rulesyncBin, ["generate", "--targets", rulesyncTargets, "--features", RULESYNC_FEATURES], {
             cwd,
             stdio: "inherit",
         });
@@ -247,6 +346,21 @@ export async function runCompile(options) {
                 message: `wp compile: rulesync exited with code ${exitCode}`,
             };
         }
+        // rulesync exits 0 when it generates nothing at all ("All files are up to
+        // date"), so the exit code above cannot distinguish a real generate from a
+        // silent no-op caused by a target it skipped or input it could not see.
+        // The files consumers need are the contract, so assert they exist.
+        const missing = expected.filter((rel) => !existsSync(join(cwd, rel)));
+        if (missing.length > 0) {
+            const shown = missing.slice(0, 5).join(", ");
+            const rest = missing.length > 5 ? ` (and ${missing.length - 5} more)` : "";
+            return {
+                ok: false,
+                targets: targetList,
+                noOp: false,
+                message: `wp compile: rulesync exited 0 but ${missing.length} expected output(s) were not generated: ${shown}${rest}`,
+            };
+        }
         // Step 4: Run mergeAgentsMd to produce AGENTS.md at repo root
         // (Plugin manifests are hand-maintained SSOT under packages/*-plugin/;
         // wp compile no longer emits them — golden tests + version stamping own
@@ -270,6 +384,10 @@ export async function runCompile(options) {
         const outputHashes = {
             "AGENTS.md": hashFile(join(cwd, "AGENTS.md")),
         };
+        // Every generated surface, not just AGENTS.md — this is what gives
+        // `wp audit compile-drift` something real to compare against.
+        for (const rel of expected)
+            outputHashes[rel] = hashFile(join(cwd, rel));
         const compileManifest = {
             version: COMPILE_MANIFEST_VERSION,
             timestamp: new Date().toISOString(),
@@ -277,7 +395,6 @@ export async function runCompile(options) {
             outputHashes,
         };
         writeCompileManifest(manifestPath, compileManifest);
-        writeFileSync(hashPath, hash);
         return {
             ok: true,
             targets: targetList,
@@ -287,6 +404,9 @@ export async function runCompile(options) {
     }
     finally {
         cleanup();
+        process.removeListener("exit", cleanup);
+        process.removeListener("SIGINT", onSigint);
+        process.removeListener("SIGTERM", onSigterm);
     }
 }
 function collectAgentsLayers(agentDir) {

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

@@ -178,11 +178,27 @@ function formatterTargetFromCwd(file, cwd) {
         return file;
     return relativeTarget;
 }
+// The blueprint root is not always the top-level `blueprints/` directory: a
+// consumer repo can resolve to `webpresso/blueprints/` (the webpresso-legacy
+// fallback layout — see #utils/blueprint-root.js) or a `.webpressorc.json`
+// override. A prefix anchored to one specific root silently fails to exclude
+// review-artifact markdown under any other layout, so `wp format` reformats
+// it. That mutates the artifact's bytes between when `wp review gate`
+// records its sha256 into review-events.jsonl and when the file is
+// committed, producing a false "Review artifact digest mismatch" at
+// `wp_blueprint_finalize` time (src/review/authority.ts correctly detects
+// the drift and fails closed). Match on the directory name alone — not
+// anchored to any specific root prefix — so this stays correct across every
+// current and future blueprint root layout without tracking
+// resolveBlueprintRoot's precedence rules in a second place. This also keeps
+// parity with the whole-repo formatter's own ignore layer
+// (vite.config.ts#fmt.ignorePatterns), which uses the same unanchored
+// `**/review-artifacts/**` glob for the same reason.
 function filterFormatableFiles(files, cwd) {
     return files.filter((file) => {
         const extension = path.extname(file).toLowerCase();
         const normalized = file.replaceAll("\\", "/");
-        const isReviewArtifact = normalized.startsWith("blueprints/") && normalized.includes("/review-artifacts/");
+        const isReviewArtifact = normalized.includes("/review-artifacts/");
         return OXFMT_EXTENSIONS.has(extension) && !isReviewArtifact && existsSync(path.join(cwd, file));
     });
 }