@desplega.ai/agent-swarm 1.165.0 → 1.167.0

package/src/tests/opencode-adapter.test.ts

@@ -1294,15 +1294,17 @@ describe("OpencodeAdapter — reasoning_effort wiring", () => {
     expect(options).toEqual({ thinking: { type: "enabled", budgetTokens: 32768 } });
   });
 
-  test("undefined reasoningEffort leaves config.provider unset", async () => {
+  test("undefined reasoningEffort leaves model options unset", async () => {
     const events: OpencodeEvent[] = [
       { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
     ];
     const cfg = testConfig({ model: "openrouter/google/gemini-3-flash-preview" });
     await driveSession(events, cfg);
 
-    const opts = lastCreateOpencodeConfig as { config?: { provider?: unknown } };
-    expect(opts.config?.provider).toBeUndefined();
+    const opts = lastCreateOpencodeConfig as {
+      config?: { provider?: Record<string, { models?: unknown }> };
+    };
+    expect(opts.config?.provider?.openrouter?.models).toBeUndefined();
   });
 });
 
@@ -1496,3 +1498,64 @@ describe("OpencodeAdapter: event stream ends without session.idle", () => {
     expect(closeServer).toHaveBeenCalledTimes(1);
   });
 });
+
+describe("OpenRouter attribution config", () => {
+  test("overrides harness attribution while preserving custom headers and options", async () => {
+    const { applyOpenRouterBaseUrlOverride } = await import("../providers/opencode-adapter");
+    const config = {
+      provider: {
+        openrouter: {
+          options: {
+            apiKey: "test",
+            headers: {
+              "X-Custom": "keep",
+              "X-Title": "opencode",
+              "HTTP-Referer": "https://opencode.ai",
+            },
+          },
+        },
+      },
+    };
+    applyOpenRouterBaseUrlOverride(config, {});
+    expect(config.provider.openrouter.options).toEqual({
+      apiKey: "test",
+      headers: {
+        "X-Custom": "keep",
+        "HTTP-Referer": "https://agent-swarm.dev",
+        "X-Title": "Agent Swarm",
+        "X-OpenRouter-Title": "Agent Swarm",
+        "X-OpenRouter-Categories": "personal-agent,cloud-agent",
+      },
+    });
+  });
+  test("gateway override preserves options without injecting attribution", async () => {
+    const { applyOpenRouterBaseUrlOverride } = await import("../providers/opencode-adapter");
+    const config = {
+      provider: {
+        openrouter: {
+          models: {
+            "google/gemini-3-flash-preview": { options: { reasoning: { effort: "low" } } },
+          },
+          options: { apiKey: "test", headers: { "X-Custom": "keep" } },
+        },
+        anthropic: { options: { apiKey: "test-other" } },
+      },
+    };
+    applyOpenRouterBaseUrlOverride(config, { OPENROUTER_BASE_URL: "http://localhost:1234/v1" });
+    expect(config.provider.openrouter.options).toEqual({
+      apiKey: "test",
+      headers: { "X-Custom": "keep" },
+      baseURL: "http://localhost:1234/v1",
+    });
+    expect(config.provider.openrouter.models).toEqual({
+      "google/gemini-3-flash-preview": { options: { reasoning: { effort: "low" } } },
+    });
+    expect(config.provider.anthropic).toEqual({ options: { apiKey: "test-other" } });
+  });
+  test("task opt-out leaves default provider config untouched", async () => {
+    const { applyOpenRouterBaseUrlOverride } = await import("../providers/opencode-adapter");
+    const config = {};
+    applyOpenRouterBaseUrlOverride(config, { OPENROUTER_APP_ATTRIBUTION: "false" });
+    expect(config).toEqual({});
+  });
+});

package/src/tests/opencode-plugin.test.ts

