message: " ping\n",

chunks: [" ACP_OK\n"],

});

const runTurnInput = runTurn.mock.calls[0]?.[0] as

const runTurnInput = runTurn.mock.calls.at(0)?.[0] as

| { mode?: string; sessionKey?: string; text?: string }

| undefined;

expect(runTurnInput?.sessionKey).toBe("agent:codex:acp:test");

await agentCommand({ message: "ping", sessionKey: "agent:kimi:acp:test" }, runtime);

const runTurnInput = runTurn.mock.calls[0]?.[0] as

const runTurnInput = runTurn.mock.calls.at(0)?.[0] as

| { sessionKey?: string; text?: string }

| undefined;

expect(runTurnInput?.sessionKey).toBe("agent:kimi:acp:test");

});

expect(loadOpenClawPlugins).toHaveBeenCalledTimes(1);

const firstLoadCall = vi.mocked(loadOpenClawPlugins).mock.calls[0]?.[0] as

const firstLoadCall = vi.mocked(loadOpenClawPlugins).mock.calls.at(0)?.[0] as

| { onlyPluginIds?: string[] }

| undefined;

expect(firstLoadCall?.onlyPluginIds).toStrictEqual([]);

runtime,

});

const call = select.mock.calls[0];

const call = select.mock.calls.at(0);

if (!call) {

throw new Error("Expected select call");

}

expect(ensureChannelSetupPluginInstalled).not.toHaveBeenCalled();

expect(registryRefreshMocks.refreshPluginRegistryAfterConfigMutation).not.toHaveBeenCalled();

const writtenConfig = configMocks.writeConfigFile.mock.calls[0]?.[0] as

const writtenConfig = configMocks.writeConfigFile.mock.calls.at(0)?.[0] as

| { channels?: Record<string, unknown> }

| undefined;

expect(writtenConfig?.channels?.["external-chat"]).toBeUndefined();

clientName: "gateway-client",

deviceIdentity: null,

});

const writtenConfig = configMocks.writeConfigFile.mock.calls[0]?.[0] as

const writtenConfig = configMocks.writeConfigFile.mock.calls.at(0)?.[0] as

| { channels?: Record<string, unknown> }

| undefined;

expect(writtenConfig?.channels?.["external-chat"]).toBeUndefined();

);

expect(noteFn).toHaveBeenCalledTimes(1);

const [message, title] = noteFn.mock.calls[0] ?? [];

const [message, title] = noteFn.mock.calls.at(0) ?? [];

expect(title).toBe("Startup optimization");

expect(message).toBe(

[

);

expect(noteFn).toHaveBeenCalledTimes(1);

const [message] = noteFn.mock.calls[0] ?? [];

const [message] = noteFn.mock.calls.at(0) ?? [];

expect(message).toBe(

[

"- NODE_DISABLE_COMPILE_CACHE is set; startup compile cache is disabled.",

// The warning should clearly indicate sandbox is enabled but won't work

expect(note).toHaveBeenCalled();

const noteCall = note.mock.calls[0];

const noteCall = note.mock.calls.at(0);

if (noteCall === undefined) {

throw new Error("expected sandbox warning note");

}

const message = noteCall[0] as string;

// The message should warn that sandbox mode won't function, not just "skipping checks"

await runSandboxRepair({ mode: "all", dockerAvailable: false });

expect(note).toHaveBeenCalled();

const noteCall = note.mock.calls[0];

const noteCall = note.mock.calls.at(0);

if (noteCall === undefined) {

throw new Error("expected sandbox warning note");

}

const message = noteCall[0] as string;

// Should warn about the impact on sandbox functionality

expect(canonical).toContain("# Legacy");

await expectPathMissing(path.join(tmpDir, "memory.md"));

expect(note).toHaveBeenCalledTimes(1);

const repairMessage = String(note.mock.calls[0]?.[0] ?? "");

const repairMessage = String(note.mock.calls.at(0)?.[0] ?? "");

const repairLines = repairMessage.split("\n");

expect(repairLines[0]).toBe("Workspace memory root merged:");

expect(repairLines).toContain(`- canonical: ${path.join(tmpDir, "MEMORY.md")}`);

expect(repairLines).toContain(

`- merged legacy content from: ${path.join(tmpDir, "memory.md")}`,

);

expect(repairLines).toContain(`- removed legacy file: ${path.join(tmpDir, "memory.md")}`);

expect(note.mock.calls[0]?.[1]).toBe("Doctor changes");

expect(note.mock.calls.at(0)?.[1]).toBe("Doctor changes");

});

});

});

