@desplega.ai/agent-swarm 2.0.0 → 2.1.0

package/src/tests/pages-feedback-keys.test.ts

@@ -0,0 +1,121 @@
+/**
+ * Typing in the page feedback overlay must not reach the page's own key
+ * handlers. The overlay lives in a shadow root, so outside it the event target
+ * is the shadow host and a page's "ignore keys from a textarea" guard misses:
+ * Space and arrows typed into a comment used to change slides in a deck page.
+ * Page capture listeners on window/document run before anything the overlay
+ * registers later, so a key guard is served first in <head>.
+ */
+import { describe, expect, test } from "bun:test";
+import { Window } from "happy-dom";
+import { feedbackKeyGuardScript, feedbackOverlayScripts } from "../pages/feedback-overlay";
+
+type Target = { dispatchEvent(e: unknown): boolean };
+
+function scriptSources(html: string): string[] {
+  return [...html.matchAll(/<script>([\s\S]*?)<\/script>/g)].map((m) => m[1]!);
+}
+
+// Served order: key guard (top of <head>), page scripts, overlay (end of body).
+function overlayPage() {
+  const window = new Window({ url: "https://api.example.test/p/abc" });
+  const document = window.document;
+  document.body.innerHTML = "<h2>Slide title</h2>";
+  for (const source of scriptSources(feedbackKeyGuardScript())) window.eval(source);
+  // A page's key handlers (e.g. a deck's slide navigation), registered before
+  // the overlay, in every phase. They record every key event they see.
+  const pageKeys: string[] = [];
+  for (const type of ["keydown", "keyup", "keypress"]) {
+    const record = (where: string) => (e: Event) =>
+      pageKeys.push(`${where}:${type}:${(e as unknown as KeyboardEvent).key}`);
+    window.addEventListener(type, record("window-capture"), true);
+    document.addEventListener(type, record("document-capture"), true);
+    window.addEventListener(type, record("window-bubble"));
+  }
+  for (const source of scriptSources(feedbackOverlayScripts("abc"))) window.eval(source);
+  const root = document.querySelector("swarm-feedback-root")!.shadowRoot!;
+  return { window, document, root, pageKeys };
+}
+
+function key(window: Window, target: Target, type: string, key: string, init = {}) {
+  target.dispatchEvent(
+    new window.KeyboardEvent(type, { key, bubbles: true, composed: true, ...init }),
+  );
+}
+
+function press(window: Window, target: Target, k: string) {
+  key(window, target, "keydown", k);
+  key(window, target, "keypress", k);
+  key(window, target, "keyup", k);
+}
+
+function openComposer(window: Window, document: Window["document"], root: ShadowRoot) {
+  // Select mode stays on after a comment, so the button is only there the first time.
+  const select = [...root.querySelectorAll("button")].find(
+    (b) => b.textContent === "Select an element",
+  );
+  select?.click();
+  document.querySelector("h2")!.dispatchEvent(new window.MouseEvent("click", { bubbles: true }));
+  const comment = root.querySelector("textarea") as unknown as HTMLTextAreaElement | null;
+  expect(comment).not.toBeNull();
+  return comment!;
+}
+
+function savedComments(window: Window): unknown[] {
+  return JSON.parse(window.sessionStorage.getItem("swarm-feedback:abc") || "[]");
+}
+
+describe("page feedback overlay keys", () => {
+  test("keys typed in a comment box never reach page capture or bubble handlers", () => {
+    const { window, document, root, pageKeys } = overlayPage();
+    const comment = openComposer(window, document, root);
+
+    for (const k of [" ", "ArrowRight", "ArrowLeft", "ArrowUp", "ArrowDown", "Enter", "PageDown"]) {
+      press(window, comment, k);
+    }
+    expect(pageKeys).toEqual([]);
+    // Escape still closes the composer, and the page never sees it.
+    key(window, comment, "keydown", "Escape");
+    expect(comment.isConnected).toBe(false);
+    expect(pageKeys).toEqual([]);
+  });
+
+  test("the release of an overlay key stays in the overlay after the composer closes", () => {
+    const { window, document, root, pageKeys } = overlayPage();
+
+    // Escape: keydown closes the composer, keyup lands on the page body.
+    let comment = openComposer(window, document, root);
+    key(window, comment, "keydown", "Escape");
+    expect(comment.isConnected).toBe(false);
+    key(window, document.body, "keyup", "Escape");
+
+    // Ctrl+Enter: keydown commits and removes the textarea, both keyups land on the body.
+    comment = openComposer(window, document, root);
+    comment.value = "Bigger title";
+    key(window, comment, "keydown", "Control", { ctrlKey: true });
+    key(window, comment, "keydown", "Enter", { ctrlKey: true });
+    expect(comment.isConnected).toBe(false);
+    expect(savedComments(window)).toHaveLength(1);
+    key(window, document.body, "keyup", "Enter", { ctrlKey: true });
+    key(window, document.body, "keyup", "Control");
+    expect(pageKeys).toEqual([]);
+
+    // The next press that starts on the page is the page's again.
+    key(window, document.body, "keydown", "Escape");
+    key(window, document.body, "keyup", "Escape");
+    expect(pageKeys).toContain("window-bubble:keydown:Escape");
+    expect(pageKeys).toContain("window-bubble:keyup:Escape");
+  });
+
+  test("keys outside the overlay still reach the page", () => {
+    const { window, document, pageKeys } = overlayPage();
+    press(window, document.body, "ArrowRight");
+    expect(pageKeys).toEqual(
+      ["keydown", "keypress", "keyup"].flatMap((type) => [
+        `window-capture:${type}:ArrowRight`,
+        `document-capture:${type}:ArrowRight`,
+        `window-bubble:${type}:ArrowRight`,
+      ]),
+    );
+  });
+});