@@ -21,11 +21,13 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import type { Message, Part } from "@opencode-ai/sdk";
 import {
   flattenOpencodeTranscript,
+  OPENROUTER_APP_ATTRIBUTION_HEADERS as PLUGIN_OPENROUTER_APP_ATTRIBUTION_HEADERS,
   runSummaryLlm,
   type SummarizeSessionForOpencodeDeps,
   type SwarmConfig,
   summarizeSessionForOpencode,
 } from "../../plugin/opencode-plugins/lib/summarize";
+import { OPENROUTER_APP_ATTRIBUTION_HEADERS } from "../utils/openrouter-base-url";
 
 // ── helpers ───────────────────────────────────────────────────────────────────
 
@@ -514,6 +516,41 @@ describe("runSummaryLlm — OPENROUTER_BASE_URL gateway", () => {
 
   afterEach(() => {
     delete process.env.OPENROUTER_BASE_URL;
+    delete process.env.OPENROUTER_APP_ATTRIBUTION;
+  });
+
+  const okSummary = async () => ({
+    ok: true,
+    status: 200,
+    text: async () => "",
+    json: async () => summaryBody,
+  });
+  const sentHeaders = () => new Headers(fetchCalls[0]?.init?.headers);
+
+  test("the inlined attribution copy matches src/utils/openrouter-base-url.ts", () => {
+    expect(PLUGIN_OPENROUTER_APP_ATTRIBUTION_HEADERS).toEqual(OPENROUTER_APP_ATTRIBUTION_HEADERS);
+  });
+
+  test("attributes direct openrouter.ai calls to Agent Swarm", async () => {
+    fetchHandler = okSummary;
+    expect(await runSummaryLlm(openrouterCred, "sys", "user")).not.toBeNull();
+    expect(sentHeaders().get("http-referer")).toBe("https://agent-swarm.dev");
+    expect(sentHeaders().get("x-openrouter-title")).toBe("Agent Swarm");
+    expect(sentHeaders().get("x-openrouter-categories")).toBe("personal-agent,cloud-agent");
+  });
+
+  test("a gateway or OPENROUTER_APP_ATTRIBUTION=false sends no attribution", async () => {
+    fetchHandler = okSummary;
+    process.env.OPENROUTER_BASE_URL = "https://control-plane.example/proxy/v1/";
+    await runSummaryLlm(openrouterCred, "sys", "user");
+    expect(sentHeaders().has("http-referer")).toBe(false);
+
+    fetchCalls.length = 0;
+    delete process.env.OPENROUTER_BASE_URL;
+    process.env.OPENROUTER_APP_ATTRIBUTION = "false";
+    await runSummaryLlm(openrouterCred, "sys", "user");
+    expect(fetchCalls[0]?.url).toBe("https://openrouter.ai/api/v1/chat/completions");
+    expect(sentHeaders().has("http-referer")).toBe(false);
   });
 
   test("defaults to openrouter.ai when the env is unset", async () => {

package/src/tests/openrouter-attribution-call-sites.test.ts

@@ -0,0 +1,204 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { OpenAIEmbeddingProvider } from "../be/memory/providers/openai-embedding";
+import { runMemoryRater } from "../be/memory/raters/llm-summarizer";
+import { validateProviderCredentials } from "../commands/provider-credentials";
+import { completeStructured } from "../utils/internal-ai/complete-structured";
+import type { ExecutorDependencies, ExecutorInput } from "../workflows/executors/base";
+import { executeRawLlm } from "../workflows/executors/raw-llm";
+import { ValidateExecutor } from "../workflows/executors/validate";
+
+/**
+ * OpenRouter app attribution at each of our own HTTP call sites: present for
+ * openrouter.ai, absent for a gateway, absent with OPENROUTER_APP_ATTRIBUTION=false.
+ */
+
+const ENV_KEYS = [
+  "OPENROUTER_API_KEY",
+  "OPENROUTER_BASE_URL",
+  "OPENROUTER_APP_ATTRIBUTION",
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "EMBEDDING_API_BASE_URL",
+] as const;
+const GATEWAY = "https://gateway.example.test/v1";
+
+type Case = { name: string; env: Record<string, string>; attributed: boolean };
+const CASES: Case[] = [
+  { name: "openrouter.ai", env: {}, attributed: true },
+  { name: "a gateway", env: { OPENROUTER_BASE_URL: GATEWAY }, attributed: false },
+  { name: "the opt-out", env: { OPENROUTER_APP_ATTRIBUTION: "false" }, attributed: false },
+];
+
+let saved: Record<string, string | undefined> = {};
+let requests: { url: string; headers: Headers }[] = [];
+const origFetch = globalThis.fetch;
+
+beforeEach(() => {
+  saved = Object.fromEntries(ENV_KEYS.map((key) => [key, process.env[key]]));
+  for (const key of ENV_KEYS) delete process.env[key];
+  requests = [];
+  globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
+    const request = new Request(input, init);
+    requests.push({ url: request.url, headers: request.headers });
+    return new Response("bad request", { status: 400 });
+  }) as typeof fetch;
+});
+
+afterEach(() => {
+  globalThis.fetch = origFetch;
+  for (const key of ENV_KEYS) {
+    if (saved[key] === undefined) delete process.env[key];
+    else process.env[key] = saved[key];
+  }
+});
+
+function setEnv(env: Record<string, string>) {
+  for (const [key, value] of Object.entries(env)) process.env[key] = value;
+}
+
+function expectAttribution(headers: Headers | undefined, attributed: boolean) {
+  expect(headers).toBeDefined();
+  if (attributed) {
+    expect(headers?.get("http-referer")).toBe("https://agent-swarm.dev");
+    expect(headers?.get("x-openrouter-title")).toBe("Agent Swarm");
+    expect(headers?.get("x-openrouter-categories")).toBe("personal-agent,cloud-agent");
+  } else {
+    expect(headers?.has("http-referer")).toBe(false);
+    expect(headers?.has("x-openrouter-title")).toBe(false);
+    expect(headers?.has("x-openrouter-categories")).toBe(false);
+  }
+}
+
+describe("memory rater (llm-summarizer)", () => {
+  for (const c of CASES) {
+    test(`${c.name}`, async () => {
+      setEnv(c.env);
+      await runMemoryRater({ prompt: "p", apiKey: "example-or-key" });
+      expectAttribution(requests[0]?.headers, c.attributed);
+    });
+  }
+});
+
+describe("completeStructured (pi-ai path)", () => {
+  for (const c of CASES) {
+    test(`${c.name}`, async () => {
+      let headers: Headers | undefined;
+      await completeStructured({
+        zodSchema: { safeParse: () => ({ success: false, error: new Error("x") }) } as never,
+        toolSchema: { type: "object", properties: {} } as never,
+        toolName: "record",
+        toolDescription: "Record.",
+        systemPrompt: "sys",
+        userPrompt: "user",
+        retries: 1,
+        env: c.env,
+        _credentialOverride: {
+          kind: "openrouter",
+          apiKey: "example-or-key",
+          modelDefault: "openrouter/deepseek/deepseek-v4.1-flash",
+        },
+        _complete: async (_model, _context, options) => {
+          headers = new Headers((options?.headers ?? {}) as Record<string, string>);
+          throw new Error("stop");
+        },
+      });
+      expectAttribution(headers, c.attributed);
+    });
+  }
+
+  test("a non-OpenRouter credential gets no attribution", async () => {
+    let headers: Headers | undefined;
+    await completeStructured({
+      zodSchema: { safeParse: () => ({ success: false, error: new Error("x") }) } as never,
+      toolSchema: { type: "object", properties: {} } as never,
+      toolName: "record",
+      toolDescription: "Record.",
+      systemPrompt: "sys",
+      userPrompt: "user",
+      retries: 1,
+      env: {},
+      _credentialOverride: {
+        kind: "anthropic",
+        apiKey: "example-ant-key",
+        modelDefault: "anthropic/claude-sonnet-4-5",
+      },
+      _complete: async (_model, _context, options) => {
+        headers = new Headers((options?.headers ?? {}) as Record<string, string>);
+        throw new Error("stop");
+      },
+    });
+    expectAttribution(headers, false);
+  });
+});
+
+describe("workflow raw-llm and validate nodes", () => {
+  const deps = { interpolate: (template: string) => template } as unknown as ExecutorDependencies;
+  const meta = { runId: "run", stepId: "step", nodeId: "node" } as unknown as ExecutorInput["meta"];
+
+  for (const c of CASES) {
+    test(`raw-llm: ${c.name}`, async () => {
+      setEnv({ OPENROUTER_API_KEY: "example-or-key", ...c.env });
+      expect((await executeRawLlm({ prompt: "hi" })).status).toBe("failed");
+      expect(
+        requests[0]?.url.startsWith(c.env.OPENROUTER_BASE_URL ?? "https://openrouter.ai/"),
+      ).toBe(true);
+      expectAttribution(requests[0]?.headers, c.attributed);
+    });
+
+    test(`validate: ${c.name}`, async () => {
+      setEnv({ OPENROUTER_API_KEY: "example-or-key", ...c.env });
+      await new ValidateExecutor(deps).run({
+        config: { targetNodeId: "a", prompt: "Is it valid?" },
+        context: { a: "output" },
+        meta,
+      });
+      expectAttribution(requests[0]?.headers, c.attributed);
+    });
+  }
+
+  test("an OpenAI credential gets no attribution", async () => {
+    setEnv({ OPENAI_API_KEY: "example-sk-openai" });
+    await executeRawLlm({ prompt: "hi" });
+    expect(requests[0]?.url.startsWith("https://api.openai.com/")).toBe(true);
+    expectAttribution(requests[0]?.headers, false);
+  });
+});
+
+describe("OpenRouter credential check (GET /models)", () => {
+  for (const c of CASES) {
+    test(`${c.name}`, async () => {
+      setEnv(c.env);
+      await validateProviderCredentials("grok", { OPENROUTER_API_KEY: "example-or-key" });
+      expect(requests[0]?.url.endsWith("/models")).toBe(true);
+      expectAttribution(requests[0]?.headers, c.attributed);
+    });
+  }
+});
+
+describe("OpenAI-compatible embedding provider", () => {
+  const embedCases: Case[] = [
+    {
+      name: "an openrouter.ai base URL",
+      env: { EMBEDDING_API_BASE_URL: "https://openrouter.ai/api/v1" },
+      attributed: true,
+    },
+    { name: "the OpenAI default", env: {}, attributed: false },
+    { name: "a gateway", env: { EMBEDDING_API_BASE_URL: GATEWAY }, attributed: false },
+    {
+      name: "the opt-out",
+      env: {
+        EMBEDDING_API_BASE_URL: "https://openrouter.ai/api/v1",
+        OPENROUTER_APP_ATTRIBUTION: "0",
+      },
+      attributed: false,
+    },
+  ];
+  for (const c of embedCases) {
+    test(`${c.name}`, async () => {
+      setEnv(c.env);
+      const provider = new OpenAIEmbeddingProvider({ apiKey: "example-embed-key" });
+      expect(await provider.embed("hello")).toBeNull();
+      expectAttribution(requests[0]?.headers, c.attributed);
+    });
+  }
+});

package/src/tests/openrouter-base-url.test.ts

@@ -3,8 +3,7 @@
  *
  * Covers the shared resolver (`src/utils/openrouter-base-url.ts`), the pi
  * models.json override writer (`ensureOpenRouterModelsOverride`) including
- * its composition through pi-coding-agent's ModelRuntime, and the opencode
- * per-task config injection (`applyOpenRouterBaseUrlOverride`).
+ * its composition through pi-coding-agent's ModelRuntime, and attribution host gating.
  */
 
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
@@ -12,10 +11,12 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ModelRuntime } from "@earendil-works/pi-coding-agent";
-import type { Config } from "@opencode-ai/sdk";
-import { applyOpenRouterBaseUrlOverride } from "../providers/opencode-adapter";
 import { ensureOpenRouterModelsOverride } from "../providers/pi-mono-adapter";
-import { DEFAULT_OPENROUTER_BASE_URL, getOpenRouterBaseUrl } from "../utils/openrouter-base-url";
+import {
+  DEFAULT_OPENROUTER_BASE_URL,
+  getOpenRouterAttributionHeaders,
+  getOpenRouterBaseUrl,
+} from "../utils/openrouter-base-url";
 
 const GATEWAY = "https://control-plane.example/proxy/v1";
 
@@ -220,40 +221,30 @@ describe("ensureOpenRouterModelsOverride (pi)", () => {
   });
 });
 
