import fs from "node:fs/promises";

import os from "node:os";

import path from "node:path";

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

import {

testing as replyRunTesting,

createReplyOperation,

replyRunRegistry,

} from "../auto-reply/reply/reply-run-registry.js";

import { onAgentEvent, resetAgentEventsForTest } from "../infra/agent-events.js";

import type { getProcessSupervisor } from "../process/supervisor/index.js";

import {

makeBootstrapWarn as realMakeBootstrapWarn,

resolveBootstrapContextForRun as realResolveBootstrapContextForRun,

} from "./bootstrap-files.js";

import { buildRunClaudeCliAgentParams } from "./cli-runner.js";

import {

createManagedRun,

mockSuccessfulCliRun,

restoreCliRunnerPrepareTestDeps,

supervisorSpawnMock,

} from "./cli-runner.test-support.js";

import {

buildClaudeLiveArgs,

resetClaudeLiveSessionsForTest,

runClaudeLiveSessionTurn,

} from "./cli-runner/claude-live-session.js";

import {

buildCliEnvAuthLog,

buildCliExecLogLine,

executePreparedCliRun,

} from "./cli-runner/execute.js";

import { buildSystemPrompt } from "./cli-runner/helpers.js";

import { setCliRunnerPrepareTestDeps } from "./cli-runner/prepare.js";

import type { PreparedCliRunContext } from "./cli-runner/types.js";

import { createClaudeApiErrorFixture } from "./test-helpers/claude-api-error-fixture.js";

vi.mock("../plugin-sdk/anthropic-cli.js", () => ({

CLAUDE_CLI_BACKEND_ID: "claude-cli",

isClaudeCliProvider: (providerId: string) => providerId === "claude-cli",

}));

type ProcessSupervisor = ReturnType<typeof getProcessSupervisor>;

type SupervisorSpawnFn = ProcessSupervisor["spawn"];

beforeEach(() => {

resetAgentEventsForTest();

resetClaudeLiveSessionsForTest();

replyRunTesting.resetReplyRunRegistry();

restoreCliRunnerPrepareTestDeps();

supervisorSpawnMock.mockClear();

});

afterEach(() => {

vi.restoreAllMocks();

resetClaudeLiveSessionsForTest();

replyRunTesting.resetReplyRunRegistry();

});

function buildPreparedCliRunContext(params: {

provider: "claude-cli" | "codex-cli";

model: string;

runId: string;

prompt?: string;

sessionId?: string;

sessionKey?: string;

sessionEntry?: PreparedCliRunContext["params"]["sessionEntry"];

agentId?: string;

backend?: Partial<PreparedCliRunContext["preparedBackend"]["backend"]>;

resolveExecutionArgs?: PreparedCliRunContext["backendResolved"]["resolveExecutionArgs"];

config?: PreparedCliRunContext["params"]["config"];

mcpConfigHash?: string;

skillsSnapshot?: PreparedCliRunContext["params"]["skillsSnapshot"];

thinkLevel?: PreparedCliRunContext["params"]["thinkLevel"];

workspaceDir?: string;

}): PreparedCliRunContext {

const workspaceDir = params.workspaceDir ?? "/tmp";

const baseBackend =

params.provider === "claude-cli"

? {

command: "claude",

args: ["-p", "--output-format", "stream-json"],

output: "jsonl" as const,

input: "stdin" as const,

modelArg: "--model",

sessionArg: "--session-id",

sessionMode: "always" as const,

systemPromptFileArg: "--append-system-prompt-file",

systemPromptWhen: "first" as const,

serialize: true,

}

: {

command: "codex",

args: ["exec", "--json"],

resumeArgs: ["exec", "resume", "{sessionId}", "--skip-git-repo-check"],

output: "text" as const,

input: "arg" as const,

modelArg: "--model",

sessionMode: "existing" as const,

systemPromptFileConfigArg: "-c",

systemPromptFileConfigKey: "model_instructions_file",

systemPromptWhen: "first" as const,

serialize: true,

};

const backend = { ...baseBackend, ...params.backend };

return {

params: {

sessionId: params.sessionId ?? "s1",

sessionKey: params.sessionKey,

sessionEntry: params.sessionEntry,

agentId: params.agentId,

sessionFile: "/tmp/session.jsonl",

workspaceDir,

config: params.config,

prompt: params.prompt ?? "hi",

provider: params.provider,

model: params.model,

thinkLevel: params.thinkLevel,

timeoutMs: 1_000,

runId: params.runId,

skillsSnapshot: params.skillsSnapshot,

},

started: Date.now(),

workspaceDir,

backendResolved: {

id: params.provider,

config: backend,

bundleMcp: params.provider === "claude-cli",

pluginId: params.provider === "claude-cli" ? "anthropic" : "openai",

resolveExecutionArgs: params.resolveExecutionArgs,

},

preparedBackend: {

backend,

env: {},

...(params.mcpConfigHash ? { mcpConfigHash: params.mcpConfigHash } : {}),

},

reusableCliSession: {},

hadSessionFile: false,

contextEngineConfig: {},

modelId: params.model,

normalizedModel: params.model,

systemPrompt: "You are a helpful assistant.",

systemPromptReport: {} as PreparedCliRunContext["systemPromptReport"],

bootstrapPromptWarningLines: [],

authEpochVersion: 2,

};

}

