PaperClipAI/tests/speko-native/integrated.spec.ts

import { test, expect } from "@playwright/test";
import { readFile, readdir } from "node:fs/promises";
import { resolve } from "node:path";
const root = resolve(import.meta.dirname, "../..");
const port = Number(process.env.SPEKO_NATIVE_TEST_PORT ?? 3480);
const origin = `http://127.0.0.1:${port}`;

test("E01/E03–E11/E13/E15/E16: setup, delayed work, duplicate input, navigation, repeat, reload and hangup use real task ledgers", async ({ page }, info) => {
  const { home, supervisorPid } = JSON.parse(await readFile(resolve(import.meta.dirname, ".instance.json"), "utf8"));
  const evidence = async () => JSON.parse(await readFile(resolve(home, "evidence.json"), "utf8"));
  const post = async (path: string, data: unknown) => {
    const response = await page.request.post(`${origin}/api${path}`, { headers: { Origin: origin }, data });
    expect(response.ok(), `${path}: ${response.status()} ${await response.text()}`).toBe(true);
    return response.json();
  };
  const company = await post("/companies", { name: "Speko integrated", issuePrefix: "SPE" });
  const other = await post("/companies", { name: "Separate company", issuePrefix: "OTH" });
  const policy = await page.request.patch(`${origin}/api/companies/${company.id}`, { headers: { Origin: origin }, data: { requireBoardApprovalForNewAgents: false } });
  expect(policy.ok()).toBe(true);
  const agent = await post(`/companies/${company.id}/agents`, { name: "Existing Paperclip Agent", role: "general", adapterType: "process", adapterConfig: { command: "fixture" }, runtimeConfig: { heartbeat: { enabled: false, wakeOnDemand: true } } });
  // Discover the built SDK chunk by its export, rather than mock any Paperclip API.
  const assets = resolve(root, "ui/dist/assets");
  const candidates = await Promise.all((await readdir(assets)).filter(name => name.endsWith(".js")).map(async name => ({ name, source: await readFile(resolve(assets, name), "utf8") })));
  const sdk = candidates.filter(file => /export\{[^}]* as VoiceConversation\}/.test(file.source));
  expect(sdk).toHaveLength(1);
  const sdkSource = (await readFile(resolve(import.meta.dirname, "stub-browser-sdk.mjs"), "utf8")).replaceAll("__STUB_PORT__", String(port + 1));
  await page.route(`**/assets/${sdk[0].name}`, route => route.fulfill({ contentType: "application/javascript", body: sdkSource }));
  const external: string[] = [];
  await page.route(/^https?:\/\//, route => {
    const url = new URL(route.request().url());
    return ["127.0.0.1", "localhost"].includes(url.hostname) ? route.fallback() : route.abort();
  });
  page.on("request", request => { const url = new URL(request.url()); if (["http:", "https:", "wss:"].includes(url.protocol) && !["127.0.0.1", "localhost"].includes(url.hostname)) external.push(url.hostname); });
  await page.addInitScript(() => { navigator.mediaDevices.getUserMedia = async () => { throw new Error("Integrated fixture must not request a real microphone"); }; });
  await page.goto(`/${company.issuePrefix}/apps/chat/connect?provider=speko`);
  await page.getByRole("button", { name: "Choose an active agent", exact: true }).click();
  await page.getByRole("button", { name: `Select ${agent.name}`, exact: true }).click();
  await page.getByRole("button", { name: "Continue", exact: true }).click();
  await expect(page.getByLabel("Speko API key", { exact: true })).toHaveAttribute("type", "password");
  await page.getByRole("textbox", { name: "Speko agent ID", exact: true }).fill("agent_fixture");
  await page.getByLabel("Speko API key", { exact: true }).fill("fixture-speko-key");
  const setupResponse = page.waitForResponse(r => r.request().method() === "POST" && /\/chat-endpoints\/[^/]+\/setup$/.test(new URL(r.url()).pathname));
  await page.getByRole("button", { name: "Connect Speko", exact: true }).click();
  const endpoint = await (await setupResponse).json(); expect(endpoint.id).toBeTruthy();
  expect(JSON.stringify(endpoint)).not.toContain("fixture-speko-key");
  await page.reload();
  await expect(page.getByRole("button", { name: "Start voice", exact: true })).toBeVisible();
  const nextSession = () => page.waitForResponse(r => r.request().method() === "POST" && /\/voice-sessions$/.test(new URL(r.url()).pathname) && r.ok()).then(r => r.json());
  const pending = nextSession(); await page.getByRole("button", { name: "Start voice", exact: true }).click(); const started = await pending;
  expect(started.session.assignedAgentId).toBe(agent.id); expect(started.media.transportToken).toMatch(/^fixture:/);
  expect(JSON.stringify(started)).not.toContain("fixture-speko-key");
  await expect(page.getByRole("button", { name: "Mute", exact: true })).toBeEnabled();
  const speak = (text: string, id: string) => page.evaluate(({ text, id }) => (window as any).__spekoTransport.speak(text, id), { text, id });
  const accepted = await speak("Run the acceptance benchmark and report its verification number.", "request-one");
  expect(accepted.status).toBe("accepted");
  expect(await speak("Run the acceptance benchmark and report its verification number.", "request-one")).toEqual(accepted);
  await speak("Also count this follow-up on the same task.", "request-two");
  // A client-side route transition must preserve the host and the original media.
  await page.getByRole("link", { name: "View conversation task", exact: true }).click();
  await expect(page).toHaveURL(new RegExp(`/issues/${started.session.issueId}$`));
  await expect(page.getByRole("button", { name: "Mute", exact: true })).toBeEnabled();
  expect(await page.evaluate(() => (window as any).__spekoTransport.creates)).toBe(1);
  await expect.poll(async () => (await evidence()).tools.filter((tool: any) => tool.sessionId === started.session.id && tool.tool === "submit_request").length).toBe(2);
  const transcript = page.getByRole("list", { name: "Conversation transcript", exact: true });
  await expect(transcript).toContainText("Verification number", { timeout: 100_000 });
  await expect.poll(async () => {
    const rows = (await readFile(resolve(home, "execution.jsonl"), "utf8")).trim().split("\n").map(line => JSON.parse(line));
    return rows.some(row => row.issueId === started.session.issueId && row.event === "completed" && row.elapsedMs >= 60_000 && row.requests === 2);
  }).toBe(true);
  await expect.poll(async () => (await evidence()).comments.filter((row: any) => row.issueId === started.session.issueId && !row.authorAgentId).length).toBe(2);
  await expect(transcript).toContainText("Your follow-up was included", { timeout: 30_000 });
  const beforeRepeat = await transcript.getByRole("listitem").count();
  await page.getByRole("button", { name: "Repeat answer", exact: true }).click();
  await expect(transcript.getByRole("listitem")).toHaveCount(beforeRepeat + 1);
  await page.getByRole("button", { name: "Mute", exact: true }).click();
  expect(await page.evaluate(() => (window as any).__spekoTransport.muted)).toBe(true);
  await page.getByRole("button", { name: "End call", exact: true }).click();
  await expect(page.getByRole("status").filter({ hasText: /^Call ended$/ })).toBeVisible();
  expect(await page.evaluate(() => (window as any).__spekoTransport.open)).toBe(false);
  // Prove connection guidance reaches the ordinary execution provider without
  // installing a template or replacing the selected agent's instructions.
  await expect.poll(async () => (await evidence()).runs.find((row: any) => row.context.issueId === started.session.issueId)?.context.paperclipTaskCommunicationGuidance).toContain("Keep your existing identity, runtime, tools, and task assignment");
  const deliveredGuidance = (await evidence()).runs.find((row: any) => row.context.issueId === started.session.issueId).context.paperclipTaskCommunicationGuidance;
  expect(deliveredGuidance).toContain("one focused clarification");
  expect(deliveredGuidance).toContain("durable Paperclip continuation");
  expect(deliveredGuidance).toContain("does not cancel work");
  expect(deliveredGuidance).toContain("Spoken consent does not replace governed approval");
  const foreign = await page.request.get(`${origin}/api/companies/${other.id}/voice-sessions/${started.session.id}`);
  expect(foreign.status()).toBe(404);
  await page.getByRole("button", { name: "Close voice panel", exact: true }).click();
  await page.goto(`/${company.issuePrefix}/apps/chat/connect?provider=speko&resume=${endpoint.id}`);
  const rejoining = nextSession(); await page.getByRole("button", { name: "Start voice", exact: true }).click(); const resumed = await rejoining;
  expect(resumed.session.issueId).toBe(started.session.issueId); expect(resumed.session.id).not.toBe(started.session.id);
  await expect(page.getByRole("button", { name: "Mute", exact: true })).toBeEnabled();
  const journal = await page.evaluate(() => Object.entries(sessionStorage).filter(([key]) => key.startsWith("paperclip:voice-attempt:")));
  expect(journal).toHaveLength(1);
  expect(journal[0][1]).not.toContain(resumed.media.transportToken);
  // Reload must reconcile the exact old call before it offers a new connection.
  await page.reload();
  await page.getByRole("button", { name: "Start voice", exact: true }).click();
  await expect(page.getByRole("alert").filter({ hasText: "The previous call was closed" })).toBeVisible();
  await expect.poll(async () => (await evidence()).sessions.find((row: any) => row.id === resumed.session.id)?.state).toBe("ended");
  expect((await evidence()).sessions).toHaveLength(2);
  const recoveredStart = nextSession();
  await page.getByRole("button", { name: "Try again", exact: true }).click();
  const recovered = await recoveredStart;
  expect(recovered.session.issueId).toBe(started.session.issueId);
  await expect(page.getByRole("button", { name: "Repeat answer", exact: true })).toBeEnabled();
  await page.getByRole("button", { name: "Repeat answer", exact: true }).click();
  await expect(transcript).toContainText("Your follow-up was included");
  await page.getByRole("button", { name: "End call", exact: true }).click();
  await expect.poll(async () => (await evidence()).sessions.filter((row: any) => row.issueId === started.session.issueId).every((row: any) => row.state === "ended")).toBe(true);
  await page.getByRole("button", { name: "Close voice panel", exact: true }).click();
  // Explicit New creates one new task; hanging up does not cancel accepted work.
  await page.getByRole("combobox", { name: "Conversation", exact: true }).selectOption("new");
  const newStart = nextSession(); await page.getByRole("button", { name: "Start voice", exact: true }).click(); const fresh = await newStart;
  expect(fresh.session.issueId).not.toBe(started.session.issueId);
  await expect(page.getByRole("button", { name: "Mute", exact: true })).toBeEnabled();
  await speak("Do the benchmark; I will return after it finishes.", "after-hangup");
  const executionRows = async () => (await readFile(resolve(home, "execution.jsonl"), "utf8")).trim().split("\n").map(line => JSON.parse(line));
  await expect.poll(async () => (await executionRows()).some(row => row.issueId === fresh.session.issueId && row.event === "started")).toBe(true);
  await page.getByRole("button", { name: "End call", exact: true }).click();
  await expect(page.getByRole("status").filter({ hasText: /^Call ended$/ })).toBeVisible();
  await expect.poll(async () => (await executionRows()).some(row => row.issueId === fresh.session.issueId && row.event === "completed" && row.elapsedMs >= 60_000), { timeout: 90_000 }).toBe(true);
  await page.getByRole("button", { name: "Close voice panel", exact: true }).click();
  await page.getByRole("combobox", { name: "Conversation", exact: true }).selectOption("continue");
  const missedStart = nextSession(); await page.getByRole("button", { name: "Start voice", exact: true }).click(); const missed = await missedStart;
  expect(missed.session.issueId).toBe(fresh.session.issueId);
  await expect(transcript).toContainText("Verification number");
  expect((await evidence()).comments.filter((row: any) => row.issueId === fresh.session.issueId && !row.authorAgentId)).toHaveLength(1);
  await speak("Ask the structured acceptance question before continuing.", "request-question");
  await expect.poll(() => page.evaluate(() => (window as any).__spekoTransport.question?.questions[0]?.id)).toBe("color");
  await expect(transcript).toContainText("Which color should I use?");
  const answer = () => page.evaluate(() => {
    const transport = (window as any).__spekoTransport;
    return transport.answer(transport.question.interactionId, [{ questionId: "color", optionIds: ["cobalt"] }], "answer-one");
  });
  const answered = await answer(); expect(answered.status).toBe("answered");
  expect(await answer()).toEqual(answered);
  await expect(transcript).toContainText("Your structured answer was received", { timeout: 30_000 });
  await expect(transcript).toContainText("cobalt");
  await expect.poll(async () => (await evidence()).questionDeliveries.filter((row: any) => row.interactionId === answered.interactionId).length).toBe(1);
  const questionEvidence = await evidence();
  expect(questionEvidence.interactions.find((row: any) => row.id === answered.interactionId)?.status).toBe("answered");
  expect(questionEvidence.tools.filter((row: any) => row.tool === "answer_question")).toHaveLength(1);
  const delivery = questionEvidence.questionDeliveries.find((row: any) => row.interactionId === answered.interactionId);
  expect(["delivered", "fallback_queued"]).toContain(delivery.status);
  expect(delivery.targetRunId).toBeTruthy();
  await expect.poll(async () => (await evidence()).runs.find((row: any) => row.id === delivery.targetRunId)?.status).toBe("succeeded");
  const beforeRestart = await evidence();
  process.kill(supervisorPid, "SIGUSR2");
  // Restart has the same startup budget as the initial fixture server.
  await expect.poll(async () => (await evidence()).appPid, { timeout: 120_000 }).not.toBe(beforeRestart.appPid);
  await expect.poll(async () => {
    try { return (await page.request.get(`${origin}/api/health`)).ok(); } catch { return false; }
  }).toBe(true);
  // Same session and signed tool identity cross the real process boundary.
  expect(await answer()).toEqual(answered);
  const beforeRecoveredRepeat = await transcript.getByRole("listitem").count();
  await page.getByRole("button", { name: "Repeat answer", exact: true }).click();
  await expect(transcript.getByRole("listitem")).toHaveCount(beforeRecoveredRepeat + 1);
  await expect(transcript).toContainText("Your structured answer was received");
  expect(await page.evaluate(() => (window as any).__spekoTransport.creates)).toBe(3);
  const afterRestart = await evidence();
  expect(afterRestart.sessions).toHaveLength(beforeRestart.sessions.length);
  expect(afterRestart.comments).toHaveLength(beforeRestart.comments.length);
  expect(afterRestart.runs).toHaveLength(beforeRestart.runs.length);
  expect(afterRestart.tools.filter((row: any) => row.tool === "answer_question")).toHaveLength(1);
  expect(afterRestart.questionDeliveries).toHaveLength(1);
  await page.getByRole("button", { name: "End call", exact: true }).click();
  await expect.poll(async () => (await evidence()).sessions.every((row: any) => row.state === "ended")).toBe(true);
  await page.getByRole("button", { name: "Close voice panel", exact: true }).click();
  const activated = await post(`/chat-endpoints/${endpoint.id}/test`, {});
  expect(activated.status).toBe("active");
  await page.goto(`/${company.issuePrefix}/apps/chat/${endpoint.id}/settings`);
  await expect(page.getByRole("textbox", { name: "Your callback number", exact: true })).toBeEnabled();
  await expect(page.getByRole("button", { name: "Start voice", exact: true })).toHaveCount(0);
  await expect(page.getByRole("combobox", { name: "Conversation", exact: true })).toHaveCount(0);
  await expect(page.getByRole("link", {name: "Open Speko"})).toHaveAttribute("href", "https://platform.speko.ai/agents");
  await expect(page.locator('header img[src="/brands/apps/speko.svg"]').first()).toBeVisible();
  await page.getByRole("textbox", { name: "Your callback number", exact: true }).fill("+12015551234");
  await page.getByRole("checkbox", { name: "Allow this agent to call me about my tasks", exact: true }).check();
  await page.getByRole("button", { name: "Save phone setting", exact: true }).click();
  await expect(page.getByRole("status").filter({ hasText: "Callback setting saved" })).toBeVisible();
  await page.reload();
  await expect(page.getByRole("textbox", { name: "Your callback number", exact: true })).toHaveValue("+12015551234");
  await expect(page.getByRole("checkbox", { name: "Allow this agent to call me about my tasks", exact: true })).toBeChecked();
  const updatedAgent = await page.request.patch(`${origin}/api/agents/${agent.id}`, { headers: { Origin: origin }, data: { adapterConfig: { command: "fixture-phone" } } });
  expect(updatedAgent.ok()).toBe(true);
  const callTask = await post(`/companies/${company.id}/issues`, { title: "Call my saved phone", status: "todo", assigneeAgentId: agent.id, responsibleUserId: "local-board" });
  await expect.poll(async () => (await executionRows()).some(row => row.event === "phone_called" && row.issueId === callTask.id), { timeout: 30_000 }).toBe(true);
  const phoneExecution = (await executionRows()).find(row => row.event === "phone_called" && row.issueId === callTask.id);
  expect(phoneExecution.secondRejected).toBe(true);
  expect(JSON.stringify(phoneExecution.result)).not.toContain("+12015551234");
  expect(JSON.stringify(phoneExecution.result)).not.toContain("fixture-speko-key");
  expect(JSON.stringify(phoneExecution.result)).not.toContain("transportToken");
  await expect.poll(async () => (await evidence()).sessions.filter((row: any) => row.issueId === callTask.id && row.mode === "outbound_phone").length).toBe(1);
  const phone = (await evidence()).sessions.find((row: any) => row.issueId === callTask.id && row.mode === "outbound_phone");
  const providerState = JSON.parse(await readFile(resolve(home, "speko-fixture-state.json"), "utf8"));
  expect(providerState.sessions.filter((entry: any) => entry[1].mode === "outbound_phone")).toHaveLength(1);
  const inspectedPhone = await (await page.request.get(`${origin}/api/companies/${company.id}/voice-sessions/${phone.id}`)).json();
  expect(inspectedPhone).toMatchObject({ id: phone.id, issueId: callTask.id, mode: "outbound_phone" });
  expect(JSON.stringify(inspectedPhone)).not.toContain("transportToken");
  const endedPhone = await post(`/companies/${company.id}/voice-sessions/${phone.id}/end`, {});
  expect(endedPhone.state).toBe("ended");
  const retainedTask = await (await page.request.get(`${origin}/api/issues/${callTask.id}`)).json();
  expect(retainedTask.status).not.toBe("cancelled");
  expect(retainedTask.assigneeAgentId).toBe(agent.id);
  await page.getByRole("checkbox", { name: "Allow this agent to call me about my tasks", exact: true }).uncheck();
  await page.getByRole("button", { name: "Save phone setting", exact: true }).click();
  await expect(page.getByRole("status").filter({ hasText: "Callback setting saved" })).toBeVisible();
  await expect.poll(async () => (await evidence()).sessions.every((row: any) => row.state === "ended")).toBe(true);
  // E08: a real signed pre-call route creates NO task before explicit live approval.
  await page.getByRole("combobox", {name: "Company phone number", exact: true}).selectOption("pn_fixture");
  await page.getByRole("checkbox", {name: "Enable incoming calls on this number", exact: true}).check();
  await page.getByRole("button", {name: "Save incoming call setting", exact: true}).click();
  await expect(page.getByRole("status").filter({hasText: "Incoming call setting saved"})).toBeVisible();
  await page.request.patch(`${origin}/api/agents/${agent.id}`, {headers: {Origin: origin}, data: {adapterConfig: {command: "fixture"}}});
  const providerCommand = async (data: unknown) => {
    const response = await page.request.post(`http://127.0.0.1:${port + 1}/command`, {headers: {Origin: origin}, data});
    expect(response.ok(), await response.text()).toBe(true); return response.json();
  };
  const beforeIncoming = (await evidence()).sessions.length;
  const incoming = await providerCommand({action: "inbound", agentId: "agent_fixture", callerId: "+12015551234"});
  await expect(page.getByRole("heading", {name: "Incoming call awaiting approval", exact: true})).toBeVisible();
  await expect.poll(async () => (await evidence()).incoming.filter((call: any) => call.endpointId === endpoint.id).length).toBe(1);
  expect((await evidence()).sessions).toHaveLength(beforeIncoming);
  const unapproved = await providerCommand({sessionId: incoming.sessionId, tool: "submit_request", args: {text: "Spoofed caller ID must not grant task access"}, toolCallId: "before-approval"});
  expect(unapproved).toMatchObject({requestAccepted: false, authorization: "awaiting_approval", updates: []});
  await page.getByRole("textbox", {name: "Code spoken on your call", exact: true}).fill("000000");
  await page.getByRole("button", {name: "Approve live call", exact: true}).click();
  await expect(page.getByRole("alert").filter({hasText: "does not match"})).toBeVisible();
  const code = incoming.firstMessage.replace(/\D/g, ""); expect(code).toHaveLength(6);
  await page.getByRole("textbox", {name: "Code spoken on your call", exact: true}).fill(code);
  const inboundTask = await post(`/companies/${company.id}/issues`, {title: "Approved incoming phone conversation", assigneeAgentId: agent.id, status: "todo"});
  // Refresh task inventory after this fixture task is created.
  await page.reload();
  await page.getByRole("textbox", {name: "Code spoken on your call", exact: true}).fill(code);
  await page.getByRole("combobox", {name: "Conversation task", exact: true}).selectOption(inboundTask.id);
  await page.getByRole("button", {name: "Approve live call", exact: true}).click();
  await expect(page.getByRole("heading", {name: "Call approved", exact: true})).toBeFocused();
  await expect.poll(async () => (await evidence()).sessions.find((call: any) => call.providerSessionId === incoming.sessionId)?.issueId).toBe(inboundTask.id);
  const phoneWork = {sessionId: incoming.sessionId, tool: "submit_request", args: {text: "Perform this approved intake task"}, toolCallId: "approved-work"};
  const incomingAccepted = await providerCommand(phoneWork); expect(incomingAccepted).toMatchObject({status: "accepted", authorization: "approved"});
  expect(await providerCommand(phoneWork)).toEqual(incomingAccepted);
  const boundIncoming = (await evidence()).sessions.find((call: any) => call.providerSessionId === incoming.sessionId);
  await expect.poll(async () => (await evidence()).tools.filter((call: any) => call.sessionId === boundIncoming.id && call.tool === "submit_request").length).toBe(1);
  // A saved task answer must reach the live phone transport before hangup.
  // Provider acceptance is asserted separately from actual spoken playback.
  await expect.poll(async () => (await evidence()).comments.some((row: any) => row.issueId === inboundTask.id && row.authorAgentId === agent.id && row.body.includes("Verification number")), {timeout: 100_000}).toBe(true);
  await expect.poll(async () => (await providerCommand({action: "messages", sessionId: incoming.sessionId})).some((message: any) => message.text.includes("Verification number")), {timeout: 30_000}).toBe(true);
  await expect.poll(async () => (await evidence()).pushActions.some((action: any) => action.payload.sessionId === boundIncoming.id && action.status === "completed" && action.result?.messageId && action.result.playback === "unknown")).toBe(true);
  await post(`/companies/${company.id}/voice-sessions/${boundIncoming.id}/end`, {});
  // E15: report reconciliation persists one report, excludes recordings and keeps task assignment.
  await expect.poll(async () => (await evidence()).reports.find((report: any) => report.sessionId === boundIncoming.id)?.status, {timeout: 45000}).toBe("available");
  const reportResponse = await page.request.get(`${origin}/api/companies/${company.id}/voice-sessions/${boundIncoming.id}/report`);
  const report = await reportResponse.json(); expect(report.session.issueId).toBe(inboundTask.id);
  expect(report.report).toMatchObject({costMicroUsd: "152340", transcript: [{text: "Fixture call transcript"}]});
  expect(JSON.stringify(report)).not.toContain("recording"); expect(JSON.stringify(report)).not.toContain("fixture-speko-key");
  await expect(page.getByRole("region", {name: "Your calls", exact: true})).toHaveCount(0);
  await page.goto(`/${company.issuePrefix}/apps/chat/${endpoint.id}/activity`);
  const history = page.getByRole("region", {name: "Connection activity", exact: true});
  await history.getByRole("button", {name: "Refresh", exact: true}).click();
  await expect(history).toContainText("Incoming call · Completed");
  await history.locator("summary").filter({hasText: "Incoming call · Completed"}).click();
  await expect(history.getByRole("list", {name: "Call transcript", exact: true})).toContainText("Fixture call transcript");
  expect((await evidence()).reports.filter((row: any) => row.sessionId === boundIncoming.id)).toHaveLength(1);
  const retainedIncomingTask = await (await page.request.get(`${origin}/api/issues/${inboundTask.id}`)).json();
  expect(retainedIncomingTask.assigneeAgentId).toBe(agent.id); expect(retainedIncomingTask.status).not.toBe("cancelled");
  await page.goto(`/${company.issuePrefix}/apps/chat/${endpoint.id}/settings`);
  // E09: opted-in callers start a task-scoped, low-trust conversation without sign-in.
  await page.getByRole("checkbox", {name: "Let callers start new low-trust tasks without sign-in", exact: true}).check();
  await page.getByRole("button", {name: "Save incoming call setting", exact: true}).click();
  await expect(page.getByRole("status").filter({hasText: "Incoming call setting saved"})).toBeVisible();
  const guest = await providerCommand({action: "inbound", agentId: "agent_fixture", callerId: "+12015559876"});
  await expect(page.getByRole("heading", {name: "Incoming conversation", exact: true})).toBeVisible();
  const guestRequest = {sessionId: guest.sessionId, tool: "submit_request", args: {text: "Please contact me about a shipping question. Do not start private work."}, toolCallId: "guest-message"};
  const guestAccepted = await providerCommand(guestRequest);
  expect(guestAccepted).toMatchObject({authorization: "guest_intake", status: "accepted"});
  expect(await providerCommand(guestRequest)).toEqual(guestAccepted);
  expect(await providerCommand({sessionId: guest.sessionId, tool: "get_updates", args: {cursor: 0}, toolCallId: "guest-read"})).toMatchObject({authorization: "guest_intake", updates: []});
  await expect.poll(async () => (await evidence()).sessions.filter((call: any) => call.providerSessionId === guest.sessionId).length).toBe(1);
  const guestSession = (await evidence()).sessions.find((call: any) => call.providerSessionId === guest.sessionId);
  const guestTaskResponse = await page.request.get(`${origin}/api/issues/${guestSession.issueId}`);
  const guestTask = await guestTaskResponse.json();
  expect(guestTask).toMatchObject({ assigneeAgentId: agent.id, responsibleUserId: null, sourceTrust: {disposition: "quarantined"}, executionPolicy: {authorizationPolicy: {trustBoundary: {allowedToolClasses: [], allowedSecretBindingIds: []}}}});
  await expect.poll(async () => (await evidence()).comments.filter((row: any) => row.issueId === guestTask.id && row.body === (guestRequest.args as {text: string}).text).length).toBe(1);
  // This fixture has only Local, so containment must block execution rather
  // than silently grant the public caller the selected agent's host privileges.
  await expect.poll(async () => (await evidence()).runs.find((run: any) => run.context?.issueId === guestTask.id)?.errorCode).toBe("low_trust_isolation_unavailable");
  const guestRun = (await evidence()).runs.find((run: any) => run.context?.issueId === guestTask.id);
  expect((await evidence()).wakeups.some((row: any) => row.runId === guestRun.id)).toBe(true);
  expect((await evidence()).tools.filter((row: any) => row.sessionId === guestSession.id && row.tool === "submit_request")).toHaveLength(1);
  await page.getByRole("button", {name: "End call", exact: true}).click();
  await expect(page.getByRole("heading", {name: "Caller hung up", exact: true})).toBeFocused();
  await expect.poll(async () => (await evidence()).sessions.find((call: any) => call.id === guestSession.id)?.state, {timeout: 45000}).toBe("ended");
  await expect.poll(async () => (await evidence()).reports.find((report: any) => report.sessionId === guestSession.id)?.status, {timeout: 45000}).toBe("available");
  await page.goto(`/${company.issuePrefix}/apps/chat/${endpoint.id}/activity`);
  await history.getByRole("button", {name: "Refresh", exact: true}).click();
  await expect(history.locator("summary").filter({hasText: "Incoming call · Completed"})).toHaveCount(2);
  expect(external).toEqual([]);
  await info.attach("durable-records", { body: JSON.stringify(await evidence(), null, 2), contentType: "application/json" });
  await page.screenshot({ path: info.outputPath("completed.png"), fullPage: true });
});

