},

});

expect(host.chatSideResult).toMatchObject({

kind: "btw",

runId: "btw-run-1",

question: "what changed?",

text: "Only the UI layer is missing support.",

});

const sideResult = host.chatSideResult as

| { kind?: string; runId?: string; question?: string; text?: string }

| undefined;

expect(sideResult?.kind).toBe("btw");

expect(sideResult?.runId).toBe("btw-run-1");

expect(sideResult?.question).toBe("what changed?");

expect(sideResult?.text).toBe("Only the UI layer is missing support.");

expect(host.chatSideResultTerminalRuns.has("btw-run-1")).toBe(true);

});

quickSettingsProps.current?.onToolProfileChange?.("full");

expect(state.configForm?.browser).toEqual({ enabled: true });

expect(state.configForm?.tools).toMatchObject({

profile: "full",

exec: { security: "full" },

});

const tools = state.configForm?.tools as

| { profile?: string; exec?: { security?: string } }

| undefined;

expect(tools?.profile).toBe("full");

expect(tools?.exec?.security).toBe("full");

});

it("renders stale cron state containing a job without a payload", () => {

contextTokens: 200_000,

};

const lowUsage = getContextNoticeViewModel(lowUsageSession, 200_000);

expect(lowUsage).toMatchObject({

pct: 23,

detail: "46k / 200k",

warning: false,

compactRecommended: false,

});

if (!lowUsage) {

throw new Error("expected low usage context notice");

}

expect(lowUsage.pct).toBe(23);

expect(lowUsage.detail).toBe("46k / 200k");

expect(lowUsage.warning).toBe(false);

expect(lowUsage.compactRecommended).toBe(false);

render(renderContextNotice(lowUsageSession, 200_000), container);

expect(container.textContent).toContain("23% context used");

expect(container.textContent).toContain("46k / 200k");

it("builds fallback commands from the browser-safe shared registry", async () => {

const mod = (await import(browserImportPath)) as SlashCommandsModule;

expect(mod.SLASH_COMMANDS.find((command) => command.name === "think")).toMatchObject({

name: "think",

category: "model",

});

const thinkCommand = mod.SLASH_COMMANDS.find((command) => command.name === "think");

expect(thinkCommand?.name).toBe("think");

expect(thinkCommand?.category).toBe("model");

});

it("keeps provider thinking runtime out of the Control UI import path", async () => {

expect(sidebarButton?.classList.contains("chat-tool-card__action-btn")).toBe(true);

sidebarButton!.click();

expect(onOpenSidebar).toHaveBeenCalledWith(

expect.objectContaining({

kind: "canvas",

docId: "cv_sidebar",

entryUrl: "/__openclaw__/canvas/documents/cv_sidebar/index.html",

}),

);

const sidebar = onOpenSidebar.mock.calls[0]?.[0] as

| { kind?: string; docId?: string; entryUrl?: string }

| undefined;

expect(sidebar?.kind).toBe("canvas");

expect(sidebar?.docId).toBe("cv_sidebar");

expect(sidebar?.entryUrl).toBe("/__openclaw__/canvas/documents/cv_sidebar/index.html");

});

});

await saveAgentsConfig(state);

expect(request).toHaveBeenNthCalledWith(

1,

"config.set",

expect.objectContaining({ baseHash: "hash-1" }),

);

expect(request.mock.calls[0]?.[0]).toBe("config.set");

expect(request.mock.calls[0]?.[1]?.baseHash).toBe("hash-1");

expect(JSON.parse(request.mock.calls[0]?.[1]?.raw as string)).toEqual({

agents: { list: [{ id: "main" }] },

});

await nextFrame();

await app.updateComplete;

expect(request).toHaveBeenCalledWith(

"config.patch",

expect.objectContaining({

baseHash: "hash-1",

}),

);

const patchCall = request.mock.calls.find((call) => call[0] === "config.patch") as

| [string, { baseHash?: string }]

| undefined;

expect(patchCall?.[1].baseHash).toBe("hash-1");

});

it("renders the refreshed top navigation shell", async () => {