@webpresso/agent-kit 3.1.26 → 3.1.28

package/dist/esm/cli/commands/dash/tui/native-host.js

@@ -0,0 +1,256 @@
+// Domain host for the native Ratatui shell: maps AppViewModel ↔ IPC and keys → reduceTuiKey.
+import { spawn } from "node:child_process";
+import { emitDashE2eState } from "#cli/commands/dash/e2e-state.js";
+import { buildRows } from "#cli/commands/dash/menu-state.js";
+import { filterPaletteCommands, groupPaletteCommands } from "#cli/commands/dash/tui/palette.js";
+import { reduceTuiKey } from "#cli/commands/dash/tui/state.js";
+import { decodeIpcFrames, encodeIpcFrame, parseClientMessage, } from "#cli/commands/dash/tui/ipc-protocol.js";
+import { sanitizeTuiText } from "#cli/commands/dash/tui/sanitize.js";
+function hostAvailabilityNote(agentKey, availability) {
+    const row = availability.find((item) => item.id === agentKey);
+    if (!row || row.available)
+        return null;
+    return row.reason ?? "unavailable";
+}
+export function projectNativeViewModel(state, input) {
+    const rows = buildRows(state.agents, state.menu.expandedAgent);
+    const menuLines = rows.map((row) => {
+        const mark = row.key === state.menu.selectedKey ? "▸" : " ";
+        const note = row.kind === "agent" ? hostAvailabilityNote(row.agentKey, state.hostAvailability) : null;
+        const label = note ? `${row.label} · ${note}` : row.label;
+        return sanitizeTuiText(`${mark} ${label}`);
+    });
+    let overlayKind = state.overlay.kind;
+    let overlayLines = [];
+    if (state.overlay.kind === "palette") {
+        const matches = filterPaletteCommands(state.overlay.query);
+        const groups = groupPaletteCommands(matches);
+        overlayLines = [sanitizeTuiText(`query: ${state.overlay.query || "…"}`)];
+        for (const group of groups) {
+            overlayLines.push(sanitizeTuiText(`— ${group.category}`));
+            for (const [index, command] of group.commands.entries()) {
+                // Approximate global cursor: mark the selected match row.
+                const globalIndex = matches.indexOf(command);
+                const mark = globalIndex === state.overlay.cursor ? "▸" : " ";
+                overlayLines.push(sanitizeTuiText(`${mark} ${command.title} · ${command.keys}`));
+                void index;
+            }
+        }
+        if (matches.length === 0) {
+            overlayLines.push("(no matches)");
+        }
+    }
+    else if (state.overlay.kind === "help") {
+        overlayLines = [
+            "^p palette",
+            "^o mode",
+            "^s sessions",
+            "^x help",
+            "j/k move · h/l fold · g/G jump",
+            "q quit",
+        ];
+    }
+    else if (state.overlay.kind === "wizard") {
+        overlayLines = state.overlay.lines.map((line) => sanitizeTuiText(line));
+    }
+    else if (state.overlay.kind === "browser") {
+        overlayLines = state.overlay.lines.map((line) => sanitizeTuiText(line));
+    }
+    else if (state.overlay.kind === "lifecycle") {
+        overlayLines = [
+            sanitizeTuiText(`target ${state.overlay.target}`),
+            "d detach · s stop · f force-kill · a archive",
+            "Backspace delete · y confirm · Esc cancel",
+        ];
+    }
+    return {
+        repoLabel: sanitizeTuiText(input.repoLabel),
+        width: input.width,
+        height: input.height,
+        permissionMode: state.permissionMode,
+        hostAvailability: state.hostAvailability.map((h) => ({
+            id: h.id,
+            available: h.available,
+            ...(h.reason ? { reason: sanitizeTuiText(h.reason) } : {}),
+        })),
+        status: state.status ? sanitizeTuiText(state.status) : null,
+        warnings: state.warnings.map((w) => sanitizeTuiText(w)),
+        menuLines,
+        overlayKind,
+        overlayLines,
+        paletteQuery: state.overlay.kind === "palette" ? state.overlay.query : null,
+    };
+}
+export function clientMessageToParsedKey(message) {
+    switch (message.kind) {
+        case "char":
+            return message.value ? { kind: "char", value: message.value } : null;
+        case "up":
+        case "down":
+        case "left":
+        case "right":
+        case "enter":
+        case "escape":
+        case "tab":
+        case "backspace":
+            return { kind: message.kind };
+        case "ctrl":
+            return message.value ? { kind: "ctrl", value: message.value } : null;
+        default:
+            return null;
+    }
+}
+/**
+ * Drive pure TUI state from a native binary over length-prefixed JSON frames.
+ * State is owned by the caller (runtime) so launch/HUD/browser updates paint.
+ */
+export async function runNativeTuiHost(input) {
+    const spawnFn = input.spawnImpl ?? spawn;
+    const child = spawnFn(input.binaryPath, [], {
+        stdio: ["pipe", "pipe", "inherit"],
+    });
+    if (!child.stdin || !child.stdout) {
+        throw new Error("native shell spawn did not provide stdio pipes");
+    }
+    let stdinBuf = Buffer.alloc(0);
+    let width = 80;
+    let height = 24;
+    const childStdin = child.stdin;
+    const childStdout = child.stdout;
+    const pushView = () => {
+        if (!childStdin.writable)
+            return;
+        const view = projectNativeViewModel(input.getState(), {
+            repoLabel: input.repoLabel,
+            width,
+            height,
+        });
+        childStdin.write(encodeIpcFrame({ type: "view", view }));
+    };
+    input.onBridge?.({ pushView });
+    childStdin.write(encodeIpcFrame({ type: "hello", schemaVersion: 1 }));
+    pushView();
+    /**
+     * Handshake hang detection: fail closed if the shell never greets.
+     * After ready, probe process liveness so a zombie/stuck native binary
+     * cannot pin the domain host forever (runtime falls back to pure-ANSI).
+     */
+    const HANDSHAKE_MS = 30_000;
+    const LIVENESS_MS = 5_000;
+    return await new Promise((resolve) => {
+        let settled = false;
+        let handshakeDone = false;
+        let handshakeTimer = setTimeout(() => {
+            if (handshakeDone || settled)
+                return;
+            input.handlers.onQuit();
+            child.kill("SIGTERM");
+            setTimeout(() => child.kill("SIGKILL"), 2_000);
+            finish(1);
+        }, HANDSHAKE_MS);
+        let livenessTimer;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (handshakeTimer)
+                clearTimeout(handshakeTimer);
+            if (livenessTimer)
+                clearInterval(livenessTimer);
+            resolve(code);
+        };
+        const armLiveness = () => {
+            if (livenessTimer)
+                return;
+            livenessTimer = setInterval(() => {
+                if (settled)
+                    return;
+                // exitCode set when the process has already exited without us finishing.
+                if (child.exitCode !== null || child.signalCode !== null) {
+                    finish(child.exitCode ?? 1);
+                    return;
+                }
+                const pid = child.pid;
+                if (pid === undefined) {
+                    finish(1);
+                    return;
+                }
+                try {
+                    process.kill(pid, 0);
+                }
+                catch {
+                    finish(1);
+                }
+            }, LIVENESS_MS);
+        };
+        childStdout.on("data", (chunk) => {
+            stdinBuf = Buffer.concat([stdinBuf, chunk]);
+            let decoded;
+            try {
+                decoded = decodeIpcFrames(stdinBuf);
+            }
+            catch {
+                // Drop a corrupted frame prefix rather than crashing the domain host.
+                // Keep a bounded tail so a subsequent well-formed frame can resync.
+                stdinBuf = stdinBuf.length > 64 * 1024 ? stdinBuf.subarray(-4096) : Buffer.alloc(0);
+                return;
+            }
+            stdinBuf = Buffer.from(decoded.rest);
+            for (const raw of decoded.messages) {
+                let msg;
+                try {
+                    msg = parseClientMessage(raw);
+                }
+                catch {
+                    continue;
+                }
+                if (msg.type === "hello" || msg.type === "ready") {
+                    handshakeDone = true;
+                    if (handshakeTimer)
+                        clearTimeout(handshakeTimer);
+                    armLiveness();
+                    pushView();
+                    continue;
+                }
+                if (msg.type === "resize") {
+                    width = msg.width;
+                    height = msg.height;
+                    pushView();
+                    continue;
+                }
+                if (msg.type === "key") {
+                    const key = clientMessageToParsedKey(msg);
+                    if (!key)
+                        continue;
+                    const result = reduceTuiKey(input.getState(), key);
+                    input.setState(result.state);
+                    // Match pure-ANSI path: selection transitions ride the E2E channel so
+                    // CI tmux harness can assert menu navigation without screen scrapes.
+                    if (result.state.menu.selectedKey) {
+                        emitDashE2eState({ kind: "selection", row: result.state.menu.selectedKey });
+                    }
+                    for (const effect of result.effects) {
+                        void input.handlers.onEffect(effect);
+                        if (effect.kind === "quit") {
+                            input.handlers.onQuit();
+                            child.kill("SIGTERM");
+                            setTimeout(() => child.kill("SIGKILL"), 2_000);
+                            finish(0);
+                            return;
+                        }
+                    }
+                    if (result.state.quit) {
+                        input.handlers.onQuit();
+                        child.kill("SIGTERM");
+                        setTimeout(() => child.kill("SIGKILL"), 2_000);
+                        finish(0);
+                        return;
+                    }
+                    pushView();
+                }
+            }
+        });
+        child.on("exit", (code) => finish(code ?? 0));
+        child.on("error", () => finish(1));
+    });
+}

