bopodev-agent-sdk 0.1.9 → 0.1.11

package/src/runtime.ts

@@ -5,6 +5,35 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { AgentRuntimeConfig } from "./types";
 
+type LocalProvider = "claude_code" | "codex" | "cursor" | "opencode";
+type ClaudeContractDiagnostics = {
+  commandOverride: boolean;
+  commandLooksClaude: boolean;
+  commandWasProviderAlias: boolean;
+  hasPromptFlag: boolean;
+  hasOutputFormatJson: boolean;
+  outputFormat: string | null;
+  hasMaxTurnsFlag: boolean;
+  hasVerboseFlag: boolean;
+  hasDangerouslySkipPermissions: boolean;
+  hasJsonSchema: boolean;
+  missingRequiredArgs: string[];
+};
+
+type ParsedUsageRecord = {
+  tokenInput?: number;
+  tokenOutput?: number;
+  usdCost?: number;
+  summary?: string;
+};
+
+type CursorParsedStream = {
+  usage: ParsedUsageRecord;
+  sessionId?: string;
+  errorMessage?: string;
+  resultSubtype?: string;
+};
+
 export interface RuntimeExecutionOutput {
   ok: boolean;
   code: number | null;
@@ -21,6 +50,36 @@ export interface RuntimeExecutionOutput {
     usdCost?: number;
     summary?: string;
   };
+  structuredOutputSource?: "stdout" | "stderr";
+  structuredOutputDiagnostics?: {
+    stdoutJsonObjectCount: number;
+    stderrJsonObjectCount: number;
+    stderrStructuredUsageDetected: boolean;
+    stdoutBytes: number;
+    stderrBytes: number;
+    hasAnyOutput: boolean;
+    lastStdoutLine?: string;
+    lastStderrLine?: string;
+    likelyCause:
+      | "no_output_from_runtime"
+      | "json_missing"
+      | "json_on_stderr_only"
+      | "schema_or_shape_mismatch";
+    claudeStopReason?: string;
+    claudeResultSubtype?: string;
+    claudeSessionId?: string;
+    claudeContract?: ClaudeContractDiagnostics;
+  };
+  commandUsed?: string;
+  argsUsed?: string[];
+  transcript?: RuntimeTranscriptEvent[];
+}
+
+export interface RuntimeTranscriptEvent {
+  kind: "system" | "assistant" | "thinking" | "tool_call" | "tool_result" | "result" | "stderr";
+  label?: string;
+  text?: string;
+  payload?: string;
 }
 
 export interface RuntimeAttemptTrace {
@@ -50,7 +109,16 @@ function pickDefaultCommand(provider: "claude_code" | "codex") {
 
 function providerDefaultArgs(provider: "claude_code" | "codex", config?: AgentRuntimeConfig) {
   if (provider === "claude_code") {
-    return ["-p"];
+    return [
+      "--print",
+      "-",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--max-turns",
+      "8",
+      "--dangerously-skip-permissions"
+    ];
   }
   // Keep Codex non-interactive, sandboxed, and writable in-workspace by default.
   // Codex CLI rejects combining --full-auto with sandbox bypass flags.
@@ -92,6 +160,13 @@ function providerConfigArgs(provider: "claude_code" | "codex", config?: AgentRun
   return args;
 }
 
+function resolveControlPlaneEnvValue(env: NodeJS.ProcessEnv | Record<string, string> | undefined, suffix: string) {
+  if (!env) {
+    return "";
+  }
+  return String(env[`BOPODEV_${suffix}`] ?? "").trim();
+}
+
 function shouldBypassCodexSandbox(config?: AgentRuntimeConfig) {
   if (config?.runPolicy?.sandboxMode === "full_access") {
     return true;
@@ -101,16 +176,12 @@ function shouldBypassCodexSandbox(config?: AgentRuntimeConfig) {
     return false;
   }
   const hasControlPlaneContext =
-    typeof env.BOPOHQ_API_BASE_URL === "string" &&
-    env.BOPOHQ_API_BASE_URL.trim().length > 0 &&
-    typeof env.BOPOHQ_REQUEST_HEADERS_JSON === "string" &&
-    env.BOPOHQ_REQUEST_HEADERS_JSON.trim().length > 0;
+    resolveControlPlaneEnvValue(env, "API_BASE_URL").length > 0 &&
+    resolveControlPlaneEnvValue(env, "REQUEST_HEADERS_JSON").length > 0;
   if (!hasControlPlaneContext) {
     return false;
   }
-  const enforceSandbox = String(env.BOPOHQ_ENFORCE_SANDBOX ?? "")
-    .trim()
-    .toLowerCase();
+  const enforceSandbox = resolveControlPlaneEnvValue(env, "ENFORCE_SANDBOX").toLowerCase();
   if (enforceSandbox === "1" || enforceSandbox === "true") {
     return false;
   }
@@ -122,31 +193,89 @@ export async function executeAgentRuntime(
   prompt: string,
   config?: AgentRuntimeConfig
 ): Promise<RuntimeExecutionOutput> {
+  const command = resolveProviderCommand(provider, config?.command);
   const commandOverride = Boolean(config?.command && config.command.trim().length > 0);
   const effectiveRetryCount = config?.retryCount ?? (provider === "codex" ? 1 : 0);
-  const mergedArgs = [
+  const candidateArgs = [
     ...(commandOverride ? [] : providerDefaultArgs(provider, config)),
     ...(commandOverride ? [] : providerConfigArgs(provider, config)),
     ...(config?.args ?? [])
   ];
-  return executePromptRuntime(
-    config?.command ?? pickDefaultCommand(provider),
+  const mergedArgs =
+    provider === "claude_code"
+      ? ensureClaudeStructuredOutputArgs(command, candidateArgs)
+      : candidateArgs;
+  let runtime = await executePromptRuntime(
+    command,
     prompt,
-    { ...config, args: mergedArgs, retryCount: effectiveRetryCount },
     {
-      provider
+      ...config,
+      args: mergedArgs,
+      retryCount: effectiveRetryCount,
+      timeoutMs: config?.timeoutMs ?? defaultProviderTimeoutMs(provider)
+    },
+    {
+      provider,
+      claudeContract:
+        provider === "claude_code" ? inspectClaudeOutputContract(command, mergedArgs, commandOverride) : undefined
     }
   );
+  if (provider !== "claude_code") {
+    return runtime;
+  }
+
+  const maxContinuationAttempts = 2;
+  let continuationArgs = [...mergedArgs];
+  for (let continuation = 0; continuation < maxContinuationAttempts; continuation += 1) {
+    if (!runtime.ok) {
+      break;
+    }
+    if (!isClaudeMaxTurnsRuntime(runtime)) {
+      break;
+    }
+    const sessionId = runtime.structuredOutputDiagnostics?.claudeSessionId?.trim();
+    if (!sessionId) {
+      break;
+    }
+    continuationArgs = withClaudeResumeArg(continuationArgs, sessionId);
+    runtime = await executePromptRuntime(
+      command,
+      "Continue from current session and finish all remaining assigned issue steps.",
+      {
+        ...config,
+        args: continuationArgs,
+        retryCount: 0,
+        timeoutMs: config?.timeoutMs ?? defaultProviderTimeoutMs(provider)
+      },
+      {
+        provider,
+        claudeContract: inspectClaudeOutputContract(command, continuationArgs, true)
+      }
+    );
+  }
+
+  return runtime;
+}
+
+function defaultProviderTimeoutMs(provider: "claude_code" | "codex") {
+  if (provider === "claude_code") {
+    return 90 * 1000;
+  }
+  return 5 * 60 * 1000;
 }
 
 export async function executePromptRuntime(
   command: string,
   prompt: string,
   config?: AgentRuntimeConfig,
-  options?: { provider?: "claude_code" | "codex" }
+  options?: {
+    provider?: LocalProvider;
+    claudeContract?: ClaudeContractDiagnostics;
+  }
 ): Promise<RuntimeExecutionOutput> {
   const baseArgs = [...(config?.args ?? [])];
   const timeoutMs = config?.timeoutMs ?? 120_000;
+  const abortSignal = config?.abortSignal;
   const interruptGraceMs = Math.max(0, config?.interruptGraceSec ?? 2) * 1000;
   const maxAttempts = Math.max(1, Math.min(3, 1 + (config?.retryCount ?? 0)));
   const retryBackoffMs = Math.max(100, config?.retryBackoffMs ?? 400);
@@ -159,7 +288,11 @@ export async function executePromptRuntime(
   const env = providerIsolation.env;
   const provider = options?.provider;
   const injection = await prepareSkillInjection(provider, env);
-  const args = [...baseArgs, ...injection.additionalArgs, prompt];
+  const baseWithInjection = [...baseArgs, ...injection.additionalArgs];
+  const readsPromptFromStdin =
+    (provider === "claude_code" && hasCliFlagValue(baseWithInjection, "--print", "-")) ||
+    (provider === "cursor" && (baseWithInjection.includes("-p") || hasCliFlag(baseWithInjection, "--print")));
+  const args = readsPromptFromStdin ? baseWithInjection : [...baseWithInjection, prompt];
   const attempts: RuntimeAttemptTrace[] = [];
   let stdout = "";
   let stderr = injection.warning ? `${injection.warning}\n` : "";
@@ -178,10 +311,12 @@ export async function executePromptRuntime(
       const attemptResult = await executeSinglePromptAttempt(
         command,
         args,
+        readsPromptFromStdin ? prompt : undefined,
         config?.cwd || process.cwd(),
         env,
         timeoutMs,
-        interruptGraceMs
+        interruptGraceMs,
+        abortSignal
       );
       const normalizedStderr = provider === "codex" ? stripCodexRolloutNoise(attemptResult.stderr) : attemptResult.stderr;
       stdout += attemptResult.stdout;
@@ -205,6 +340,10 @@ export async function executePromptRuntime(
       };
 
       if (attemptResult.ok) {
+        const claudeStream = provider === "claude_code" ? parseClaudeStreamOutput(stdout) : undefined;
+        const cursorStream = provider === "cursor" ? parseCursorStreamOutput(stdout) : undefined;
+        const stdoutUsage = cursorStream?.usage ?? claudeStream?.usage ?? parseStructuredUsage(stdout);
+        const stderrUsage = parseStructuredUsage(stderr);
         return {
           ok: true,
           code: attemptResult.code,
@@ -214,7 +353,28 @@ export async function executePromptRuntime(
           elapsedMs: attempts.reduce((sum, item) => sum + item.elapsedMs, 0),
           attemptCount: attempts.length,
           attempts,
-          parsedUsage: parseStructuredUsage(stdout)
+          parsedUsage: stdoutUsage ?? stderrUsage,
+          structuredOutputSource: stdoutUsage ? "stdout" : stderrUsage ? "stderr" : undefined,
+          structuredOutputDiagnostics: {
+            stdoutJsonObjectCount: extractJsonObjectBlocks(stdout).length,
+            stderrJsonObjectCount: extractJsonObjectBlocks(stderr).length,
+            stderrStructuredUsageDetected: Boolean(stderrUsage),
+            stdoutBytes: Buffer.byteLength(stdout, "utf8"),
+            stderrBytes: Buffer.byteLength(stderr, "utf8"),
+            hasAnyOutput: stdout.trim().length > 0 || stderr.trim().length > 0,
+            lastStdoutLine: tailLine(stdout),
+            lastStderrLine: tailLine(stderr),
+            likelyCause: classifyStructuredOutputLikelyCause(stdout, stderr, stdoutUsage, stderrUsage),
+            ...(claudeStream?.stopReason ? { claudeStopReason: claudeStream.stopReason } : {}),
+            ...(claudeStream?.resultSubtype ? { claudeResultSubtype: claudeStream.resultSubtype } : {}),
+            ...(claudeStream?.sessionId ? { claudeSessionId: claudeStream.sessionId } : {}),
+            ...(cursorStream?.sessionId ? { cursorSessionId: cursorStream.sessionId } : {}),
+            ...(cursorStream?.errorMessage ? { cursorErrorMessage: cursorStream.errorMessage } : {}),
+            ...(options?.claudeContract ? { claudeContract: options.claudeContract } : {})
+          },
+          commandUsed: command,
+          argsUsed: args,
+          transcript: parseRuntimeTranscript(provider, stdout, stderr)
         };
       }
 
@@ -234,6 +394,10 @@ export async function executePromptRuntime(
       await sleep(retryBackoffMs * attempt);
     }
 
+    const claudeStream = provider === "claude_code" ? parseClaudeStreamOutput(stdout) : undefined;
+    const cursorStream = provider === "cursor" ? parseCursorStreamOutput(stdout) : undefined;
+    const stdoutUsage = cursorStream?.usage ?? claudeStream?.usage ?? parseStructuredUsage(stdout);
+    const stderrUsage = parseStructuredUsage(stderr);
     return {
       ok: false,
       code: lastResult?.code ?? null,
@@ -244,7 +408,28 @@ export async function executePromptRuntime(
       attemptCount: attempts.length,
       attempts,
       failureType: classifyFailure(lastResult?.timedOut ?? false, lastResult?.spawnErrorCode, lastResult?.code ?? null),
-      parsedUsage: parseStructuredUsage(stdout)
+      parsedUsage: stdoutUsage ?? stderrUsage,
+      structuredOutputSource: stdoutUsage ? "stdout" : stderrUsage ? "stderr" : undefined,
+      structuredOutputDiagnostics: {
+        stdoutJsonObjectCount: extractJsonObjectBlocks(stdout).length,
+        stderrJsonObjectCount: extractJsonObjectBlocks(stderr).length,
+        stderrStructuredUsageDetected: Boolean(stderrUsage),
+        stdoutBytes: Buffer.byteLength(stdout, "utf8"),
+        stderrBytes: Buffer.byteLength(stderr, "utf8"),
+        hasAnyOutput: stdout.trim().length > 0 || stderr.trim().length > 0,
+        lastStdoutLine: tailLine(stdout),
+        lastStderrLine: tailLine(stderr),
+        likelyCause: classifyStructuredOutputLikelyCause(stdout, stderr, stdoutUsage, stderrUsage),
+        ...(claudeStream?.stopReason ? { claudeStopReason: claudeStream.stopReason } : {}),
+        ...(claudeStream?.resultSubtype ? { claudeResultSubtype: claudeStream.resultSubtype } : {}),
+        ...(claudeStream?.sessionId ? { claudeSessionId: claudeStream.sessionId } : {}),
+        ...(cursorStream?.sessionId ? { cursorSessionId: cursorStream.sessionId } : {}),
+        ...(cursorStream?.errorMessage ? { cursorErrorMessage: cursorStream.errorMessage } : {}),
+        ...(options?.claudeContract ? { claudeContract: options.claudeContract } : {})
+      },
+      commandUsed: command,
+      argsUsed: args,
+      transcript: parseRuntimeTranscript(provider, stdout, stderr)
     };
   } finally {
     await providerIsolation.cleanup();
@@ -252,6 +437,159 @@ export async function executePromptRuntime(
   }
 }
 
+function ensureClaudeStructuredOutputArgs(command: string, args: string[]) {
+  const contract = inspectClaudeOutputContract(command, args, true);
+  if (!contract.commandLooksClaude) {
+    return args;
+  }
+  const next = [...args];
+  if (!contract.hasPromptFlag) {
+    next.push("--print", "-");
+  }
+  if (!contract.hasOutputFormatJson) {
+    next.push("--output-format", "stream-json");
+  }
+  if (contract.outputFormat === "json" && !contract.hasJsonSchema) {
+    next.push("--json-schema", CLAUDE_HEARTBEAT_OUTPUT_SCHEMA);
+  }
+  if (!contract.hasMaxTurnsFlag) {
+    next.push("--max-turns", "8");
+  }
+  if (!contract.hasVerboseFlag) {
+    next.push("--verbose");
+  }
+  if (!contract.hasDangerouslySkipPermissions) {
+    next.push("--dangerously-skip-permissions");
+  }
+  return next;
+}
+
+function inspectClaudeOutputContract(command: string, args: string[], commandOverride: boolean) {
+  const commandToken = command.trim().split(/[\\/]/).pop() ?? "";
+  const commandLooksClaude = /\bclaude(?:\.exe)?$/i.test(commandToken);
+  const commandWasProviderAlias = /^claude_code$/i.test(commandToken);
+  const hasPromptFlag = args.includes("-p") || hasCliFlagValue(args, "--print", "-");
+  const outputFormat = resolveCliFlagValue(args, "--output-format");
+  const hasOutputFormatJson = outputFormat === "json" || outputFormat === "stream-json";
+  const hasMaxTurnsFlag = hasCliFlag(args, "--max-turns");
+  const hasVerboseFlag = hasCliFlag(args, "--verbose");
+  const hasDangerouslySkipPermissions = hasCliFlag(args, "--dangerously-skip-permissions");
+  const hasJsonSchema = hasCliFlag(args, "--json-schema");
+  const missingRequiredArgs: string[] = [];
+  if (!hasPromptFlag) {
+    missingRequiredArgs.push("--print -");
+  }
+  if (!hasOutputFormatJson) {
+    missingRequiredArgs.push("--output-format stream-json");
+  }
+  if (outputFormat === "json" && !hasJsonSchema) {
+    missingRequiredArgs.push("--json-schema <heartbeat-schema>");
+  }
+  if (!hasMaxTurnsFlag) {
+    missingRequiredArgs.push("--max-turns 8");
+  }
+  if (!hasVerboseFlag) {
+    missingRequiredArgs.push("--verbose");
+  }
+  if (!hasDangerouslySkipPermissions) {
+    missingRequiredArgs.push("--dangerously-skip-permissions");
+  }
+  return {
+    commandOverride,
+    commandLooksClaude,
+    commandWasProviderAlias,
+    hasPromptFlag,
+    hasOutputFormatJson,
+    outputFormat,
+    hasMaxTurnsFlag,
+    hasVerboseFlag,
+    hasDangerouslySkipPermissions,
+    hasJsonSchema,
+    missingRequiredArgs
+  };
+}
+
+function resolveProviderCommand(provider: "claude_code" | "codex", configuredCommand: string | undefined) {
+  const trimmed = configuredCommand?.trim();
+  if (!trimmed) {
+    return pickDefaultCommand(provider);
+  }
+  // Normalize accidental provider id aliases used as command strings.
+  if (provider === "claude_code" && trimmed === "claude_code") {
+    return "claude";
+  }
+  return trimmed;
+}
+
+function withClaudeResumeArg(args: string[], sessionId: string) {
+  const next: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const current = args[index] ?? "";
+    if (current === "--resume") {
+      index += 1;
+      continue;
+    }
+    if (current.startsWith("--resume=")) {
+      continue;
+    }
+    next.push(current);
+  }
+  next.push("--resume", sessionId);
+  return next;
+}
+
+function isClaudeMaxTurnsRuntime(runtime: RuntimeExecutionOutput) {
+  return (
+    runtime.structuredOutputDiagnostics?.claudeStopReason === "max_turns" ||
+    runtime.structuredOutputDiagnostics?.claudeResultSubtype === "error_max_turns"
+  );
+}
+
+function hasCliFlag(args: string[], flag: string) {
+  return args.some((arg, index) => arg === flag || (arg.startsWith(`${flag}=`) && index >= 0));
+}
+
+function resolveCliFlagValue(args: string[], flag: string) {
+  for (let index = 0; index < args.length; index += 1) {
+    const current = (args[index] ?? "").trim();
+    if (!current) {
+      continue;
+    }
+    if (current === flag) {
+      const next = (args[index + 1] ?? "").trim();
+      return next || null;
+    }
+    if (current.startsWith(`${flag}=`)) {
+      return current.slice(flag.length + 1).trim() || null;
+    }
+  }
+  return null;
+}
+
+function hasCliFlagValue(args: string[], flag: string, expectedValue: string) {
+  const expected = expectedValue.toLowerCase();
+  for (let index = 0; index < args.length; index += 1) {
+    const current = (args[index] ?? "").trim();
+    if (!current) {
+      continue;
+    }
+    if (current === flag) {
+      const next = (args[index + 1] ?? "").trim().toLowerCase();
+      if (next === expected) {
+        return true;
+      }
+      continue;
+    }
+    if (current.startsWith(`${flag}=`)) {
+      const inlineValue = current.slice(flag.length + 1).trim().toLowerCase();
+      if (inlineValue === expected) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 const SKILLS_DIR_NAME = "skills";
 const CLAUDE_SKILLS_DIR = ".claude/skills";
 const SKILL_MD = "SKILL.md";
@@ -260,7 +598,17 @@ const DEFAULT_CODEX_HOME_FALLBACK = ".codex";
 const CODEX_VOLATILE_STATE_ENTRIES = ["rollouts", "state.db", "data/rollouts", "data/state.db"];
 const CODEX_ROLLOUT_NOISE_RE =
   /^\d{4}-\d{2}-\d{2}T[^\s]+\s+ERROR\s+codex_core::rollout::list:\s+state db missing rollout path for thread\s+[a-z0-9-]+$/i;
-
+const CLAUDE_HEARTBEAT_OUTPUT_SCHEMA = JSON.stringify({
+  type: "object",
+  additionalProperties: false,
+  required: ["summary"],
+  properties: {
+    summary: { type: "string", minLength: 1 },
+    tokenInput: { type: "number" },
+    tokenOutput: { type: "number" },
+    usdCost: { type: "number" }
+  }
+});
 type SkillInjectionContext = {
   additionalArgs: string[];
   warning?: string;
@@ -268,7 +616,7 @@ type SkillInjectionContext = {
 };
 
 async function prepareSkillInjection(
-  provider: "claude_code" | "codex" | undefined,
+  provider: LocalProvider | undefined,
   env: NodeJS.ProcessEnv
 ): Promise<SkillInjectionContext> {
   if (!provider) {
@@ -279,7 +627,7 @@ async function prepareSkillInjection(
   if (!skillsSource) {
     return {
       ...noSkillInjection(),
-      warning: "[bopohq] skills injection skipped: no skills directory found."
+      warning: "[bopodev] skills injection skipped: no skills directory found."
     };
   }
 
@@ -290,7 +638,31 @@ async function prepareSkillInjection(
     } catch (error) {
       return {
         ...noSkillInjection(),
-        warning: `[bopohq] skills injection failed for codex: ${String(error)}`
+        warning: `[bopodev] skills injection failed for codex: ${String(error)}`
+      };
+    }
+  }
+
+  if (provider === "cursor") {
+    try {
+      await ensureSkillsInjectedAtHome(skillsSource, join(homedir(), ".cursor", "skills"));
+      return noSkillInjection();
+    } catch (error) {
+      return {
+        ...noSkillInjection(),
+        warning: `[bopodev] skills injection failed for cursor: ${String(error)}`
+      };
+    }
+  }
+
+  if (provider === "opencode") {
+    try {
+      await ensureSkillsInjectedAtHome(skillsSource, join(homedir(), ".claude", "skills"));
+      return noSkillInjection();
+    } catch (error) {
+      return {
+        ...noSkillInjection(),
+        warning: `[bopodev] skills injection failed for opencode: ${String(error)}`
       };
     }
   }
@@ -306,7 +678,7 @@ async function prepareSkillInjection(
   } catch (error) {
     return {
       ...noSkillInjection(),
-      warning: `[bopohq] skills injection failed for claude_code: ${String(error)}`
+      warning: `[bopodev] skills injection failed for claude_code: ${String(error)}`
     };
   }
 }
@@ -322,10 +694,12 @@ const TRANSIENT_SPAWN_ERROR_CODES = new Set(["EAGAIN", "EMFILE", "ENFILE", "ETXT
 async function executeSinglePromptAttempt(
   command: string,
   args: string[],
+  stdinPrompt: string | undefined,
   cwd: string,
   env: NodeJS.ProcessEnv,
   timeoutMs: number,
-  interruptGraceMs: number
+  interruptGraceMs: number,
+  abortSignal?: AbortSignal
 ) {
   const startedAt = Date.now();
   return new Promise<{
@@ -350,9 +724,10 @@ async function executeSinglePromptAttempt(
     let resolved = false;
     let timedOut = false;
     let forcedKill = false;
+    let abortedBySignal = false;
     let timeoutKillTimer: NodeJS.Timeout | undefined;
-    const timeout = setTimeout(() => {
-      timedOut = true;
+    let abortListener: (() => void) | undefined;
+    const scheduleTermination = () => {
       child.kill("SIGTERM");
       timeoutKillTimer = setTimeout(() => {
         if (!resolved) {
@@ -360,7 +735,23 @@ async function executeSinglePromptAttempt(
           child.kill("SIGKILL");
         }
       }, interruptGraceMs);
+    };
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      scheduleTermination();
     }, timeoutMs);
+    if (abortSignal) {
+      abortListener = () => {
+        abortedBySignal = true;
+        timedOut = true;
+        scheduleTermination();
+      };
+      if (abortSignal.aborted) {
+        abortListener();
+      } else {
+        abortSignal.addEventListener("abort", abortListener, { once: true });
+      }
+    }
 
     child.stdout.on("data", (chunk) => {
       stdout += String(chunk);
@@ -368,6 +759,10 @@ async function executeSinglePromptAttempt(
     child.stderr.on("data", (chunk) => {
       stderr += String(chunk);
     });
+    if (stdinPrompt !== undefined) {
+      child.stdin.write(stdinPrompt);
+      child.stdin.end();
+    }
 
     child.on("close", (code, signal) => {
       if (resolved) {
@@ -378,11 +773,14 @@ async function executeSinglePromptAttempt(
       if (timeoutKillTimer) {
         clearTimeout(timeoutKillTimer);
       }
+      if (abortSignal && abortListener) {
+        abortSignal.removeEventListener("abort", abortListener);
+      }
       resolve({
         ok: code === 0 && !timedOut,
         code,
         stdout,
-        stderr,
+        stderr: abortedBySignal ? [stderr, "Execution aborted by watchdog signal."].filter(Boolean).join("\n") : stderr,
         timedOut,
         elapsedMs: Date.now() - startedAt,
         signal,
@@ -399,6 +797,9 @@ async function executeSinglePromptAttempt(
       if (timeoutKillTimer) {
         clearTimeout(timeoutKillTimer);
       }
+      if (abortSignal && abortListener) {
+        abortSignal.removeEventListener("abort", abortListener);
+      }
       const errorWithCode = error as NodeJS.ErrnoException;
       resolve({
         ok: false,
@@ -542,7 +943,7 @@ function resolveCodexHome(env: NodeJS.ProcessEnv) {
 }
 
 function normalizeProviderAuthEnv(
-  provider: "claude_code" | "codex" | undefined,
+  provider: LocalProvider | undefined,
   env: NodeJS.ProcessEnv
 ) {
   if (provider !== "codex") {
@@ -563,7 +964,7 @@ type ProviderIsolationContext = {
 };
 
 async function withProviderRuntimeIsolation(
-  provider: "claude_code" | "codex" | undefined,
+  provider: LocalProvider | undefined,
   env: NodeJS.ProcessEnv
 ): Promise<ProviderIsolationContext> {
   if (provider !== "codex") {
@@ -572,7 +973,7 @@ async function withProviderRuntimeIsolation(
       cleanup: async () => {}
     };
   }
-  const forceManagedCodexHome = env.BOPOHQ_FORCE_MANAGED_CODEX_HOME === "true";
+  const forceManagedCodexHome = resolveControlPlaneEnvValue(env, "FORCE_MANAGED_CODEX_HOME") === "true";
   if (env.CODEX_HOME?.trim() && !forceManagedCodexHome) {
     await sanitizeCodexHomeVolatileState(env.CODEX_HOME.trim());
     return {
@@ -582,7 +983,7 @@ async function withProviderRuntimeIsolation(
   }
   const hasApiKey = typeof env.OPENAI_API_KEY === "string" && env.OPENAI_API_KEY.trim().length > 0;
   if (hasApiKey) {
-    const runScopedCodexHome = await mkdtemp(join(tmpdir(), "bopohq-codex-home-run-"));
+    const runScopedCodexHome = await mkdtemp(join(tmpdir(), "bopodev-codex-home-run-"));
     await sanitizeCodexHomeVolatileState(runScopedCodexHome);
     return {
       env: {
@@ -614,10 +1015,24 @@ async function withProviderRuntimeIsolation(
   };
 }
 
+async function ensureSkillsInjectedAtHome(skillsSourceDir: string, targetRoot: string) {
+  await mkdir(targetRoot, { recursive: true });
+  const entries = await readdir(skillsSourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const source = join(skillsSourceDir, entry.name);
+    if (!(await hasSkillManifest(source))) continue;
+    const target = join(targetRoot, entry.name);
+    const existing = await lstat(target).catch(() => null);
+    if (existing) continue;
+    await symlink(source, target);
+  }
+}
+
 function resolveManagedCodexHome(env: NodeJS.ProcessEnv) {
   const managedRoot = resolveManagedCodexHomeRoot(env);
-  const companyId = sanitizePathSegment(env.BOPOHQ_COMPANY_ID);
-  const agentId = sanitizePathSegment(env.BOPOHQ_AGENT_ID);
+  const companyId = sanitizePathSegment(resolveControlPlaneEnvValue(env, "COMPANY_ID"));
+  const agentId = sanitizePathSegment(resolveControlPlaneEnvValue(env, "AGENT_ID"));
   if (companyId && agentId) {
     return join(managedRoot, companyId, agentId);
   }
@@ -629,7 +1044,7 @@ function resolveManagedCodexHomeRoot(env: NodeJS.ProcessEnv) {
   if (configuredRoot) {
     return configuredRoot;
   }
-  return join(tmpdir(), "bopohq-codex-home");
+  return join(tmpdir(), "bopodev-codex-home");
 }
 
 async function prepareManagedCodexHome(targetCodexHome: string, env: NodeJS.ProcessEnv) {
@@ -690,7 +1105,7 @@ function sanitizePathSegment(value: string | undefined) {
 }
 
 async function buildClaudeSkillsAddDir(skillsSourceDir: string) {
-  const tempRoot = await mkdtemp(join(tmpdir(), "bopohq-skills-"));
+  const tempRoot = await mkdtemp(join(tmpdir(), "bopodev-skills-"));
   const skillsTargetDir = join(tempRoot, CLAUDE_SKILLS_DIR);
   await mkdir(skillsTargetDir, { recursive: true });
 
@@ -728,6 +1143,22 @@ async function fileExists(path: string) {
 }
 
 function parseStructuredUsage(stdout: string) {
+  const whole = stdout.trim();
+  if (whole.startsWith("{") && whole.endsWith("}")) {
+    const parsedWhole = tryParseUsage(whole);
+    if (parsedWhole) {
+      return parsedWhole;
+    }
+  }
+
+  const jsonBlocks = extractJsonObjectBlocks(stdout);
+  for (let index = jsonBlocks.length - 1; index >= 0; index -= 1) {
+    const parsedBlock = tryParseUsage(jsonBlocks[index] ?? "");
+    if (parsedBlock) {
+      return parsedBlock;
+    }
+  }
+
   const lines = stdout
     .split(/\r?\n/)
     .map((line) => line.trim())
@@ -754,9 +1185,730 @@ function parseStructuredUsage(stdout: string) {
   return undefined;
 }
 
+function parseClaudeStreamOutput(stdout: string) {
+  let summary = "";
+  let tokenInput: number | undefined;
+  let tokenOutput: number | undefined;
+  let usdCost: number | undefined;
+  let stopReason: string | undefined;
+  let resultSubtype: string | undefined;
+  let sessionId: string | undefined;
+  const assistantTexts: string[] = [];
+
+  for (const rawLine of stdout.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    let parsed: Record<string, unknown>;
+    try {
+      parsed = JSON.parse(line) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    if (!sessionId && typeof parsed.session_id === "string" && parsed.session_id.trim()) {
+      sessionId = parsed.session_id.trim();
+    }
+    if (type === "assistant") {
+      const message = parsed.message;
+      if (message && typeof message === "object" && !Array.isArray(message)) {
+        const content = (message as Record<string, unknown>).content;
+        if (Array.isArray(content)) {
+          for (const entry of content) {
+            if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+            const block = entry as Record<string, unknown>;
+            if (block.type === "text" && typeof block.text === "string" && block.text.trim()) {
+              assistantTexts.push(block.text.trim());
+            }
+          }
+        }
+      }
+      continue;
+    }
+    if (type !== "result") continue;
+    if (typeof parsed.result === "string" && parsed.result.trim()) {
+      summary = parsed.result.trim();
+    }
+    const usage = parsed.usage;
+    if (usage && typeof usage === "object" && !Array.isArray(usage)) {
+      const usageObj = usage as Record<string, unknown>;
+      const inputTokens = toNumber(usageObj.input_tokens);
+      const cacheReadTokens = toNumber(usageObj.cache_read_input_tokens);
+      const outputTokens = toNumber(usageObj.output_tokens);
+      tokenInput =
+        inputTokens !== undefined || cacheReadTokens !== undefined
+          ? (inputTokens ?? 0) + (cacheReadTokens ?? 0)
+          : undefined;
+      tokenOutput = outputTokens;
+    }
+    usdCost = toNumber(parsed.total_cost_usd);
+    if (typeof parsed.stop_reason === "string" && parsed.stop_reason.trim()) {
+      stopReason = parsed.stop_reason.trim().toLowerCase();
+    }
+    if (typeof parsed.subtype === "string" && parsed.subtype.trim()) {
+      resultSubtype = parsed.subtype.trim().toLowerCase();
+    }
+  }
+
+  const resolvedSummary = summary || assistantTexts.join("\n\n").trim();
+  if (!resolvedSummary && tokenInput === undefined && tokenOutput === undefined && usdCost === undefined) {
+    return undefined;
+  }
+  return {
+    usage: {
+      summary: resolvedSummary || undefined,
+      tokenInput,
+      tokenOutput,
+      usdCost
+    },
+    stopReason,
+    resultSubtype,
+    sessionId
+  };
+}
+
+function parseCursorStreamOutput(stdout: string): CursorParsedStream | undefined {
+  let sessionId: string | undefined;
+  let errorMessage: string | undefined;
+  let resultSubtype: string | undefined;
+  let tokenInput = 0;
+  let tokenOutput = 0;
+  let usdCost = 0;
+  let sawUsage = false;
+  const assistantTexts: string[] = [];
+
+  for (const rawLine of stdout.split(/\r?\n/)) {
+    const normalized = normalizeCursorStreamLine(rawLine).line;
+    if (!normalized) {
+      continue;
+    }
+    let parsed: Record<string, unknown>;
+    try {
+      parsed = JSON.parse(normalized) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+    const foundSessionId = readCursorSessionId(parsed);
+    if (foundSessionId) {
+      sessionId = foundSessionId;
+    }
+    const type = typeof parsed.type === "string" ? parsed.type.trim().toLowerCase() : "";
+    if (type === "assistant") {
+      assistantTexts.push(...collectCursorAssistantText(parsed.message));
+      continue;
+    }
+    if (type === "result") {
+      const usage = parsed.usage;
+      if (usage && typeof usage === "object" && !Array.isArray(usage)) {
+        const usageRecord = usage as Record<string, unknown>;
+        tokenInput += toNumber(usageRecord.input_tokens) ?? toNumber(usageRecord.inputTokens) ?? 0;
+        tokenInput +=
+          toNumber(usageRecord.cached_input_tokens) ??
+          toNumber(usageRecord.cachedInputTokens) ??
+          toNumber(usageRecord.cache_read_input_tokens) ??
+          0;
+        tokenOutput += toNumber(usageRecord.output_tokens) ?? toNumber(usageRecord.outputTokens) ?? 0;
+        sawUsage = true;
+      }
+      usdCost += toNumber(parsed.total_cost_usd) ?? toNumber(parsed.cost_usd) ?? toNumber(parsed.cost) ?? 0;
+      if (typeof parsed.subtype === "string" && parsed.subtype.trim()) {
+        resultSubtype = parsed.subtype.trim().toLowerCase();
+      }
+      const resultText = firstNonEmptyString(parsed.result);
+      if (resultText && assistantTexts.length === 0) {
+        assistantTexts.push(resultText);
+      }
+      const isError = parsed.is_error === true || resultSubtype === "error";
+      if (isError) {
+        const message = asCursorErrorText(parsed.error ?? parsed.message ?? parsed.result);
+        if (message) {
+          errorMessage = message;
+        }
+      }
+      continue;
+    }
+    if (type === "error") {
+      const message = asCursorErrorText(parsed.message ?? parsed.error ?? parsed.detail);
+      if (message) {
+        errorMessage = message;
+      }
+      continue;
+    }
+    if (type === "system") {
+      const subtype = typeof parsed.subtype === "string" ? parsed.subtype.trim().toLowerCase() : "";
+      if (subtype === "error") {
+        const message = asCursorErrorText(parsed.message ?? parsed.error ?? parsed.detail);
+        if (message) {
+          errorMessage = message;
+        }
+      }
+      continue;
+    }
+    if (type === "text") {
+      const part = parsed.part;
+      if (part && typeof part === "object" && !Array.isArray(part)) {
+        const text = firstNonEmptyString((part as Record<string, unknown>).text);
+        if (text) {
+          assistantTexts.push(text);
+        }
+      }
+      continue;
+    }
+    if (type === "step_finish") {
+      const part = parsed.part;
+      if (!part || typeof part !== "object" || Array.isArray(part)) {
+        continue;
+      }
+      const tokens = (part as Record<string, unknown>).tokens;
+      if (tokens && typeof tokens === "object" && !Array.isArray(tokens)) {
+        const tokenRecord = tokens as Record<string, unknown>;
+        tokenInput += toNumber(tokenRecord.input) ?? 0;
+        tokenOutput += toNumber(tokenRecord.output) ?? 0;
+        const cache = tokenRecord.cache;
+        if (cache && typeof cache === "object" && !Array.isArray(cache)) {
+          tokenInput += toNumber((cache as Record<string, unknown>).read) ?? 0;
+        }
+        sawUsage = true;
+      }
+      usdCost += toNumber((part as Record<string, unknown>).cost) ?? 0;
+    }
+  }
+
+  const summary = assistantTexts.join("\n\n").trim() || errorMessage;
+  if (!summary && !sawUsage && usdCost <= 0) {
+    return undefined;
+  }
+  return {
+    usage: {
+      summary: summary || undefined,
+      tokenInput: sawUsage ? tokenInput : undefined,
+      tokenOutput: sawUsage ? tokenOutput : undefined,
+      usdCost: usdCost > 0 ? usdCost : undefined
+    },
+    sessionId,
+    errorMessage,
+    resultSubtype
+  };
+}
+
+function parseClaudeTranscript(stdout: string, stderr: string): RuntimeTranscriptEvent[] | undefined {
+  const events: RuntimeTranscriptEvent[] = [];
+  for (const rawLine of stdout.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line.startsWith("{") || !line.endsWith("}")) {
+      continue;
+    }
+    let parsed: Record<string, unknown>;
+    try {
+      parsed = JSON.parse(line) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    if (type === "system") {
+      const model = typeof parsed.model === "string" ? parsed.model : "";
+      const subtype = typeof parsed.subtype === "string" ? parsed.subtype : undefined;
+      events.push({
+        kind: "system",
+        label: subtype,
+        text: model ? `model:${model}` : "session init"
+      });
+      continue;
+    }
+    if (type === "assistant" || type === "user") {
+      const message = parsed.message;
+      const content =
+        message && typeof message === "object" && !Array.isArray(message)
+          ? ((message as Record<string, unknown>).content as unknown[])
+          : undefined;
+      if (!Array.isArray(content)) {
+        continue;
+      }
+      for (const entry of content) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+          continue;
+        }
+        const block = entry as Record<string, unknown>;
+        const blockType = typeof block.type === "string" ? block.type : "";
+        if (blockType === "thinking" && typeof block.thinking === "string") {
+          events.push({ kind: "thinking", text: clipText(block.thinking, 300) });
+          continue;
+        }
+        if (blockType === "text" && typeof block.text === "string") {
+          events.push({ kind: "assistant", text: clipText(block.text, 300) });
+          continue;
+        }
+        if (blockType === "tool_use") {
+          const label = typeof block.name === "string" ? block.name : "tool";
+          const payload = block.input ? safeJson(block.input) : undefined;
+          events.push({
+            kind: "tool_call",
+            label,
+            payload: payload ? clipText(payload, 520) : undefined
+          });
+          continue;
+        }
+        if (blockType === "tool_result") {
+          const payload = typeof block.content === "string" ? block.content : safeJson(block.content);
+          events.push({
+            kind: "tool_result",
+            text: payload ? clipText(payload, 320) : "tool result"
+          });
+        }
+      }
+      continue;
+    }
+    if (type === "result") {
+      const stopReason = typeof parsed.stop_reason === "string" ? parsed.stop_reason : undefined;
+      const result = typeof parsed.result === "string" ? parsed.result : "result event";
+      events.push({
+        kind: "result",
+        label: stopReason,
+        text: clipText(result, 320)
+      });
+    }
+  }
+  const stderrEvents = parseStderrTranscript(stderr);
+  if (stderrEvents) {
+    events.push(...stderrEvents.slice(0, 10));
+  }
+  if (events.length === 0) {
+    return undefined;
+  }
+  return events.slice(0, 120);
+}
+
+function parseRuntimeTranscript(
+  provider: LocalProvider | undefined,
+  stdout: string,
+  stderr: string
+): RuntimeTranscriptEvent[] | undefined {
+  const claudeEvents = provider === "claude_code" ? parseClaudeTranscript(stdout, stderr) : undefined;
+  const cursorEvents = provider === "cursor" ? parseCursorTranscript(stdout, stderr) : undefined;
+  const genericEvents = parseGenericTranscript(stdout, stderr);
+  const providerEvents = claudeEvents ?? cursorEvents;
+  if (providerEvents?.length && genericEvents?.length) {
+    return [...providerEvents, ...genericEvents].slice(0, 140);
+  }
+  return providerEvents ?? genericEvents;
+}
+
+function parseCursorTranscript(stdout: string, stderr: string): RuntimeTranscriptEvent[] | undefined {
+  const events: RuntimeTranscriptEvent[] = [];
+  for (const rawLine of stdout.split(/\r?\n/)) {
+    const normalized = normalizeCursorStreamLine(rawLine).line;
+    if (!normalized.startsWith("{") || !normalized.endsWith("}")) {
+      continue;
+    }
+    let parsed: Record<string, unknown>;
+    try {
+      parsed = JSON.parse(normalized) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+    const type = typeof parsed.type === "string" ? parsed.type.trim().toLowerCase() : "";
+    if (type === "system") {
+      const model = firstNonEmptyString(parsed.model);
+      const sessionId = readCursorSessionId(parsed);
+      const bits = [model ? `model:${model}` : "", sessionId ? `session:${sessionId}` : ""].filter(Boolean);
+      events.push({
+        kind: "system",
+        label: firstNonEmptyString(parsed.subtype),
+        text: bits.join(" ") || "session init"
+      });
+      continue;
+    }
+    if (type === "assistant" || type === "user") {
+      const kind = type === "user" ? "system" : "assistant";
+      const content =
+        parsed.message && typeof parsed.message === "object" && !Array.isArray(parsed.message)
+          ? (((parsed.message as Record<string, unknown>).content as unknown[]) ?? [])
+          : [];
+      for (const entry of content) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+          continue;
+        }
+        const block = entry as Record<string, unknown>;
+        const blockType = typeof block.type === "string" ? block.type.trim().toLowerCase() : "";
+        if ((blockType === "thinking" || blockType === "reasoning") && typeof block.text === "string") {
+          events.push({ kind: "thinking", text: clipText(block.text, 300) });
+          continue;
+        }
+        if (blockType === "text" || blockType === "output_text") {
+          const text = firstNonEmptyString(block.text);
+          if (text) {
+            events.push({ kind, text: clipText(text, 300) });
+          }
+          continue;
+        }
+        if (blockType === "tool_call" || blockType === "tool_use") {
+          const label = firstNonEmptyString(block.name) ?? firstNonEmptyString(block.tool_name) ?? "tool";
+          const payload = safeJson(block.input ?? block.args ?? block.tool_call);
+          events.push({
+            kind: "tool_call",
+            label,
+            ...(payload ? { payload: clipText(payload, 520) } : {})
+          });
+          continue;
+        }
+        if (blockType === "tool_result") {
+          const payload = safeJson(block.output ?? block.content ?? block.result);
+          events.push({
+            kind: "tool_result",
+            label: firstNonEmptyString(block.tool_use_id) ?? undefined,
+            text: clipText(payload ?? "tool result", 320)
+          });
+        }
+      }
+      continue;
+    }
+    if (type === "thinking") {
+      const thinkingText = firstNonEmptyString(parsed.text, parsed.message);
+      if (thinkingText) {
+        events.push({ kind: "thinking", text: clipText(thinkingText, 300) });
+      }
+      continue;
+    }
+    if (type === "tool_call") {
+      const subtype = firstNonEmptyString(parsed.subtype);
+      const toolCall = parsed.tool_call;
+      if (toolCall && typeof toolCall === "object" && !Array.isArray(toolCall)) {
+        const [toolName, toolValue] = Object.entries(toolCall as Record<string, unknown>)[0] ?? [];
+        if (subtype === "completed") {
+          events.push({
+            kind: "tool_result",
+            label: firstNonEmptyString(parsed.call_id) ?? toolName ?? undefined,
+            text: clipText(safeJson(toolValue) ?? "tool result", 320)
+          });
+        } else {
+          const payload =
+            toolValue && typeof toolValue === "object" && !Array.isArray(toolValue)
+              ? safeJson((toolValue as Record<string, unknown>).args ?? toolValue)
+              : safeJson(toolValue);
+          events.push({
+            kind: "tool_call",
+            label: toolName ?? firstNonEmptyString(parsed.call_id) ?? "tool",
+            ...(payload ? { payload: clipText(payload, 520) } : {})
+          });
+        }
+      }
+      continue;
+    }
+    if (type === "result" || type === "error") {
+      const label = firstNonEmptyString(parsed.subtype);
+      const text =
+        firstNonEmptyString(parsed.result, parsed.message, parsed.error, parsed.detail) ?? `${type} event`;
+      events.push({
+        kind: type === "error" ? "stderr" : "result",
+        ...(label ? { label } : {}),
+        text: clipText(text, 320)
+      });
+    }
+  }
+  const stderrEvents = parseStderrTranscript(stderr);
+  if (stderrEvents) {
+    events.push(...stderrEvents.slice(0, 10));
+  }
+  if (events.length === 0) {
+    return undefined;
+  }
+  return events.slice(0, 120);
+}
+
+function parseGenericTranscript(stdout: string, stderr: string): RuntimeTranscriptEvent[] | undefined {
+  const events: RuntimeTranscriptEvent[] = [];
+  let lastToolEventIndex = -1;
+  for (const rawLine of stdout.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) {
+      continue;
+    }
+    const fromJson = parseGenericTranscriptJsonLine(line);
+    if (fromJson) {
+      events.push(fromJson);
+      lastToolEventIndex =
+        fromJson.kind === "tool_call" || fromJson.kind === "tool_result" ? events.length - 1 : lastToolEventIndex;
+      continue;
+    }
+    const fromTagged = parseTaggedTranscriptLine(line);
+    if (fromTagged) {
+      events.push(fromTagged);
+      lastToolEventIndex =
+        fromTagged.kind === "tool_call" || fromTagged.kind === "tool_result" ? events.length - 1 : lastToolEventIndex;
+      continue;
+    }
+    if (lastToolEventIndex >= 0 && looksLikeToolPayloadLine(line)) {
+      const current = events[lastToolEventIndex];
+      if (!current) {
+        continue;
+      }
+      const nextPayload = [current.payload, line].filter(Boolean).join("\n");
+      events[lastToolEventIndex] = {
+        ...current,
+        payload: clipText(nextPayload, 520)
+      };
+    }
+  }
+  const stderrEvents = parseStderrTranscript(stderr);
+  if (stderrEvents) {
+    events.push(...stderrEvents.slice(0, 10));
+  }
+  if (events.length === 0) {
+    return undefined;
+  }
+  return events.slice(0, 120);
+}
+
+function parseGenericTranscriptJsonLine(line: string): RuntimeTranscriptEvent | undefined {
+  if (!line.startsWith("{") || !line.endsWith("}")) {
+    return undefined;
+  }
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(line) as Record<string, unknown>;
+  } catch {
+    return undefined;
+  }
+  const kind = normalizeTranscriptKind(parsed.type ?? parsed.kind ?? parsed.event);
+  if (!kind) {
+    return undefined;
+  }
+  const label = pickString(parsed.subtype, parsed.name, parsed.tool, parsed.tool_name, parsed.status);
+  const text =
+    pickString(
+      parsed.message,
+      parsed.text,
+      parsed.result,
+      parsed.summary,
+      parsed.content,
+      parsed.detail,
+      parsed.command
+    ) ?? `${kind} event`;
+  const payload = safeJson(parsed.input ?? parsed.arguments ?? parsed.params ?? parsed.output ?? parsed.data);
+  return {
+    kind,
+    ...(label ? { label: clipText(label, 100) } : {}),
+    text: clipText(text, 300),
+    ...(payload ? { payload: clipText(payload, 520) } : {})
+  };
+}
+
+function parseTaggedTranscriptLine(line: string): RuntimeTranscriptEvent | undefined {
+  const timestampPrefix = /^\d{2}:\d{2}:\d{2}\s+/;
+  const withoutTimestamp = timestampPrefix.test(line) ? line.replace(timestampPrefix, "") : line;
+  const match = /^(system|assistant|thinking|tool_call|tool_result|result|stderr)\s*(.*)$/i.exec(
+    withoutTimestamp
+  );
+  if (!match) {
+    return undefined;
+  }
+  const kind = normalizeTranscriptKind(match[1]);
+  if (!kind) {
+    return undefined;
+  }
+  const rest = match[2]?.trim();
+  return {
+    kind,
+    text: clipText(rest || `${kind} event`, 300),
+    ...(rest && (kind === "tool_call" || kind === "tool_result") ? { label: clipText(rest, 120) } : {})
+  };
+}
+
+function normalizeTranscriptKind(value: unknown): RuntimeTranscriptEvent["kind"] | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (
+    normalized === "system" ||
+    normalized === "assistant" ||
+    normalized === "thinking" ||
+    normalized === "tool_call" ||
+    normalized === "tool_result" ||
+    normalized === "result" ||
+    normalized === "stderr"
+  ) {
+    return normalized;
+  }
+  return undefined;
+}
+
+function pickString(...values: unknown[]) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return undefined;
+}
+
+function looksLikeToolPayloadLine(line: string) {
+  return (
+    line.startsWith("{") ||
+    line.startsWith("}") ||
+    line.startsWith("\"") ||
+    /^[a-zA-Z_][a-zA-Z0-9_]*\s*:/.test(line)
+  );
+}
+
+function parseStderrTranscript(stderr: string): RuntimeTranscriptEvent[] | undefined {
+  const lines = stderr
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .slice(0, 40);
+  if (lines.length === 0) {
+    return undefined;
+  }
+  return lines.map((line) => ({
+    kind: "stderr",
+    text: clipText(line, 300)
+  }));
+}
+
+function safeJson(value: unknown) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return undefined;
+  }
+}
+
+function normalizeCursorStreamLine(rawLine: string) {
+  const trimmed = rawLine.trim();
+  if (trimmed.startsWith("stdout{") || trimmed.startsWith("stderr{")) {
+    return { line: trimmed.slice(6), stream: trimmed.slice(0, 6) as "stdout" | "stderr" };
+  }
+  return { line: trimmed, stream: undefined };
+}
+
+function readCursorSessionId(event: Record<string, unknown>) {
+  return firstNonEmptyString(event.session_id, event.sessionId, event.sessionID);
+}
+
+function collectCursorAssistantText(message: unknown) {
+  if (typeof message === "string") {
+    return message.trim() ? [message.trim()] : [];
+  }
+  if (!message || typeof message !== "object" || Array.isArray(message)) {
+    return [];
+  }
+  const record = message as Record<string, unknown>;
+  const lines: string[] = [];
+  const directText = firstNonEmptyString(record.text);
+  if (directText) {
+    lines.push(directText);
+  }
+  const content = Array.isArray(record.content) ? record.content : [];
+  for (const entry of content) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      continue;
+    }
+    const block = entry as Record<string, unknown>;
+    const type = typeof block.type === "string" ? block.type.trim().toLowerCase() : "";
+    if (type !== "output_text" && type !== "text") {
+      continue;
+    }
+    const text = firstNonEmptyString(block.text);
+    if (text) {
+      lines.push(text);
+    }
+  }
+  return lines;
+}
+
+function asCursorErrorText(value: unknown) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return "";
+  }
+  const record = value as Record<string, unknown>;
+  const direct = firstNonEmptyString(record.message, record.error, record.code, record.detail);
+  if (direct) {
+    return direct;
+  }
+  return safeJson(record) ?? "";
+}
+
+function firstNonEmptyString(...values: unknown[]) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return undefined;
+}
+
+function clipText(text: string, max = 220) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (normalized.length <= max) {
+    return normalized;
+  }
+  return `${normalized.slice(0, max)}...`;
+}
+
+function extractJsonObjectBlocks(text: string) {
+  const blocks: string[] = [];
+  let depth = 0;
+  let startIndex = -1;
+  let inString = false;
+  let escaped = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === "\"") {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === "\"") {
+      inString = true;
+      continue;
+    }
+    if (char === "{") {
+      if (depth === 0) {
+        startIndex = index;
+      }
+      depth += 1;
+      continue;
+    }
+    if (char === "}") {
+      if (depth === 0) {
+        continue;
+      }
+      depth -= 1;
+      if (depth === 0 && startIndex >= 0) {
+        blocks.push(text.slice(startIndex, index + 1));
+        startIndex = -1;
+      }
+    }
+  }
+  return blocks;
+}
+
 function tryParseUsage(candidate: string) {
   try {
     const parsed = JSON.parse(candidate) as Record<string, unknown>;
+    const direct = toUsageRecord(parsed);
+    if (direct) {
+      return direct;
+    }
+    const nested = findNestedUsage(parsed);
+    if (nested) {
+      return nested;
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function toUsageRecord(parsed: Record<string, unknown>) {
     const tokenInput = toNumber(parsed.tokenInput);
     const tokenOutput = toNumber(parsed.tokenOutput);
     const usdCost = toNumber(parsed.usdCost);
@@ -773,9 +1925,45 @@ function tryParseUsage(candidate: string) {
       return undefined;
     }
     return { tokenInput, tokenOutput, usdCost, summary };
-  } catch {
-    return undefined;
+}
+
+function findNestedUsage(parsed: Record<string, unknown>) {
+  const queue: unknown[] = Object.values(parsed);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) {
+      continue;
+    }
+    if (typeof current === "string") {
+      const trimmed = current.trim();
+      if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        try {
+          const parsedString = JSON.parse(trimmed) as Record<string, unknown>;
+          const usage = toUsageRecord(parsedString);
+          if (usage) {
+            return usage;
+          }
+          queue.push(...Object.values(parsedString));
+        } catch {
+          // ignore malformed nested JSON
+        }
+      }
+      continue;
+    }
+    if (Array.isArray(current)) {
+      queue.push(...current);
+      continue;
+    }
+    if (typeof current === "object") {
+      const objectValue = current as Record<string, unknown>;
+      const usage = toUsageRecord(objectValue);
+      if (usage) {
+        return usage;
+      }
+      queue.push(...Object.values(objectValue));
+    }
   }
+  return undefined;
 }
 
 function isPromptTemplateUsage(
@@ -812,3 +2000,32 @@ function toNumber(value: unknown) {
   }
   return undefined;
 }
+
+function tailLine(value: string) {
+  const lines = value
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  return lines.length > 0 ? lines[lines.length - 1] : undefined;
+}
+
+function classifyStructuredOutputLikelyCause(
+  stdout: string,
+  stderr: string,
+  stdoutUsage: { summary?: string } | undefined,
+  stderrUsage: { summary?: string } | undefined
+) {
+  const hasStdout = stdout.trim().length > 0;
+  const hasStderr = stderr.trim().length > 0;
+  if (!hasStdout && !hasStderr) {
+    return "no_output_from_runtime" as const;
+  }
+  if (!stdoutUsage && stderrUsage) {
+    return "json_on_stderr_only" as const;
+  }
+  const jsonLike = /[\{\}\[\]\"]/m.test(stdout) || /[\{\}\[\]\"]/m.test(stderr);
+  if (jsonLike) {
+    return "schema_or_shape_mismatch" as const;
+  }
+  return "json_missing" as const;
+}