package/src/tests/pages-feedback.test.ts

@@ -127,6 +127,9 @@ describe("page feedback", () => {
     const html = await res.text();
     expect(html).toContain(`window.__swarmFeedback = {"pageId":"${pageId}"};`);
     expect(html).toContain("swarm-feedback-root");
+    // The key guard is served before the page's own markup and scripts.
+    expect(html.indexOf("__swarmFeedbackKeys")).toBeGreaterThan(-1);
+    expect(html.indexOf("__swarmFeedbackKeys")).toBeLessThan(html.indexOf("<h1>Hello</h1>"));
     // The agent-authored body and the SDK are still served.
     expect(html).toContain("<h1>Hello</h1>");
     expect(html).toContain("class SwarmSDK");

package/src/tests/pi-context-compaction.test.ts

@@ -0,0 +1,193 @@
+/**
+ * Pi's `context` hook fires before every LLM call. It must report usage as a
+ * `progress` snapshot; only `session_compact` reports a compaction. Migration
+ * 219 relabels the trigger-less pi compaction rows written before the fix.
+ */
+
+import type { Database } from "bun:sqlite";
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import type {
+  ContextEvent,
+  ExtensionFactory,
+  SessionCompactEvent,
+} from "@earendil-works/pi-coding-agent";
+import type { CreateContextSnapshotInput } from "../be/db";
+import {
+  closeDb,
+  createAgent,
+  createContextSnapshot,
+  createTaskExtended,
+  getContextSnapshotsByTaskId,
+  getContextSummaryByTaskId,
+  initDb,
+} from "../be/db";
+import { createSwarmHooksExtension } from "../providers/pi-mono-extension";
+
+const TEST_DB_PATH = "./test-pi-context-compaction.sqlite";
+const agentId = "aaaa0000-0000-4000-8000-0000000000a1";
+
+type Handler = (event: unknown, ctx: unknown) => Promise<unknown> | unknown;
+
+let db: Database;
+const origFetch = globalThis.fetch;
+
+async function removeDbFiles() {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {
+      // File doesn't exist
+    }
+  }
+}
+
+beforeAll(async () => {
+  await removeDbFiles();
+  db = initDb(TEST_DB_PATH);
+  await createAgent({ id: agentId, name: "Pi Worker", isLead: false, status: "idle" });
+});
+
+afterEach(() => {
+  globalThis.fetch = origFetch;
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles();
+});
+
+async function createTask(provider: string): Promise<string> {
+  const task = await createTaskExtended(`context compaction ${provider}`, {
+    agentId,
+    source: "mcp",
+  });
+  db.run("UPDATE agent_tasks SET provider = ? WHERE id = ?", [provider, task.id]);
+  return task.id;
+}
+
+/**
+ * Load the extension and route its `/context` POSTs into the real snapshot
+ * writer, the same path `POST /api/tasks/:id/context` takes.
+ */
+function loadExtension(taskId: string) {
+  const handlers = new Map<string, Handler>();
+  const pending: Promise<unknown>[] = [];
+  globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+    const urlStr = typeof url === "string" ? url : url.toString();
+    if (urlStr.endsWith(`/api/tasks/${taskId}/context`) && init?.method === "POST") {
+      const body = JSON.parse(String(init.body)) as Omit<
+        CreateContextSnapshotInput,
+        "taskId" | "agentId"
+      >;
+      const write = createContextSnapshot({ ...body, taskId, agentId });
+      pending.push(write);
+      await write;
+    }
+    return new Response("{}", { status: 200 });
+  }) as typeof fetch;
+
+  const pi = {
+    on: (event: string, handler: Handler) => {
+      handlers.set(event, handler);
+    },
+    sendMessage: () => {},
+    registerMcpServer: () => {},
+  };
+  createSwarmHooksExtension({
+    apiUrl: "http://localhost:3013",
+    apiKey: "example-test-key",
+    agentId,
+    taskId,
+    isLead: false,
+  })(pi as unknown as Parameters<ExtensionFactory>[0]);
+
+  let tokens = 0;
+  const ctx = {
+    getContextUsage: () => ({ tokens, contextWindow: 1_000_000, percent: tokens / 10_000 }),
+  };
+  const fire = async (event: ContextEvent | SessionCompactEvent, usedTokens: number) => {
+    tokens = usedTokens;
+    await handlers.get(event.type)?.(event, ctx);
+    await Promise.all(pending);
+  };
+  return { fire };
+}
+
+describe("pi context hook", () => {
+  test("per-call context usage is progress; only session_compact counts", async () => {
+    const taskId = await createTask("pi");
+    const { fire } = loadExtension(taskId);
+
+    for (const used of [82_000, 94_000, 94_400]) {
+      await fire({ type: "context", messages: [] }, used);
+    }
+
+    let snapshots = await getContextSnapshotsByTaskId(taskId);
+    expect(snapshots.length).toBe(3);
+    expect(snapshots.filter((s) => s.eventType === "compaction")).toEqual([]);
+    let summary = await getContextSummaryByTaskId(taskId);
+    expect(summary.compactionCount).toBe(0);
+    expect(summary.peakContextTokens).toBe(94_400);
+
+    await fire(
+      {
+        type: "session_compact",
+        reason: "threshold",
+        willRetry: false,
+        fromExtension: false,
+        compactionEntry: {
+          type: "compaction",
+          id: "c1",
+          parentId: null,
+          timestamp: new Date().toISOString(),
+          summary: "s",
+          firstKeptEntryId: "e1",
+          tokensBefore: 120_000,
+        },
+      },
+      30_000,
+    );
+
+    snapshots = await getContextSnapshotsByTaskId(taskId);
+    const compactions = snapshots.filter((s) => s.eventType === "compaction");
+    expect(compactions.length).toBe(1);
+    expect(compactions[0]?.compactTrigger).toBe("auto");
+    expect(compactions[0]?.preCompactTokens).toBe(120_000);
+    summary = await getContextSummaryByTaskId(taskId);
+    expect(summary.compactionCount).toBe(1);
+  });
+});
+
+describe("migration 219", () => {
+  test("relabels trigger-less pi compactions and leaves other rows alone", async () => {
+    const piTask = await createTask("pi");
+    const claudeTask = await createTask("claude");
+    const snapshot = (taskId: string, sessionId: string, extra = {}) =>
+      createContextSnapshot({
+        taskId,
+        agentId,
+        sessionId,
+        eventType: "compaction",
+        contextPercent: 9,
+        ...extra,
+      });
+
+    await snapshot(piTask, `pi-${piTask}`);
+    await snapshot(piTask, `pi-${piTask}`);
+    await snapshot(piTask, `pi-${piTask}`, { compactTrigger: "auto", preCompactTokens: 150_000 });
+    await snapshot(claudeTask, "claude-session");
+    expect((await getContextSummaryByTaskId(piTask)).compactionCount).toBe(3);
+
+    db.exec(await Bun.file("src/be/migrations/219_relabel_pi_context_compactions.sql").text());
+
+    const piRows = await getContextSnapshotsByTaskId(piTask);
+    expect(piRows.map((s) => s.eventType).sort()).toEqual(["compaction", "progress", "progress"]);
+    expect(piRows.find((s) => s.eventType === "compaction")?.preCompactTokens).toBe(150_000);
+    expect((await getContextSummaryByTaskId(piTask)).compactionCount).toBe(1);
+
+    const claudeRows = await getContextSnapshotsByTaskId(claudeTask);
+    expect(claudeRows.map((s) => s.eventType)).toEqual(["compaction"]);
+    expect((await getContextSummaryByTaskId(claudeTask)).compactionCount).toBe(1);
+  });
+});

