);

expect(params.runEmbeddedPiAgentMock).toHaveBeenCalledOnce();

const runParams = params.runEmbeddedPiAgentMock.mock.calls[0]?.[0] as

const runParams = params.runEmbeddedPiAgentMock.mock.calls.at(0)?.[0] as

| Record<string, unknown>

| undefined;

if (!runParams) {

expect(text, testCase.label).not.toMatch(/Thinking level set/i);

expect(runEmbeddedPiAgentMock, testCase.label).toHaveBeenCalledOnce();

if (testCase.assertPrompt) {

const prompt = runEmbeddedPiAgentMock.mock.calls[0]?.[0]?.prompt ?? "";

const prompt = runEmbeddedPiAgentMock.mock.calls.at(0)?.[0]?.prompt ?? "";

expect(prompt).toContain("Give me the status");

expect(prompt).not.toContain("/thinking high");

expect(prompt).not.toContain("/think high");

testCase.setup(cfg);

await getReplyFromConfig(BASE_MESSAGE, { isHeartbeat: true }, cfg);

const call = runEmbeddedPiAgentMock.mock.calls[0]?.[0];

const call = runEmbeddedPiAgentMock.mock.calls.at(0)?.[0];

expect(call?.provider).toBe(testCase.expected.provider);

expect(call?.model).toBe(testCase.expected.model);

}

const text = maybeReplyText(res);

expect(text?.startsWith("⚙️ Compacted")).toBe(true);

expect(getCompactEmbeddedPiSessionMock()).toHaveBeenCalledOnce();

expect(getCompactEmbeddedPiSessionMock().mock.calls[0]?.[0]?.sessionFile).toContain(

expect(getCompactEmbeddedPiSessionMock().mock.calls.at(0)?.[0]?.sessionFile).toContain(

join("agents", "worker1", "sessions"),

);

});

await channelsAddCommand({}, runtime, { hasFlags: false });

expect(channelWizardMocks.prompter.intro).toHaveBeenCalledWith("Channel setup");

expect(channelWizardMocks.setupChannels.mock.calls[0]?.[0]).toBe(config);

expect(channelWizardMocks.setupChannels.mock.calls[0]?.[1]).toBe(runtime);

expect(channelWizardMocks.setupChannels.mock.calls[0]?.[2]).toBe(channelWizardMocks.prompter);

expect(channelWizardMocks.setupChannels.mock.calls.at(0)?.[0]).toBe(config);

expect(channelWizardMocks.setupChannels.mock.calls.at(0)?.[1]).toBe(runtime);

expect(channelWizardMocks.setupChannels.mock.calls.at(0)?.[2]).toBe(

channelWizardMocks.prompter,

);

expect(setupOptions().deferStatusUntilSelection).toBe(true);

expect(setupOptions().skipStatusNote).toBe(true);

expect(setupOptions().promptAccountIds).toBe(true);

expect(configMocks.writeConfigFile.mock.invocationCallOrder[0]).toBeLessThan(

afterAccountConfigWritten.mock.invocationCallOrder[0] ?? Number.POSITIVE_INFINITY,

);

const hookCall = requireRecord(afterAccountConfigWritten.mock.calls[0]?.[0], "hook call");

const hookCall = requireRecord(afterAccountConfigWritten.mock.calls.at(0)?.[0], "hook call");

expect(hookCall.previousCfg).toBe(baseConfigSnapshot.config);