package/dist/esm/cli/commands/dash/tui/native-path.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Env contract:
+ * - `WP_DASH_NATIVE=0|false|off` → force pure-ANSI
+ * - `WP_DASH_NATIVE=1|true|on` → prefer native when binary present
+ * - unset → prefer native when binary present (cutover default)
+ * - `WP_DASH_TUI_BIN` → absolute path override
+ * - `WP_DASH_FORCE_ANSI=1` → runtime force pure-ANSI even if a binary resolves
+ */
+export declare function shouldPreferNativeDashTui(env?: NodeJS.ProcessEnv): boolean;
+export declare function resolveNativeDashTuiBinary(env?: NodeJS.ProcessEnv, candidates?: readonly string[]): string | null;
+export declare function defaultBinaryCandidates(cwd?: string): readonly string[];

package/dist/esm/cli/commands/dash/tui/native-path.js

@@ -0,0 +1,41 @@
+// Resolve the optional native wp-dash-tui binary for the control-plane shell.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { findPackageAsset } from "#utils/package-assets.js";
+/**
+ * Env contract:
+ * - `WP_DASH_NATIVE=0|false|off` → force pure-ANSI
+ * - `WP_DASH_NATIVE=1|true|on` → prefer native when binary present
+ * - unset → prefer native when binary present (cutover default)
+ * - `WP_DASH_TUI_BIN` → absolute path override
+ * - `WP_DASH_FORCE_ANSI=1` → runtime force pure-ANSI even if a binary resolves
+ */
+export function shouldPreferNativeDashTui(env = process.env) {
+    const flag = env["WP_DASH_NATIVE"]?.trim().toLowerCase();
+    if (flag === "0" || flag === "false" || flag === "off" || flag === "no") {
+        return false;
+    }
+    return true;
+}
+export function resolveNativeDashTuiBinary(env = process.env, candidates = defaultBinaryCandidates()) {
+    const override = env["WP_DASH_TUI_BIN"]?.trim();
+    if (override && existsSync(override))
+        return override;
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+export function defaultBinaryCandidates(cwd = process.cwd()) {
+    const fromPackage = [
+        findPackageAsset("native/dash-tui/target/release/wp-dash-tui", { cwd }),
+        findPackageAsset("native/dash-tui/target/debug/wp-dash-tui", { cwd }),
+    ].filter((path) => path !== null);
+    return [
+        join(cwd, "native/dash-tui/target/release/wp-dash-tui"),
+        join(cwd, "native/dash-tui/target/debug/wp-dash-tui"),
+        ...fromPackage,
+        join(cwd, "bin/wp-dash-tui"),
+    ];
+}

package/dist/esm/cli/commands/dash/tui/runtime.js

@@ -234,6 +234,8 @@ export async function runTuiMenu(input) {
     let dirty = true;
     let lastFrame = "";
     let running = true;
+    /** When set, domain state paints via the native shell instead of pure-ANSI. */
+    let nativePushView = null;
     /** Once true, no new launch effects may call selectAgent. */
     let shuttingDown = false;
     let initialLaunchConsumed = false;
@@ -261,6 +263,14 @@ export async function runTuiMenu(input) {
     const paint = () => {
         if (shuttingDown)
             return;
+        // Native shell owns the terminal; never write pure-ANSI frames over it.
+        if (nativePushView) {
+            if (!dirty && !input.smokeOnce)
+                return;
+            nativePushView();
+            dirty = false;
+            return;
+        }
         if (!dirty && !input.smokeOnce)
             return;
         const frame = renderFrame(toViewModel(state, {
@@ -621,6 +631,68 @@ export async function runTuiMenu(input) {
             stdout.write(`\n${note}\n`);
         return 0;
     }
+    // Primary path: native Ratatui shell when binary is available (WP_DASH_NATIVE=0 forces pure-ANSI).
+    const { shouldPreferNativeDashTui, resolveNativeDashTuiBinary } = await import("#cli/commands/dash/tui/native-path.js");
+    const nativeBinary = shouldPreferNativeDashTui() && !process.env["WP_DASH_FORCE_ANSI"]
+        ? resolveNativeDashTuiBinary()
+        : null;
+    if (nativeBinary) {
+        try {
+            const { runNativeTuiHost } = await import("#cli/commands/dash/tui/native-host.js");
+            process.stderr.write(`wp dash: native control-plane shell (${nativeBinary})\n`);
+            // Ensure agent list is loaded before first native frame when possible.
+            state = { ...state, loading: false };
+            const code = await runNativeTuiHost({
+                binaryPath: nativeBinary,
+                repoLabel: input.repoLabel,
+                getState: () => state,
+                setState: (next) => {
+                    state = next;
+                },
+                onBridge: (bridge) => {
+                    nativePushView = bridge.pushView;
+                },
+                handlers: {
+                    onEffect: (effect) => {
+                        // Match pure-ANSI: repaint after async effects settle so launch /
+                        // browser / status mutations reach the native shell without waiting
+                        // for the next key or timer tick.
+                        void enqueueEffects([effect]).then(() => {
+                            if (!shuttingDown)
+                                paint();
+                        });
+                    },
+                    onQuit: () => {
+                        shuttingDown = true;
+                        running = false;
+                        coordinator.discardPending();
+                    },
+                },
+            });
+            nativePushView = null;
+            if (code !== 0) {
+                throw new Error(`native shell exited with code ${code}`);
+            }
+            shuttingDown = true;
+            running = false;
+            coordinator.discardPending();
+            clearInterval(usageTimer);
+            clearInterval(ultragoalTimer);
+            clearInterval(statusTimer);
+            stopObservingLayout?.();
+            const note = await controller?.dispose();
+            await effectQueue.catch(() => {
+                /* best-effort drain after dispose */
+            });
+            if (note)
+                stdout.write(`\n${note}\n`);
+            return code;
+        }
+        catch (error) {
+            nativePushView = null;
+            process.stderr.write(`wp dash: native shell failed (${error instanceof Error ? error.message : String(error)}); falling back to pure-ANSI\n`);
+        }
+    }
     const wasRaw = stdin.isRaw;
     if (typeof stdin.setRawMode === "function")
         stdin.setRawMode(true);

package/dist/esm/cli/commands/init/scaffolders/agent-kit-global/index.js

@@ -26,7 +26,7 @@ import { spawnSync } from "node:child_process";
 import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync, } from "node:fs";
 import { dirname, join } from "node:path";
 import { buildVpGlobalInstallCommand, confirmInstalledGlobally, PUBLIC_PACKAGE_NAME, resolveBundledVpCommand, } from "#cli/auto-update/detect-pm.js";
-import { buildSelfInvocationCommand } from "#cli/commands/self-install-guard.js";
+import { buildSelfInvocationCommand } from "#cli/auto-update/self-invocation.js";
 import { findAgentKitPackageRoot, resolveAgentKitPackageRoot, } from "#cli/commands/init/package-root";
 import { makeNoopSpinnerFactory, } from "#cli/commands/init/scaffolders/spinner";
 import { UPDATE_CACHE_FILENAME, readFreshCachedLatestVersion } from "#cli/auto-update/cache.js";

package/dist/esm/cli/commands/package-manager.js

@@ -7,7 +7,8 @@ import { readToolingOwnershipState, tryReadRepoKey, writeToolingOwnershipState,
 import { resolveGlobalCapableVpCommand } from "#cli/global-vp.js";
 import { UPDATE_CACHE_FILENAME, formatStaleAgentKitVersionWarning, reconcileUpdateNotifierCache, } from "#cli/auto-update/cache.js";
 import { buildVpGlobalUpdateCommand, resolveBundledVpCommand } from "#cli/auto-update/detect-pm.js";
-import { GUARD_EXIT_CHILD_FAILED, GUARD_EXIT_LEASE_HELD, GUARD_EXIT_OWNERSHIP_LOST, GUARD_EXIT_UNRESOLVABLE, buildSelfInvocationCommand, } from "#cli/commands/self-install-guard.js";
+import { buildSelfInvocationCommand } from "#cli/auto-update/self-invocation.js";
+import { GUARD_EXIT_CHILD_FAILED, GUARD_EXIT_LEASE_HELD, GUARD_EXIT_OWNERSHIP_LOST, GUARD_EXIT_UNRESOLVABLE, } from "#cli/commands/self-install-guard.js";
 import { readPackageVersion } from "#cli/utils";
 import { resolveFreshAgentKitPackageRoot } from "#cli/commands/init/package-root";
 import { DEFAULT_PLUGIN_CACHE_PRUNE_HOSTS, pruneOutdatedAgentKitPluginCaches, } from "#cli/commands/init/plugin-cache-prune.js";

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/hooks/guard-switch/index.js

@@ -6,9 +6,10 @@ import { isDirectEntrypoint } from "#hooks/shared/direct-entrypoint";
 import { runHook } from "#hooks/shared/hook-bootstrap";
 import { resolveHookProjectDir } from "#hooks/shared/project-dir.js";
 import { createManagedHookExecutionContext, reportSessionMemoryHookDegradation, sessionMemoryHookStoreOptions, } from "#hooks/shared/session-memory-deadline.js";
+import { resolveHookSessionId } from "#hooks/shared/types.js";
 import { getSurfacePath, NotInGitRepoError } from "#paths/state-root.js";
 import { buildContinuityEvent, buildPromptContinuityEvents } from "#session-memory/hook-capture.js";
-import { repoHashFromRoot } from "#session-memory/repo-hash.js";
+import { computeRepoHash, repoHashFromRoot } from "#session-memory/repo-hash.js";
 import { SessionMemorySessionStore, } from "#session-memory/session.js";
 import { classifyPromptRoutingIntent, } from "#hooks/prompt-routing";
 import { setActivePromptRouting, setGuardEnabled } from "./state.js";
@@ -67,13 +68,15 @@ function capturePromptContinuity(input, projectDir, env, deps, routing) {
     const store = deps.createStore?.(dbPath, deps.storeOptions) ??
         new SessionMemorySessionStore(dbPath, deps.storeOptions);
     try {
-        const repoHash = deps.repoHash?.(projectDir) ?? repoHashFromRoot(projectDir);
+        // Match readCurrentSessionId hashing (computeRepoHash), not path-only.
+        const repoHash = deps.repoHash?.(projectDir) ?? computeRepoHash(projectDir);
         const timestamp = (deps.now?.() ?? new Date()).toISOString();
+        const sessionId = resolveHookSessionId(input, env);
         for (const event of events) {
             store.captureEvent({
                 repoHash,
                 agentId: input.agent_id ?? input.agent_type ?? "UserPromptSubmit",
-                ...(input.session_id === undefined ? {} : { sessionId: input.session_id }),
+                ...(sessionId === undefined ? {} : { sessionId }),
                 event: {
                     ...event,
                     ts: timestamp,
@@ -124,13 +127,14 @@ export function processGuardSwitchInput(inputValue, cwd, env = process.env, deps
             reason: "🛡️ Guard enabled — pretool validators active",
         };
     }
+    const routingSessionId = resolveHookSessionId(input, env);
     const routing = normalized.length === 0
         ? null
         : {
             intent: deps.classifyPromptRoutingIntent?.(normalized) ??
                 classifyPromptRoutingIntent(normalized),
             updatedAt: (deps.now?.() ?? new Date()).toISOString(),
-            ...(input.session_id === undefined ? {} : { sessionId: input.session_id }),
+            ...(routingSessionId === undefined ? {} : { sessionId: routingSessionId }),
             ...(input.turn_id === undefined ? {} : { turnId: input.turn_id }),
         };
     if (routing !== null) {