@webpresso/agent-kit 3.3.3 → 3.3.4

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));
     });
 }

package/dist/esm/cli/commands/gain/index.js

@@ -1,17 +1,24 @@
 import { spawnSync } from "node:child_process";
 import { SessionMemoryStore } from "#session-memory/store.js";
 import { defaultIndexDbPath } from "#mcp/tools/session-restore.js";
+import { resolveManagedRtkExecutable } from "#tool-runtime/managed-rtk.js";
 export function runGain(options = {}) {
     const dbPath = options.indexDbPath ?? defaultIndexDbPath(options.cwd);
     const webpressoStats = readWebpressoGainStats(dbPath);
     printWebpressoGain(webpressoStats, dbPath, { sessions: options.sessions === true });
     console.log("\n── RTK Gain Totals ──────────────────────────────────────────");
-    const rtk = spawnSync("rtk", ["gain", "--format", "json"], { encoding: "utf8" });
+    const rtkBin = resolveManagedRtkExecutable();
+    if (!rtkBin) {
+        console.log("  Managed RTK not available.");
+        console.log("  Enable: wp setup --with rtk  (or set WP_RTK_BIN to a capable rtk binary)");
+        return 0;
+    }
+    const rtk = spawnSync(rtkBin, ["gain", "--format", "json"], { encoding: "utf8" });
     if (rtk.error) {
         const err = rtk.error;
         if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-            console.log("  RTK not installed.");
-            console.log("  Enable: wp setup --with rtk  |  Manual: brew install rtk");
+            console.log("  Managed RTK binary missing at resolved path.");
+            console.log("  Enable: wp setup --with rtk  (or set WP_RTK_BIN)");
             return 0;
         }
         throw err;

package/dist/esm/cli/commands/init/gitignore-patcher.js

@@ -76,6 +76,12 @@ export const GENERATED_PATHS_BLOCK = {
         ".agent/.blueprints.lock",
         ".agent/.blueprints.snapshot.sql",
         ".agent/.tail-hint-history.jsonl",
+        "# `wp compile` derives .rulesync/ from the canonical agent sources and replaces",
+        "# it wholesale on every run, so it is a build artifact rather than the",
+        "# hand-authored source tree rulesync's own docs describe. The .tmp- dirs are",
+        "# its staging area, normally renamed away but left behind by an interrupt.",
+        ".rulesync/",
+        ".rulesync.tmp-*",
         "# Stryker writes these mutation-test artifacts beside consumer source trees.",
         ".stryker-tmp/",
         "reports/mutation/",

package/dist/esm/cli/commands/init/index.js

@@ -54,7 +54,7 @@ import { ensureClaudeCodeUserPlugin } from "./scaffolders/claude-plugin/index.js
 import { ensureCodexUserPlugin } from "./scaffolders/codex-plugin/index.js";
 import { scaffoldClaudeRules } from "./scaffolders/claude-rules/index.js";
 import { ensureCodexCli } from "./scaffolders/codex-cli/index.js";
-import { ensureClaudePlaywrightMcp, ensureCodexProjectMcpServers, ensureCodexWebpressoMcp, } from "./scaffolders/codex-mcp/index.js";
+import { ensureClaudePlaywrightMcp, ensureCodexProjectMcpServers, pruneLegacyCodexWebpressoMcp, } from "./scaffolders/codex-mcp/index.js";
 import { scaffoldExampleSkill } from "./scaffolders/example-skill/index.js";
 import { scaffoldLoreCommits } from "./scaffolders/lore-commits/index.js";
 import { ensureOpenCodeWebpressoPlugin } from "./scaffolders/opencode-plugin/index.js";
@@ -381,24 +381,7 @@ async function runUserOnlySetup(input) {
         console.log("  playwright mcp: - skipped (the preset requires a project-owned .mcp.json; run setup inside the project repo)");
     }
     if (selectedHosts.includes("codex")) {
-        const webpressoMcpResult = ensureCodexWebpressoMcp({ options: userScopeOptions });
-        switch (webpressoMcpResult.kind) {
-            case "codex-webpresso-mcp-written":
-                console.log(`  codex webpresso mcp: ✓ ${webpressoMcpResult.path} → ${webpressoMcpResult.entryPath}`);
-                break;
-            case "codex-webpresso-mcp-unchanged":
-                console.log(`  codex webpresso mcp: already configured at ${webpressoMcpResult.path}`);
-                break;
-            case "codex-webpresso-mcp-ambiguous":
-                console.warn(`  codex webpresso mcp: ⚠ ambiguous MCP config at ${webpressoMcpResult.path}; left unchanged`);
-                break;
-            case "codex-webpresso-mcp-skipped-dry-run":
-                console.log("  codex webpresso mcp: skipped (--dry-run)");
-                break;
-            case "codex-webpresso-mcp-not-installed":
-                console.log(`  codex webpresso mcp: ⚠ no install root found (checked ${webpressoMcpResult.checked.length} paths). Install @webpresso/agent-kit globally (\`bun add -g @webpresso/agent-kit\`) or via the Claude plugin to wire up codex MCP.`);
-                break;
-        }
+        reportLegacyCodexWebpressoMcpPrune(pruneLegacyCodexWebpressoMcp({ options: userScopeOptions }));
         console.log("  codex project mcp: - skipped (no project .mcp.json outside a repo)");
     }
     if (isCiEnvironment) {
@@ -696,6 +679,25 @@ function printCodexPluginResult(result) {
             break;
     }
 }
+function reportLegacyCodexWebpressoMcpPrune(result) {
+    switch (result.kind) {
+        case "codex-legacy-webpresso-mcp-removed":
+            console.log(`  codex webpresso mcp: ✓ retired legacy [mcp_servers.webpresso] in ${result.path} (the bundled Codex plugin is the single delivery channel)`);
+            break;
+        case "codex-legacy-webpresso-mcp-absent":
+            console.log("  codex webpresso mcp: ✓ delivered by the bundled Codex plugin");
+            break;
+        case "codex-legacy-webpresso-mcp-preserved":
+            console.warn(`  codex webpresso mcp: ⚠ ${result.path} declares a user-authored webpresso server (${result.command ?? "no command"}); left unchanged — remove it manually to use the bundled Codex plugin`);
+            break;
+        case "codex-legacy-webpresso-mcp-ambiguous":
+            console.warn(`  codex webpresso mcp: ⚠ ambiguous MCP config at ${result.path}; left unchanged`);
+            break;
+        case "codex-legacy-webpresso-mcp-skipped-dry-run":
+            console.log("  codex webpresso mcp: skipped (--dry-run)");
+            break;
+    }
+}
 function reconcileCodexProjectMcpServers(repoRoot, options) {
     const result = ensureCodexProjectMcpServers({ repoRoot, options });
     switch (result.kind) {
@@ -1625,29 +1627,14 @@ export async function runInit(flags, deps = {}) {
                 ? { kind: "apply" }
                 : { kind: "skip", reason: skipGlobal ? "--skip-global" : "user-scope writes declined" });
         }
-        // Always upsert webpresso's MCP entry into the user's codex config when
-        // an install root is discoverable. Codex's config.toml is user-global, so
-        // we resolve to whatever absolute install path exists today (Claude
-        // plugin / bun global / pnpm global / npm global) and write that.
+        // Codex receives webpresso over ONE channel: the bundled Codex plugin's
+        // `.mcp.json`. Setup retires the user-global `[mcp_servers.webpresso]`
+        // block earlier versions wrote here rather than refreshing it.
         if (selectedHosts.includes("codex")) {
-            const webpressoMcpResult = ensureCodexWebpressoMcp({ options: userScopeOptions });
-            switch (webpressoMcpResult.kind) {
-                case "codex-webpresso-mcp-written":
-                    console.log(`  codex webpresso mcp: ✓ ${webpressoMcpResult.path} → ${webpressoMcpResult.entryPath}`);
-                    recordUserScope("codex-config");
-                    break;
-                case "codex-webpresso-mcp-unchanged":
-                    console.log(`  codex webpresso mcp: already configured at ${webpressoMcpResult.path}`);
-                    break;
-                case "codex-webpresso-mcp-ambiguous":
-                    console.warn(`  codex webpresso mcp: ⚠ ambiguous MCP config at ${webpressoMcpResult.path}; left unchanged`);
-                    break;
-                case "codex-webpresso-mcp-skipped-dry-run":
-                    console.log("  codex webpresso mcp: skipped (--dry-run)");
-                    break;
-                case "codex-webpresso-mcp-not-installed":
-                    console.log(`  codex webpresso mcp: ⚠ no install root found (checked ${webpressoMcpResult.checked.length} paths). Install @webpresso/agent-kit globally (\`bun add -g @webpresso/agent-kit\`) or via the Claude plugin to wire up codex MCP.`);
-                    break;
+            const pruneResult = pruneLegacyCodexWebpressoMcp({ options: userScopeOptions });
+            reportLegacyCodexWebpressoMcpPrune(pruneResult);
+            if (pruneResult.kind === "codex-legacy-webpresso-mcp-removed") {
+                recordUserScope("codex-config");
             }
             reconcileCodexProjectMcpServers(consumer.repoRoot, userScopeOptions);
         }
@@ -1829,7 +1816,7 @@ export async function runInit(flags, deps = {}) {
             const rtkResult = ensureRtk({ repoRoot: consumer.repoRoot, options: userScopeOptions });
             switch (rtkResult.kind) {
                 case "rtk-ok":
-                    console.log(rtkResult.installed ? "  rtk: ✓ installed + configured" : "  rtk: ✓");
+                    console.log(rtkResult.installed ? "  rtk: ✓ managed binary installed" : "  rtk: ✓");
                     recordUserScope("rtk-install");
                     break;
                 case "rtk-skipped-dry-run":
@@ -1839,10 +1826,6 @@ export async function runInit(flags, deps = {}) {
                     console.error(`  rtk: ✗ ${rtkResult.hint}`);
                     rtkFailure = "not-found";
                     break;
-                case "rtk-init-failed":
-                    console.error(`  rtk: ✗ rtk init exited with ${rtkResult.exitCode}`);
-                    rtkFailure = "init-failed";
-                    break;
             }
         }
         const all = [
@@ -2039,8 +2022,6 @@ export async function runInit(flags, deps = {}) {
         console.log("\nwp init: setup phases finished.");
         if (rtkFailure === "not-found")
             return EXIT_SETUP_FAIL;
-        if (rtkFailure === "init-failed")
-            return EXIT_WRITE_FAIL;
         if (isTelemetryEnabled(process.env)) {
             const payload = {
                 event: "setup-complete",

package/dist/esm/cli/commands/init/mcp-spec.d.ts

@@ -30,7 +30,24 @@ export interface WebpressoInstallProbe {
     stableEntry?: () => string | null;
     /** Test seam — verify that a PATH entry is the Webpresso command. */
     stableEntryIsWebpresso?: (entryPath: string) => boolean;
+    /**
+     * Test seam — resolve the currently executing agent-kit package root.
+     *
+     * Without this seam the self-trust branch below is only reachable when the
+     * test file itself happens to live in a managed worktree, so the regression
+     * guard would silently skip in CI — where the checkout is a plain clone.
+     */
+    sourceRoot?: () => string | null;
 }
+/**
+ * True when `entryPath` is the stable vite-plus multi-package `wp` shim that
+ * dispatches to `@webpresso/agent-kit` via `~/.vite-plus/bins/wp.json`.
+ *
+ * Unlike {@link isWebpressoWpEntry}, this does **not** require realpath to land
+ * inside a package `bin/wp` tree — vite-plus's `wp` is a symlink to the `vp`
+ * binary, so package-root ownership is proven via the bins metadata instead.
+ */
+export declare function isVitePlusManagedWebpressoWp(entryPath: string): boolean;
 /**
  * Resolve the absolute path to webpresso's global `bin/wp` launcher on this
  * machine. Probes the locations consumers use to install webpresso, in order
@@ -43,25 +60,43 @@ export interface WebpressoInstallProbe {
  *   3. Claude plugin install — `~/.claude/plugins/cache/.../agent-kit/`
  *   4. bun global — `~/.bun/install/global/node_modules/@webpresso/agent-kit/`
  *
- * Host MCP configs (Grok/Codex/etc.) must never be pinned to a versioned
+ * Host MCP configs (Grok/OpenCode) must never be pinned to a versioned
  * installId tree: the next `wp update` / `vp update -g` deletes that path and
- * leaves every host with a dead launcher. Returns `null` when none of the
- * candidates yield a durable `wp`.
+ * leaves every host with a dead launcher. `entryPath` is `null` when none of
+ * the candidates yield a durable `wp`.
  */
-export declare function findWebpressoMcpEntry(probe?: WebpressoInstallProbe): string | null;
-/**
- * True when `entryPath` is the stable vite-plus multi-package `wp` shim that
- * dispatches to `@webpresso/agent-kit` via `~/.vite-plus/bins/wp.json`.
- *
- * Unlike {@link isWebpressoWpEntry}, this does **not** require realpath to land
- * inside a package `bin/wp` tree — vite-plus's `wp` is a symlink to the `vp`
- * binary, so package-root ownership is proven via the bins metadata instead.
- */
-export declare function isVitePlusManagedWebpressoWp(entryPath: string): boolean;
 export declare function resolveWebpressoMcpEntry(probe?: WebpressoInstallProbe): {
     entryPath: string | null;
     checked: readonly string[];
 };
+/**
+ * Seams for classifying a persisted host-config `command` path as agent-kit's
+ * own. Kept separate from {@link WebpressoInstallProbe}: that probe answers
+ * "where should we WRITE a launcher", this one answers "did WE write this".
+ */
+export interface AgentKitOwnedCommandProbe {
+    /** Test seam — override `$HOME`. */
+    readonly home?: string;
+    /** Test seam — resolve the currently executing agent-kit package root. */
+    readonly sourceRoot?: () => string | null;
+    /** Test seam — filesystem existence check for the persisted command path. */
+    readonly exists?: (path: string) => boolean;
+}
+/**
+ * Every root under which agent-kit itself installs (or checks out) a `bin/wp`.
+ * A `wp` launcher recorded inside one of these was written by agent-kit; a
+ * launcher anywhere else is an operator's deliberate choice.
+ */
+export declare function agentKitOwnedCommandRoots(probe?: AgentKitOwnedCommandProbe): readonly string[];
+/**
+ * Ownership — not shape — decides whether setup may retire a persisted MCP
+ * entry. An entry is agent-kit's own when it launches `wp mcp` from an
+ * ABSOLUTE path AND either that path is gone (one we would have deleted) or
+ * it lives inside one
+ * of {@link agentKitOwnedCommandRoots}. A *live* `wp mcp` launcher outside
+ * those roots is an operator pointing Codex at a custom build: preserve it.
+ */
+export declare function isAgentKitOwnedWpCommand(command: string, args: readonly string[], probe?: AgentKitOwnedCommandProbe): boolean;
 export declare function isWebpressoWpEntry(entryPath: string): boolean;
 /** Run a discovery probe with bounded output and SIGKILL escalation. */
 export declare function runQuiet(cmd: string, args: readonly string[], timeoutMs?: number): string | null;