expect(requireRecord(hookCall.cfg, "hook config").channels).toEqual({

signal: {

await runWebConfigureWizard();

const setupConfig = requireRecord(mocks.setupSearch.mock.calls[0]?.[0], "setupSearch config");

const setupConfig = requireRecord(

mocks.setupSearch.mock.calls.at(0)?.[0],

"setupSearch config",

);

expect(getGateway(setupConfig).mode).toBe("local");

const written = requireWriteConfig();

const search = getWebSearch(written);

await runWebConfigureWizard();

const ownersRequest = requireRecord(

mocks.resolvePluginContributionOwners.mock.calls[0]?.[0],

mocks.resolvePluginContributionOwners.mock.calls.at(0)?.[0],

"plugin owner request",

);

expect(ownersRequest.contribution).toBe("contracts");

await runConfigureWizard({ command: "configure", sections: ["channels"] }, createRuntime());

const setupChannelsCall = mocks.setupChannels.mock.calls[0] as Array<unknown> | undefined;

const setupChannelsCall = mocks.setupChannels.mock.calls.at(0) as Array<unknown> | undefined;

const setupChannelsConfig = requireRecord(setupChannelsCall?.[0], "setupChannels config");

expect(getGateway(setupChannelsConfig).mode).toBe("local");

const setupChannelsOptions = requireRecord(setupChannelsCall?.[3], "setupChannels options");

expect(mocks.readConfigFileSnapshot).toHaveBeenCalledTimes(3);

// Verify plugin-written nested config survived the retry merge.

const retryCall = mocks.replaceConfigFile.mock.calls[1][0] as {

const retryCall = mocks.replaceConfigFile.mock.calls.at(1)?.[0] as {

nextConfig: Record<string, unknown>;

};

const agents = requireRecord(retryCall.nextConfig.agents, "agents config");

await runGatewayStatus(runtime, { timeout: "1000", json: true, sshAuto: true });

expect(startSshPortForward).toHaveBeenCalledTimes(1);

const call = startSshPortForward.mock.calls[0]?.[0] as { target: string };

const call = startSshPortForward.mock.calls.at(0)?.[0] as { target: string };

expect(call.target).toBe("steipete@goodhost:2222");

});

});

await runGatewayStatus(runtime, { timeout: "1000", json: true });

expect(startSshPortForward).toHaveBeenCalledTimes(1);

const call = startSshPortForward.mock.calls[0]?.[0] as {

const call = startSshPortForward.mock.calls.at(0)?.[0] as {

target: string;

identity?: string;

};

startSshPortForward.mockClear();

await runGatewayStatus(runtime, { timeout: "1000", json: true });

const call = startSshPortForward.mock.calls[0]?.[0] as {

const call = startSshPortForward.mock.calls.at(0)?.[0] as {

target: string;

};

expect(call.target).toBe("studio.example");

sshIdentity: "/tmp/explicit_id",

});

const call = startSshPortForward.mock.calls[0]?.[0] as {

const call = startSshPortForward.mock.calls.at(0)?.[0] as {

identity?: string;

};

expect(call.identity).toBe("/tmp/explicit_id");

await modelsListCommand({ all: true, provider: "openai", json: true }, runtime as never);

expect(mocks.loadModelRegistry.mock.calls[0]?.[0]).toBe(mocks.resolvedConfig);

expect(mocks.loadModelRegistry.mock.calls.at(0)?.[0]).toBe(mocks.resolvedConfig);

expect(modelRegistryOptions().providerFilter).toBe("openai");

expect(modelRegistryOptions().normalizeModels).toBe(true);

expectRowKeys(lastPrintedRows<{ key: string }>(), ["openai/gpt-5.4", "openai/gpt-5.5-pro"]);

await modelsListCommand({ all: true, json: true }, runtime as never);

expect(mocks.loadModelRegistry.mock.calls[0]?.[0]).toBe(mocks.resolvedConfig);

expect(mocks.loadModelRegistry.mock.calls.at(0)?.[0]).toBe(mocks.resolvedConfig);

expect(modelRegistryOptions().providerFilter).toBeUndefined();

expect(modelRegistryOptions().normalizeModels).toBe(false);

expect(mocks.loadProviderCatalogModelsForList).not.toHaveBeenCalled();

runtime as never,

);

expect(mocks.loadModelRegistry.mock.calls[0]?.[0]).toBe(mocks.resolvedConfig);

expect(mocks.loadModelRegistry.mock.calls.at(0)?.[0]).toBe(mocks.resolvedConfig);

expect(modelRegistryOptions().providerFilter).toBe("openai-codex");

expect(modelRegistryOptions().normalizeModels).toBe(true);