function requireArgAfter(argv: string[] | undefined, flag: string): string {

const index = argv?.indexOf(flag) ?? -1;

if (index < 0) {

throw new Error(`expected CLI arg ${flag}`);

}

const value = argv?.[index + 1]?.trim();

if (!value) {

throw new Error(`expected value after CLI arg ${flag}`);

}

return value;

}

function requireRegexMatch(value: string, pattern: RegExp): RegExpExecArray {

const match = pattern.exec(value);

if (!match) {

throw new Error(`expected ${value} to match ${pattern}`);

}

return match;

}

function requireRecord(value: unknown, label: string): Record<string, unknown> {

if (!value || typeof value !== "object") {

throw new Error(`expected ${label} to be an object`);

}

return value as Record<string, unknown>;

}

function mockCallArg(mock: ReturnType<typeof vi.fn>, callIndex = 0, argIndex = 0): unknown {

const call = mock.mock.calls[callIndex] as unknown[] | undefined;

if (!call) {

throw new Error(`expected mock call ${callIndex}`);

}

return call[argIndex];

}

async function expectRejectsWithFields(

promise: Promise<unknown>,

expected: Record<string, unknown>,

): Promise<Record<string, unknown>> {

try {

await promise;

} catch (error) {

const actual = requireRecord(error, "rejection");

for (const [key, value] of Object.entries(expected)) {

expect(actual[key]).toBe(value);

}

return actual;

}

throw new Error("expected promise to reject");

}

async function expectPathMissing(targetPath: string): Promise<void> {

try {

await fs.access(targetPath);

} catch (error) {

expect(requireRecord(error, "filesystem error").code).toBe("ENOENT");

return;

}

throw new Error(`expected ${targetPath} to be missing`);

}

async function withTempExecApprovalsFile(

file: Record<string, unknown>,

run: () => Promise<void>,

): Promise<void> {

const originalHome = process.env.HOME;

const home = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-cli-exec-approvals-"));

await fs.mkdir(path.join(home, ".openclaw"), { recursive: true });

await fs.writeFile(

path.join(home, ".openclaw", "exec-approvals.json"),

`${JSON.stringify(file)}\n`,

"utf-8",

);

process.env.HOME = home;

try {

await run();

} finally {

if (originalHome === undefined) {

delete process.env.HOME;

} else {

process.env.HOME = originalHome;

}

await fs.rm(home, { recursive: true, force: true });

}

}

async function withTempOpenClawHome(run: (home: string) => Promise<void>): Promise<void> {

const originalOpenClawHome = process.env.OPENCLAW_HOME;

const home = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-cli-home-"));

process.env.OPENCLAW_HOME = home;

try {

await run(home);

} finally {

if (originalOpenClawHome === undefined) {

delete process.env.OPENCLAW_HOME;

} else {

process.env.OPENCLAW_HOME = originalOpenClawHome;

}

await fs.rm(home, { recursive: true, force: true });

}

}