package/src/tests/profile-claim.test.ts

@@ -0,0 +1,269 @@
+// Claim-time resolution of model profiles: a task's own `profile`, the agent's
+// default (MODEL_PROFILE), and how both sit in the precedence next to a raw
+// `model` and a `modelTier`. Drives the real `/api/poll` handler.
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getDbClient,
+  getTaskById,
+  initDb,
+  upsertSwarmConfig,
+} from "../be/db";
+import { createModelProfile, getAgentDefaultProfileName } from "../be/db/model-profiles";
+import { recordClaimModelResolution } from "../be/model-tier-resolution";
+import { handlePoll } from "../http/poll";
+import { taskModelPin } from "../tasks/model-pin";
+import { inheritedModelSelection } from "../tasks/worker-follow-up";
+
+const TEST_DB_PATH = "./test-profile-claim.sqlite";
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+type Trigger = { type: string; taskId: string; task: Record<string, unknown> };
+
+async function callPoll(agentId: string): Promise<Trigger | null> {
+  let bodyStr = "";
+  const req = {
+    method: "GET",
+    url: "/api/poll",
+    headers: { "x-agent-id": agentId },
+  } as unknown as Parameters<typeof handlePoll>[0];
+  const res = {
+    setHeader() {},
+    writeHead() {},
+    end(body?: string) {
+      bodyStr = body ?? "";
+    },
+  } as unknown as Parameters<typeof handlePoll>[1];
+  await handlePoll(req, res, ["api", "poll"], new URLSearchParams(), agentId);
+  return (JSON.parse(bodyStr) as { trigger: Trigger | null }).trigger;
+}
+
+async function claimRecord(id: string) {
+  return await getDbClient().get<{
+    resolvedModel: string | null;
+    modelSource: string | null;
+    resolvedProfile: string | null;
+  }>("SELECT resolvedModel, modelSource, resolvedProfile FROM agent_tasks WHERE id = ?", [id]);
+}
+
+async function worker(name: string, harnessProvider: "claude" | "codex", maxTasks = 1) {
+  return await createAgent({ name, isLead: false, status: "idle", maxTasks, harnessProvider });
+}
+
+async function setDefault(agentId: string, profile: string): Promise<void> {
+  await upsertSwarmConfig({
+    scope: "agent",
+    scopeId: agentId,
+    key: "MODEL_PROFILE",
+    value: profile,
+    exportToEnv: false,
+  });
+}
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+beforeEach(async () => {
+  const client = getDbClient();
+  // References first: migration 220's triggers refuse deleting a named profile.
+  await client.run("DELETE FROM agent_tasks");
+  await client.run("DELETE FROM swarm_config WHERE scope IN ('agent', 'repo')");
+  await client.run("DELETE FROM swarm_repos");
+  await client.run("DELETE FROM agents");
+  await client.run("DELETE FROM model_profiles");
+  await createModelProfile({
+    name: "claude-opus-high",
+    harness: "claude",
+    model: "opus",
+    effort: "high",
+  });
+  await createModelProfile({ name: "claude-haiku", harness: "claude", model: "haiku" });
+  await createModelProfile({
+    name: "codex-sol",
+    harness: "codex",
+    model: "gpt-5.6-sol",
+    effort: "xhigh",
+  });
+});
+
+describe("a task's own profile", () => {
+  test("claim stamps the profile and hands its model and effort to the worker", async () => {
+    const w = await worker("p-task", "claude");
+    const task = await createTaskExtended("work", { agentId: w.id, profile: "claude-opus-high" });
+    const trigger = await callPoll(w.id);
+
+    expect(trigger?.task).toMatchObject({
+      resolvedModel: "opus",
+      modelSource: "profile:task",
+      resolvedProfile: "claude-opus-high",
+      effort: "high",
+    });
+    expect(await claimRecord(task.id)).toEqual({
+      resolvedModel: "opus",
+      modelSource: "profile:task",
+      resolvedProfile: "claude-opus-high",
+    });
+    // The profile's effort rides on the trigger only; the row keeps the creator's ask.
+    expect((await getTaskById(task.id))?.effort).toBeUndefined();
+  });
+
+  test("the task's own effort wins over the profile's", async () => {
+    const w = await worker("p-effort", "claude");
+    await createTaskExtended("work", { agentId: w.id, profile: "claude-opus-high", effort: "low" });
+    expect((await callPoll(w.id))?.task.effort).toBe("low");
+  });
+
+  test("a profile beats the agent default", async () => {
+    const w = await worker("p-beats-default", "claude");
+    await setDefault(w.id, "claude-haiku");
+    const task = await createTaskExtended("work", { agentId: w.id, profile: "claude-opus-high" });
+    await callPoll(w.id);
+    expect((await claimRecord(task.id))?.resolvedProfile).toBe("claude-opus-high");
+  });
+
+  test("a directed task with another harness's profile fails fast without a spawn", async () => {
+    const w = await worker("p-mismatch", "claude");
+    await createTaskExtended("work", { agentId: w.id, profile: "codex-sol" });
+    const trigger = await callPoll(w.id);
+    expect(String(trigger?.task.modelUnsupported)).toContain("[model-harness-mismatch]");
+  });
+
+  test("a task naming a missing profile fails fast with a tagged reason", async () => {
+    // Migration 220's triggers keep such a row from existing; the claim still
+    // refuses one rather than run a model nobody picked.
+    const w = await worker("p-missing", "claude");
+    const task = await createTaskExtended("work", { agentId: w.id });
+    const fields = await recordClaimModelResolution(
+      { id: task.id, profile: "claude-gone" },
+      { id: w.id, harnessProvider: "claude" },
+    );
+    expect(String(fields.modelUnsupported)).toContain("[model-profile-missing]");
+  });
+
+  test("a pool task waits for a worker on the profile's harness", async () => {
+    const codex = await worker("p-pool-codex", "codex");
+    const claude = await worker("p-pool-claude", "claude");
+    const task = await createTaskExtended("pool work", { profile: "claude-opus-high" });
+
+    expect(await callPoll(codex.id)).toBeNull();
+    const trigger = await callPoll(claude.id);
+    expect(trigger?.taskId).toBe(task.id);
+    expect(trigger?.task.resolvedProfile).toBe("claude-opus-high");
+  });
+});
+
+describe("the agent's default profile", () => {
+  test("applies to a task with no model and no tier", async () => {
+    const w = await worker("d-applies", "codex");
+    await setDefault(w.id, "codex-sol");
+    const task = await createTaskExtended("work", { agentId: w.id });
+    const trigger = await callPoll(w.id);
+    expect(trigger?.task).toMatchObject({
+      resolvedModel: "gpt-5.6-sol",
+      modelSource: "profile:agent-default",
+      resolvedProfile: "codex-sol",
+      effort: "xhigh",
+    });
+    expect((await claimRecord(task.id))?.modelSource).toBe("profile:agent-default");
+  });
+
+  test("a raw task model and a task tier both win over it", async () => {
+    const w = await worker("d-loses", "claude", 2);
+    await setDefault(w.id, "claude-opus-high");
+    const pinned = await createTaskExtended("pinned", { agentId: w.id, model: "sonnet" });
+    const tiered = await createTaskExtended("tiered", { agentId: w.id, modelTier: "smol" });
+    await callPoll(w.id);
+    await callPoll(w.id);
+    expect(await claimRecord(pinned.id)).toEqual({
+      resolvedModel: "sonnet",
+      modelSource: "model",
+      resolvedProfile: null,
+    });
+    expect(await claimRecord(tiered.id)).toEqual({
+      resolvedModel: "haiku",
+      modelSource: "tier-default",
+      resolvedProfile: null,
+    });
+  });
+
+  test("a default for another harness is ignored; a missing one cannot be stored", async () => {
+    const w = await worker("d-ignored", "claude", 2);
+    await setDefault(w.id, "codex-sol");
+    const first = await createTaskExtended("work", { agentId: w.id });
+    const trigger = await callPoll(w.id);
+    expect(trigger?.task.modelUnsupported).toBeUndefined();
+    expect(trigger?.task.resolvedModel).toBeUndefined();
+    expect(await claimRecord(first.id)).toEqual({
+      resolvedModel: null,
+      modelSource: null,
+      resolvedProfile: null,
+    });
+
+    await expect(setDefault(w.id, "gone")).rejects.toThrow("model-profile-missing");
+    expect(await getAgentDefaultProfileName(w.id)).toBe("codex-sol");
+  });
+});
+
+describe("re-runs", () => {
+  test("a profile-filled model is not a pin, so a re-claim resolves the profile again", async () => {
+    const w = await worker("r-rerun", "claude");
+    await setDefault(w.id, "claude-opus-high");
+    const task = await createTaskExtended("work", { agentId: w.id });
+    await callPoll(w.id);
+    // The session report writes the model it ran into `model`.
+    await getDbClient().run(
+      "UPDATE agent_tasks SET model = 'opus', claudeSessionId = 's1', status = 'pending' WHERE id = ?",
+      [task.id],
+    );
+    const ran = await getTaskById(task.id);
+    expect(ran && taskModelPin(ran)).toBeUndefined();
+
+    // The default changes between runs; the re-claim follows it.
+    await setDefault(w.id, "claude-haiku");
+    const trigger = await callPoll(w.id);
+    expect(trigger?.task).toMatchObject({
+      resolvedModel: "haiku",
+      resolvedProfile: "claude-haiku",
+    });
+    // Neither the previous run's model (no pin) nor its profile effort carries over.
+    expect(trigger?.task.model).toBeUndefined();
+    expect(trigger?.task.effort).toBeUndefined();
+  });
+
+  test("a resume carries the task's own profile, not an agent default", async () => {
+    const a = await worker("r-resume-own", "claude");
+    const b = await worker("r-resume-default", "claude");
+    await setDefault(a.id, "claude-opus-high");
+    await setDefault(b.id, "claude-opus-high");
+    const own = await createTaskExtended("work", { agentId: a.id, profile: "claude-haiku" });
+    const viaDefault = await createTaskExtended("work", { agentId: b.id });
+    await callPoll(a.id);
+    await callPoll(b.id);
+
+    const ownRow = await getTaskById(own.id);
+    const defaultRow = await getTaskById(viaDefault.id);
+    expect(ownRow && inheritedModelSelection(ownRow)).toEqual({ profile: "claude-haiku" });
+    expect(defaultRow?.resolvedProfile).toBe("claude-opus-high");
+    expect(defaultRow && inheritedModelSelection(defaultRow)).toEqual({});
+  });
+});