-describe("applyOpenRouterBaseUrlOverride (opencode)", () => {
-  test("no-op when OPENROUTER_BASE_URL is unset", () => {
-    const config: Config = { model: "openrouter/google/gemini-3-flash-preview" };
-    applyOpenRouterBaseUrlOverride(config, {});
-    expect(config.provider).toBeUndefined();
-  });
-
-  test("sets provider.openrouter.options.baseURL when the env is set", () => {
-    const config: Config = { model: "openrouter/google/gemini-3-flash-preview" };
-    applyOpenRouterBaseUrlOverride(config, { OPENROUTER_BASE_URL: GATEWAY });
-    expect(config.provider?.openrouter?.options?.baseURL).toBe(GATEWAY);
-  });
-
-  test("preserves existing provider config (e.g. reasoning model options)", () => {
-    const config: Config = {
-      model: "openrouter/google/gemini-3-flash-preview",
-      provider: {
-        openrouter: {
-          models: {
-            "google/gemini-3-flash-preview": { options: { reasoning: { effort: "low" } } },
-          },
-          options: { apiKey: "sk-keep" },
-        },
-        anthropic: { options: { apiKey: "sk-ant" } },
-      },
-    };
-    applyOpenRouterBaseUrlOverride(config, { OPENROUTER_BASE_URL: GATEWAY });
-    expect(config.provider?.openrouter?.options).toEqual({
-      apiKey: "sk-keep",
-      baseURL: GATEWAY,
-    });
-    expect(config.provider?.openrouter?.models).toEqual({
-      "google/gemini-3-flash-preview": { options: { reasoning: { effort: "low" } } },
+describe("getOpenRouterAttributionHeaders", () => {
+  test.each([
+    "https://openrouter.ai/api/v1",
+    "https://api.openrouter.ai/v1",
+  ])("attributes direct OpenRouter host %s", (url) => {
+    expect(getOpenRouterAttributionHeaders(url, {})).toEqual({
+      "HTTP-Referer": "https://agent-swarm.dev",
+      "X-OpenRouter-Title": "Agent Swarm",
+      "X-OpenRouter-Categories": "personal-agent,cloud-agent",
     });
-    expect(config.provider?.anthropic).toEqual({ options: { apiKey: "sk-ant" } });
+  });
+  test.each([
+    "http://localhost:1234/v1",
+    "https://evil-openrouter.ai",
+    "https://openrouter.ai.evil.com",
+    "invalid",
+  ])("does not attribute gateway, lookalike or invalid URL %s", (url) => {
+    expect(getOpenRouterAttributionHeaders(url, {})).toEqual({});
+  });
+  test.each(["false", "FALSE", "FaLsE", "0"])("honors opt-out %s", (value) => {
+    expect(
+      getOpenRouterAttributionHeaders("https://openrouter.ai", {
+        OPENROUTER_APP_ATTRIBUTION: value,
+      }),
+    ).toEqual({});
   });
 });

package/src/tests/pi-mono-extension.test.ts

@@ -1,5 +1,6 @@
 /**
- * Unit tests for `summarizeSessionForPi` in `src/providers/pi-mono-extension.ts`.
+ * Unit tests for `summarizeSessionForPi` in `src/providers/pi-mono-extension.ts`,
+ * plus the extension's advisory nudges (delivered with `pi.sendMessage`).
  *
  * Plan: thoughts/taras/plans/2026-05-10-fix-session-summarization-workers.md
  * → Phase 1 § "Test coverage"
@@ -19,8 +20,14 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import type { ExtensionAPI, ExtensionFactory } from "@earendil-works/pi-coding-agent";
+import { clearToolHistory } from "../hooks/tool-loop-detection";
 import type { SummarizeSessionForPiDeps, SwarmHooksConfig } from "../providers/pi-mono-extension";
-import { summarizeSessionForPi } from "../providers/pi-mono-extension";
+import {
+  createSwarmHooksExtension,
+  SWARM_NUDGE_CUSTOM_TYPE,
+  summarizeSessionForPi,
+} from "../providers/pi-mono-extension";
 
 // ── helpers ───────────────────────────────────────────────────────────────────
 
@@ -345,3 +352,155 @@ describe("summarizeSessionForPi", () => {
     expect(consoleErrors.length).toBe(0);
   });
 });
+
+describe("pi provider header attribution", () => {
+  test("uses request model URL and task env, replacing pi attribution", async () => {
+    let handler:
+      | ((event: { headers: Record<string, string> }, ctx: { model: { baseUrl: string } }) => void)
+      | undefined;
+    const pi = {
+      on: (event: string, callback: unknown) => {
+        if (event === "before_provider_headers") handler = callback as NonNullable<typeof handler>;
+      },
+    } as unknown as ExtensionAPI;
+    const config = { ...makeConfig(), env: {} as Record<string, string | undefined> };
+    await createSwarmHooksExtension(config)(pi);
+    expect(handler).toBeDefined();
+    const headers = {
+      "HTTP-Referer": "https://pi.dev",
+      "X-OpenRouter-Title": "pi",
+      "X-Custom": "keep",
+    };
+    handler!({ headers }, { model: { baseUrl: "https://openrouter.ai/api" } });
+    expect(headers).toEqual({
+      "HTTP-Referer": "https://agent-swarm.dev",
+      "X-OpenRouter-Title": "Agent Swarm",
+      "X-OpenRouter-Categories": "personal-agent,cloud-agent",
+      "X-Custom": "keep",
+    });
+    config.env.OPENROUTER_APP_ATTRIBUTION = "false";
+    const optedOut = { "X-Custom": "keep" };
+    handler!({ headers: optedOut }, { model: { baseUrl: "https://openrouter.ai/api" } });
+    expect(optedOut).toEqual({ "X-Custom": "keep" });
+    config.env = {};
+    const gateway = {};
+    handler!({ headers: gateway }, { model: { baseUrl: "http://localhost:1234/v1" } });
+    expect(gateway).toEqual({});
+  });
+});
+
+// ── advisory nudges reach the model via pi.sendMessage ───────────────────────
+
+type Handler = (event: unknown, ctx: unknown) => Promise<unknown> | unknown;
+type SentMessage = { customType: string; content: Array<{ type: string; text: string }> };
+
+/** Minimal stand-in for pi's ExtensionAPI: records handlers and sent messages. */
+function loadExtension(config: SwarmHooksConfig) {
+  const handlers = new Map<string, Handler>();
+  const sent: SentMessage[] = [];
+  const pi = {
+    on: (event: string, handler: Handler) => {
+      handlers.set(event, handler);
+    },
+    sendMessage: (message: SentMessage) => {
+      sent.push(message);
+    },
+    registerMcpServer: () => {},
+  };
+  createSwarmHooksExtension(config)(pi as unknown as Parameters<ExtensionFactory>[0]);
+  const ctx = { getContextUsage: () => undefined };
+  const fire = (event: string, payload: unknown = {}) => {
+    const handler = handlers.get(event);
+    if (!handler) throw new Error(`no handler for ${event}`);
+    return handler({ type: event, ...(payload as object) }, ctx);
+  };
+  const texts = () =>
+    sent.map((m) => {
+      expect(m.customType).toBe(SWARM_NUDGE_CUSTOM_TYPE);
+      return m.content.map((c) => c.text).join("");
+    });
+  return { fire, texts };
+}
+
+function jsonResponse(body: unknown): FetchHandlerResp {
+  return { ok: true, status: 200, text: async () => "", json: async () => body };
+}
+
+describe("createSwarmHooksExtension nudges", () => {
+  test("loop warning on tool_call is sent to the model", async () => {
+    const config = { ...makeConfig(), taskId: `task-pi-loop-${crypto.randomUUID()}` };
+    const { fire, texts } = loadExtension(config);
+    try {
+      for (let i = 0; i < 8; i++) {
+        const result = await fire("tool_call", { toolName: "bash", input: { command: "ls" } });
+        expect(result).toBeUndefined();
+      }
+      const warnings = texts().filter((t) => t.startsWith("Warning: "));
+      expect(warnings.length).toBe(1);
+      expect(warnings[0]).toContain("bash");
+    } finally {
+      await clearToolHistory(config.taskId);
+    }
+  });
+
+  test("lead send-task reminder on tool_result is sent to the model", async () => {
+    const { fire, texts } = loadExtension({ ...makeConfig(), isLead: true });
+    await fire("tool_result", { toolName: "mcp__agent-swarm__send-task", input: {} });
+    expect(texts()).toEqual([
+      "Task sent successfully. Monitor progress using the get-task-details tool periodically.",
+    ]);
+  });
+
+  test("lead concurrent context on session_start is sent to the model", async () => {
+    fetchHandler = async (url) =>
+      url.includes("/api/concurrent-context")
+        ? jsonResponse({
+            processingInboxMessages: [
+              { content: "deploy the thing", source: "slack", createdAt: "now" },
+            ],
+            recentTaskDelegations: [],
+            activeSwarmTasks: [],
+          })
+        : jsonResponse({});
+    const { fire, texts } = loadExtension({ ...makeConfig(), isLead: true });
+    await fire("session_start");
+    expect(texts().length).toBe(1);
+    expect(texts()[0]).toContain("=== CONCURRENT SESSION AWARENESS ===");
+    expect(texts()[0]).toContain("deploy the thing");
+  });
+
+  test("goal reminder is sent after compaction, not before every LLM call", async () => {
+    fetchHandler = async (url) =>
+      url.endsWith("/api/tasks/task-pi-1")
+        ? jsonResponse({ id: "task-pi-1", task: "ship the fix", progress: "tests green" })
+        : jsonResponse({});
+    const { fire, texts } = loadExtension(makeConfig());
+
+    await fire("context", { messages: [] });
+    expect(texts()).toEqual([]);
+
+    await fire("session_compact");
+    expect(texts()).toEqual([
+      [
+        "=== GOAL REMINDER (injected before context compaction) ===",
+        "Task ID: task-pi-1",
+        "Task: ship the fix",
+        "Current Progress: tests green",
+        "=== Continue working on this task after compaction ===",
+      ].join("\n"),
+    ]);
+  });
+
+  test("cancelled task on input skips the turn and leaves the nudge in the session", async () => {
+    fetchHandler = async (url) =>
+      url.includes("/cancelled-tasks")
+        ? jsonResponse({ cancelled: [{ id: "task-pi-1", failureReason: "lead stopped it" }] })
+        : jsonResponse({});
+    const { fire, texts } = loadExtension(makeConfig());
+    const result = await fire("input", { text: "go", source: "rpc" });
+    expect(result).toEqual({ action: "handled" });
+    expect(texts()).toEqual([
+      "🛑 TASK CANCELLED: lead stopped it. Stop working and use store-progress to acknowledge.",
+    ]);
+  });
+});