describe("runCliAgent spawn path", () => {

it("formats redacted CLI resume diagnostics without exposing raw session ids", () => {

const logLine = buildCliExecLogLine({

provider: "claude-cli",

model: "claude-opus-4-7",

promptChars: 42,

trigger: "heartbeat",

useResume: true,

cliSessionId: "claude-session-secret",

resolvedSessionId: "claude-session-secret",

reusableSessionId: "claude-session-secret",

hasHistoryPrompt: false,

});

expect(logLine).toContain("trigger=heartbeat");

expect(logLine).toContain("useResume=true");

expect(logLine).toContain("session=present");

expect(logLine).toContain("reuse=reusable");

expect(logLine).toContain("historyPrompt=none");

expect(logLine).not.toContain("claude-session-secret");

});

it("does not inject hardcoded 'Tools are disabled' text into CLI arguments", async () => {

supervisorSpawnMock.mockResolvedValueOnce(

createManagedRun({

reason: "exit",

exitCode: 0,

exitSignal: null,

durationMs: 50,

stdout: "ok",

stderr: "",

timedOut: false,

noOutputTimedOut: false,

}),

);

const backendConfig = {

command: "claude",

args: ["-p", "--output-format", "stream-json"],

output: "jsonl" as const,

input: "stdin" as const,

modelArg: "--model",

sessionArg: "--session-id",

systemPromptArg: "--append-system-prompt",

systemPromptWhen: "first" as const,

serialize: true,

};

const context: PreparedCliRunContext = {

params: {

sessionId: "s1",

sessionFile: "/tmp/session.jsonl",

workspaceDir: "/tmp",

prompt: "Run: node script.mjs",

provider: "claude-cli",

model: "sonnet",

timeoutMs: 1_000,

runId: "run-no-tools-disabled",

extraSystemPrompt: "You are a helpful assistant.",

},

started: Date.now(),

workspaceDir: "/tmp",

backendResolved: {

id: "claude-cli",

config: backendConfig,

bundleMcp: true,

pluginId: "anthropic",

},

preparedBackend: {

backend: backendConfig,

env: {},

},

reusableCliSession: {},

hadSessionFile: false,

contextEngineConfig: {},

modelId: "sonnet",

normalizedModel: "sonnet",

systemPrompt: "You are a helpful assistant.",

systemPromptReport: {} as PreparedCliRunContext["systemPromptReport"],

bootstrapPromptWarningLines: [],

authEpochVersion: 2,

};

await executePreparedCliRun(context);

const input = mockCallArg(supervisorSpawnMock) as { argv?: string[] };

const allArgs = (input.argv ?? []).join("\n");

expect(allArgs).not.toContain("Tools are disabled in this session");

expect(allArgs).toContain("You are a helpful assistant.");

});

it("includes the OpenClaw skills prompt in CLI system prompts", () => {

const systemPrompt = buildSystemPrompt({

workspaceDir: "/tmp",

modelDisplay: "claude-cli/sonnet",

tools: [],

skillsPrompt: [

"<available_skills>",

" <skill>",

" <name>weather</name>",

" <description>Use weather tools.</description>",

" <location>/tmp/skills/weather/SKILL.md</location>",

" </skill>",

"</available_skills>",

].join("\n"),

});

expect(systemPrompt).toContain("## Skills");

expect(systemPrompt).toContain("<name>weather</name>");

expect(systemPrompt).toContain("/tmp/skills/weather/SKILL.md");

});

it("pipes Claude prompts over stdin instead of argv", async () => {

supervisorSpawnMock.mockResolvedValueOnce(

createManagedRun({

reason: "exit",

exitCode: 0,

exitSignal: null,

durationMs: 50,

stdout: "ok",

stderr: "",

timedOut: false,

noOutputTimedOut: false,

}),

);

await executePreparedCliRun(

buildPreparedCliRunContext({

provider: "claude-cli",

model: "sonnet",

runId: "run-stdin-claude",

prompt: "Explain this diff",

}),

);

const input = mockCallArg(supervisorSpawnMock) as {

argv?: string[];

input?: string;

};

expect(input.input).toContain("Explain this diff");

expect(input.argv).not.toContain("Explain this diff");

});

it("passes Claude system prompts through a file instead of argv", async () => {

let systemPromptPath = "";

supervisorSpawnMock.mockImplementationOnce(async (...args: unknown[]) => {

const input = (args[0] ?? {}) as { argv?: string[] };

systemPromptPath = requireArgAfter(input.argv, "--append-system-prompt-file");

expect(systemPromptPath).toContain("openclaw-cli-system-prompt-");

await expect(fs.readFile(systemPromptPath, "utf-8")).resolves.toBe(

"You are a helpful assistant.",

);

expect(input.argv).not.toContain("You are a helpful assistant.");

return createManagedRun({

reason: "exit",

exitCode: 0,

exitSignal: null,

durationMs: 50,

stdout: "ok",

stderr: "",

timedOut: false,

noOutputTimedOut: false,

});

});

await executePreparedCliRun(

buildPreparedCliRunContext({

provider: "claude-cli",

model: "sonnet",

runId: "run-claude-system-prompt-file",

}),

);

await expectPathMissing(systemPromptPath);

});

it("passes --session-id for new Claude sessions", async () => {

mockSuccessfulCliRun();

await executePreparedCliRun(

buildPreparedCliRunContext({

provider: "claude-cli",

model: "sonnet",

runId: "run-claude-session-id",

}),

);

const input = mockCallArg(supervisorSpawnMock) as {

argv?: string[];

input?: string;

mode?: string;

};

expect(input.mode).toBe("child");

expect(input.argv).toContain("claude");

expect(requireArgAfter(input.argv, "--session-id")).not.toBe("");

expect(input.input).toContain("hi");

expect(input.argv).not.toContain("hi");

});

it("applies backend-owned per-run args before spawning", async () => {

mockSuccessfulCliRun();

const resolveExecutionArgs = vi.fn(({ baseArgs }) => [...baseArgs, "--effort", "high"]);

await executePreparedCliRun(

buildPreparedCliRunContext({

provider: "claude-cli",

model: "sonnet",

runId: "run-claude-thinking-args",

thinkLevel: "high",

resolveExecutionArgs,

}),

);

const resolveArgsInput = requireRecord(mockCallArg(resolveExecutionArgs), "resolved args");

expect(resolveArgsInput.provider).toBe("claude-cli");

expect(resolveArgsInput.modelId).toBe("sonnet");

expect(resolveArgsInput.thinkingLevel).toBe("high");

expect(resolveArgsInput.useResume).toBe(false);

expect(resolveArgsInput.baseArgs).toEqual(["-p", "--output-format", "stream-json"]);

const input = mockCallArg(supervisorSpawnMock) as { argv?: string[] };

expect(requireArgAfter(input.argv, "--effort")).toBe("high");

});

it("passes OpenClaw skills to Claude as a session plugin", async () => {

const workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-cli-skills-"));

const skillDir = path.join(workspaceDir, "skills", "weather");

await fs.mkdir(skillDir, { recursive: true });

await fs.writeFile(

path.join(skillDir, "SKILL.md"),

[

"---",

"name: weather",

"description: Use weather tools for forecasts.",

"---",

"",

"Read forecast data before replying.",

].join("\n"),

"utf-8",

);

let pluginDir = "";

supervisorSpawnMock.mockImplementationOnce(async (...args: unknown[]) => {

const input = (args[0] ?? {}) as { argv?: string[] };

pluginDir = requireArgAfter(input.argv, "--plugin-dir");

const manifest = JSON.parse(

await fs.readFile(path.join(pluginDir, ".claude-plugin", "plugin.json"), "utf-8"),

) as { name?: string; skills?: string };

expect(manifest.name).toBe("openclaw-skills");

expect(manifest.skills).toBe("./skills");

await expect(

fs.readFile(path.join(pluginDir, "skills", "weather", "SKILL.md"), "utf-8"),

).resolves.toContain("Read forecast data before replying.");

return createManagedRun({

reason: "exit",

exitCode: 0,

exitSignal: null,

durationMs: 50,

stdout: "ok",

stderr: "",

timedOut: false,

noOutputTimedOut: false,

});

});

try {

await executePreparedCliRun(

buildPreparedCliRunContext({

provider: "claude-cli",

model: "sonnet",

runId: "run-claude-skills-plugin",

workspaceDir,

skillsSnapshot: {

prompt: "",

skills: [{ name: "weather" }],

resolvedSkills: [

{

name: "weather",

description: "Use weather tools for forecasts.",

filePath: path.join(skillDir, "SKILL.md"),

baseDir: skillDir,

source: "test",

sourceInfo: {

path: skillDir,

source: "test",

scope: "project",

origin: "top-level",

baseDir: skillDir,

},

disableModelInvocation: false,

},

],

},

}),

);

let accessError: unknown;

try {

await fs.access(pluginDir);

} catch (error) {

accessError = error;

}

expect((accessError as NodeJS.ErrnoException | undefined)?.code).toBe("ENOENT");

} finally {

await fs.rm(workspaceDir, { recursive: true, force: true });

}

});

it("injects skill env overrides into CLI child env and restores host env", async () => {

const previousEnvValue = process.env.CLI_SKILL_API_KEY;

delete process.env.CLI_SKILL_API_KEY;

supervisorSpawnMock.mockImplementationOnce(async (...args: unknown[]) => {

const input = (args[0] ?? {}) as { env?: Record<string, string> };

expect(input.env?.CLI_SKILL_API_KEY).toBe("skill-secret");

return createManagedRun({

reason: "exit",

exitCode: 0,

exitSignal: null,

durationMs: 50,

stdout: "ok",

stderr: "",

timedOut: false,

noOutputTimedOut: false,

});

});

try {

await executePreparedCliRun(

buildPreparedCliRunContext({

provider: "claude-cli",

model: "sonnet",

runId: "run-claude-skill-env",

config: {

skills: {

entries: {

envskill: { apiKey: "skill-secret" }, // pragma: allowlist secret

},

},

},

skillsSnapshot: {

prompt: "",

skills: [{ name: "envskill", primaryEnv: "CLI_SKILL_API_KEY" }],

},

}),

);

expect(process.env.CLI_SKILL_API_KEY).toBeUndefined();

} finally {

if (previousEnvValue === undefined) {

delete process.env.CLI_SKILL_API_KEY;

} else {

process.env.CLI_SKILL_API_KEY = previousEnvValue;

}

}

});

it("ignores legacy claudeSessionId on the compat wrapper", () => {

const params = buildRunClaudeCliAgentParams({

sessionId: "openclaw-session",

sessionFile: "/tmp/session.jsonl",

workspaceDir: "/tmp",

prompt: "hi",

model: "opus",

timeoutMs: 1_000,

runId: "run-claude-legacy-wrapper",

claudeSessionId: "c9d7b831-1c31-4d22-80b9-1e50ca207d4b",

});

expect(params.provider).toBe("claude-cli");

expect(params.prompt).toBe("hi");

expect(params).not.toHaveProperty("cliSessionId");

expect(JSON.stringify(params)).not.toContain("c9d7b831-1c31-4d22-80b9-1e50ca207d4b");

});

it("forwards channel context through the compat wrapper", () => {

const params = buildRunClaudeCliAgentParams({

sessionId: "openclaw-session",

sessionFile: "/tmp/session.jsonl",

workspaceDir: "/tmp",

prompt: "hi",

timeoutMs: 1_000,

runId: "run-claude-channel-wrapper",

messageChannel: "telegram",

messageProvider: "acp",

});

expect(params.messageChannel).toBe("telegram");

expect(params.messageProvider).toBe("acp");

});

it("forwards static extra system prompt through the compat wrapper", () => {

const params = buildRunClaudeCliAgentParams({

sessionId: "openclaw-session",

sessionFile: "/tmp/session.jsonl",

workspaceDir: "/tmp",

prompt: "hi",

timeoutMs: 1_000,

runId: "run-claude-static-prompt-wrapper",

extraSystemPrompt: "dynamic\n\nstatic",

extraSystemPromptStatic: "static",

});

expect(params.extraSystemPrompt).toBe("dynamic\n\nstatic");

expect(params.extraSystemPromptStatic).toBe("static");

});

it("forwards cron jobId through the compat wrapper", () => {

const params = buildRunClaudeCliAgentParams({

sessionId: "openclaw-session",

sessionFile: "/tmp/session.jsonl",

workspaceDir: "/tmp",

prompt: "hi",

timeoutMs: 1_000,

runId: "run-claude-jobid-wrapper",

trigger: "cron",

jobId: "cron-job-123",

});

expect(params.trigger).toBe("cron");

expect(params.jobId).toBe("cron-job-123");

});

it("runs CLI through supervisor and returns payload", async () => {

supervisorSpawnMock.mockResolvedValueOnce(

createManagedRun({

reason: "exit",

exitCode: 0,

exitSignal: null,

durationMs: 50,

stdout: "ok",

stderr: "",

timedOut: false,

noOutputTimedOut: false,

}),

);

const context = buildPreparedCliRunContext({

provider: "codex-cli",

model: "gpt-5.4",

runId: "run-1",

});

context.reusableCliSession = { sessionId: "thread-123" };

const result = await executePreparedCliRun(context, "thread-123");

expect(result.text).toBe("ok");

const input = mockCallArg(supervisorSpawnMock) as {

argv?: string[];

mode?: string;

timeoutMs?: number;

noOutputTimeoutMs?: number;

replaceExistingScope?: boolean;

scopeKey?: string;

};

expect(input.mode).toBe("child");

expect(input.argv).toEqual([

"codex",

"exec",

"resume",

"thread-123",

"--skip-git-repo-check",

"--model",

"gpt-5.4",

"hi",

]);

expect(input.timeoutMs).toBe(1_000);

expect(input.noOutputTimeoutMs).toBeGreaterThanOrEqual(1_000);

expect(input.replaceExistingScope).toBe(true);

expect(input.scopeKey).toContain("thread-123");

});

it("passes Codex system prompts through model_instructions_file", async () => {

let promptFileText = "";

supervisorSpawnMock.mockImplementationOnce(async (...args: unknown[]) => {

const input = (args[0] ?? {}) as { argv?: string[] };

const configArg = requireArgAfter(input.argv, "-c");

const match = requireRegexMatch(configArg, /^model_instructions_file="(.+)"$/);

promptFileText = await fs.readFile(match[1], "utf-8");

return createManagedRun({

reason: "exit",

exitCode: 0,

exitSignal: null,

durationMs: 50,

stdout: "ok",

stderr: "",

timedOut: false,

noOutputTimedOut: false,

});

});

await executePreparedCliRun(

buildPreparedCliRunContext({

provider: "codex-cli",

model: "gpt-5.4",

runId: "run-codex-system-prompt-file",

}),

);

expect(promptFileText).toBe("You are a helpful assistant.");

});

it("cancels the managed CLI run when the abort signal fires", async () => {

const abortController = new AbortController();

let resolveWait:

| ((value: {

reason:

| "manual-cancel"

| "overall-timeout"

| "no-output-timeout"

| "spawn-error"

| "signal"

| "exit";

exitCode: number | null;

exitSignal: NodeJS.Signals | number | null;

durationMs: number;

stdout: string;

stderr: string;

timedOut: boolean;

noOutputTimedOut: boolean;

}) => void)

| undefined;

const cancel = vi.fn((reason?: string) => {

if (!resolveWait) {

throw new Error("Expected managed CLI wait resolver to be initialized");

}

resolveWait({

reason: reason === "manual-cancel" ? "manual-cancel" : "signal",

exitCode: null,

exitSignal: null,

durationMs: 50,

stdout: "",

stderr: "",

timedOut: false,

noOutputTimedOut: false,

});

});

supervisorSpawnMock.mockResolvedValueOnce({

runId: "run-supervisor",

pid: 1234,

startedAtMs: Date.now(),

stdin: undefined,

wait: vi.fn(

async () =>

await new Promise((resolve) => {

resolveWait = resolve;

}),

),

cancel,

});

const context = buildPreparedCliRunContext({

provider: "codex-cli",

model: "gpt-5.4",

runId: "run-abort",

});

context.params.abortSignal = abortController.signal;

const runPromise = executePreparedCliRun(context);

await vi.waitFor(() => {

expect(supervisorSpawnMock).toHaveBeenCalledTimes(1);

});

abortController.abort();

await expectRejectsWithFields(runPromise, { name: "AbortError" });

expect(cancel).toHaveBeenCalledWith("manual-cancel");

});

it("streams Claude text deltas from stream-json stdout", async () => {

const agentEvents: Array<{ stream: string; text?: string; delta?: string }> = [];

const stop = onAgentEvent((evt) => {

agentEvents.push({

stream: evt.stream,

text: typeof evt.data.text === "string" ? evt.data.text : undefined,

delta: typeof evt.data.delta === "string" ? evt.data.delta : undefined,

});

});

supervisorSpawnMock.mockImplementationOnce(async (...args: unknown[]) => {

const input = (args[0] ?? {}) as { onStdout?: (chunk: string) => void };

input.onStdout?.(

[

JSON.stringify({ type: "init", session_id: "session-123" }),

JSON.stringify({

type: "stream_event",

event: { type: "content_block_delta", delta: { type: "text_delta", text: "Hello" } },

}),

].join("\n") + "\n",

);

input.onStdout?.(

JSON.stringify({

type: "stream_event",

event: { type: "content_block_delta", delta: { type: "text_delta", text: " world" } },

}) + "\n",

);

input.onStdout?.(

JSON.stringify({

type: "result",

session_id: "session-123",

result: "Hello world",

}) + "\n",

);

return createManagedRun({

reason: "exit",

exitCode: 0,

exitSignal: null,

durationMs: 50,

stdout: "",

stderr: "",

timedOut: false,

noOutputTimedOut: false,

});

});

try {

const result = await executePreparedCliRun(

buildPreparedCliRunContext({

provider: "claude-cli",

model: "sonnet",

runId: "run-claude-stream-json",

}),

);

expect(result.text).toBe("Hello world");

expect(agentEvents).toEqual([

{ stream: "assistant", text: "Hello", delta: "Hello" },

{ stream: "assistant", text: "Hello world", delta: " world" },

]);

} finally {

stop();

}

});

it("reuses a Claude live session process across turns", async () => {

const agentEvents: unknown[] = [];

const stop = onAgentEvent((evt) => {

if (evt.stream === "assistant") {

agentEvents.push(evt.data);

}

});

const writes: string[] = [];

let stdoutListener: ((chunk: string) => void) | undefined;

const stdin = {

write: vi.fn((data: string, cb?: (err?: Error | null) => void) => {

writes.push(data);

const prompt = (JSON.parse(data) as { message: { content: string } }).message.content;

const text = prompt === "first" ? "one" : "two";

stdoutListener?.(

[

JSON.stringify({ type: "system", subtype: "init", session_id: "live-session-1" }),

JSON.stringify({

type: "stream_event",

event: {

type: "content_block_delta",

delta: { type: "text_delta", text },

},

}),

JSON.stringify({

type: "result",

session_id: "live-session-1",

result: text,

}),

].join("\n") + "\n",

);

cb?.();

}),

end: vi.fn(),

};

supervisorSpawnMock.mockImplementation(async (...args: unknown[]) => {

const input = (args[0] ?? {}) as { onStdout?: (chunk: string) => void };

stdoutListener = input.onStdout;

return {

runId: "live-run",

pid: 2345,

startedAtMs: Date.now(),

stdin,

wait: vi.fn(() => new Promise(() => {})),

cancel: vi.fn(),

};

});

try {

const first = await executePreparedCliRun(

buildPreparedCliRunContext({

provider: "claude-cli",

model: "sonnet",

runId: "run-live-1",

prompt: "first",

backend: {

args: ["-p", "--strict-mcp-config", "--mcp-config", "/tmp/mcp-one.json"],

liveSession: "claude-stdio",

},

mcpConfigHash: "same-mcp-config",

}),

);

const second = await executePreparedCliRun(

buildPreparedCliRunContext({

provider: "claude-cli",

model: "sonnet",

runId: "run-live-2",

prompt: "second",

backend: {

args: ["-p", "--strict-mcp-config", "--mcp-config", "/tmp/mcp-two.json"],

liveSession: "claude-stdio",

},

mcpConfigHash: "same-mcp-config",

}),

);

const spawnInput = mockCallArg(supervisorSpawnMock) as {

argv?: string[];

stdinMode?: string;

};

expect(first.text).toBe("one");

expect(second.text).toBe("two");

expect(supervisorSpawnMock).toHaveBeenCalledOnce();

expect(spawnInput.stdinMode).toBe("pipe-open");

expect(spawnInput.argv).toContain("--input-format");

expect(spawnInput.argv).toContain("--output-format");

expect(spawnInput.argv).toContain("stream-json");

expect(spawnInput.argv).toContain("--replay-user-messages");

expect(spawnInput.argv).not.toContain("--session-id");

expect(spawnInput.argv).toContain("/tmp/mcp-one.json");

expect(

writes.map(

(entry) => (JSON.parse(entry) as { message: { content: string } }).message.content,

),

).toEqual(["first", "second"]);

expect(agentEvents).toEqual([

{ text: "one", delta: "one" },

{ text: "two", delta: "two" },

]);

} finally {

stop();

}

});

it("defers prepared backend cleanup to the Claude live session lifecycle", async () => {

let stdoutListener: ((chunk: string) => void) | undefined;

const stdin = {

write: vi.fn((dataValue: string, cb?: (err?: Error | null) => void) => {

stdoutListener?.(

[

JSON.stringify({ type: "system", subtype: "init", session_id: "live-session-cleanup" }),

JSON.stringify({

type: "result",

session_id: "live-session-cleanup",

result: "ok",

}),

].join("\n") + "\n",

);

cb?.();

}),

end: vi.fn(),

};

supervisorSpawnMock.mockImplementation(async (...args: unknown[]) => {