portable-agent-layer 0.39.0 → 0.41.0

package/src/cli/index.ts

@@ -22,6 +22,8 @@ import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
+import { inference, previewInferenceRoute } from "../hooks/lib/inference";
+import { DEBUG_LOG_MAX_ROTATED } from "../hooks/lib/log";
 import { palHome, palPkg, platform } from "../hooks/lib/paths";
 import { hasRealContent, SETUP_STEPS, STEP_ORDER } from "../hooks/lib/setup";
 import { log } from "../targets/lib";
@@ -167,9 +169,13 @@ async function runCli(command: string | undefined, args: string[]) {
     case "status":
       await status();
       break;
-    case "doctor":
+    case "doctor": {
       doctor();
+      if (args.includes("--probe-inference") || args.includes("--probe")) {
+        await probeInference();
+      }
       break;
+    }
     case "migrate": {
       const { runMigrate } = await import("./migrate");
       runMigrate(args);
@@ -217,7 +223,7 @@ function showHelp() {
     pal cli export [path] [--dry-run]       Export state to zip
     pal cli import [path] [--dry-run]       Import state from zip
     pal cli status                          Show PAL configuration
-    pal cli doctor                          Check prerequisites and health
+    pal cli doctor [--probe-inference]      Check prerequisites and health (--probe fires real inference per route)
     pal cli migrate [--list] [--dry-run]    Run pending data migrations
     pal cli usage                           Summarize token usage and cost
 
@@ -385,6 +391,136 @@ function checkCopilotInstructionsPresent(): boolean {
   return existsSync(resolve(platform.copilotDir(), "copilot-instructions.md"));
 }
 
+// ── Install integrity (Tier 2 doctor checks) ──
+
+/** Recursively collect every `command` or `bash` field value in a hook-config JSON. */
+function extractAllHookCommands(obj: unknown, out: string[] = []): string[] {
+  if (Array.isArray(obj)) {
+    for (const item of obj) extractAllHookCommands(item, out);
+  } else if (obj && typeof obj === "object") {
+    for (const [k, v] of Object.entries(obj)) {
+      if ((k === "command" || k === "bash") && typeof v === "string") {
+        out.push(v);
+      } else {
+        extractAllHookCommands(v, out);
+      }
+    }
+  }
+  return out;
+}
+
+interface HookPrefixCheck {
+  ok: boolean;
+  total: number;
+  missing: number;
+  firstMissing?: string;
+}
+
+/** Verify every command in an installed hook file starts with `PAL_AGENT=<agent>`. */
+function checkAgentHookPrefix(filePath: string, agentName: string): HookPrefixCheck {
+  if (!existsSync(filePath)) return { ok: false, total: 0, missing: 0 };
+  try {
+    const data = JSON.parse(readFileSync(filePath, "utf-8"));
+    const commands = extractAllHookCommands(data);
+    const prefix = `PAL_AGENT=${agentName} `;
+    const missing = commands.filter((c) => !c.startsWith(prefix));
+    return {
+      ok: commands.length > 0 && missing.length === 0,
+      total: commands.length,
+      missing: missing.length,
+      firstMissing: missing[0]?.slice(0, 80),
+    };
+  } catch {
+    return { ok: false, total: 0, missing: 0 };
+  }
+}
+
+interface FreshnessCheck {
+  ok: boolean;
+  reason?: string;
+}
+
+/**
+ * Verify the installed opencode plugin is at least as new as the source. Catches
+ * the "stale install" failure mode we hit live — plugin file is a copy, not a
+ * symlink, so source edits don't reach the running opencode until reinstall.
+ */
+/**
+ * Probe every supported agent route with a tiny real inference call.
+ * Sequential (concurrent multi-CLI spawns trigger the empty-abort race we
+ * already mitigate but don't want to invite). Each probe temporarily sets
+ * PAL_AGENT then restores; doesn't pollute user shell.
+ *
+ * Triggered by `pal cli doctor --probe-inference` (opt-in: costs tokens).
+ */
+async function probeInference(): Promise<void> {
+  console.log("");
+  log.info("Inference probe (live calls, ~5-60s each)");
+  const green = "\x1b[32m";
+  const red = "\x1b[31m";
+  const yellow = "\x1b[33m";
+  const dim = "\x1b[90m";
+  const reset = "\x1b[0m";
+  const agents = ["claude", "codex", "opencode", "copilot", "cursor"] as const;
+  const savedAgent = process.env.PAL_AGENT;
+  try {
+    for (const agent of agents) {
+      process.env.PAL_AGENT = agent;
+      const preview = previewInferenceRoute();
+      const tag = `${agent.padEnd(10)} → ${preview.route.padEnd(15)}`;
+      if (preview.route === "none") {
+        console.log(`  ${dim}-${reset} ${tag} ${dim}(skip: ${preview.reason})${reset}`);
+        continue;
+      }
+      if (preview.route === "disabled") {
+        console.log(`  ${yellow}⚠${reset} ${tag} ${dim}${preview.reason}${reset}`);
+        continue;
+      }
+      const start = Date.now();
+      const r = await inference({
+        user: "Reply with exactly: OK",
+        system: "Reply in 3 words or fewer.",
+        caller: "doctor-probe",
+        timeout: 60_000,
+      });
+      const elapsedMs = Date.now() - start;
+      if (r.success) {
+        const bytes = r.output?.length ?? 0;
+        console.log(
+          `  ${green}✓${reset} ${tag} ${String(elapsedMs).padStart(6)}ms  bytes=${bytes}`
+        );
+      } else {
+        console.log(
+          `  ${red}✗${reset} ${tag} ${String(elapsedMs).padStart(6)}ms  ${dim}failed — see ~/.pal/memory/state/debug.log${reset}`
+        );
+      }
+    }
+  } finally {
+    if (savedAgent === undefined) delete process.env.PAL_AGENT;
+    else process.env.PAL_AGENT = savedAgent;
+  }
+}
+
+function checkOpencodePluginFresh(): FreshnessCheck {
+  const installedPath = resolve(platform.opencodeDir(), "plugins", "pal-plugin.ts");
+  const sourcePath = resolve(palPkg(), "src", "targets", "opencode", "plugin.ts");
+  if (!existsSync(installedPath))
+    return { ok: false, reason: "installed plugin missing" };
+  if (!existsSync(sourcePath)) return { ok: true }; // can't compare; assume installed is fine
+  try {
+    const installedMtime = statSync(installedPath).mtimeMs;
+    const sourceMtime = statSync(sourcePath).mtimeMs;
+    if (installedMtime >= sourceMtime) return { ok: true };
+    const ageMin = Math.round((sourceMtime - installedMtime) / 60000);
+    return {
+      ok: false,
+      reason: `source is ${ageMin}m newer than installed — run 'pal cli install --opencode'`,
+    };
+  } catch {
+    return { ok: true };
+  }
+}
+
 function playwrightBrowsersPath(): string {
   if (process.env.PLAYWRIGHT_BROWSERS_PATH) return process.env.PLAYWRIGHT_BROWSERS_PATH;
   const home = homedir();
@@ -437,12 +573,24 @@ function nodeInstallHint(): string {
 }
 
 function checkHookHealth(home: string): HookHealth {
-  const logPath = resolve(home, "memory", "state", "debug.log");
+  const stateDir = resolve(home, "memory", "state");
+  // Read current + all rotated logs (`.1`..`.5`) + legacy `.prev` so a recent
+  // rotation doesn't make the 24h window appear empty.
+  const candidates = [
+    resolve(stateDir, "debug.log"),
+    resolve(stateDir, "debug.log.prev"),
+    ...Array.from({ length: DEBUG_LOG_MAX_ROTATED }, (_, i) =>
+      resolve(stateDir, `debug.log.${i + 1}`)
+    ),
+  ];
 
   try {
-    if (!existsSync(logPath)) return { totalErrors: 0, lastError: null };
+    let content = "";
+    for (const path of candidates) {
+      if (existsSync(path)) content += `${readFileSync(path, "utf-8")}\n`;
+    }
+    if (!content) return { totalErrors: 0, lastError: null };
 
-    const content = readFileSync(logPath, "utf-8");
     const lines = content.split("\n").filter((l) => l.includes("] ERROR "));
 
     // Filter to last 24h
@@ -516,9 +664,10 @@ function doctor(silent = false): DoctorResult {
     const ok = (msg: string) => console.log(`  \x1b[32m\u2713\x1b[0m ${msg}`);
     const warn = (msg: string) => console.log(`  \x1b[33m\u26A0\x1b[0m ${msg}`);
     const fail = (msg: string) => console.log(`  \x1b[31m\u2717\x1b[0m ${msg}`);
+    const info = (msg: string) => console.log(`  \x1b[90m\u00B7\x1b[0m ${msg}`);
 
     console.log("");
-    log.info("Doctor");
+    log.info("Prerequisites");
     ok(`Bun ${bun.version}`);
     const node = checkNode();
     if (!node.available) {
@@ -547,6 +696,14 @@ function doctor(silent = false): DoctorResult {
     codex.available
       ? ok(`Codex ${codex.version || ""}`.trim())
       : fail("Codex — not found");
+    checkPlaywrightChromium()
+      ? ok("Playwright Chromium installed")
+      : fail(
+          "Playwright Chromium — not found (run 'pal cli install' or 'bunx playwright install chromium')"
+        );
+
+    console.log("");
+    log.info("PAL state");
     ok(`PAL home: ${home}`);
     telosCount > 0 ? ok(`TELOS: ${telosCount} files`) : fail("TELOS: not scaffolded");
 
@@ -591,7 +748,15 @@ function doctor(silent = false): DoctorResult {
           );
     }
 
+    // Dependencies (PAL's own npm packages)
+    const nodeModulesPath = resolve(palPkg(), "node_modules");
+    existsSync(nodeModulesPath)
+      ? ok("Dependencies installed")
+      : fail("Dependencies missing — run 'pal cli install'");
+
     // Skills (per installed agent)
+    console.log("");
+    log.info("Skills");
     const countSkillsIn = (dir: string) =>
       existsSync(dir)
         ? readdirSync(dir).filter((f) => existsSync(resolve(dir, f, "SKILL.md"))).length
@@ -627,20 +792,9 @@ function doctor(silent = false): DoctorResult {
         : warn("Codex skills — none found (run 'pal cli install --codex')");
     }
 
-    // Dependencies
-    const nodeModulesPath = resolve(palPkg(), "node_modules");
-    existsSync(nodeModulesPath)
-      ? ok("Dependencies installed")
-      : fail("Dependencies missing — run 'pal cli install'");
-
-    // Playwright Chromium (required by create-pdf + consulting-report skills)
-    checkPlaywrightChromium()
-      ? ok("Playwright Chromium installed")
-      : fail(
-          "Playwright Chromium — not found (run 'pal cli install' or 'bunx playwright install chromium')"
-        );
-
     // Hook registration (per installed agent)
+    console.log("");
+    log.info("Hooks");
     if (claude.available) {
       checkClaudeHooksRegistered()
         ? ok("Claude Code hooks registered")
@@ -670,10 +824,116 @@ function doctor(silent = false): DoctorResult {
         : fail("Codex hooks — not registered (run 'pal cli install --codex')");
     }
 
-    // API key checks
+    // Install integrity — verify PAL_AGENT prefix on every command in installed
+    // hook files. Catches stale installs after template changes (the exact bug
+    // we hit live for opencode + copilot). opencode uses a plugin file instead
+    // of a hooks.json, so it gets a separate freshness check.
+    console.log("");
+    log.info("Install integrity");
+    const prefixCheck = (
+      filePath: string,
+      agentName: string,
+      installCmd: string
+    ): void => {
+      const r = checkAgentHookPrefix(filePath, agentName);
+      if (r.ok) {
+        ok(`${agentName}: PAL_AGENT=${agentName} on all ${r.total} hook commands`);
+      } else if (r.total === 0) {
+        fail(`${agentName}: hook file missing or unreadable at ${filePath}`);
+      } else {
+        fail(
+          `${agentName}: ${r.missing}/${r.total} hook commands missing PAL_AGENT=${agentName} prefix (run '${installCmd}')`
+        );
+        if (r.firstMissing) {
+          log.warn(`    First offender: ${r.firstMissing}…`);
+        }
+      }
+    };
+    if (claude.available) {
+      prefixCheck(
+        resolve(platform.claudeDir(), "settings.json"),
+        "claude",
+        "pal cli install --claude"
+      );
+    }
+    if (cursor.available) {
+      prefixCheck(
+        resolve(platform.cursorDir(), "hooks.json"),
+        "cursor",
+        "pal cli install --cursor"
+      );
+    }
+    if (copilot.available) {
+      prefixCheck(
+        resolve(platform.copilotDir(), "hooks", "pal-hooks.json"),
+        "copilot",
+        "pal cli install --copilot"
+      );
+    }
+    if (codex.available) {
+      prefixCheck(
+        resolve(platform.codexDir(), "hooks.json"),
+        "codex",
+        "pal cli install --codex"
+      );
+    }
+    if (opencode.available) {
+      const fresh = checkOpencodePluginFresh();
+      fresh.ok
+        ? ok("opencode plugin: source-and-installed in sync")
+        : fail(`opencode plugin: ${fresh.reason}`);
+    }
+
+    // Inference routing preview — what `inference()` would do RIGHT NOW
+    console.log("");
+    log.info("Inference");
+    {
+      const preview = previewInferenceRoute();
+      console.log(`  → Active agent: ${preview.agent}`);
+      if (preview.route === "none") {
+        fail(`Would route to: NONE — ${preview.reason}`);
+      } else if (preview.route === "disabled") {
+        warn(`Would route to: DISABLED — ${preview.reason}`);
+      } else if (preview.route.endsWith("-api")) {
+        warn(`Would route to: ${preview.route} (${preview.reason})`);
+      } else {
+        ok(`Would route to: ${preview.route} (${preview.reason})`);
+      }
+    }
+    if (process.env.PAL_INFERENCE_DISABLED === "1") {
+      warn(
+        "PAL_INFERENCE_DISABLED=1 — test kill-switch leaked into prod env; every inference call will return failure"
+      );
+    } else {
+      ok("PAL_INFERENCE_DISABLED is not set (production-safe)");
+    }
+
+    // Spawn-guard env vars should never appear in the user's shell — they're
+    // set ONLY in PAL-spawned subprocesses. Leaks into the user shell cause
+    // every inference call to short-circuit silently.
+    if (process.env.PAL_SPAWNED_INFERENCE) {
+      fail(
+        `PAL_SPAWNED_INFERENCE=${process.env.PAL_SPAWNED_INFERENCE} leaked into shell — every inference call will refuse. Unset it.`
+      );
+    } else {
+      ok("PAL_SPAWNED_INFERENCE not leaked (recursion guard clean)");
+    }
+    if (process.env.PAL_INFERENCE_DEPTH) {
+      fail(
+        `PAL_INFERENCE_DEPTH=${process.env.PAL_INFERENCE_DEPTH} leaked into shell — depth circuit-breaker will fire. Unset it.`
+      );
+    } else {
+      ok("PAL_INFERENCE_DEPTH not leaked (depth counter clean)");
+    }
+
+    // API key checks — both are optional safety-net fallbacks. Unset is normal
+    // for CLI-only setups; only matters if your native CLI breaks.
     process.env.PAL_ANTHROPIC_API_KEY
-      ? ok("PAL_ANTHROPIC_API_KEY is set")
-      : fail("PAL_ANTHROPIC_API_KEY — not set (hooks need it for inference)");
+      ? ok("PAL_ANTHROPIC_API_KEY set (anthropic-api fallback available)")
+      : info("PAL_ANTHROPIC_API_KEY unset (optional — anthropic-api fallback off)");
+    process.env.PAL_OPENAI_API_KEY
+      ? ok("PAL_OPENAI_API_KEY set (openai-api fallback for codex available)")
+      : info("PAL_OPENAI_API_KEY unset (optional — openai-api fallback off)");
     process.env.PAL_GEMINI_API_KEY
       ? ok("PAL_GEMINI_API_KEY is set")
       : warn("PAL_GEMINI_API_KEY — not set (optional, for YouTube analysis)");

package/src/cli/migrate.ts

@@ -14,8 +14,8 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { paths } from "../hooks/lib/paths";
 import {
+  legacyJsonToProgress,
   type ProjectProgress,
-  type ProjectStatus,
   readAllProjects,
   readProject,
   writeProject,
@@ -39,26 +39,6 @@ interface Migration {
 
 // ── v1-projects: JSON progress files → ISA.md ─────────────────────
 
-interface LegacyDecision {
-  ts: string;
-  decision: string;
-  rationale: string;
-}
-
-interface LegacyProject {
-  name: string;
-  path: string;
-  status: ProjectStatus;
-  created: string;
-  updated: string;
-  facts?: string[];
-  objectives?: string[];
-  next_steps?: string[];
-  blockers?: string[];
-  handoff?: string;
-  decisions?: LegacyDecision[];
-}
-
 function pendingJsonFiles(): string[] {
   const progressDir = paths.progress();
   if (!existsSync(progressDir)) return [];
@@ -92,37 +72,14 @@ const v1Projects: Migration = {
       const filePath = resolve(progressDir, file);
 
       try {
-        const raw = JSON.parse(readFileSync(filePath, "utf-8")) as LegacyProject;
-        if (!raw?.name || !raw?.path || !raw?.status) {
+        const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+        const p = legacyJsonToProgress(raw);
+        if (!p) {
           skipped++;
           results.push(`${slug}: skipped (malformed JSON)`);
           continue;
         }
-
-        if (!dryRun) {
-          const p: ProjectProgress = {
-            name: raw.name,
-            path: raw.path,
-            status: raw.status,
-            created: raw.created ?? new Date().toISOString(),
-            updated: raw.updated ?? new Date().toISOString(),
-            ...(raw.handoff ? { handoff: raw.handoff } : {}),
-            ...(raw.next_steps?.length ? { next: raw.next_steps } : {}),
-            ...(raw.blockers?.length ? { blockers: raw.blockers } : {}),
-          };
-
-          if (raw.facts?.length) p.context = raw.facts.join("\n");
-          if (raw.objectives?.length)
-            p.goal = raw.objectives.map((o) => `- ${o}`).join("\n");
-          if (raw.decisions?.length) {
-            p.decisions = raw.decisions
-              .map((d) => `- ${d.ts.slice(0, 10)}: ${d.decision} (${d.rationale})`)
-              .join("\n");
-          }
-
-          writeProject(p);
-        }
-
+        if (!dryRun) writeProject(p);
         migrated++;
         results.push(`${slug}: ${dryRun ? "would migrate" : "migrated"} (source kept)`);
       } catch {

package/src/hooks/CompactRecover.ts

@@ -14,8 +14,12 @@ import { resolve } from "node:path";
 import { isCursor } from "./lib/agent";
 import { logDebug, logError } from "./lib/log";
 import { paths } from "./lib/paths";
+import { isPalSpawnedInference } from "./lib/spawn-guard";
 import { readStdinJSON } from "./lib/stdin";
 
+// Recursion guard — spawned subprocesses don't compact, so nothing to recover.
+if (isPalSpawnedInference()) process.exit(0);
+
 interface SessionStartInput {
   session_id?: string;
   hook_event_name?: string;

package/src/hooks/LoadContext.ts

@@ -11,10 +11,16 @@
 
 import { mkdirSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
+import { getActiveAgent, isCodex, isCopilot, isCursor } from "./lib/agent";
 import { buildClaudeMd, regenerateIfNeeded } from "./lib/claude-md";
 import { type AgentTarget, buildSystemReminder } from "./lib/context";
 import { logDebug, logError } from "./lib/log";
 import { platform } from "./lib/paths";
+import { isPalSpawnedInference } from "./lib/spawn-guard";
+
+// Recursion guard — when this process is a PAL-spawned inference subprocess,
+// skip all context loading so we don't trigger another inference call.
+if (isPalSpawnedInference()) process.exit(0);
 
 // --- Skip heavy context for subagents ---
 const isSubagent =
@@ -37,14 +43,13 @@ try {
 // --- Context to stdout (or file for Copilot) ---
 try {
   // Determine agent target — controls which sections are skipped (loaded natively instead).
-  let agent: AgentTarget = "claude";
-  if (process.env.PAL_AGENT === "copilot") agent = "copilot";
-  else if (process.env.PAL_AGENT === "cursor" || process.env.CURSOR_VERSION)
-    agent = "cursor";
+  const active = getActiveAgent();
+  const agent: AgentTarget =
+    active === "copilot" || active === "cursor" ? active : "claude";
   const reminder = buildSystemReminder({ agent });
   if (!reminder) process.exit(0);
 
-  if (process.env.PAL_AGENT === "copilot") {
+  if (isCopilot()) {
     // Copilot: semi-static in ~/.copilot/instructions/pal-*.instructions.md (written at stop).
     // Write AGENTS.md + dynamic context to pal-session.instructions.md on each session start.
     const instructionsDir = resolve(platform.copilotDir(), "instructions");
@@ -62,13 +67,13 @@ try {
       "LoadContext",
       `Copilot session instructions written: ${context.length} chars`
     );
-  } else if (process.env.PAL_AGENT === "cursor" || process.env.CURSOR_VERSION) {
+  } else if (isCursor()) {
     // Cursor: semi-static in ~/.cursor/rules/pal-context.mdc; inject AGENTS.md + dynamic here
     const agentsMd = buildClaudeMd();
     const context = [agentsMd, reminder].filter(Boolean).join("\n\n");
     process.stdout.write(JSON.stringify({ additional_context: context }));
     logDebug("LoadContext", `Reminder injected: ${reminder.length} chars`);
-  } else if (process.env.PAL_AGENT === "codex") {
+  } else if (isCodex()) {
     // Codex: AGENTS.md already loaded via symlink; inject only dynamic context
     process.stdout.write(
       JSON.stringify({
@@ -80,7 +85,7 @@ try {
     );
     logDebug("LoadContext", `Codex reminder injected: ${reminder.length} chars`);
   } else {
-    // Claude Code: raw text
+    // Claude Code (and opencode, which uses the plugin path not this hook): raw text
     console.log(reminder);
     logDebug("LoadContext", `Reminder injected: ${reminder.length} chars`);
   }

package/src/hooks/PreCompactPersist.ts

@@ -17,9 +17,13 @@ import { resolve } from "node:path";
 import { persistLastExchange } from "./handlers/persist-last-exchange";
 import { logDebug, logError } from "./lib/log";
 import { paths } from "./lib/paths";
+import { isPalSpawnedInference } from "./lib/spawn-guard";
 import { readStdinJSON } from "./lib/stdin";
 import { readTranscriptFile } from "./lib/transcript";
 
+// Recursion guard — spawned subprocesses don't compact, so nothing to persist.
+if (isPalSpawnedInference()) process.exit(0);
+
 interface PreCompactInput {
   session_id?: string;
   transcript_path?: string;

package/src/hooks/StopOrchestrator.ts

@@ -9,14 +9,22 @@
 import { checkReadmeSync } from "./handlers/readme-sync";
 import { isCodex, isCursor } from "./lib/agent";
 import { logError } from "./lib/log";
+import { isPalSpawnedInference } from "./lib/spawn-guard";
 import { readStdinJSON } from "./lib/stdin";
 import { runStopHandlers } from "./lib/stop";
 import { readTranscriptFile } from "./lib/transcript";
 
+// Recursion guard — spawned inference subprocesses must not record session
+// learning, ratings, or handoffs from their throwaway transcript.
+if (isPalSpawnedInference()) process.exit(0);
+
 interface StopHookInput {
-  session_id: string;
-  transcript_path: string;
+  session_id?: string;
+  sessionId?: string; // Copilot uses camelCase
+  transcript_path?: string;
+  transcriptPath?: string; // Copilot uses camelCase
   last_assistant_message?: string;
+  lastAssistantMessage?: string; // Copilot uses camelCase
 }
 
 // Check README sync before anything else — may block the session
@@ -40,18 +48,22 @@ try {
 }
 
 const input = await readStdinJSON<StopHookInput>();
-if (!input?.transcript_path) {
+const transcriptPath = input?.transcript_path ?? input?.transcriptPath;
+const sessionId = input?.session_id ?? input?.sessionId;
+const lastAssistant = input?.last_assistant_message ?? input?.lastAssistantMessage;
+
+if (!transcriptPath) {
   logError("StopOrchestrator", "No transcript_path in hook input");
   process.exit(0);
 }
 
 // Read the actual transcript from the file on disk
-const messages = readTranscriptFile(input.transcript_path);
+const messages = readTranscriptFile(transcriptPath);
 if (messages.length < 2) process.exit(0);
 
 // Serialize and run handlers
 const transcript = JSON.stringify(messages);
 await runStopHandlers(transcript, {
-  lastAssistantMessage: input.last_assistant_message,
-  sessionId: input.session_id,
+  lastAssistantMessage: lastAssistant,
+  sessionId,
 });

package/src/hooks/UserPromptOrchestrator.ts

@@ -11,11 +11,17 @@ import { injectRetrieval } from "./handlers/inject-retrieval";
 import { captureRating } from "./handlers/rating";
 import { captureSessionName } from "./handlers/session-name";
 import { logDebug, logError } from "./lib/log";
+import { isPalSpawnedInference } from "./lib/spawn-guard";
 import { readStdinJSON } from "./lib/stdin";
 
+// Recursion guard — the "prompt" inside a spawned inference is the dispatcher's
+// payload, not a real user message. Skip rating capture, session naming, etc.
+if (isPalSpawnedInference()) process.exit(0);
+
 interface PromptSubmitInput {
   prompt: string;
   session_id?: string;
+  sessionId?: string; // Copilot sends this (camelCase) instead of session_id
   conversation_id?: string; // Cursor sends this instead of session_id
 }
 
@@ -23,7 +29,7 @@ const input = await readStdinJSON<PromptSubmitInput>();
 logDebug("UserPromptOrchestrator", `Input: ${JSON.stringify(input).slice(0, 200)}`);
 if (!input?.prompt) process.exit(0);
 
-const sessionId = input.session_id ?? input.conversation_id;
+const sessionId = input.session_id ?? input.sessionId ?? input.conversation_id;
 const results = await Promise.allSettled([
   captureRating(input.prompt, sessionId),
   captureSessionName(input.prompt, sessionId ?? ""),

package/src/hooks/handlers/auto-graduate.ts

@@ -96,6 +96,7 @@ interface AutoGraduateResult {
  * Returns a summary of what happened so callers (handler, tests) can reason
  * about the run without re-reading state.
  */
+/** @lintignore — consumed by test/auto-graduate.test.ts via dynamic import */
 export async function autoGraduate(
   opts: AutoGraduateOptions = {}
 ): Promise<AutoGraduateResult> {
@@ -167,3 +168,10 @@ export async function autoGraduate(
   }
   return result;
 }
+
+// Detached child entry point — runs the full autoGraduate cycle in isolation
+// so the parent Stop hook does not block on the inference step.
+if (process.argv[2] === "--run") {
+  await autoGraduate();
+  process.exit(0);
+}