expect(applyPluginDoctorCompatibilityMigrations).toHaveBeenCalledOnce();

const migrationCall = applyPluginDoctorCompatibilityMigrations.mock.calls[0];

const migrationCall = applyPluginDoctorCompatibilityMigrations.mock.calls.at(0);

expect(typeof migrationCall?.[0]).toBe("object");

expect(migrationCall?.[1]?.config).toStrictEqual({

channels: {

const result = applyChannelDoctorCompatibilityMigrations(config);

expect(applyPluginDoctorCompatibilityMigrations).toHaveBeenCalledOnce();

const migrationCall = applyPluginDoctorCompatibilityMigrations.mock.calls[0];

const migrationCall = applyPluginDoctorCompatibilityMigrations.mock.calls.at(0);

expect(typeof migrationCall?.[0]).toBe("object");

expect(migrationCall?.[1]).toStrictEqual({

config,

function readOnlyMessageActionCall(): RunMessageActionParams {

expect(runMessageActionMock).toHaveBeenCalledOnce();

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

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

if (!call) {

throw new Error("Expected message action call");

}

expect(actionCall.gateway?.clientName).toBe("cli");

expect(actionCall.gateway?.mode).toBe("cli");

expect(actionCall.cfg).not.toBe(rawConfig);

const configResolutionCall = resolveCommandConfigWithSecrets.mock.calls[0]?.[0] as {

const configResolutionCall = resolveCommandConfigWithSecrets.mock.calls.at(0)?.[0] as {

commandName?: string;

config?: unknown;

targetIds?: Set<string>;

appliedCount: 1,

});

expect(mocks.runSessionsCleanup).toHaveBeenCalledOnce();

const cleanupCall = mocks.runSessionsCleanup.mock.calls[0]?.[0];

const cleanupCall = mocks.runSessionsCleanup.mock.calls.at(0)?.[0];

expect(cleanupCall?.cfg).toEqual({ session: { store: "/cfg/sessions.json" } });

expect(cleanupCall?.opts.enforce).toBe(true);

expect(cleanupCall?.opts.activeKey).toBe("agent:main:main");

);

expect(mocks.callGateway).toHaveBeenCalledOnce();

const gatewayCall = mocks.callGateway.mock.calls[0]?.[0];

const gatewayCall = mocks.callGateway.mock.calls.at(0)?.[0];

expect(gatewayCall?.method).toBe("sessions.cleanup");

expect(gatewayCall?.params.enforce).toBe(true);

expect(gatewayCall?.requiredMethods).toEqual(["sessions.cleanup"]);

await scanStatusJsonFast({}, {} as never);

expect(mocks.getStatusSummary).toHaveBeenCalledOnce();

const summaryOptions = mocks.getStatusSummary.mock.calls[0]?.[0] as

const summaryOptions = mocks.getStatusSummary.mock.calls.at(0)?.[0] as

| { includeChannelSummary?: unknown }

| undefined;

expect(summaryOptions?.includeChannelSummary).toBe(false);

});

expect(mocks.resolveMemorySearchConfig).toHaveBeenCalled();

expect(mocks.getMemorySearchManager).toHaveBeenCalledOnce();

expect(mocks.getMemorySearchManager.mock.calls[0]?.[0]).toStrictEqual({

expect(mocks.getMemorySearchManager.mock.calls.at(0)?.[0]).toStrictEqual({

cfg: createStatusMemorySearchConfig(),

agentId: "main",

purpose: "status",