@desplega.ai/agent-swarm 1.173.0 → 2.1.0

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({});
+  });
+});

package/src/tests/prompt-template-remaining.test.ts

@@ -12,6 +12,7 @@ import "../heartbeat/templates";
 import "../tools/templates";
 import "../commands/templates";
 import "../slack/templates";
+import "../integrations/chat-sdk/templates";
 import "../prompts/session-templates";
 
 const TEST_DB_PATH = "./test-prompt-remaining.sqlite";
@@ -33,6 +34,7 @@ async function ensureTemplatesRegistered(): Promise<void> {
   await import(`../tools/templates?t=${ts}`);
   await import(`../commands/templates?t=${ts}`);
   await import(`../slack/templates?t=${ts}`);
+  await import(`../integrations/chat-sdk/templates?t=${ts}`);
   await import(`../prompts/session-templates?t=${ts}`);
 }
 
@@ -115,6 +117,22 @@ describe("template registration — all sources", () => {
     expect(eventTypes).toContain("heartbeat.checklist");
   });
 
+  test("Heartbeat checklist puts the live status after the standing orders and instructions", () => {
+    // The status changes every tick; the orders and instructions usually do
+    // not, so they lead the text and the status goes last.
+    const { text } = resolveTemplate("heartbeat.checklist", {
+      system_status: "STATUS_MARKER",
+      heartbeat_content: "ORDERS_MARKER",
+    });
+    const orders = text.indexOf("ORDERS_MARKER");
+    const instructions = text.indexOf("## Instructions");
+    const status = text.indexOf("## Current System Status");
+    expect(orders).toBeGreaterThan(-1);
+    expect(instructions).toBeGreaterThan(orders);
+    expect(status).toBeGreaterThan(instructions);
+    expect(text.trimEnd()).toEndWith("STATUS_MARKER");
+  });
+
   test("Task lifecycle templates are registered (3 task_lifecycle)", () => {
     const all = getAllTemplateDefinitions();
     const eventTypes = all.map((d) => d.eventType);
@@ -143,6 +161,11 @@ describe("template registration — all sources", () => {
     expect(eventTypes).toContain("slack.assistant.offline");
     expect(eventTypes).toContain("slack.message.thread_context");
   });
+
+  test("Chat SDK templates are registered (1 system)", () => {
+    const eventTypes = getAllTemplateDefinitions().map((d) => d.eventType);
+    expect(eventTypes).toContain("chat.message.thread_context");
+  });
 });
 
 // ============================================================================
@@ -608,4 +631,16 @@ Alice: Hello
 
     expect(result.text).toBe(expected);
   });
+
+  test("chat.message.thread_context produces the same block as Slack", () => {
+    const result = resolveTemplate("chat.message.thread_context", {
+      thread_messages: "Alice: Hello\n[Agent]: Hi there!",
+    });
+
+    expect(result.skipped).toBe(false);
+    expect(result.text).toBe(`<thread_context>
+Alice: Hello
+[Agent]: Hi there!
+</thread_context>`);
+  });
 });

package/src/tests/quickjs-compat.test.ts