expect(mocks.loadProviderCatalogModelsForList).toHaveBeenNthCalledWith(1, {

await modelsListCommand({ all: true, provider: "anthropic", json: true }, runtime as never);

expect(mocks.loadModelRegistry.mock.calls[0]?.[0]).toBe(mocks.resolvedConfig);

expect(mocks.loadModelRegistry.mock.calls.at(0)?.[0]).toBe(mocks.resolvedConfig);

expect(modelRegistryOptions().providerFilter).toBe("anthropic");

expect(modelRegistryOptions().normalizeModels).toBe(false);

expect(modelRegistryOptions().loadAvailability).toBe(false);

const runtime = createRuntime();

await tasksAuditCommand({ json: true }, runtime);

const payload = JSON.parse(String(vi.mocked(runtime.log).mock.calls[0]?.[0])) as {

const payload = JSON.parse(String(vi.mocked(runtime.log).mock.calls.at(0)?.[0])) as {

summary: {

total: number;

errors: number;

const limitedRuntime = createRuntime();

await tasksAuditCommand({ json: true, limit: 1 }, limitedRuntime);

const limitedPayload = JSON.parse(String(vi.mocked(limitedRuntime.log).mock.calls[0]?.[0]));

const limitedPayload = JSON.parse(

String(vi.mocked(limitedRuntime.log).mock.calls.at(0)?.[0]),

);

expect(limitedPayload.findings).toStrictEqual([

{

const runtime = createRuntime();

await tasksMaintenanceCommand({ json: true, apply: false }, runtime);

const payload = JSON.parse(String(vi.mocked(runtime.log).mock.calls[0]?.[0])) as {

const payload = JSON.parse(String(vi.mocked(runtime.log).mock.calls.at(0)?.[0])) as {

mode: string;

maintenance: { taskFlows: { pruned: number } };

auditBefore: {

const runtime = createRuntime();

await tasksMaintenanceCommand({ json: true, apply: true }, runtime);

const payload = JSON.parse(String(vi.mocked(runtime.log).mock.calls[0]?.[0])) as {

const payload = JSON.parse(String(vi.mocked(runtime.log).mock.calls.at(0)?.[0])) as {

maintenance: {

sessions: {

pruned: number;

});

expect(agentCommand).toHaveBeenCalledTimes(1);

const call = agentCommand.mock.calls[0]?.[0];

const call = agentCommand.mock.calls.at(0)?.[0];

expect(call?.deliver).toBe(false);

expect(call?.sessionKey).toBe(resolveMainSessionKey({}));

expect(call?.message).toContain("BOOT.md:");

});

expect(agentCommand).toHaveBeenCalledTimes(1);

const perAgentCall = agentCommand.mock.calls[0]?.[0];

const perAgentCall = agentCommand.mock.calls.at(0)?.[0];

expect(perAgentCall?.sessionKey).toBe(resolveAgentMainSessionKey({ cfg, agentId }));

});

});

});

expect(agentCommand).toHaveBeenCalledTimes(1);

const call = agentCommand.mock.calls[0]?.[0];

const call = agentCommand.mock.calls.at(0)?.[0];

// Verify a boot-style session ID was generated (format: boot-YYYY-MM-DD_HH-MM-SS-xxx-xxxxxxxx)

expect(call?.sessionId).toMatch(

});

expect(agentCommand).toHaveBeenCalledTimes(1);

const call = agentCommand.mock.calls[0]?.[0];

const call = agentCommand.mock.calls.at(0)?.[0];

expect(call?.sessionId).not.toBe(existingSessionId);

expect(call?.sessionId).toMatch(

onConnectError: ReturnType<typeof vi.fn>,

params?: { expectTailscaleHint?: boolean },

) {

const error = onConnectError.mock.calls[0]?.[0] as Error;

const error = onConnectError.mock.calls.at(0)?.[0] as Error;

expect(error.message).toContain("SECURITY ERROR");

expect(error.message).toContain("openclaw doctor --fix");

if (params?.expectTailscaleHint) {

client.stop();

await vi.waitFor(() => {

const error = onConnectError.mock.calls[0]?.[0] as Error | undefined;

const error = onConnectError.mock.calls.at(0)?.[0] as Error | undefined;

expect(error?.message).toBe("gateway client stopped");

});

expect(logDebugMock).toHaveBeenCalledWith(

emitConnectChallenge(ws);

const loadTokenParams = expectRecordFields(

loadDeviceAuthTokenMock.mock.calls[0]?.[0],

loadDeviceAuthTokenMock.mock.calls.at(0)?.[0],

{

role: "operator",

env,

failureDetails: { code: "AUTH_DEVICE_TOKEN_MISMATCH" },

});

const clearTokenParams = expectRecordFields(

clearDeviceAuthTokenMock.mock.calls[0]?.[0],

clearDeviceAuthTokenMock.mock.calls.at(0)?.[0],

{ role: "operator" },

"clear device token params",

);

function getOnlyRestartCall(harness: ReloaderHarness): [GatewayReloadPlan, OpenClawConfig] {

expect(harness.onRestart).toHaveBeenCalledTimes(1);

const call = harness.onRestart.mock.calls[0];

const call = harness.onRestart.mock.calls.at(0);

if (!call) {

throw new Error("expected one restart call");

}

function getOnlyHotReloadCall(harness: ReloaderHarness): [GatewayReloadPlan, OpenClawConfig] {

expect(harness.onHotReload).toHaveBeenCalledTimes(1);

const call = harness.onHotReload.mock.calls[0];

const call = harness.onHotReload.mock.calls.at(0);

if (!call) {

throw new Error("expected one hot reload call");

}

expect(readSnapshot).toHaveBeenCalledTimes(1);

expect(harness.onHotReload).toHaveBeenCalledTimes(1);

const [promotedSnapshot, promotionReason] = promoteSnapshot.mock.calls[0] ?? [];

const [promotedSnapshot, promotionReason] = promoteSnapshot.mock.calls.at(0) ?? [];

expect(promotedSnapshot?.hash).toBe("internal-1");

expect(promotionReason).toBe("in-process-write");

expect(harness.log.info).toHaveBeenCalledWith(

"config reload skipped by writer intent (caller handles follow-up)",

);

const [promotedSnapshot, promotionReason] = promoteSnapshot.mock.calls[0] ?? [];

const [promotedSnapshot, promotionReason] = promoteSnapshot.mock.calls.at(0) ?? [];

expect(promotedSnapshot?.hash).toBe("internal-none");

expect(promotionReason).toBe("in-process-write");

await invokeUpdateRun({ timeoutMs: 1 });

expect(runGatewayUpdateMock).toHaveBeenCalledTimes(1);

const updateCall = runGatewayUpdateMock.mock.calls[0] as unknown as

const updateCall = runGatewayUpdateMock.mock.calls.at(0) as unknown as

| [{ timeoutMs?: number }]

| undefined;

const updateParams = updateCall?.[0];

expect(runGatewayUpdateMock).toHaveBeenCalledTimes(1);

expect(scheduleGatewaySigusr1RestartMock).toHaveBeenCalledTimes(1);

const restartCall = scheduleGatewaySigusr1RestartMock.mock.calls[0] as unknown as

const restartCall = scheduleGatewaySigusr1RestartMock.mock.calls.at(0) as unknown as

| [{ delayMs?: number; reason?: string; skipCooldown?: boolean; skipDeferral?: boolean }]

| undefined;

const restartParams = restartCall?.[0];

} as never);

expect(respond).toHaveBeenCalledTimes(1);

const response = respond.mock.calls[0]?.[1] as

const response = respond.mock.calls.at(0)?.[1] as

| { sentinel?: { kind?: string; status?: string } }

| undefined;

expect(respond.mock.calls[0]?.[0]).toBe(true);

expect(respond.mock.calls.at(0)?.[0]).toBe(true);

expect(response?.sentinel?.kind).toBe("update");

expect(response?.sentinel?.status).toBe("ok");

});