@webpresso/agent-kit 3.1.25 → 3.1.26

package/catalog/agent/rules/changeset-release.md

@@ -180,7 +180,11 @@ for the current repository and package configuration contract.
    `npm view <package> version`. For consumer setup smoke, use
    `vp install -g @webpresso/agent-kit@latest`, `wp setup`, and
    `wp sync --check`.
-6. After the OIDC publish path succeeds, set npm package publishing access to
+6. If the Version Packages PR has no WP check / CI is `action_required` with
+   zero jobs, follow
+   [`docs/runbooks/version-packages-bot-ci.md`](../../../docs/runbooks/version-packages-bot-ci.md)
+   (`gh run rerun` or Approve workflows). Do not admin-merge without WP check.
+7. After the OIDC publish path succeeds, set npm package publishing access to
    require two-factor authentication and disallow tokens, then revoke obsolete
    automation tokens. Do not remove a credential that another verified release
    path still needs.

package/dist/esm/cli/commands/quality-log-store.d.ts

@@ -10,6 +10,12 @@ export interface CliLogEntry {
     readonly summary?: string;
 }
 export declare function isCliLogCommandName(value: string): value is CliLogCommandName;
+/**
+ * Create a durable CLI log sink. When the preferred repo state surface is not
+ * writable (EPERM/EACCES/EROFS — common in Codex/read-only sandboxes), fall
+ * back to TMPDIR so `wp audit`/`wp test` still execute. The fallback is loud
+ * on stderr; it is not a silent swallow.
+ */
 export declare function createCliLogSink(command: CliLogCommandName, cwd?: string): CliLogSink;
 export interface CliLogSink {
     readonly command: CliLogCommandName;

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

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { closeSync, 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 { getSurfacePath } from "#paths/state-root.js";
 import { readTrustedJsonFile } from "#shared-utils/read-json-file.js";
@@ -18,9 +19,17 @@ const ORPHAN_LOG_GRACE_MS = 60_000;
 export function isCliLogCommandName(value) {
     return CLI_LOG_COMMANDS.includes(value);
 }
-export function createCliLogSink(command, cwd = process.cwd()) {
+function isUnwritableFsError(error) {
+    if (typeof error !== "object" || error === null || !("code" in error))
+        return false;
+    const code = error.code;
+    return code === "EPERM" || code === "EACCES" || code === "EROFS";
+}
+/**
+ * Open a CLI log sink in an explicit directory (preferred state surface or fallback).
+ */
+function openCliLogSink(commandDir, command, cwd) {
     const id = createLogId();
-    const commandDir = getCommandLogDir(command, cwd);
     mkdirSync(commandDir, { recursive: true });
     const absoluteLogPath = join(commandDir, `${id}.log`);
     const activeMarkerPath = getActiveMarkerPath(absoluteLogPath);
@@ -80,7 +89,8 @@ export function createCliLogSink(command, cwd = process.cwd()) {
             };
             try {
                 markLogRecentlyFinalized(absoluteLogPath);
-                writeLogEntry(entry, cwd);
+                // Index/lock live next to the log file so fallback dirs stay consistent.
+                writeLogEntryInDir(entry, commandDir);
             }
             finally {
                 rmSync(activeMarkerPath, { force: true });
@@ -89,6 +99,28 @@ export function createCliLogSink(command, cwd = process.cwd()) {
         },
     };
 }
+/**
+ * Create a durable CLI log sink. When the preferred repo state surface is not
+ * writable (EPERM/EACCES/EROFS — common in Codex/read-only sandboxes), fall
+ * back to TMPDIR so `wp audit`/`wp test` still execute. The fallback is loud
+ * on stderr; it is not a silent swallow.
+ */
+export function createCliLogSink(command, cwd = process.cwd()) {
+    const preferredDir = getCommandLogDir(command, cwd);
+    try {
+        return openCliLogSink(preferredDir, command, cwd);
+    }
+    catch (error) {
+        if (!isUnwritableFsError(error))
+            throw error;
+        const fallbackDir = join(tmpdir(), "webpresso", "cli-logs", command);
+        const code = typeof error === "object" && error !== null && "code" in error
+            ? String(error.code)
+            : "unknown";
+        process.stderr.write(`wp: CLI log directory not writable (${preferredDir}): ${code}; using ${fallbackDir}\n`);
+        return openCliLogSink(fallbackDir, command, cwd);
+    }
+}
 export function readCliLogEntries(command, cwd = process.cwd()) {
     const indexPath = getCommandIndexPath(command, cwd);
     try {
@@ -104,11 +136,21 @@ export function readCliLogEntry(command, ordinal = 1, cwd = process.cwd()) {
         return;
     return readCliLogEntries(command, cwd)[ordinal - 1];
 }
-function writeLogEntry(entry, cwd) {
-    withCommandIndexLock(entry.command, cwd, () => {
-        const indexPath = getCommandIndexPath(entry.command, cwd);
+function readCliLogEntriesFromDir(commandDir) {
+    const indexPath = join(commandDir, "index.json");
+    try {
+        const parsed = readTrustedJsonFile(indexPath);
+        return Array.isArray(parsed.entries) ? parsed.entries : [];
+    }
+    catch {
+        return [];
+    }
+}
+function writeLogEntryInDir(entry, commandDir) {
+    withCommandIndexLockInDir(commandDir, () => {
+        const indexPath = join(commandDir, "index.json");
         mkdirSync(dirname(indexPath), { recursive: true });
-        const currentEntries = readCliLogEntries(entry.command, cwd).filter((current) => current.id !== entry.id);
+        const currentEntries = readCliLogEntriesFromDir(commandDir).filter((current) => current.id !== entry.id);
         const nextEntries = [entry, ...currentEntries].slice(0, 10);
         const retainedLogPaths = new Set(nextEntries.map((item) => item.logPath));
         for (const removed of currentEntries.slice(9)) {
@@ -116,7 +158,7 @@ function writeLogEntry(entry, cwd) {
                 rmSync(removed.logPath, { force: true });
             }
         }
-        pruneInactiveOrphanedLogFiles(entry.command, retainedLogPaths, cwd);
+        pruneInactiveOrphanedLogFilesInDir(commandDir, retainedLogPaths);
         const index = {
             version: 1,
             command: entry.command,
@@ -125,8 +167,7 @@ function writeLogEntry(entry, cwd) {
         writeIndexAtomically(indexPath, index);
     });
 }
-function withCommandIndexLock(command, cwd, fn) {
-    const commandDir = getCommandLogDir(command, cwd);
+function withCommandIndexLockInDir(commandDir, fn) {
     mkdirSync(commandDir, { recursive: true });
     const lockPath = join(commandDir, "index.lock");
     const started = Date.now();
@@ -157,13 +198,12 @@ function writeIndexAtomically(indexPath, index) {
     writeJsonFile(tmpPath, index);
     renameSync(tmpPath, indexPath);
 }
-function pruneInactiveOrphanedLogFiles(command, retainedLogPaths, cwd) {
-    const directory = getCommandLogDir(command, cwd);
-    mkdirSync(directory, { recursive: true });
-    for (const file of readdirSync(directory)) {
+function pruneInactiveOrphanedLogFilesInDir(commandDir, retainedLogPaths) {
+    mkdirSync(commandDir, { recursive: true });
+    for (const file of readdirSync(commandDir)) {
         if (!file.endsWith(".log"))
             continue;
-        const absolutePath = join(directory, file);
+        const absolutePath = join(commandDir, file);
         if (!retainedLogPaths.has(absolutePath) && canPruneLogPath(absolutePath)) {
             rmSync(absolutePath, { force: true });
         }

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

@@ -86,11 +86,27 @@ export interface SelfInstallGuardDeps {
  */
 export declare function runSelfInstallGuard(rawArgs: readonly string[], deps?: SelfInstallGuardDeps): Promise<number>;
 /**
- * How wp re-invokes itself: the bun-compiled binary IS process.execPath (its
- * argv[1] is a virtual /$bunfs path), while the source/dev lane runs
- * `<runtime> <script>`.
+ * 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

@@ -45,6 +45,8 @@
  * 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 { INSTALL_LOCK_HEARTBEAT_MS, claimInstallLock, refreshInstallLock, releaseInstallLock, resolveInstallLockPath, } from "#cli/auto-update/install-lock.js";
 import { probeGlobalWpResolvable } from "#cli/commands/init/package-root.js";
@@ -146,17 +148,55 @@ function extractChildCommand(rawArgs) {
     return rawArgs.slice(separator + 1);
 }
 /**
- * How wp re-invokes itself: the bun-compiled binary IS process.execPath (its
- * argv[1] is a virtual /$bunfs path), while the source/dev lane runs
- * `<runtime> <script>`.
+ * 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.

package/dist/esm/paths/state-root.js

@@ -1,7 +1,8 @@
 import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, realpathSync } from "node:fs";
+import { existsSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { readFile, realpath, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import envPaths from "env-paths";
 import lockfile from "proper-lockfile";
@@ -67,18 +68,44 @@ function normalizeCwdForCache(cwd) {
 function sha256Hex(value) {
     return createHash("sha256").update(value).digest("hex");
 }
+/**
+ * Probe whether a directory can hold state files.
+ * Used so quality CLIs (wp audit/test/…) keep working in sandboxes that
+ * deny writes under Application Support (e.g. Codex outside-voice).
+ */
+function canWriteStateRoot(root) {
+    try {
+        mkdirSync(root, { recursive: true });
+        const probe = join(root, `.wp-write-probe-${process.pid}`);
+        writeFileSync(probe, "ok");
+        rmSync(probe, { force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function getStateRoot() {
     if (cachedStateRoot !== null)
         return cachedStateRoot;
     const override = process.env.WP_STATE_ROOT;
     if (override && override.trim().length > 0) {
+        // Explicit override is authoritative — fail later if unwritable rather than
+        // silently relocating the user's chosen root.
         cachedStateRoot = override;
         return override;
     }
     const paths = envPaths("webpresso", { suffix: "" });
     const root = paths.data;
-    cachedStateRoot = root;
-    return root;
+    if (canWriteStateRoot(root)) {
+        cachedStateRoot = root;
+        return root;
+    }
+    const fallback = join(tmpdir(), "webpresso-state");
+    mkdirSync(fallback, { recursive: true });
+    process.stderr.write(`wp: state root not writable (${root}); using ${fallback}\n`);
+    cachedStateRoot = fallback;
+    return fallback;
 }
 export function getRepoKey() {
     if (cachedRepoKey !== null)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webpresso/agent-kit",
-  "version": "3.1.25",
+  "version": "3.1.26",
   "private": false,
   "description": "TypeScript-first agent harness for guarded develop/deploy workflows: wp CLI gates, MCP tools, hooks, memory, worktrees, secrets, audits, and evidence checks.",
   "keywords": [
@@ -499,16 +499,16 @@
     "setupWpActionRef": "c2c71a7a4be446fc6858e6b57bf55a11ccfa2d88"
   },
   "optionalDependencies": {
-    "@webpresso/agent-kit-runtime-darwin-arm64": "3.1.25",
-    "@webpresso/agent-kit-runtime-darwin-x64": "3.1.25",
-    "@webpresso/agent-kit-runtime-linux-x64": "3.1.25",
-    "@webpresso/agent-kit-runtime-linux-arm64": "3.1.25",
-    "@webpresso/agent-kit-runtime-windows-x64": "3.1.25",
-    "@webpresso/agent-kit-session-memory-darwin-x64": "3.1.25",
-    "@webpresso/agent-kit-session-memory-darwin-arm64": "3.1.25",
-    "@webpresso/agent-kit-session-memory-linux-x64": "3.1.25",
-    "@webpresso/agent-kit-session-memory-linux-arm64": "3.1.25",
-    "@webpresso/agent-kit-session-memory-win32-x64": "3.1.25",
-    "@webpresso/agent-kit-session-memory-win32-arm64": "3.1.25"
+    "@webpresso/agent-kit-runtime-darwin-arm64": "3.1.26",
+    "@webpresso/agent-kit-runtime-darwin-x64": "3.1.26",
+    "@webpresso/agent-kit-runtime-linux-x64": "3.1.26",
+    "@webpresso/agent-kit-runtime-linux-arm64": "3.1.26",
+    "@webpresso/agent-kit-runtime-windows-x64": "3.1.26",
+    "@webpresso/agent-kit-session-memory-darwin-x64": "3.1.26",
+    "@webpresso/agent-kit-session-memory-darwin-arm64": "3.1.26",
+    "@webpresso/agent-kit-session-memory-linux-x64": "3.1.26",
+    "@webpresso/agent-kit-session-memory-linux-arm64": "3.1.26",
+    "@webpresso/agent-kit-session-memory-win32-x64": "3.1.26",
+    "@webpresso/agent-kit-session-memory-win32-arm64": "3.1.26"
   }
 }