// Connection setup selects an existing agent without changing its runtime or
// reassigning tasks created before the connection.
test("E02: selecting an existing agent preserves its configuration and historical assignment", async ({ page }) => {
  const company = await (await page.request.post("/api/companies", { data: { name: "Speko existing agent" } })).json();
  const created = await page.request.post(`/api/companies/${company.id}/agents`, { data: { name: "Existing support agent", role: "general", adapterType: "process", adapterConfig: { command: "true" }, runtimeConfig: { heartbeat: { enabled: false, wakeOnDemand: false } } } });
  expect(created.ok()).toBe(true);
  const agent = await created.json();
  const task = await (await page.request.post(`/api/companies/${company.id}/issues`, { data: { title: "Preserve existing work", status: "backlog", assigneeAgentId: agent.id } })).json();
  await page.goto(`/${company.issuePrefix}/apps/chat/connect?provider=speko`);
  await expect(page.getByRole("button", { name: "Review recommended agent" })).toHaveCount(0);
  await page.getByRole("button", { name: "Choose an active agent", exact: true }).click();
  await page.getByRole("button", { name: "Select Existing support agent", exact: true }).click();
  await page.getByRole("button", { name: "Continue", exact: true }).click();
  await expect(page.getByText(/Existing support agent keeps its existing runtime/)).toBeVisible();
  await page.reload();
  await expect(page.getByText(/Existing support agent keeps its existing runtime/)).toBeVisible();
  const agents = await (await page.request.get(`/api/companies/${company.id}/agents`)).json();
  expect(agents).toHaveLength(1);
  expect(agents[0].id).toBe(agent.id);
  expect(agents[0].adapterConfig).toEqual(agent.adapterConfig);
  expect(agents[0].reportsTo).toBe(agent.reportsTo);
  expect((await (await page.request.get(`/api/issues/${task.id}`)).json()).assigneeAgentId).toBe(agent.id);
  const endpoints = await (await page.request.get(`/api/companies/${company.id}/chat-endpoints`)).json();
  expect(endpoints).toHaveLength(1);
  expect(endpoints[0].assignedAgentId).toBe(agent.id);
});