@@ -0,0 +1,213 @@
+import { describe, expect, test } from "bun:test";
+import {
+  checkQuickJSCompat,
+  type QuickJSCompatRule,
+  quickJSCompatWarnings,
+} from "../scripts-runtime/quickjs-compat";
+
+const wrap = (body: string) => `export default async (args, ctx) => {\n${body}\n};`;
+
+// One positive (flagged) and one negative (clean, but close) fixture per rule.
+const FIXTURES: Array<{ rule: QuickJSCompatRule; flagged: string; clean: string }> = [
+  {
+    rule: "bunGlobal",
+    flagged: wrap("return Bun.hash('x');"),
+    clean: wrap("const Bun = { hash: (s) => s }; return typeof globalThis.Bun;"),
+  },
+  {
+    rule: "process",
+    flagged: wrap("return process.env.HOME;"),
+    clean: wrap("const config = { process: 1 }; return config.process + args.process;"),
+  },
+  {
+    rule: "fsStdlib",
+    flagged: wrap("return ctx.stdlib.glob('*.ts');"),
+    clean: wrap("return ctx.stdlib.fetchJson('https://example.com');"),
+  },
+  {
+    rule: "require",
+    flagged: wrap("const fs = require('fs'); return fs;"),
+    clean: wrap("const require = (name) => name; return require('fs');"),
+  },
+  {
+    rule: "unsupportedGlobal",
+    flagged: wrap("return Buffer.from('aGk=', 'base64').toString();"),
+    clean: wrap("const bytes: Buffer | null = null; return { Buffer: bytes };"),
+  },
+  {
+    rule: "cryptoSubtle",
+    flagged: wrap("return crypto.subtle.digest('SHA-256', new Uint8Array());"),
+    clean: wrap("return crypto.randomUUID();"),
+  },
+  {
+    rule: "responseBody",
+    flagged: wrap("const res = await fetch('https://example.com'); return res.arrayBuffer();"),
+    clean: wrap("const res = await fetch('https://example.com'); return res.text();"),
+  },
+  {
+    rule: "localeFormat",
+    flagged: wrap("return new Date().toLocaleString('en-GB', { timeZone: 'Europe/Madrid' });"),
+    clean: wrap("return new Date().toISOString();"),
+  },
+  {
+    rule: "hostCredential",
+    flagged: wrap("return ctx.stdlib.Redacted.value(ctx.swarm.config.apiKey);"),
+    clean: wrap("return ctx.stdlib.Redacted.value(ctx.swarm.config.agentId);"),
+  },
+  {
+    rule: "privateHost",
+    flagged: wrap("return ctx.stdlib.fetchJson('http://intranet:8080/status');"),
+    clean: wrap("return ctx.stdlib.fetchJson('https://api.example.com/status');"),
+  },
+];
+
+describe("checkQuickJSCompat", () => {
+  for (const { rule, flagged, clean } of FIXTURES) {
+    test(`${rule}: flags the positive fixture`, () => {
+      const report = checkQuickJSCompat(flagged);
+      expect(report.compatible).toBe(false);
+      expect(report.findings.map((finding) => finding.rule)).toContain(rule);
+    });
+
+    test(`${rule}: passes the negative fixture`, () => {
+      expect(checkQuickJSCompat(clean)).toEqual({ compatible: true, findings: [] });
+    });
+  }
+
+  test("workspaceRw: flags the fsMode, not the source", () => {
+    const source = wrap("return 'workspace-rw';");
+    expect(checkQuickJSCompat(source, { fsMode: "workspace-rw" }).findings).toEqual([
+      { rule: "workspaceRw", message: "fsMode workspace-rw is not available under quickjs" },
+    ]);
+    expect(checkQuickJSCompat(source, { fsMode: "none" }).compatible).toBe(true);
+  });
+
+  test("fsStdlib also catches stdlib imports and destructuring", () => {
+    const imported = `import { glob } from "stdlib";\n${wrap("return glob('*');")}`;
+    const destructured = wrap("const { grep } = ctx.stdlib; return grep('x', '.');");
+    expect(checkQuickJSCompat(imported).findings[0]?.rule).toBe("fsStdlib");
+    expect(checkQuickJSCompat(destructured).findings[0]?.rule).toBe("fsStdlib");
+  });
+
+  test("globals read off globalThis count, typeof feature checks do not", () => {
+    expect(checkQuickJSCompat(wrap("return globalThis.process.env;")).findings[0]?.rule).toBe(
+      "process",
+    );
+    expect(
+      checkQuickJSCompat(wrap("return (globalThis as any).Bun.version;")).findings[0]?.rule,
+    ).toBe("bunGlobal");
+    expect(checkQuickJSCompat(wrap("return typeof process === 'undefined';")).compatible).toBe(
+      true,
+    );
+  });
+
+  test("the shimmed web globals are compatible", () => {
+    const source = wrap(`const url = new URL("/x?a=1", "https://example.com");
+url.searchParams.set("b", "2");
+const bytes = new TextEncoder().encode(url.href);
+const id = setInterval(() => {}, 10);
+clearInterval(id);
+await fetch(url, { method: "POST", body: bytes });
+return [new TextDecoder().decode(bytes), crypto.randomUUID(), crypto.getRandomValues(new Uint8Array(4))];`);
+    expect(checkQuickJSCompat(source)).toEqual({ compatible: true, findings: [] });
+  });
+
+  test("bindings resolve by lexical scope", () => {
+    // A local Buffer parameter in one function does not hide a global Buffer in another.
+    const shadowed = `function decode(Buffer: { from(x: string): string }) { return Buffer.from("x"); }
+export default async () => [decode({ from: (x) => x }), Buffer.from("aGk=", "base64").toString()];`;
+    expect(checkQuickJSCompat(shadowed).findings).toEqual([
+      { rule: "unsupportedGlobal", message: "Buffer is not available under quickjs", line: 2 },
+    ]);
+    // Block scope too, and a shorthand property reads the binding it names.
+    const block = wrap("{ const process = 1; } return { process };");
+    expect(checkQuickJSCompat(block).findings[0]?.rule).toBe("process");
+    // Every use resolves locally: clean.
+    const local = `function decode(Buffer: { from(x: string): string }) { return Buffer.from("x"); }
+export default async () => { const process = { env: {} }; return [decode({ from: (x) => x }), process.env]; };`;
+    expect(checkQuickJSCompat(local)).toEqual({ compatible: true, findings: [] });
+    // A declare-only binding defines nothing at run time, so the global still counts.
+    const ambient = `declare const Buffer: any;\n${wrap("return Buffer.from('x');")}`;
+    expect(checkQuickJSCompat(ambient).findings[0]?.rule).toBe("unsupportedGlobal");
+  });
+
+  test("atob and btoa are shimmed; AbortSignal stays reported", () => {
+    expect(checkQuickJSCompat(wrap("return atob(btoa('hi'));"))).toEqual({
+      compatible: true,
+      findings: [],
+    });
+    expect(
+      checkQuickJSCompat(
+        wrap("return fetch('https://example.com', { signal: AbortSignal.timeout(5) });"),
+      ).findings[0]?.message,
+    ).toBe("AbortSignal is not available under quickjs");
+  });
+
+  test("privateHost: literal fetch URLs to single-label or private hosts", () => {
+    const hosts = (body: string) =>
+      checkQuickJSCompat(wrap(body)).findings.filter((finding) => finding.rule === "privateHost");
+    const flagged = [
+      "fetch('http://api:3013/health')",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: script source under test
+      "fetch(`http://localhost:8080/${args.path}`)",
+      "globalThis.fetch('http://10.0.0.5/x')",
+      "ctx.stdlib.fetch('http://192.168.1.10/')",
+      "ctx.stdlib.fetchJson('http://[::1]:9000/')",
+      "ctx.stdlib.fetchJson('http://0x7f.1/')",
+      "fetch('http://[fd00::1]/')",
+      "fetch('http://[::ffff:10.1.2.3]/')",
+      "fetch('https://svc.localhost/')",
+      "const { fetchJson } = ctx.stdlib; await fetchJson('http://intranet/')",
+    ];
+    for (const call of flagged) expect(hosts(`return ${call};`)).toHaveLength(1);
+    const clean = [
+      "fetch('https://example.com/x')",
+      "fetch('https://8.8.8.8/')",
+      "fetch('http://[2001:db8::1]/')",
+      "fetch(args.url)",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: script source under test
+      "fetch(`http://${args.host}/x`)",
+      "fetch('relative/path')",
+      "ctx.api.github.fetch('http://intranet/')",
+      "console.log('http://intranet/')",
+    ];
+    for (const call of clean) expect(hosts(`return ${call};`)).toEqual([]);
+    // A const that holds the base URL fixes the host too; a let or a cut-off name does not.
+    const constBase = [
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: script source under test
+      "const API = 'http://api:3013'; return fetch(`${API}/health`);",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: script source under test
+      "const API = 'http://api:3013'; return fetch(`${API}${args.path}`);",
+      "const API = 'http://api:3013'; return ctx.stdlib.fetch(API + '/x');",
+      "const API = `http://10.1.2.3`; return fetch(API);",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: script source under test
+      "const API = 'http://api:3013'; const rows = `${API}/rows/${args.id}`; return fetch(`${rows}?limit=5`);",
+    ];
+    for (const body of constBase) expect(hosts(body)).toHaveLength(1);
+    const dynamicBase = [
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: script source under test
+      "let API = 'http://api:3013'; API = args.base; return fetch(`${API}/x`);",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: script source under test
+      "return fetch(`http://intra${args.suffix}/x`);",
+      "return fetch('http://intra' + args.suffix);",
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: script source under test
+      "const API = 'https://api.example.com'; return fetch(`${API}/x`);",
+    ];
+    for (const body of dynamicBase) expect(hosts(body)).toEqual([]);
+    expect(hosts("return fetch('http://api:3013/health');")[0]?.message).toBe(
+      "fetch to api:3013 (single-label host) depends on the egress policy: quickjs refuses private hosts unless the operator allows them",
+    );
+  });
+
+  test("reports each rule and name once, with its first line", () => {
+    const report = checkQuickJSCompat(wrap("Bun.sleep(1);\nBun.sleep(2);\nreturn process.pid;"));
+    expect(report.findings).toEqual([
+      { rule: "bunGlobal", message: "Bun.* is not available under quickjs", line: 2 },
+      { rule: "process", message: "process is not available under quickjs", line: 4 },
+    ]);
+    expect(quickJSCompatWarnings(report, "actions.sync")).toEqual([
+      "actions.sync: quickjs compat (bunGlobal, line 2): Bun.* is not available under quickjs",
+      "actions.sync: quickjs compat (process, line 4): process is not available under quickjs",
+    ]);
+  });
+});

