@webpresso/agent-kit 3.1.25 → 3.1.28

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
@@ -46,10 +50,14 @@
  */
 import { spawn } from "node:child_process";
 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)")
@@ -145,18 +153,6 @@ function extractChildCommand(rawArgs) {
         return [];
     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>`.
- */
-export function buildSelfInvocationCommand(args, options = {}) {
-    const execPath = options.execPath ?? process.execPath;
-    const argv1 = options.argv1 ?? process.argv[1] ?? "";
-    if (argv1.startsWith("/$bunfs"))
-        return [execPath, ...args];
-    return [execPath, argv1, ...args];
-}
 function defaultSpawnChild(command) {
     const [executable, ...args] = command;
     // detached: own process group, so lost-ownership kills reap descendants.
@@ -211,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) {

package/dist/esm/hooks/post-tool/lint-after-edit.js

@@ -5,11 +5,11 @@ import { tmpdir } from "node:os";
 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 { getCommand, getContent, getFilePath, isBashInput, isFileEditInput, isFileReadInput, isFileWriteInput, } from "#hooks/shared/types";
+import { getCommand, getContent, getFilePath, isBashInput, isFileEditInput, isFileReadInput, isFileWriteInput, resolveHookSessionId, } from "#hooks/shared/types";
 import { isDirectEntrypoint } from "#hooks/shared/direct-entrypoint";
 import { getSurfacePath, NotInGitRepoError } from "#paths/state-root.js";
 import { buildContinuityEvent } 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";
 export const LINTABLE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".json", ".css"];
 export const DEFAULT_MAX_CAPTURE_BYTES = 2048;
@@ -116,7 +116,8 @@ export function capturePostToolUse(input, projectDir, env = process.env, deps =
         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 event = buildContinuityEvent({
                 eventType,
                 toolName: input.tool_name ?? "PostToolUse",
@@ -131,10 +132,11 @@ export function capturePostToolUse(input, projectDir, env = process.env, deps =
                 },
                 maxContentBytes: DEFAULT_MAX_CAPTURE_BYTES,
             });
+            const sessionId = resolveHookSessionId(input, env);
             store.captureEvent({
                 repoHash,
                 agentId: input.tool_name ?? "default",
-                ...(input.session_id === undefined ? {} : { sessionId: input.session_id }),
+                ...(sessionId === undefined ? {} : { sessionId }),
                 event: { ...event, ts: (deps.now?.() ?? new Date()).toISOString() },
             });
             return true;

package/dist/esm/hooks/precompact/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 } 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";
 export const DEFAULT_MAX_SNAPSHOT_BYTES = 32 * 1024;
 export const DEFAULT_MAX_EVENT_BYTES = 2 * 1024;
@@ -61,14 +62,15 @@ export function buildOutput(inputValue, cwd, env, deps = {}) {
     try {
         const input = normalizeInput(inputValue);
         const projectDir = resolveHookProjectDir(input, cwd, env);
-        const repoHash = deps.repoHash?.(projectDir) ?? repoHashFromRoot(projectDir);
+        // Match readCurrentSessionId hashing (computeRepoHash), not path-only.
+        const repoHash = deps.repoHash?.(projectDir) ?? computeRepoHash(projectDir);
         const dbPath = deps.dbPath ?? resolveSessionMemoryDbPath(projectDir, env);
         mkdirSync(dirname(dbPath), { recursive: true });
         const store = deps.createStore?.(dbPath, deps.storeOptions) ??
             new SessionMemorySessionStore(dbPath, deps.storeOptions);
         try {
             const agentId = input.agent_id ?? input.agent_type ?? "default";
-            const sessionId = input.session_id;
+            const sessionId = resolveHookSessionId(input, env);
             const timestamp = (deps.now?.() ?? new Date()).toISOString();
             const boundary = buildContinuityEvent({
                 eventType: "compaction_boundary",

package/dist/esm/hooks/sessionstart/index.d.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 import { Database } from "#db/sqlite.js";
+import { SessionMemorySessionStore } from "#session-memory/session.js";
 export declare const MAX_BYTES: number;
 export declare const TRUNCATION_NOTICE = "\n\n[truncated: file exceeded 200KB limit]";
 export declare const RESUME_MAX_EVENT_BYTES: number;
@@ -10,10 +11,19 @@ type StartInput = Record<string, unknown>;
 type EnvLike = Record<string, string | undefined>;
 export interface SessionStartDeps {
     readonly createDatabase?: (dbPath: string) => Pick<Database, "prepare" | "close">;
+    readonly createStore?: (dbPath: string) => Pick<SessionMemorySessionStore, "captureEvent" | "close">;
     readonly dbPath?: string;
     readonly repoHash?: (projectDir: string) => string;
+    readonly now?: () => Date;
+    readonly onStorageError?: (error: unknown) => void;
 }
 export declare function resolveSessionMemoryDbPath(projectDir: string, env: EnvLike): string;
+/**
+ * Seed session-memory with a real host session id so `wp session-info` works
+ * under Grok (and similar hosts) before any Edit/Write tool capture. Fail-open:
+ * storage errors never break SessionStart stdout.
+ */
+export declare function seedSessionIdentityCapture(input: StartInput, projectDir: string, env: EnvLike, deps?: SessionStartDeps): void;
 /**
  * Pure function: given a parsed input payload, a working directory, and
  * environment variables, produce the JSON string that the hook should write

package/dist/esm/hooks/sessionstart/index.js

@@ -18,20 +18,23 @@
  * Always emits valid JSON; `additionalContext` is empty when there is no
  * `.agent/routing.md`, continuity, or update banner to surface.
  */
-import { readFileSync, statSync } from "node:fs";
+import { mkdirSync, readFileSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { performance } from "node:perf_hooks";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { renderSessionStartInstructionContext } from "#hooks/shared/instruction-surfaces";
 import { writeHookOutput } from "#hooks/shared/hook-bootstrap";
 import { rememberHookStdin } from "#hooks/logs/store.js";
 import { resolveHookProjectDir } from "#hooks/shared/project-dir.js";
+import { resolveHookSessionId } from "#hooks/shared/types.js";
 import { getSurfacePath, NotInGitRepoError } from "#paths/state-root.js";
 import { WP_AGENT_LAUNCHED_VIA_WP_ENV, WP_AGENT_LAUNCHED_VIA_WP_VALUE, } from "#runtime/agent-launch-marker.js";
 import { Database } from "#db/sqlite.js";
 import { readUpdateBanner } from "./update-banner.js";
 import { isDirectEntrypoint } from "#hooks/shared/direct-entrypoint";
-import { repoHashFromRoot } from "#session-memory/repo-hash.js";
+import { buildContinuityEvent } from "#session-memory/hook-capture.js";
+import { computeRepoHash, repoHashFromRoot } from "#session-memory/repo-hash.js";
+import { SessionMemorySessionStore } from "#session-memory/session.js";
 export const MAX_BYTES = 200 * 1024;
 export const TRUNCATION_NOTICE = "\n\n[truncated: file exceeded 200KB limit]";
 export const RESUME_MAX_EVENT_BYTES = 2 * 1024;
@@ -223,7 +226,8 @@ function buildResumeContext(input, projectDir, env, deps) {
             const rows = readRecentContinuityEvents({
                 db,
                 repoHash,
-                sessionId: optionalString(input["session_id"]),
+                // Prefer stdin session id; fall back to GROK_SESSION_ID for Grok hooks.
+                sessionId: resolveHookSessionId(input, env),
                 minPriority: parsePositiveInt(env.WP_SESSIONSTART_RESUME_MIN_PRIORITY, RESUME_MIN_PRIORITY),
                 limit: parsePositiveInt(env.WP_SESSIONSTART_RESUME_MAX_EVENTS, 16),
             });
@@ -267,6 +271,56 @@ function buildDirectLaunchWarning(input, env) {
         "</wp_launch_warning>",
     ].join("\n");
 }
+/**
+ * Seed session-memory with a real host session id so `wp session-info` works
+ * under Grok (and similar hosts) before any Edit/Write tool capture. Fail-open:
+ * storage errors never break SessionStart stdout.
+ */
+export function seedSessionIdentityCapture(input, projectDir, env, deps = {}) {
+    const sessionId = resolveHookSessionId(input, env);
+    if (!sessionId)
+        return;
+    try {
+        const dbPath = deps.dbPath ?? resolveSessionMemoryDbPath(projectDir, env);
+        mkdirSync(dirname(dbPath), { recursive: true });
+        const store = deps.createStore?.(dbPath) ?? new SessionMemorySessionStore(dbPath);
+        try {
+            // Match `readCurrentSessionId` (computeRepoHash), not path-only hashing.
+            const repoHash = deps.repoHash?.(projectDir) ?? computeRepoHash(projectDir);
+            const event = buildContinuityEvent({
+                eventType: "session_identity",
+                toolName: "SessionStart",
+                content: `Session identity: ${sessionId}`,
+                summary: "Session identity for PR disclosure",
+                // Below RESUME_MIN_PRIORITY (50): kept for `wp session-info`, not resume inject.
+                priority: 40,
+                metadata: {
+                    source: "sessionstart-hook",
+                    hookEventName: "SessionStart",
+                    sessionStartSource: sessionStartSource(input),
+                },
+            });
+            store.captureEvent({
+                repoHash,
+                agentId: "SessionStart",
+                sessionId,
+                event: {
+                    ...event,
+                    ts: (deps.now?.() ?? new Date()).toISOString(),
+                },
+            });
+        }
+        finally {
+            store.close();
+        }
+    }
+    catch (error) {
+        deps.onStorageError?.(error);
+        if (env.WP_SESSIONSTART_DEBUG === "1") {
+            process.stderr.write(`wp-sessionstart-identity: ${error.message}\n`);
+        }
+    }
+}
 /**
  * Pure function: given a parsed input payload, a working directory, and
  * environment variables, produce the JSON string that the hook should write
@@ -277,6 +331,9 @@ function buildDirectLaunchWarning(input, env) {
  */
 export function buildOutput(input, cwd, env, deps = {}) {
     const projectDir = resolveHookProjectDir(input, cwd, env);
+    // Capture before resume read so this SessionStart can seed disclosure even
+    // when no prior events exist (Grok option-3 path).
+    seedSessionIdentityCapture(input, projectDir, env, deps);
     const target = join(projectDir, ".agent", "routing.md");
     let routingMd = null;
     try {

package/dist/esm/hooks/shared/types.d.ts

@@ -29,6 +29,16 @@ export type UpdatedInputEnvelope = {
  */
 export declare function normalizeHookToolInput(raw: Record<string, unknown>): ToolInput;
 export declare function parseToolInput(json: string): ToolInput;
+type EnvLike = Record<string, string | undefined>;
+/**
+ * Resolve a real host session id for session-memory capture / PR disclosure.
+ * Prefer stdin session fields (snake_case Claude/Codex or camelCase Grok), then
+ * Grok hook env `GROK_SESSION_ID` (documented for every Grok hook process).
+ */
+export declare function resolveHookSessionId(input: {
+    readonly session_id?: unknown;
+    readonly sessionId?: unknown;
+}, env?: EnvLike): string | undefined;
 export declare function isBashInput(input: ToolInput): boolean;
 export declare function isFileEditInput(input: ToolInput): boolean;
 export declare function isFileWriteInput(input: ToolInput): boolean;
@@ -72,3 +82,4 @@ export type DenyEnvelope = ClaudeCodexDenyEnvelope | GrokDualDenyEnvelope;
 export declare function buildDenyEnvelope(options: {
     readonly reason: string;
 }, env?: NodeJS.ProcessEnv): DenyEnvelope;
+export {};

package/dist/esm/hooks/shared/types.js

@@ -55,6 +55,27 @@ export function parseToolInput(json) {
     }
     return normalizeHookToolInput(parsed);
 }
+/**
+ * Resolve a real host session id for session-memory capture / PR disclosure.
+ * Prefer stdin session fields (snake_case Claude/Codex or camelCase Grok), then
+ * Grok hook env `GROK_SESSION_ID` (documented for every Grok hook process).
+ */
+export function resolveHookSessionId(input, env = process.env) {
+    const pick = (value) => {
+        if (typeof value !== "string")
+            return undefined;
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : undefined;
+    };
+    // Prefer snake_case when both present (Claude/Codex contract).
+    const fromInput = pick(input.session_id) ?? pick(input.sessionId);
+    if (fromInput)
+        return fromInput;
+    const fromEnv = env.GROK_SESSION_ID?.trim();
+    if (fromEnv)
+        return fromEnv;
+    return undefined;
+}
 export function isBashInput(input) {
     return "command" in (input.tool_input || {});
 }

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,50 @@ 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).
+ *
+ * Any probe failure means the root is not usable (permission, ENOSPC, bad
+ * path, …). That is intentionally broader than `createCliLogSink`, which only
+ * remaps EPERM/EACCES/EROFS so unexpected IO errors stay loud at the log layer.
+ * A failed preferred env-paths root falls back once and is memoized for the
+ * process; set `WP_STATE_ROOT` to pin an explicit location instead.
+ */
+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/dist/esm/session-memory/current-session.js

@@ -23,6 +23,8 @@ const LIVE_SESSION_ENV_KEYS = [
     "CLAUDE_SESSION_ID",
     "CLAUDE_CODE_SESSION_ID",
     "OPENCODE_SESSION_ID",
+    // Grok Build: hook processes always get this; tool children may in future builds.
+    "GROK_SESSION_ID",
     "RUNTIME_SESSION_ID",
 ];
 export function readLiveSessionIdFromEnv(env) {

package/dist/esm/session-memory/native-runtime.js

@@ -9,6 +9,7 @@ import envPaths from "env-paths";
 import lockfile from "proper-lockfile";
 import { resolveAgentKitPackageRoot } from "#cli/commands/init/package-root.js";
 import { SESSION_MEMORY_NATIVE_ADDON_FILENAME, resolveSessionMemoryNativeTarget, } from "./native-targets.js";
+import { NATIVE_WARM_LOG_CORRUPT_REBUILD, NATIVE_WARM_LOG_HIT, NATIVE_WARM_LOG_REBUILD, } from "./native-warm-markers.js";
 const requireFromHere = createRequire(import.meta.url);
 const NATIVE_WORKSPACE_DIRNAME = join("native", "session-memory-engine");
 const BUILD_PACKAGE = "session-memory-napi";
@@ -240,12 +241,12 @@ function ensureNativeModuleBuilt(options = {}) {
     const nodePath = compiledNodePath();
     const force = options.force === true;
     if (!force && !shouldRebuildNativeSessionMemoryNode(nodePath, workspaceRoot)) {
-        console.log(`[native-session-memory] warm=hit path=${nodePath} trust=${trustCachedNativeNode() ? "1" : "0"}`);
+        console.log(`[native-session-memory] ${NATIVE_WARM_LOG_HIT}${nodePath} trust=${trustCachedNativeNode() ? "1" : "0"}`);
         return nodePath;
     }
     return withNativeBuildLock(sessionMemoryNativeCacheRoot(), () => {
         if (!force && !shouldRebuildNativeSessionMemoryNode(nodePath, workspaceRoot)) {
-            console.log(`[native-session-memory] warm=hit path=${nodePath} trust=${trustCachedNativeNode() ? "1" : "0"}`);
+            console.log(`[native-session-memory] ${NATIVE_WARM_LOG_HIT}${nodePath} trust=${trustCachedNativeNode() ? "1" : "0"}`);
             return nodePath;
         }
         if (force && existsSync(nodePath)) {
@@ -256,7 +257,8 @@ function ensureNativeModuleBuilt(options = {}) {
                 // Best-effort: cargo rebuild overwrites via copyFileSync below.
             }
         }
-        console.log(`[native-session-memory] warm=${force ? "corrupt-rebuild" : "rebuild"} path=${nodePath} trust=${trustCachedNativeNode() ? "1" : "0"}`);
+        const warmMarker = force ? NATIVE_WARM_LOG_CORRUPT_REBUILD : NATIVE_WARM_LOG_REBUILD;
+        console.log(`[native-session-memory] ${warmMarker}${nodePath} trust=${trustCachedNativeNode() ? "1" : "0"}`);
         const targetDir = cargoTargetDir();
         mkdirSync(targetDir, { recursive: true });
         try {

package/dist/esm/session-memory/native-warm-markers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Grep-stable warm-path log markers for the session-memory native warm step.
+ *
+ * Emitted by `native-runtime` and classified by the Test job E1 summary greps
+ * in `.github/workflows/ci.agent-kit.yml`. YAML cannot import TS — contract
+ * tests in `src/ci/native-session-memory-cache.test.ts` pin that the workflow
+ * greps these exact substrings.
+ *
+ * Rename only with a coordinated workflow + contract-test update.
+ */
+/** Exact-hit warm log marker (`grep -q` target + runtime emit prefix). */
+export declare const NATIVE_WARM_LOG_HIT = "warm=hit path=";
+/** Source/mtime rebuild warm log marker. */
+export declare const NATIVE_WARM_LOG_REBUILD = "warm=rebuild path=";
+/** Forced corrupt-node rebuild warm log marker. */
+export declare const NATIVE_WARM_LOG_CORRUPT_REBUILD = "warm=corrupt-rebuild path=";
+/** All E1-classified warm markers (corrupt-rebuild → hit → rebuild order matches workflow). */
+export declare const NATIVE_WARM_LOG_MARKERS: readonly ["warm=corrupt-rebuild path=", "warm=hit path=", "warm=rebuild path="];

package/dist/esm/session-memory/native-warm-markers.js

@@ -0,0 +1,22 @@
+/**
+ * Grep-stable warm-path log markers for the session-memory native warm step.
+ *
+ * Emitted by `native-runtime` and classified by the Test job E1 summary greps
+ * in `.github/workflows/ci.agent-kit.yml`. YAML cannot import TS — contract
+ * tests in `src/ci/native-session-memory-cache.test.ts` pin that the workflow
+ * greps these exact substrings.
+ *
+ * Rename only with a coordinated workflow + contract-test update.
+ */
+/** Exact-hit warm log marker (`grep -q` target + runtime emit prefix). */
+export const NATIVE_WARM_LOG_HIT = "warm=hit path=";
+/** Source/mtime rebuild warm log marker. */
+export const NATIVE_WARM_LOG_REBUILD = "warm=rebuild path=";
+/** Forced corrupt-node rebuild warm log marker. */
+export const NATIVE_WARM_LOG_CORRUPT_REBUILD = "warm=corrupt-rebuild path=";
+/** All E1-classified warm markers (corrupt-rebuild → hit → rebuild order matches workflow). */
+export const NATIVE_WARM_LOG_MARKERS = [
+    NATIVE_WARM_LOG_CORRUPT_REBUILD,
+    NATIVE_WARM_LOG_HIT,
+    NATIVE_WARM_LOG_REBUILD,
+];

package/dist/esm/session-memory/sync/types.d.ts

@@ -48,6 +48,7 @@ export declare const shareContinuityEventV1: z.ZodObject<{
         helper_waiting: "helper_waiting";
         rejected_approach: "rejected_approach";
         rule_snapshot: "rule_snapshot";
+        session_identity: "session_identity";
         tool_command: "tool_command";
         tool_edit: "tool_edit";
         tool_read: "tool_read";
@@ -81,6 +82,7 @@ export declare const shareAgentRunDeltaV1: z.ZodObject<{
             helper_waiting: "helper_waiting";
             rejected_approach: "rejected_approach";
             rule_snapshot: "rule_snapshot";
+            session_identity: "session_identity";
             tool_command: "tool_command";
             tool_edit: "tool_edit";
             tool_read: "tool_read";
@@ -119,6 +121,7 @@ export declare const localAgentRunDeltaEnvelopeV1: z.ZodObject<{
                 helper_waiting: "helper_waiting";
                 rejected_approach: "rejected_approach";
                 rule_snapshot: "rule_snapshot";
+                session_identity: "session_identity";
                 tool_command: "tool_command";
                 tool_edit: "tool_edit";
                 tool_read: "tool_read";
@@ -155,6 +158,7 @@ export declare const sessionShareEnvelopeV1: z.ZodObject<{
                 helper_waiting: "helper_waiting";
                 rejected_approach: "rejected_approach";
                 rule_snapshot: "rule_snapshot";
+                session_identity: "session_identity";
                 tool_command: "tool_command";
                 tool_edit: "tool_edit";
                 tool_read: "tool_read";

package/dist/esm/session-memory/types.d.ts

@@ -23,7 +23,9 @@ export interface SessionMemorySearchResult extends IndexedSessionMemoryChunk {
     score: number;
     tier: "porter" | "trigram" | "levenshtein";
 }
-export declare const SESSION_CONTINUITY_EVENT_TYPES: readonly ["user_prompt", "decision", "constraint", "tool_read", "tool_edit", "tool_command", "failure", "rejected_approach", "assistant_turn_summary", "compaction_boundary", "rule_snapshot", "helper_selected", "helper_started", "helper_waiting", "helper_completed", "helper_failed", "helper_returned"];
+export declare const SESSION_CONTINUITY_EVENT_TYPES: readonly ["user_prompt", "decision", "constraint", "tool_read", "tool_edit", "tool_command", "failure", "rejected_approach", "assistant_turn_summary", "compaction_boundary", "rule_snapshot", 
+/** SessionStart seed so `wp session-info` can resolve a real host session id. */
+"session_identity", "helper_selected", "helper_started", "helper_waiting", "helper_completed", "helper_failed", "helper_returned"];
 export type SessionContinuityEventType = (typeof SESSION_CONTINUITY_EVENT_TYPES)[number];
 /**
  * Optional dashboard identity carried in continuity-event metadata.  It keeps

package/dist/esm/session-memory/types.js

@@ -10,6 +10,8 @@ export const SESSION_CONTINUITY_EVENT_TYPES = [
     "assistant_turn_summary",
     "compaction_boundary",
     "rule_snapshot",
+    /** SessionStart seed so `wp session-info` can resolve a real host session id. */
+    "session_identity",
     "helper_selected",
     "helper_started",
     "helper_waiting",

package/dist/esm/ultragoal/runtime.js

@@ -2,8 +2,9 @@ import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { runQaCommand } from "#cli/commands/qa.js";
-import { validateTrackedReviewProvenance } from "#lifecycle/review-provenance.js";
+import { collectV2ReviewProvenance, validateTrackedReviewProvenance, } from "#lifecycle/review-provenance.js";
 import { evaluateRequiredChecks } from "#mcp/tools/_shared/required-checks.js";
+import { createDeliverySubjectAtRef, createPlanSubjectAtRef } from "#review/subject.js";
 import { scanBlueprintDirectory } from "#service/scanner.js";
 import { resolveBlueprintRoot } from "#utils/blueprint-root.js";
 import matter from "gray-matter";
@@ -105,6 +106,11 @@ async function collectPrProbe(cwd) {
 function hasRequiredGreenChecks(checks) {
     return evaluateRequiredChecks(checks).green;
 }
+/**
+ * Validation needs two distinct reviewers bound to the current ultragoal source
+ * snapshot. Prefer legacy frontmatter+reviews.md; fall back to current v2 plan +
+ * delivery authorities (distinct lanes) when their subjects still match HEAD.
+ */
 function collectValidationEvidence(cwd, blueprintSlugs, sourceSnapshot) {
     const entries = scanBlueprintDirectory({
         baseDir: resolveBlueprintRoot(cwd),
@@ -115,7 +121,43 @@ function collectValidationEvidence(cwd, blueprintSlugs, sourceSnapshot) {
         if (!entry)
             return undefined;
         const approvals = matter(readFileSync(entry.path, "utf8")).data.approvals;
-        return validateTrackedReviewProvenance(entry.path, approvals, { sourceSnapshot });
+        const legacy = validateTrackedReviewProvenance(entry.path, approvals, { sourceSnapshot });
+        if (legacy.valid)
+            return legacy;
+        const stableSlug = slug.includes("/") ? (slug.split("/").pop() ?? slug) : slug;
+        let deliveryDigest;
+        let planDigest;
+        try {
+            deliveryDigest = createDeliverySubjectAtRef(cwd, "HEAD", stableSlug).digest;
+            planDigest = createPlanSubjectAtRef(cwd, "HEAD", stableSlug).digest;
+        }
+        catch {
+            return undefined;
+        }
+        const bind = (records) => records.map((record) => ({
+            reviewer: record.reviewer,
+            artifact: record.artifact,
+            sourceSnapshot,
+            targetHash: record.targetHash,
+        }));
+        const delivery = bind(collectV2ReviewProvenance(entry.path, "delivery", "HEAD").filter((record) => record.targetHash === deliveryDigest));
+        const plan = bind(collectV2ReviewProvenance(entry.path, "plan", "HEAD").filter((record) => record.targetHash === planDigest));
+        // Prefer delivery as code-review lane; plan as verify/architecture lane.
+        const byReviewer = new Map();
+        for (const record of [...plan, ...delivery]) {
+            byReviewer.set(record.reviewer, record);
+        }
+        const v2Records = [...byReviewer.values()];
+        const distinctReviewers = [...new Set(v2Records.map((record) => record.reviewer))];
+        const distinctArtifacts = [...new Set(v2Records.map((record) => record.artifact))];
+        return {
+            distinctArtifacts,
+            distinctReviewers,
+            records: v2Records,
+            valid: v2Records.length >= 2 &&
+                distinctReviewers.length === v2Records.length &&
+                distinctArtifacts.length === v2Records.length,
+        };
     });
     if (evaluations.some((evaluation) => evaluation?.valid !== true))
         return undefined;