@webpresso/agent-kit 3.1.26 → 3.1.30

package/dist/esm/cli/commands/quality-log-store.js

@@ -1,7 +1,7 @@
-import { randomUUID } from "node:crypto";
-import { closeSync, createWriteStream, mkdirSync, openSync, readdirSync, readFileSync, statSync, renameSync, utimesSync, rmSync, writeFileSync, } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { createWriteStream, mkdirSync, openSync, readdirSync, readFileSync, statSync, renameSync, utimesSync, rmSync, writeFileSync, } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { getSurfacePath } from "#paths/state-root.js";
 import { readTrustedJsonFile } from "#shared-utils/read-json-file.js";
 import { shortId } from "#shared-utils/short-id.js";
@@ -16,6 +16,7 @@ export const CLI_LOG_COMMANDS = [
     "format",
 ];
 const ORPHAN_LOG_GRACE_MS = 60_000;
+const INDEX_LOCK_STALE_MS = 5_000;
 export function isCliLogCommandName(value) {
     return CLI_LOG_COMMANDS.includes(value);
 }
@@ -63,39 +64,39 @@ function openCliLogSink(commandDir, command, cwd) {
             stream.write(chunk);
         },
         async finalize(metadata) {
-            await new Promise((resolve, reject) => {
-                if (streamError) {
-                    reject(streamError);
-                    return;
-                }
-                rejectPendingFinalize = reject;
-                stream.end(() => {
-                    rejectPendingFinalize = undefined;
+            try {
+                await new Promise((resolve, reject) => {
                     if (streamError) {
                         reject(streamError);
                         return;
                     }
-                    resolve();
+                    rejectPendingFinalize = reject;
+                    stream.end(() => {
+                        rejectPendingFinalize = undefined;
+                        if (streamError) {
+                            reject(streamError);
+                            return;
+                        }
+                        resolve();
+                    });
                 });
-            });
-            const entry = {
-                id,
-                command,
-                timestamp: metadata.timestamp ?? new Date().toISOString(),
-                exitCode: metadata.exitCode,
-                logPath: absoluteLogPath,
-                ...(metadata.options ? { options: metadata.options } : {}),
-                ...(metadata.summary ? { summary: metadata.summary } : {}),
-            };
-            try {
+                const entry = {
+                    id,
+                    command,
+                    timestamp: metadata.timestamp ?? new Date().toISOString(),
+                    exitCode: metadata.exitCode,
+                    logPath: absoluteLogPath,
+                    ...(metadata.options ? { options: metadata.options } : {}),
+                    ...(metadata.summary ? { summary: metadata.summary } : {}),
+                };
                 markLogRecentlyFinalized(absoluteLogPath);
                 // Index/lock live next to the log file so fallback dirs stay consistent.
                 writeLogEntryInDir(entry, commandDir);
+                return entry;
             }
             finally {
                 rmSync(activeMarkerPath, { force: true });
             }
-            return entry;
         },
     };
 }
@@ -113,7 +114,7 @@ export function createCliLogSink(command, cwd = process.cwd()) {
     catch (error) {
         if (!isUnwritableFsError(error))
             throw error;
-        const fallbackDir = join(tmpdir(), "webpresso", "cli-logs", command);
+        const fallbackDir = getFallbackCommandLogDir(command, cwd);
         const code = typeof error === "object" && error !== null && "code" in error
             ? String(error.code)
             : "unknown";
@@ -122,13 +123,37 @@ export function createCliLogSink(command, cwd = process.cwd()) {
     }
 }
 export function readCliLogEntries(command, cwd = process.cwd()) {
-    const indexPath = getCommandIndexPath(command, cwd);
+    const entries = [
+        ...readCliLogEntriesFromCommandDir(command, getCommandLogDir(command, cwd)),
+        ...readCliLogEntriesFromCommandDir(command, getFallbackCommandLogDir(command, cwd)),
+    ];
+    const byLogPath = new Map();
+    for (const entry of entries) {
+        byLogPath.set(entry.logPath, entry);
+    }
+    return [...byLogPath.values()]
+        .sort((a, b) => {
+        if (a.active === true && b.active !== true)
+            return -1;
+        if (b.active === true && a.active !== true)
+            return 1;
+        return b.timestamp.localeCompare(a.timestamp);
+    })
+        .slice(0, 10);
+}
+function readCliLogEntriesFromCommandDir(command, commandDir) {
+    const activeEntries = readActiveCliLogEntriesFromDir(command, commandDir);
+    const indexPath = join(commandDir, "index.json");
     try {
         const parsed = readTrustedJsonFile(indexPath);
-        return Array.isArray(parsed.entries) ? parsed.entries : [];
+        const finalizedEntries = Array.isArray(parsed.entries) ? parsed.entries : [];
+        return [
+            ...activeEntries,
+            ...finalizedEntries.filter((entry) => !activeEntries.some((active) => active.id === entry.id)),
+        ].slice(0, 10);
     }
     catch {
-        return [];
+        return activeEntries;
     }
 }
 export function readCliLogEntry(command, ordinal = 1, cwd = process.cwd()) {
@@ -146,6 +171,45 @@ function readCliLogEntriesFromDir(commandDir) {
         return [];
     }
 }
+function readActiveCliLogEntriesFromDir(command, commandDir) {
+    let files;
+    try {
+        files = readdirSync(commandDir);
+    }
+    catch {
+        return [];
+    }
+    return files
+        .filter((file) => file.endsWith(".log.active"))
+        .map((file) => readActiveCliLogEntryFromMarker(command, join(commandDir, file)))
+        .filter((entry) => entry !== null)
+        .sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+}
+function readActiveCliLogEntryFromMarker(command, markerPath) {
+    try {
+        const markerStat = statSync(markerPath);
+        const marker = readFileSync(markerPath, "utf8");
+        const id = basename(markerPath).slice(0, -".log.active".length);
+        if (!id)
+            return null;
+        const markerLines = marker.split("\n");
+        const live = isActiveMarkerSnapshotLive(marker, markerStat.mtimeMs);
+        return {
+            id,
+            command,
+            timestamp: markerLines[1]?.trim() || new Date(markerStat.mtimeMs).toISOString(),
+            exitCode: -1,
+            logPath: markerPath.slice(0, -".active".length),
+            ...(live ? { active: true } : {}),
+            summary: live ? "active log" : "orphaned log from exited process",
+        };
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return null;
+        throw error;
+    }
+}
 function writeLogEntryInDir(entry, commandDir) {
     withCommandIndexLockInDir(commandDir, () => {
         const indexPath = join(commandDir, "index.json");
@@ -169,28 +233,86 @@ function writeLogEntryInDir(entry, commandDir) {
 }
 function withCommandIndexLockInDir(commandDir, fn) {
     mkdirSync(commandDir, { recursive: true });
-    const lockPath = join(commandDir, "index.lock");
+    const lockDir = join(commandDir, "index.lock.d");
+    mkdirSync(lockDir, { recursive: true });
+    const ownerPath = join(lockDir, `${Date.now()}-${process.pid}-${randomUUID()}.owner`);
+    writeFileSync(ownerPath, `${process.pid}\n${new Date().toISOString()}\n`, {
+        encoding: "utf8",
+        flag: "wx",
+    });
     const started = Date.now();
-    let fd;
-    while (fd === undefined) {
-        try {
-            fd = openSync(lockPath, "wx");
-        }
-        catch (error) {
-            if (!isFileExistsError(error))
-                throw error;
-            if (Date.now() - started > 5_000) {
-                throw new Error(`Timed out waiting for CLI log index lock: ${lockPath}`);
+    try {
+        while (!isCurrentIndexLockOwner(lockDir, ownerPath)) {
+            if (Date.now() - started > INDEX_LOCK_STALE_MS) {
+                throw new Error(`Timed out waiting for CLI log index lock: ${lockDir}`);
             }
             sleepSync(10);
         }
-    }
-    try {
         return fn();
     }
     finally {
-        closeSync(fd);
-        rmSync(lockPath, { force: true });
+        rmSync(ownerPath, { force: true });
+    }
+}
+function isCurrentIndexLockOwner(lockDir, ownerPath) {
+    const liveOwners = readLiveIndexLockOwners(lockDir);
+    const firstOwner = liveOwners[0];
+    if (firstOwner === undefined)
+        return false;
+    return firstOwner.path === ownerPath;
+}
+function readLiveIndexLockOwners(lockDir) {
+    let files;
+    try {
+        files = readdirSync(lockDir);
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return [];
+        throw error;
+    }
+    return files
+        .filter((file) => file.endsWith(".owner"))
+        .map((file) => readIndexLockOwner(join(lockDir, file)))
+        .filter((owner) => owner !== null)
+        .sort((a, b) => a.timestampMs - b.timestampMs || a.path.localeCompare(b.path));
+}
+function readIndexLockOwner(ownerPath) {
+    let marker = "";
+    let markerMtimeMs = 0;
+    try {
+        const markerStat = statSync(ownerPath);
+        markerMtimeMs = markerStat.mtimeMs;
+        marker = readFileSync(ownerPath, "utf8");
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return null;
+        throw error;
+    }
+    const markerLines = marker.split("\n");
+    const pid = Number(markerLines[0]);
+    const hasOwner = Number.isInteger(pid) && pid > 0;
+    const timestamp = Date.parse(markerLines[1] ?? "");
+    const timestampMs = Number.isFinite(timestamp) ? timestamp : markerMtimeMs;
+    const stale = (hasOwner && !isProcessLive(pid)) ||
+        (!hasOwner && Date.now() - markerMtimeMs > INDEX_LOCK_STALE_MS);
+    if (stale) {
+        rmSync(ownerPath, { force: true });
+        return null;
+    }
+    return { path: ownerPath, timestampMs };
+}
+function isProcessLive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error) {
+            return error.code === "EPERM";
+        }
+        return false;
     }
 }
 function writeIndexAtomically(indexPath, index) {
@@ -233,31 +355,45 @@ function canPruneLogPath(logPath) {
     }
 }
 function isActiveLogPath(logPath) {
+    const activeMarkerPath = getActiveMarkerPath(logPath);
     try {
-        readFileSync(getActiveMarkerPath(logPath), "utf8");
-        return true;
+        const markerStat = statSync(activeMarkerPath);
+        const marker = readFileSync(activeMarkerPath, "utf8");
+        const live = isActiveMarkerSnapshotLive(marker, markerStat.mtimeMs);
+        if (!live)
+            rmSync(activeMarkerPath, { force: true });
+        return live;
     }
-    catch {
+    catch (error) {
+        if (!isMissingFileError(error))
+            throw error;
         return false;
     }
 }
+function isActiveMarkerSnapshotLive(marker, markerMtimeMs) {
+    const pid = Number(marker.split("\n")[0]);
+    if (Number.isInteger(pid) && pid > 0) {
+        return isProcessLive(pid);
+    }
+    return Date.now() - markerMtimeMs <= ORPHAN_LOG_GRACE_MS;
+}
 function getActiveMarkerPath(logPath) {
     return `${logPath}.active`;
 }
 function sleepSync(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
-function isFileExistsError(error) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
-}
 function isMissingFileError(error) {
     return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function getCommandLogDir(command, cwd) {
     return getSurfacePath(join("cli-logs", command), "repo", cwd);
 }
-function getCommandIndexPath(command, cwd) {
-    return join(getCommandLogDir(command, cwd), "index.json");
+function getFallbackCommandLogDir(command, cwd) {
+    return join(tmpdir(), "webpresso", "cli-logs", fallbackScopeId(cwd), command);
+}
+function fallbackScopeId(cwd) {
+    return createHash("sha256").update(resolve(cwd)).digest("hex").slice(0, 12);
 }
 function createLogId(now = new Date()) {
     const iso = now.toISOString().replaceAll(":", "-").replaceAll(".", "-");

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

@@ -7,6 +7,7 @@ import { z } from "zod";
 import { MAX_PORTABLE_REPOSITORY_PATH_LENGTH } from "#audit/absolute-path-policy.js";
 import { getProjectRoot } from "#cli/utils";
 import { relativeBlueprintSlug, resolveBlueprintFile } from "#lifecycle/local.js";
+import { readBlueprintOverviewAtRef } from "#lifecycle/review-provenance.js";
 import { scanBlueprintDirectory } from "#service/scanner.js";
 import { resolveBlueprintRoot } from "#utils/blueprint-root.js";
 import { CLAUDE_DEFAULT_REVIEW_MODEL, CODEX_DEFAULT_REVIEW_MODEL, GROK_DEFAULT_REVIEW_MODEL, DEFAULT_REVIEW_MAX_PROGRESS_EVENTS, runReviewExecution, } from "#review/execution/index.js";
@@ -860,14 +861,10 @@ function readBlueprintAtTarget(projectRoot, blueprintPath, targetSha) {
         throw new Error(`Blueprint path is outside Git toplevel: ${blueprintPath}`);
     }
     const relative = gitRelativePath.replace(/\\/gu, "/");
-    try {
-        return runBoundedReviewGit(gitRoot, ["show", `${targetSha}:${relative}`]);
-    }
-    catch (error) {
-        throw new Error(`Blueprint ${relative} is not tracked at target ${targetSha}.`, {
-            cause: error,
-        });
-    }
+    const content = readBlueprintOverviewAtRef(gitRoot, targetSha, absoluteBlueprintPath);
+    if (content)
+        return content.toString("utf8");
+    throw new Error(`Blueprint ${relative} is not tracked at target ${targetSha}.`);
 }
 function blueprintPathAtGitRoot(projectRoot, blueprintPath) {
     const gitRoot = resolveReviewGitToplevel(projectRoot);

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

@@ -2,6 +2,7 @@ import type { CAC } from "cac";
 import { spawnRuntimeCommandSync } from "#runtime/executor.js";
 export interface SecretsCommandOptions {
     readonly cwd?: string;
+    readonly commandCwd?: string;
     readonly profile?: string;
     readonly sink?: string;
     readonly json?: boolean;

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

@@ -14,6 +14,7 @@ export function registerSecretsCommand(cli) {
         .command("secrets <action> [target]", "Secret orchestration commands (doctor, bootstrap github)")
         .option("--profile <name>", "Secret profile name", { default: "preview" })
         .option("--sink <id>", "Secret sink id")
+        .option("--command-cwd <dir>", "Run the scoped command from this directory")
         .option("--json", "Emit machine-readable JSON")
         .option("--lane <lane>", "Lane to bootstrap (repeatable)", { default: [] })
         .option("--apply", "Apply GitHub bootstrap changes instead of dry-run planning")
@@ -22,6 +23,7 @@ export function registerSecretsCommand(cli) {
             cwd: process.cwd(),
             profile: flags.profile,
             sink: flags.sink,
+            commandCwd: flags.commandCwd,
             json: Boolean(flags.json),
             lanes: toArray(flags.lane),
             apply: Boolean(flags.apply),
@@ -109,7 +111,8 @@ export function runSecretsRun(options = {}, deps = {}) {
     const result = (deps.runSecretScopedCommand ?? spawnRuntimeCommandSync)({
         command,
         args,
-        cwd: options.cwd,
+        cwd: options.commandCwd ?? options.cwd,
+        envCwd: options.cwd,
         profile: plan.runtimeProfile,
         secretProfile: plan.profile,
         environment: plan.environment,

package/dist/esm/cli/commands/self-install-guard.d.ts

@@ -30,13 +30,17 @@
  *      chain unresolvable after repair; 12 lease held; 13 ownership lost.
  *   7. Release the lease owner-checked in a finally.
  *
- * Post-swap import rule: the child `vp update -g @webpresso/agent-kit` may
- * delete this process's on-disk package tree (old installId) before probe/
- * repair run. Post-child helpers MUST be static imports loaded at process
- * start — never `await import("#cli/…")` after the child exits, or Node
- * re-resolves against a removed path (`Cannot find module …/global-vp.js`).
- * Probe/repair logic itself reads the vite-plus store SSOT + PATH, not this
- * process's dying package root.
+ * Survival layers (in-repo SOTA bar):
+ * 1. Prefer a **stable** non-versioned launcher when re-execing the guard
+ *    (`#cli/auto-update/self-invocation.js`) — primary defense.
+ * 2. Self-package helpers (probe, repair, tombstone) MUST be static imports
+ *    loaded at process start — never package-local dynamic import, or Node
+ *    re-resolves against a removed installId path after `vp update -g`.
+ * 3. Argument builders depend on cycle-free leaves (self-invocation,
+ *    guard-tombstone), never on this command module solely for argv.
+ *
+ * Probe/repair reads the vite-plus store SSOT + PATH, not this process's
+ * dying package root.
  *
  * Custody boundary (stated exactly, mirrored from install-lock.ts): a stale,
  * OS-suspended holder whose child completes a mutation AFTER the successor
@@ -45,6 +49,9 @@
  * resource-side fencing.
  */
 import type { CAC } from "cac";
+import { buildSelfInvocationCommand, isVersionedAgentKitPayloadPath, resolveStableWpLauncher } from "#cli/auto-update/self-invocation.js";
+/** Re-export leaf helpers for public ergonomics / existing imports. */
+export { buildSelfInvocationCommand, isVersionedAgentKitPayloadPath, resolveStableWpLauncher };
 export declare function registerSelfInstallGuardCommand(cli: CAC): void;
 export declare const GUARD_EXIT_CHILD_FAILED = 10;
 export declare const GUARD_EXIT_UNRESOLVABLE = 11;
@@ -85,28 +92,3 @@ export interface SelfInstallGuardDeps {
  * Testable core. The CLI action wires `process.exit(await runSelfInstallGuard(...))`.
  */
 export declare function runSelfInstallGuard(rawArgs: readonly string[], deps?: SelfInstallGuardDeps): Promise<number>;
-/**
- * How wp re-invokes itself:
- * - Prefer a **stable** global launcher (`~/.vite-plus/bin/wp` or PATH `wp`
- *   outside an installId package tree). Re-execing `node …/agent-kit#id/…/cli.js`
- *   dies after `vp update -g` deletes the pre-swap tree mid-guard.
- * - Bun-compiled binary: process.execPath IS the binary (argv[1] is /$bunfs).
- * - Source/dev lane without a stable launcher: `<runtime> <script>`.
- */
-export declare function buildSelfInvocationCommand(args: readonly string[], options?: {
-    readonly execPath?: string;
-    readonly argv1?: string;
-    /** Injectable stable launcher for tests; `null` forces legacy argv1 path. */
-    readonly stableWp?: string | null;
-}): string[];
-/**
- * A launcher that survives installId package-tree deletion during global update.
- * Rejects paths under `agent-kit#<uuid>/` (versioned store payload).
- */
-export declare function resolveStableWpLauncher(options?: {
-    readonly home?: string;
-    readonly pathEnv?: string;
-    readonly existsSync?: (path: string) => boolean;
-}): string | null;
-/** True when path lives inside a vite-plus installId package tree. */
-export declare function isVersionedAgentKitPayloadPath(filePath: string): boolean;

package/dist/esm/cli/commands/self-install-guard.js

@@ -30,13 +30,17 @@
  *      chain unresolvable after repair; 12 lease held; 13 ownership lost.
  *   7. Release the lease owner-checked in a finally.
  *
- * Post-swap import rule: the child `vp update -g @webpresso/agent-kit` may
- * delete this process's on-disk package tree (old installId) before probe/
- * repair run. Post-child helpers MUST be static imports loaded at process
- * start — never `await import("#cli/…")` after the child exits, or Node
- * re-resolves against a removed path (`Cannot find module …/global-vp.js`).
- * Probe/repair logic itself reads the vite-plus store SSOT + PATH, not this
- * process's dying package root.
+ * Survival layers (in-repo SOTA bar):
+ * 1. Prefer a **stable** non-versioned launcher when re-execing the guard
+ *    (`#cli/auto-update/self-invocation.js`) — primary defense.
+ * 2. Self-package helpers (probe, repair, tombstone) MUST be static imports
+ *    loaded at process start — never package-local dynamic import, or Node
+ *    re-resolves against a removed installId path after `vp update -g`.
+ * 3. Argument builders depend on cycle-free leaves (self-invocation,
+ *    guard-tombstone), never on this command module solely for argv.
+ *
+ * Probe/repair reads the vite-plus store SSOT + PATH, not this process's
+ * dying package root.
  *
  * Custody boundary (stated exactly, mirrored from install-lock.ts): a stale,
  * OS-suspended holder whose child completes a mutation AFTER the successor
@@ -45,13 +49,15 @@
  * resource-side fencing.
  */
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import path from "node:path";
 import { buildVpGlobalInstallCommand, resolveBundledVpCommand, } from "#cli/auto-update/detect-pm.js";
+import { writeGuardTombstone } from "#cli/auto-update/guard-tombstone.js";
 import { INSTALL_LOCK_HEARTBEAT_MS, claimInstallLock, refreshInstallLock, releaseInstallLock, resolveInstallLockPath, } from "#cli/auto-update/install-lock.js";
+import { buildSelfInvocationCommand, isVersionedAgentKitPayloadPath, resolveStableWpLauncher, } from "#cli/auto-update/self-invocation.js";
 import { probeGlobalWpResolvable } from "#cli/commands/init/package-root.js";
 import { resolveGlobalCapableVpCommand } from "#cli/global-vp.js";
 import { resolveEffectiveRunnerRoot } from "#tool-runtime";
+/** Re-export leaf helpers for public ergonomics / existing imports. */
+export { buildSelfInvocationCommand, isVersionedAgentKitPayloadPath, resolveStableWpLauncher };
 export function registerSelfInstallGuardCommand(cli) {
     cli
         .command("self-install-guard [...args]", "Serialize and verify a global agent-kit self-install (internal)")
@@ -147,56 +153,6 @@ function extractChildCommand(rawArgs) {
         return [];
     return rawArgs.slice(separator + 1);
 }
-/**
- * How wp re-invokes itself:
- * - Prefer a **stable** global launcher (`~/.vite-plus/bin/wp` or PATH `wp`
- *   outside an installId package tree). Re-execing `node …/agent-kit#id/…/cli.js`
- *   dies after `vp update -g` deletes the pre-swap tree mid-guard.
- * - Bun-compiled binary: process.execPath IS the binary (argv[1] is /$bunfs).
- * - Source/dev lane without a stable launcher: `<runtime> <script>`.
- */
-export function buildSelfInvocationCommand(args, options = {}) {
-    const stableWp = options.stableWp !== undefined ? options.stableWp : resolveStableWpLauncher();
-    if (typeof stableWp === "string" && stableWp.length > 0) {
-        return [stableWp, ...args];
-    }
-    const execPath = options.execPath ?? process.execPath;
-    const argv1 = options.argv1 ?? process.argv[1] ?? "";
-    if (argv1.startsWith("/$bunfs"))
-        return [execPath, ...args];
-    return [execPath, argv1, ...args];
-}
-/**
- * A launcher that survives installId package-tree deletion during global update.
- * Rejects paths under `agent-kit#<uuid>/` (versioned store payload).
- */
-export function resolveStableWpLauncher(options = {}) {
-    const exists = options.existsSync ?? existsSync;
-    const home = options.home ?? process.env.HOME ?? process.env.USERPROFILE ?? "";
-    const candidates = [];
-    if (home) {
-        candidates.push(path.join(home, ".vite-plus", "bin", "wp"));
-    }
-    const pathEnv = options.pathEnv ?? process.env.PATH ?? "";
-    for (const dir of pathEnv.split(path.delimiter)) {
-        if (!dir)
-            continue;
-        candidates.push(path.join(dir, "wp"));
-    }
-    for (const candidate of candidates) {
-        if (!exists(candidate))
-            continue;
-        if (isVersionedAgentKitPayloadPath(candidate))
-            continue;
-        return candidate;
-    }
-    return null;
-}
-/** True when path lives inside a vite-plus installId package tree. */
-export function isVersionedAgentKitPayloadPath(filePath) {
-    const normalized = filePath.replaceAll("\\", "/");
-    return /\/@webpresso\/agent-kit#[^/]+\//u.test(normalized);
-}
 function defaultSpawnChild(command) {
     const [executable, ...args] = command;
     // detached: own process group, so lost-ownership kills reap descendants.
@@ -251,8 +207,6 @@ async function defaultRunRepair() {
     return child.exited;
 }
 function writeObservabilityTombstone() {
-    // Lazy import keeps the guard's cold path minimal; best-effort by contract.
-    void import("#cli/auto-update/installer.js")
-        .then(({ writeGuardTombstone }) => writeGuardTombstone())
-        .catch(() => undefined);
+    // Static import only — leaf module; see survival layers in the file header.
+    writeGuardTombstone();
 }

package/dist/esm/cli/direct-provider-launch.js

@@ -11,6 +11,7 @@ import { canonicalizeWorktreePath } from "#worktrees/identity.js";
 import { dashProviderOwnershipName, parseDashPermissionMode, } from "#cli/commands/dash/provider-capabilities.js";
 import { optionalToolCanonicalCommand } from "#cli/optional-tools.js";
 import { commandExists } from "#runtime/command-exists.js";
+import { ensureCodexProjectMcpServers, ensureCodexWebpressoMcp, } from "#cli/commands/init/scaffolders/codex-mcp/index.js";
 export class DirectProviderLaunchPreparationError extends Error {
     action;
     constructor(message, action) {
@@ -90,6 +91,25 @@ function validateDirectProviderLaunch(provider, cwd) {
         vpCommand,
     };
 }
+function ensureCodexSessionTooling(repoRoot) {
+    const options = { dryRun: false, overwrite: false };
+    const webpresso = ensureCodexWebpressoMcp({ options });
+    if (webpresso.kind === "codex-webpresso-mcp-not-installed") {
+        throw new DirectProviderLaunchPreparationError(`Codex webpresso MCP is not configured because no usable agent-kit install root was found. Checked: ${webpresso.checked.join(", ") || "(none)"}`, "Run `wp setup --yes-global` from this repo, then retry `wp codex`.");
+    }
+    const project = ensureCodexProjectMcpServers({ repoRoot, options });
+    if (project.kind === "codex-project-mcp-invalid") {
+        throw new DirectProviderLaunchPreparationError(`Codex project MCP config is invalid: ${project.reason}`, "Fix .mcp.json or run `wp setup --yes-global` for detailed setup diagnostics.");
+    }
+    if (project.kind === "codex-project-mcp-unavailable") {
+        throw new DirectProviderLaunchPreparationError(`Codex project MCP server ${project.server} is unavailable: ${project.reason}`, "Run `wp setup --yes-global` from this repo to provision project MCP servers, then retry.");
+    }
+}
+function ensureProviderSessionTooling(provider, cwd) {
+    if (provider !== "codex")
+        return;
+    ensureCodexSessionTooling(cwd);
+}
 export function isBareInteractiveProviderLaunch(args) {
     return parseDashPermissionMode(args).args.length === 0;
 }
@@ -136,14 +156,17 @@ export async function prepareDirectProviderLaunch(provider, args, cwd) {
         return { cwd, warnings: [] };
     }
     const { managedCwd, warnings } = await prepareLaunchEnvironment(provider, cwd);
-    if (managedCwd)
+    if (managedCwd) {
+        ensureProviderSessionTooling(provider, managedCwd);
         return { cwd: managedCwd, warnings };
+    }
     const created = await createManagedWorktree({
         cwd,
         prefix: provider,
         base: "origin/main",
         dependencyHydration: dependencyHydrationForProvider(provider),
     });
+    ensureProviderSessionTooling(provider, created.path);
     return { cwd: created.path, warnings };
 }
 /**
@@ -163,5 +186,6 @@ export function dependencyHydrationForProvider(provider) {
  */
 export async function prepareDirectProviderLaunchAt(provider, cwd) {
     const { warnings } = await prepareLaunchEnvironment(provider, cwd);
+    ensureProviderSessionTooling(provider, cwd);
     return { cwd, warnings };
 }

package/dist/esm/hooks/doctor.d.ts

@@ -116,6 +116,21 @@ export declare function checkCodexConfigKeys(configFilePath?: string, deps?: Hos
  * (exact `vp dlx` pins, launcher rules) at doctor time instead of only at setup.
  */
 export declare function checkProjectMcpPins(cwd?: string, deps?: HostConfigDoctorDeps): DoctorCheck;
+export interface ClaudeMcpDuplicateRegistrationOptions {
+    readonly home?: string;
+    readonly exists?: (path: string) => boolean;
+    readonly readFile?: (path: string) => string;
+}
+/**
+ * `claude-mcp-duplicate-registration` — advisory. A machine can register the
+ * webpresso MCP server twice for the same Claude Code session: a manual
+ * `claude mcp add webpresso` entry in `~/.claude.json` (user scope or a
+ * project scope) plus the agent-kit marketplace plugin's bundled server
+ * (plugin cache under `~/.claude/plugins/`). Both spawn `wp mcp`, so affected
+ * sessions run two server processes and carry a duplicated wp_* tool list.
+ * Degrades to ok on missing/unreadable config — loud only on real duplication.
+ */
+export declare function checkClaudeMcpDuplicateRegistration(options?: ClaudeMcpDuplicateRegistrationOptions): DoctorCheck;
 export interface DanglingHostPathsOptions {
     readonly configFilePath?: string;
     readonly home?: string;