test("E12: insufficient credits explains funding and never blindly retries a rejected call", async ({page}) => {
  const company=await (await page.request.post("/api/companies",{data:{name:"Speko credit rejection"}})).json();
  const agent=await (await page.request.post(`/api/companies/${company.id}/agents`,{data:{name:"Credit-test agent",role:"general",adapterType:"process",adapterConfig:{command:"true"},runtimeConfig:{heartbeat:{enabled:false,wakeOnDemand:false}}}})).json();
  await page.addInitScript(() => { navigator.mediaDevices.getUserMedia=async () => {throw new Error("Rejected call must not request microphone");}; });
  await page.goto(`/${company.issuePrefix}/apps/chat/connect?provider=speko`);
  await page.getByRole("button",{name:"Choose an active agent",exact:true}).click();
  await page.getByRole("button",{name:"Select Credit-test agent",exact:true}).click();
  await page.getByRole("button",{name:"Continue",exact:true}).click();
  await page.getByRole("textbox",{name:"Speko agent ID",exact:true}).fill("agent_credit_fixture");
  await page.getByLabel("Speko API key",{exact:true}).fill("fixture-speko-key");
  await page.getByRole("button",{name:"Connect Speko",exact:true}).click();
  await expect(page.getByRole("button",{name:"Start voice",exact:true})).toBeVisible();
  const creditState=async () => (await page.request.post(`http://127.0.0.1:${port+1}/command`,{headers:{Origin:origin},data:{action:"credits_required",agentId:"agent_credit_fixture",enabled:true}})).json();
  expect((await creditState()).creationAttempts).toBe(0);
  const responsePromise=page.waitForResponse(r => r.request().method()==="POST" && /\/voice-sessions$/.test(new URL(r.url()).pathname));
  await page.getByRole("button",{name:"Start voice",exact:true}).click();
  const response=await responsePromise;expect(response.status()).toBe(409);
  const error=await response.json();expect(error.details.code).toBe("voice_credits_required");
  expect(JSON.stringify(error)).not.toContain("private fixture provider detail");
  await expect(page.getByRole("alert").filter({hasText:"Add credits in Speko"})).toBeVisible();
  await expect(page.getByRole("button",{name:"Mute",exact:true})).toHaveCount(0);
  const inspected=await (await page.request.get(`/api/companies/${company.id}/voice-sessions/${error.details.sessionId}`)).json();
  expect(inspected).not.toHaveProperty("providerSessionId");expect(inspected.errorCode).toBe("insufficient_credits");
  const {home}=JSON.parse(await readFile(resolve(import.meta.dirname,".instance.json"),"utf8"));
  await expect.poll(async () => JSON.parse(await readFile(resolve(home,"evidence.json"),"utf8")).sessions.find((row: {id: string}) => row.id===error.details.sessionId)?.providerSessionId).toBeNull();
  expect(["failed","ended"]).toContain(inspected.state);
  // Replay the exact already-rejected creation, as after a lost response.
  const replay=await page.request.post(response.url(),{data:response.request().postDataJSON()});
  expect(replay.ok()).toBe(true);expect((await replay.json()).session.id).toBe(error.details.sessionId);
  expect((await creditState()).creationAttempts).toBe(1);
});