@webpresso/agent-kit 3.1.26 → 3.1.30

package/dist/esm/ci/act-worktree-git.js

@@ -0,0 +1,219 @@
+import { execFileSync } from "node:child_process";
+import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, rmSync, symlinkSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+export function prepareActGitWorkspace(cwd) {
+    const sourceCwd = resolve(cwd);
+    const linked = readLinkedWorktreeGitMetadata(sourceCwd);
+    if (!linked) {
+        return {
+            cwd: sourceCwd,
+            prepared: false,
+            cleanup() { },
+        };
+    }
+    assertExistingDirectory(linked.gitDir, "linked-worktree gitdir");
+    const commonDir = resolveGitCommonDir(linked.gitDir);
+    assertExistingDirectory(commonDir, "linked-worktree commondir");
+    const tempRoot = mkdtempSync(join(tmpdir(), "wp-ci-act-worktree-"));
+    const preparedCwd = join(tempRoot, "workspace");
+    try {
+        const head = git(sourceCwd, ["rev-parse", "HEAD"]);
+        git(sourceCwd, ["rev-parse", "--is-inside-work-tree"]);
+        execFileSync("git", [
+            "clone",
+            "--local",
+            "--no-hardlinks",
+            "--dissociate",
+            "--no-checkout",
+            sourceCwd,
+            preparedCwd,
+        ], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        syncOriginRemote(sourceCwd, preparedCwd);
+        git(preparedCwd, ["checkout", "--detach", "--quiet", head]);
+        overlayWorkingTreeChanges(sourceCwd, preparedCwd);
+        assertPreparedGitMetadataIsSelfContained(preparedCwd);
+        return {
+            cwd: preparedCwd,
+            prepared: true,
+            cleanup() {
+                rmSync(tempRoot, { recursive: true, force: true });
+            },
+        };
+    }
+    catch (error) {
+        rmSync(tempRoot, { recursive: true, force: true });
+        throw error;
+    }
+}
+export function readLinkedWorktreeGitMetadata(cwd) {
+    const gitPath = join(cwd, ".git");
+    if (!existsSync(gitPath)) {
+        return null;
+    }
+    const stat = lstatSync(gitPath);
+    if (stat.isDirectory())
+        return null;
+    if (!stat.isFile()) {
+        throw new Error(`Cannot prepare ci act workspace: ${gitPath} is not a file or directory.`);
+    }
+    const content = readFileSync(gitPath, "utf8").trim();
+    const match = /^gitdir:\s*(.+)$/u.exec(content);
+    if (!match?.[1]) {
+        throw new Error(`Cannot prepare ci act workspace: ${gitPath} is not a valid gitdir file.`);
+    }
+    return { gitDir: resolve(cwd, match[1]) };
+}
+function resolveGitCommonDir(gitDir) {
+    const commonDirPath = join(gitDir, "commondir");
+    if (!existsSync(commonDirPath))
+        return gitDir;
+    const raw = readFileSync(commonDirPath, "utf8").trim();
+    if (!raw)
+        throw new Error(`Cannot prepare ci act workspace: ${commonDirPath} is empty.`);
+    return resolve(gitDir, raw);
+}
+function overlayWorkingTreeChanges(sourceCwd, preparedCwd) {
+    const changed = parseGitDiffNameStatus(splitGitNullOutput(gitRaw(sourceCwd, ["diff", "--name-status", "--find-renames", "-z", "HEAD", "--"])));
+    const untracked = splitGitNullOutput(gitRaw(sourceCwd, ["ls-files", "--others", "--exclude-standard", "-z"]));
+    const copyPaths = new Set([...changed.copyPaths, ...untracked]);
+    for (const relativePath of changed.removePaths) {
+        assertSafeGitRelativePath(relativePath);
+        rmSync(join(preparedCwd, relativePath), { recursive: true, force: true });
+    }
+    for (const relativePath of copyPaths) {
+        assertSafeGitRelativePath(relativePath);
+        const sourcePath = join(sourceCwd, relativePath);
+        const preparedPath = join(preparedCwd, relativePath);
+        const sourceStat = tryLstat(sourcePath);
+        if (!sourceStat) {
+            rmSync(preparedPath, { recursive: true, force: true });
+            continue;
+        }
+        mkdirSync(dirname(preparedPath), { recursive: true });
+        if (sourceStat.isSymbolicLink()) {
+            rmSync(preparedPath, { recursive: true, force: true });
+            symlinkSync(readlinkSync(sourcePath), preparedPath);
+            continue;
+        }
+        rmSync(preparedPath, { recursive: true, force: true });
+        cpSync(sourcePath, preparedPath, { recursive: true, force: true, errorOnExist: false });
+    }
+}
+function tryLstat(path) {
+    try {
+        return lstatSync(path);
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+function parseGitDiffNameStatus(entries) {
+    const copyPaths = new Set();
+    const removePaths = new Set();
+    for (let index = 0; index < entries.length;) {
+        const status = entries[index++];
+        if (!status)
+            continue;
+        if (status.startsWith("R")) {
+            const oldPath = entries[index++];
+            const newPath = entries[index++];
+            if (oldPath)
+                removePaths.add(oldPath);
+            if (newPath)
+                copyPaths.add(newPath);
+            continue;
+        }
+        if (status.startsWith("C")) {
+            index++;
+            const newPath = entries[index++];
+            if (newPath)
+                copyPaths.add(newPath);
+            continue;
+        }
+        const path = entries[index++];
+        if (!path)
+            continue;
+        if (status.startsWith("D")) {
+            removePaths.add(path);
+        }
+        else {
+            copyPaths.add(path);
+        }
+    }
+    return { copyPaths, removePaths };
+}
+function syncOriginRemote(sourceCwd, preparedCwd) {
+    const originUrl = tryGit(sourceCwd, ["remote", "get-url", "origin"]);
+    if (originUrl) {
+        git(preparedCwd, ["remote", "set-url", "origin", originUrl]);
+        return;
+    }
+    tryGit(preparedCwd, ["remote", "remove", "origin"]);
+}
+function assertPreparedGitMetadataIsSelfContained(preparedCwd) {
+    const gitPath = join(preparedCwd, ".git");
+    if (!existsSync(gitPath) || !lstatSync(gitPath).isDirectory()) {
+        throw new Error("Cannot prepare ci act workspace: prepared .git metadata is not a directory.");
+    }
+    const commonDir = resolve(preparedCwd, git(preparedCwd, ["rev-parse", "--git-common-dir"]));
+    const relative = commonDirRelativeToPrepared(preparedCwd, commonDir);
+    if (relative === null) {
+        throw new Error(`Cannot prepare ci act workspace: prepared git common dir escaped the execution workspace (${commonDir}).`);
+    }
+    const alternatesPath = join(commonDir, "objects", "info", "alternates");
+    if (existsSync(alternatesPath) && readFileSync(alternatesPath, "utf8").trim().length > 0) {
+        throw new Error(`Cannot prepare ci act workspace: prepared git objects still depend on alternates (${alternatesPath}).`);
+    }
+}
+function commonDirRelativeToPrepared(preparedCwd, commonDir) {
+    const normalizedRoot = resolve(preparedCwd);
+    const normalizedCommon = resolve(commonDir);
+    if (normalizedCommon === normalizedRoot)
+        return "";
+    if (normalizedCommon.startsWith(`${normalizedRoot}${sep}`)) {
+        return normalizedCommon.slice(normalizedRoot.length + 1);
+    }
+    return null;
+}
+function splitGitNullOutput(output) {
+    return output.split("\0").filter((entry) => entry.length > 0);
+}
+function assertSafeGitRelativePath(relativePath) {
+    if (relativePath.length === 0 ||
+        relativePath.startsWith("/") ||
+        relativePath === ".." ||
+        relativePath.startsWith("../") ||
+        relativePath.includes("/../")) {
+        throw new Error(`Unsafe git path returned while preparing ci act workspace: ${relativePath}`);
+    }
+}
+function assertExistingDirectory(path, label) {
+    if (!existsSync(path) || !lstatSync(path).isDirectory()) {
+        throw new Error(`Cannot prepare ci act workspace: ${label} is missing or unreadable: ${path}`);
+    }
+}
+function git(cwd, args) {
+    return gitRaw(cwd, args).trim();
+}
+function tryGit(cwd, args) {
+    try {
+        return git(cwd, args);
+    }
+    catch {
+        return null;
+    }
+}
+function gitRaw(cwd, args) {
+    return execFileSync("git", [...args], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}

package/dist/esm/ci/native-session-memory-cache.d.ts

@@ -26,7 +26,15 @@ export declare const NATIVE_SESSION_MEMORY_TRUST_CACHED_NODE_ENV = "WP_NATIVE_SE
  * Absolute cache dir still comes from env-paths / CACHE_ROOT override at runtime.
  */
 export declare const NATIVE_SESSION_MEMORY_CACHE_HASH_GLOBS: readonly ["native/session-memory-engine/Cargo.lock", "native/session-memory-engine/Cargo.toml", "native/session-memory-engine/crates/**/*.rs", "native/session-memory-engine/crates/**/Cargo.toml"];
-/** Linux CI default env-paths cache root (XDG). Documented for workflow `path:`. */
+/**
+ * Default **env-paths** Linux cache location when `WP_NATIVE_SESSION_MEMORY_CACHE_ROOT`
+ * is unset (`$HOME/.cache/webpresso-agent-kit/session-memory-engine`).
+ *
+ * Agent-kit self-CI does **not** use this path for the warm cache: it overrides via
+ * `WP_NATIVE_SESSION_MEMORY_CACHE_ROOT` → `${{ runner.temp }}/sm-native-cache` (see
+ * the Test job warm cache step in `.github/workflows/ci.agent-kit.yml`). This helper
+ * documents the unset-override default only — not the workflow `path:`.
+ */
 export declare function defaultLinuxNativeSessionMemoryCachePath(home?: string): string;
 /**
  * Trust is only safe on an exact primary-key GHA cache hit (sources match the key).

package/dist/esm/ci/native-session-memory-cache.js

@@ -31,7 +31,15 @@ export const NATIVE_SESSION_MEMORY_CACHE_HASH_GLOBS = [
     "native/session-memory-engine/crates/**/*.rs",
     "native/session-memory-engine/crates/**/Cargo.toml",
 ];
-/** Linux CI default env-paths cache root (XDG). Documented for workflow `path:`. */
+/**
+ * Default **env-paths** Linux cache location when `WP_NATIVE_SESSION_MEMORY_CACHE_ROOT`
+ * is unset (`$HOME/.cache/webpresso-agent-kit/session-memory-engine`).
+ *
+ * Agent-kit self-CI does **not** use this path for the warm cache: it overrides via
+ * `WP_NATIVE_SESSION_MEMORY_CACHE_ROOT` → `${{ runner.temp }}/sm-native-cache` (see
+ * the Test job warm cache step in `.github/workflows/ci.agent-kit.yml`). This helper
+ * documents the unset-override default only — not the workflow `path:`.
+ */
 export function defaultLinuxNativeSessionMemoryCachePath(home = "~") {
     return `${home}/.cache/${NATIVE_SESSION_MEMORY_CACHE_ENV_NAME}/${NATIVE_SESSION_MEMORY_CACHE_SUBDIR}`;
 }

package/dist/esm/ci/vitest-ci-shards.d.ts

@@ -4,11 +4,13 @@
  * All shards together still run every file discovered by vitest.config.ts
  * projects; each shard is a slice via `vitest run --shard=i/n`.
  *
- * Six shards keep max-shard job wall under the 150s Test average target when
- * serial-subprocess heavy files (package.contract, install-lock, etc.) cluster.
+ * Three shards on ubicloud-standard-2 cut billed runner-minutes (fewer
+ * parallel installs × smaller class) while keeping full suite coverage.
+ * Wall-clock per shard may rise vs the prior 6×standard-4 layout; that is an
+ * intentional minutes-vs-wall tradeoff (see docs/ci-test-perf.md).
  */
-export declare const VITEST_CI_SHARD_TOTAL = 6;
-export declare const VITEST_CI_SHARD_INDICES: readonly [1, 2, 3, 4, 5, 6];
+export declare const VITEST_CI_SHARD_TOTAL = 3;
+export declare const VITEST_CI_SHARD_INDICES: readonly [1, 2, 3];
 /** CLI args for a single shard (excludes `vitest` binary). */
 export declare function vitestCiShardArgs(shardIndex: number, shardTotal?: number): string[];
 /** Matrix values for GitHub Actions strategy.matrix.shard */

package/dist/esm/ci/vitest-ci-shards.js

@@ -4,11 +4,13 @@
  * All shards together still run every file discovered by vitest.config.ts
  * projects; each shard is a slice via `vitest run --shard=i/n`.
  *
- * Six shards keep max-shard job wall under the 150s Test average target when
- * serial-subprocess heavy files (package.contract, install-lock, etc.) cluster.
+ * Three shards on ubicloud-standard-2 cut billed runner-minutes (fewer
+ * parallel installs × smaller class) while keeping full suite coverage.
+ * Wall-clock per shard may rise vs the prior 6×standard-4 layout; that is an
+ * intentional minutes-vs-wall tradeoff (see docs/ci-test-perf.md).
  */
-export const VITEST_CI_SHARD_TOTAL = 6;
-export const VITEST_CI_SHARD_INDICES = [1, 2, 3, 4, 5, 6];
+export const VITEST_CI_SHARD_TOTAL = 3;
+export const VITEST_CI_SHARD_INDICES = [1, 2, 3];
 /** CLI args for a single shard (excludes `vitest` binary). */
 export function vitestCiShardArgs(shardIndex, shardTotal = VITEST_CI_SHARD_TOTAL) {
     if (!Number.isInteger(shardIndex) || shardIndex < 1 || shardIndex > shardTotal) {

package/dist/esm/cli/auto-update/guard-tombstone.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Observability tombstone for the self-install guard.
+ *
+ * Cycle-free leaf: no imports of the guard command or installer scheduler.
+ * Static-importable from the guard so mid-update installId package-tree
+ * deletion cannot race a package-local dynamic import.
+ *
+ * NOT a concurrency gate — the heartbeat lease in install-lock.ts owns
+ * mutual exclusion. Best-effort writes only.
+ */
+export interface Tombstone {
+    autoInstallInProgress: {
+        pid: number;
+        ts: number;
+    };
+}
+/**
+ * Build the canonical tombstone shape. Exported for testability.
+ */
+export declare function buildTombstone(pid: number, ts: number): Tombstone;
+/**
+ * Record the guard's pid + start time in the notifier cache for humans and
+ * `wp update`'s cache-reconcile step.
+ */
+export declare function writeGuardTombstone(): void;

package/dist/esm/cli/auto-update/guard-tombstone.js

@@ -0,0 +1,67 @@
+/**
+ * Observability tombstone for the self-install guard.
+ *
+ * Cycle-free leaf: no imports of the guard command or installer scheduler.
+ * Static-importable from the guard so mid-update installId package-tree
+ * deletion cannot race a package-local dynamic import.
+ *
+ * NOT a concurrency gate — the heartbeat lease in install-lock.ts owns
+ * mutual exclusion. Best-effort writes only.
+ */
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { getSurfacePath } from "#paths/state-root.js";
+import { writeJsonFile } from "#shared-utils/write-json-file.js";
+import { logUpdateError } from "./log.js";
+/**
+ * Build the canonical tombstone shape. Exported for testability.
+ */
+export function buildTombstone(pid, ts) {
+    return { autoInstallInProgress: { pid, ts } };
+}
+/**
+ * Record the guard's pid + start time in the notifier cache for humans and
+ * `wp update`'s cache-reconcile step.
+ */
+export function writeGuardTombstone() {
+    try {
+        const configPath = resolveConfigPath();
+        if (configPath === null)
+            return;
+        writeTombstone(configPath, buildTombstone(process.pid, Date.now()));
+    }
+    catch (err) {
+        logUpdateError(err);
+    }
+}
+function resolveConfigPath() {
+    try {
+        return getSurfacePath("update-notifier-cache.json", "user");
+    }
+    catch {
+        return null;
+    }
+}
+function readRaw(configPath) {
+    if (!existsSync(configPath))
+        return {};
+    try {
+        const text = readFileSync(configPath, "utf-8");
+        if (text.trim().length === 0)
+            return {};
+        const parsed = JSON.parse(text);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+function writeTombstone(configPath, tombstone) {
+    const dir = dirname(configPath);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const merged = { ...readRaw(configPath), ...tombstone };
+    writeJsonFile(configPath, merged, { atomic: true, indent: 0, trailingNewline: false });
+}

package/dist/esm/cli/auto-update/installer.d.ts

@@ -13,6 +13,8 @@
  * releases the lease. Concurrency control, the observability tombstone,
  * verification, and repair all live in the guard — this module only decides
  * WHETHER to spawn and wires the detached stdio to auto-update.log.
+ * Guard argv uses the cycle-free self-invocation leaf (never a full import of
+ * the guard command module).
  *
  * Invariants:
  *   - Synchronous: returns before the install starts.
@@ -25,15 +27,11 @@
  *     from a successful CLI run.
  */
 export { isProcessAlive } from "./install-lock.js";
+/** Re-export for existing call sites and tests (implementation in guard-tombstone). */
+export { buildTombstone, writeGuardTombstone, type Tombstone } from "./guard-tombstone.js";
 export interface InstallPlan {
     command: string[];
 }
-export interface Tombstone {
-    autoInstallInProgress: {
-        pid: number;
-        ts: number;
-    };
-}
 export interface ScheduleResult {
     /** Did we actually fork the guard child? */
     spawned: boolean;
@@ -56,14 +54,3 @@ export interface ScheduleDeferredInstallOptions {
  * holds the lease, the guard itself exits 12 without running anything.
  */
 export declare function scheduleDeferredInstall(plan: InstallPlan, options?: ScheduleDeferredInstallOptions): ScheduleResult;
-/**
- * Observability tombstone written by the self-install guard when it takes
- * the lease: records the guard's pid + start time in the notifier cache for
- * humans and `wp update`'s cache-reconcile step. NOT a concurrency gate —
- * the heartbeat lease in install-lock.ts owns mutual exclusion. Best-effort.
- */
-export declare function writeGuardTombstone(): void;
-/**
- * Build the canonical tombstone shape. Exported for testability.
- */
-export declare function buildTombstone(pid: number, ts: number): Tombstone;

package/dist/esm/cli/auto-update/installer.js

@@ -13,6 +13,8 @@
  * releases the lease. Concurrency control, the observability tombstone,
  * verification, and repair all live in the guard — this module only decides
  * WHETHER to spawn and wires the detached stdio to auto-update.log.
+ * Guard argv uses the cycle-free self-invocation leaf (never a full import of
+ * the guard command module).
  *
  * Invariants:
  *   - Synchronous: returns before the install starts.
@@ -24,14 +26,15 @@
  *     `logUpdateError` and swallowed; the user never sees an exception
  *     from a successful CLI run.
  */
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { closeSync, existsSync, mkdirSync, openSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { dirname } from "node:path";
 import { getSurfacePath } from "#paths/state-root.js";
-import { writeJsonFile } from "#shared-utils/write-json-file.js";
-import { buildSelfInvocationCommand } from "#cli/commands/self-install-guard.js";
 import { logUpdateError } from "./log.js";
+import { buildSelfInvocationCommand } from "./self-invocation.js";
 export { isProcessAlive } from "./install-lock.js";
+/** Re-export for existing call sites and tests (implementation in guard-tombstone). */
+export { buildTombstone, writeGuardTombstone } from "./guard-tombstone.js";
 /**
  * Schedule a deferred install for the supplied package-manager command,
  * routed through the self-install guard. Synchronous — spawn() returns
@@ -66,37 +69,6 @@ export function scheduleDeferredInstall(plan, options = {}) {
         return { spawned: false, reason: "spawn error" };
     }
 }
-/**
- * Observability tombstone written by the self-install guard when it takes
- * the lease: records the guard's pid + start time in the notifier cache for
- * humans and `wp update`'s cache-reconcile step. NOT a concurrency gate —
- * the heartbeat lease in install-lock.ts owns mutual exclusion. Best-effort.
- */
-export function writeGuardTombstone() {
-    try {
-        const configPath = resolveConfigPath();
-        if (configPath === null)
-            return;
-        writeTombstone(configPath, buildTombstone(process.pid, Date.now()));
-    }
-    catch (err) {
-        logUpdateError(err);
-    }
-}
-/**
- * Build the canonical tombstone shape. Exported for testability.
- */
-export function buildTombstone(pid, ts) {
-    return { autoInstallInProgress: { pid, ts } };
-}
-function resolveConfigPath() {
-    try {
-        return getSurfacePath("update-notifier-cache.json", "user");
-    }
-    catch {
-        return null;
-    }
-}
 function resolveLogPath() {
     try {
         return getSurfacePath("auto-update.log", "user");
@@ -105,29 +77,6 @@ function resolveLogPath() {
         return null;
     }
 }
-function readRaw(configPath) {
-    if (!existsSync(configPath))
-        return {};
-    try {
-        const text = readFileSync(configPath, "utf-8");
-        if (text.trim().length === 0)
-            return {};
-        const parsed = JSON.parse(text);
-        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
-            return {};
-        return parsed;
-    }
-    catch {
-        return {};
-    }
-}
-function writeTombstone(configPath, tombstone) {
-    const dir = dirname(configPath);
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    const merged = { ...readRaw(configPath), ...tombstone };
-    writeJsonFile(configPath, merged, { atomic: true, indent: 0, trailingNewline: false });
-}
 function openLogForAppend(logPath) {
     const dir = dirname(logPath);
     if (!existsSync(dir))

package/dist/esm/cli/auto-update/self-invocation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Cycle-free leaf: how `wp` re-invokes itself for self-install-guard.
+ *
+ * Lives outside `self-install-guard.ts` so deferred install, `wp update`, and
+ * setup can build guard argv without importing the full guard command module
+ * (which would re-create installer ↔ guard cycles and tempt dynamic imports).
+ *
+ * Survival rule: 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.
+ */
+export interface SelfInvocationOptions {
+    readonly execPath?: string;
+    readonly argv1?: string;
+    /** Injectable stable launcher for tests; `null` forces legacy argv1 path. */
+    readonly stableWp?: string | null;
+}
+/**
+ * Build argv to re-invoke wp with the given subcommand args.
+ * - Prefer stable non-versioned launcher when available.
+ * - 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?: SelfInvocationOptions): string[];
+export interface ResolveStableWpLauncherOptions {
+    readonly home?: string;
+    readonly pathEnv?: string;
+    readonly existsSync?: (path: string) => boolean;
+}
+/**
+ * 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?: ResolveStableWpLauncherOptions): string | null;
+/** True when path lives inside a vite-plus installId package tree. */
+export declare function isVersionedAgentKitPayloadPath(filePath: string): boolean;

package/dist/esm/cli/auto-update/self-invocation.js

@@ -0,0 +1,62 @@
+/**
+ * Cycle-free leaf: how `wp` re-invokes itself for self-install-guard.
+ *
+ * Lives outside `self-install-guard.ts` so deferred install, `wp update`, and
+ * setup can build guard argv without importing the full guard command module
+ * (which would re-create installer ↔ guard cycles and tempt dynamic imports).
+ *
+ * Survival rule: 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.
+ */
+import { existsSync } from "node:fs";
+import path from "node:path";
+/**
+ * Build argv to re-invoke wp with the given subcommand args.
+ * - Prefer stable non-versioned launcher when available.
+ * - 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);
+}

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

@@ -27,6 +27,7 @@ export const REPO_AUDIT_REGISTRY = {
         includeRuntimePlans: options.runtimePlans,
         baseRef: options.baseRef ?? options.base,
         changedOnly: options.changedOnly,
+        affectedFiles: options.affectedFiles,
     }),
     "blueprint-trust": async (root) => (await import("#audit/blueprint-trust")).auditBlueprintTrust(root),
     "roadmap-links": async (root, options) => (await import("#audit/roadmap-links")).auditRoadmapLinks(root, {
@@ -122,6 +123,9 @@ export const REPO_AUDIT_REGISTRY = {
     "secrets-config": async (root) => (await import("#audit/secrets-config")).auditSecretsConfig(root),
     "consumer-agent-kit-dependency": async (root) => (await import("#audit/consumer-agent-kit-dependency")).auditConsumerAgentKitDependency(root),
     "ci-test-perf": async (root) => (await import("#audit/ci-test-perf")).auditCiTestPerf(root),
+    "test-scan-perf": async (root, options) => (await import("#audit/test-scan-perf")).auditTestScanPerf(root, {
+        affectedFiles: options.affectedFiles,
+    }),
     "worktree-main-ownership": async (root) => (await import("#audit/worktree-main-ownership")).auditWorktreeMainOwnership(root),
     sast: async (root, options) => (await import("#audit/sast")).auditSast(root, {
         bin: options.bin,