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> {

await expect(fs.access(targetPath)).rejects.toMatchObject({ code: "ENOENT" });

try {

await fs.access(targetPath);

} catch (error) {

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

return;

}

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

}

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

}),

);

await expect(fs.access(systemPromptPath)).rejects.toMatchObject({ code: "ENOENT" });

await expectPathMissing(systemPromptPath);

});

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

}),

);

expect(resolveExecutionArgs).toHaveBeenCalledWith(

expect.objectContaining({

provider: "claude-cli",

modelId: "sonnet",

thinkingLevel: "high",

useResume: false,

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

}),

);

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 = supervisorSpawnMock.mock.calls[0]?.[0] as { argv?: string[] };

const effortArgIndex = input.argv?.indexOf("--effort") ?? -1;

expect(effortArgIndex).toBeGreaterThanOrEqual(0);

const manifest = JSON.parse(

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

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

expect(manifest).toMatchObject({

name: "openclaw-skills",

skills: "./skills",

});

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.");

});

abortController.abort();

await expect(runPromise).rejects.toMatchObject({ name: "AbortError" });

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

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

});

};

});

await expect(

await expectRejectsWithFields(

executePreparedCliRun(

buildPreparedCliRunContext({

provider: "claude-cli",

},

}),

),

).rejects.toMatchObject({

name: "FailoverError",

message: "Claude CLI JSONL line exceeded output limit.",

});

{

name: "FailoverError",

message: "Claude CLI JSONL line exceeded output limit.",

},

);

});

it("accepts operator-raised Claude live stream-json raw turn limits", async () => {

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

);

await expect(run).resolves.toMatchObject({ text: "done" });

const result = await run;

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

expect(replyRunRegistry.isStreaming("agent:main:main")).toBe(false);

operation.complete();

});

useResume: false,

});

expect(args).toEqual(

expect.arrayContaining([

"--input-format",

"stream-json",

"--output-format",

"stream-json",

"--permission-prompt-tool",

"stdio",

]),

);

expect(requireArgAfter(args, "--input-format")).toBe("stream-json");

expect(requireArgAfter(args, "--output-format")).toBe("stream-json");

expect(requireArgAfter(args, "--permission-prompt-tool")).toBe("stdio");

});

it("restarts Claude live sessions for env changes and fresh retries", async () => {

};

});

await expect(

await expectRejectsWithFields(

executePreparedCliRun(

buildPreparedCliRunContext({

provider: "claude-cli",

},

}),

),

).rejects.toMatchObject({

name: "FailoverError",

message: "Credit balance is too low",

});

{

name: "FailoverError",

message: "Credit balance is too low",

},

);

});

it("fails when Claude exits before a live turn starts", async () => {

});

abortController.abort();

await expect(first).rejects.toMatchObject({ name: "AbortError" });

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

expect(cancels[0]).toHaveBeenCalledWith("manual-cancel");

stdoutListener?.(

[

);

expect(first.text).toBe("first-ok");

await expect(second).rejects.toMatchObject({

await expectRejectsWithFields(second, {

name: "FailoverError",

message: "Claude CLI failed.",

});

}),

);

await expect(run).rejects.toMatchObject({

await expectRejectsWithFields(run, {

name: "FailoverError",

message,

reason: "billing",