package/src/tests/rbac-engine.test.ts

@@ -49,6 +49,10 @@ const LEAD_ONLY_VERBS: PermissionVerb[] = [
   "memory.write.consolidated",
   "channel.delete",
   "integration.kapso.manage",
+  "integration.chat.manage",
+  "integration.chat.post",
+  "integration.chat.read",
+  "integration.chat.dm",
   "integration.slack.post",
   "integration.slack.read",
   "integration.slack.thread.start",
@@ -103,6 +107,9 @@ const OPERATOR_OR_USER_VERBS: PermissionVerb[] = [
 
 const LEAD_OR_OPERATOR_VERBS: PermissionVerb[] = ["models.catalog.write"];
 
+// The shared API key alone: dashboard users are denied too.
+const API_KEY_OPERATOR_VERBS: PermissionVerb[] = ["models.profiles.write"];
+
 const AGENT_OR_OPERATOR_VERBS: PermissionVerb[] = ["models.harness-support.write"];
 
 const LEAD_OR_RESOURCE_OWNER_VERBS: PermissionVerb[] = [
@@ -140,6 +147,7 @@ const REQUESTER_OWNS_TASK_VERBS: PermissionVerb[] = [
 const COMPOSITE_VERBS: PermissionVerb[] = [
   "memory.delete.any",
   "task.fs.mutate",
+  "task.parent.attach",
   "task.progress.write",
 ];
 
@@ -206,6 +214,7 @@ describe("verb-group partition", () => {
       ...LEAD_OR_OPERATOR_OR_USER_VERBS,
       ...OPERATOR_OR_USER_VERBS,
       ...LEAD_OR_OPERATOR_VERBS,
+      ...API_KEY_OPERATOR_VERBS,
       ...AGENT_OR_OPERATOR_VERBS,
     ];
     expect(new Set(grouped).size).toBe(grouped.length);
@@ -320,6 +329,23 @@ describe("agent-or-operator verbs", () => {
   }
 });
 
+describe("api-key operator verbs", () => {
+  const expected: Expected = {
+    lead: false,
+    worker: false,
+    ownerWorker: false,
+    creatorWorker: false,
+    userRequester: false,
+    foreignUser: false,
+    operator: true,
+  };
+  for (const verb of API_KEY_OPERATOR_VERBS) {
+    test(`${verb}: only the operator allowed`, () => {
+      expectDecisions(verb, { kind: "none" }, expected);
+    });
+  }
+});
+
 describe("lead-or-operator verbs", () => {
   const expected: Expected = {
     lead: true,
@@ -570,9 +596,12 @@ describe("memory.delete.any composite (human, lead for swarm, owner for agent sc
   });
 });
 
-describe("task.fs.mutate composite (operator OR user OR lead OR assignee OR creator)", () => {
-  test("only an unrelated worker agent is denied", () => {
-    expectDecisions("task.fs.mutate", TASK_RESOURCE, {
+describe("task.fs.mutate and task.parent.attach composite (operator OR user OR lead OR assignee OR creator)", () => {
+  test.each([
+    "task.fs.mutate",
+    "task.parent.attach",
+  ] as const)("%s: only an unrelated worker agent is denied", (verb) => {
+    expectDecisions(verb, TASK_RESOURCE, {
       lead: true,
       worker: false,
       ownerWorker: true, // assignee (task.agentId)

package/src/tests/runner-exit-after-tasks.test.ts

@@ -122,8 +122,6 @@ test(
     const tempDir = `/tmp/runner-exit-shutdown-${crypto.randomUUID()}`;
     await Bun.$`mkdir -p ${tempDir}`.quiet();
     try {
-      await Bun.write(`${tempDir}/pm2`, '#!/bin/sh\nprintf "%s" "$1" > "$SHUTDOWN_TEST_PM2_LOG"\n');
-      await Bun.$`chmod +x ${tempDir}/pm2`.quiet();
       await Bun.write(
         `${tempDir}/runner.ts`,
         `
@@ -141,14 +139,12 @@ test(
             ...process.env,
             PATH: tempDir,
             ANONYMIZED_TELEMETRY: "false",
-            SHUTDOWN_TEST_PM2_LOG: `${tempDir}/pm2.log`,
           },
         }),
         "runner shutdown",
       );
       expect(result.stdout).toContain("shutdown callback");
       expect(result.stdout).not.toContain("unexpected return");
-      expect(await Bun.file(`${tempDir}/pm2.log`).text()).toBe("save");
       expect(requests).toHaveLength(1);
       expect(requests[0]?.path).toBe("/close");
       expect(requests[0]?.headers["x-agent-id"]).toBe(agentId);