@desplega.ai/agent-swarm 1.20.0 → 1.51.2

package/src/tests/onboard-compose.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, test } from "bun:test";
+import { generateCompose } from "../commands/onboard/compose-generator.ts";
+import { INITIAL_STATE, type OnboardState } from "../commands/onboard/types.ts";
+
+function makeState(overrides: Partial<OnboardState>): OnboardState {
+  return { ...INITIAL_STATE, ...overrides };
+}
+
+describe("generateCompose", () => {
+  // ── Dev preset: 1 lead + 2 coders ──
+
+  const devState = makeState({
+    presetId: "dev",
+    services: [
+      { template: "official/lead", displayName: "Lead", count: 1, role: "lead", isLead: true },
+      { template: "official/coder", displayName: "Coder", count: 2, role: "coder" },
+    ],
+    agentIds: {
+      lead: "aaa-lead-id",
+      "worker-coder-1": "bbb-coder-1",
+      "worker-coder-2": "ccc-coder-2",
+    },
+    apiKey: "test-api-key",
+    claudeOAuthToken: "test-oauth",
+  });
+
+  test("dev preset produces 3 agent services + 1 API service", () => {
+    const yaml = generateCompose(devState);
+    // Only count service definitions in the services section (before volumes:)
+    const servicesSection = yaml.split("\nvolumes:\n")[0];
+    const serviceHeaders = servicesSection.split("\n").filter((l) => /^ {2}[a-z][\w-]+:$/.test(l));
+    // swarm-api + lead + worker-coder-1 + worker-coder-2
+    expect(serviceHeaders).toHaveLength(4);
+    expect(yaml).toContain("swarm-api:");
+    expect(yaml).toContain("  lead:");
+    expect(yaml).toContain("  worker-coder-1:");
+    expect(yaml).toContain("  worker-coder-2:");
+  });
+
+  // ── Solo preset: 1 coder, no lead ──
+
+  const soloState = makeState({
+    presetId: "solo",
+    services: [{ template: "official/coder", displayName: "Coder", count: 1, role: "coder" }],
+    agentIds: { "worker-coder": "solo-coder-id" },
+    apiKey: "key",
+    claudeOAuthToken: "oauth",
+  });
+
+  test("solo preset produces 1 agent service", () => {
+    const yaml = generateCompose(soloState);
+    const servicesSection = yaml.split("\nvolumes:\n")[0];
+    const serviceHeaders = servicesSection.split("\n").filter((l) => /^ {2}[a-z][\w-]+:$/.test(l));
+    // swarm-api + worker-coder
+    expect(serviceHeaders).toHaveLength(2);
+    expect(yaml).toContain("  worker-coder:");
+    expect(yaml).not.toContain("  lead:");
+  });
+
+  // ── All integrations enabled ──
+
+  const allIntegrationsState = makeState({
+    presetId: "solo",
+    services: [{ template: "official/coder", displayName: "Coder", count: 1, role: "coder" }],
+    agentIds: { "worker-coder": "int-coder-id" },
+    apiKey: "key",
+    claudeOAuthToken: "oauth",
+    integrations: { github: true, slack: true, gitlab: true, sentry: true },
+  });
+
+  test("all integrations enabled includes GitHub/Slack/GitLab/Sentry env vars", () => {
+    const yaml = generateCompose(allIntegrationsState);
+    // GitHub vars on agent services
+    expect(yaml).toContain("GITHUB_TOKEN");
+    expect(yaml).toContain("GITHUB_EMAIL");
+    expect(yaml).toContain("GITHUB_NAME");
+    // Slack vars on API service
+    expect(yaml).toContain("SLACK_BOT_TOKEN");
+    expect(yaml).toContain("SLACK_APP_TOKEN");
+    // GitLab vars on agent services
+    expect(yaml).toContain("GITLAB_TOKEN");
+    expect(yaml).toContain("GITLAB_EMAIL");
+    // Sentry vars on agent services
+    expect(yaml).toContain("SENTRY_AUTH_TOKEN");
+    expect(yaml).toContain("SENTRY_ORG");
+    // GitHub enabled flag on API service
+    expect(yaml).toContain("GITHUB_DISABLE=false");
+    expect(yaml).toContain("SLACK_DISABLE=false");
+  });
+
+  // ── No integrations ──
+
+  test("no integrations omits integration env vars from agent services", () => {
+    const yaml = generateCompose(soloState);
+    expect(yaml).not.toContain("GITHUB_TOKEN");
+    expect(yaml).not.toContain("SLACK_BOT_TOKEN");
+    expect(yaml).not.toContain("GITLAB_TOKEN");
+    expect(yaml).not.toContain("SENTRY_AUTH_TOKEN");
+    expect(yaml).not.toContain("GITHUB_DISABLE");
+    expect(yaml).not.toContain("SLACK_DISABLE");
+  });
+
+  // ── Real agent IDs appear ──
+
+  test("agent IDs from state appear in compose output", () => {
+    const yaml = generateCompose(devState);
+    expect(yaml).toContain("AGENT_ID=aaa-lead-id");
+    expect(yaml).toContain("AGENT_ID=bbb-coder-1");
+    expect(yaml).toContain("AGENT_ID=ccc-coder-2");
+  });
+
+  // ── Port allocation starts at 3201 ──
+
+  test("port allocation starts at 3201 and increments", () => {
+    const yaml = generateCompose(devState);
+    expect(yaml).toContain('"3201:3000"');
+    expect(yaml).toContain('"3202:3000"');
+    expect(yaml).toContain('"3203:3000"');
+  });
+
+  // ── API service has healthcheck ──
+
+  test("API service has healthcheck", () => {
+    const yaml = generateCompose(devState);
+    expect(yaml).toContain("healthcheck:");
+    expect(yaml).toContain("curl -f http://localhost:3013/health || exit 1");
+    expect(yaml).toContain("interval: 10s");
+    expect(yaml).toContain("retries: 3");
+  });
+
+  // ── Agent services depend on healthy API ──
+
+  test("agent services depend on swarm-api being healthy", () => {
+    const yaml = generateCompose(devState);
+    expect(yaml).toContain("depends_on:");
+    expect(yaml).toContain("condition: service_healthy");
+  });
+});

package/src/tests/onboard-env.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, test } from "bun:test";
+import { generateEnv } from "../commands/onboard/env-generator.ts";
+import { INITIAL_STATE, type OnboardState } from "../commands/onboard/types.ts";
+
+function makeState(overrides: Partial<OnboardState>): OnboardState {
+  return { ...INITIAL_STATE, ...overrides };
+}
+
+describe("generateEnv", () => {
+  // ── Claude harness with OAuth token ──
+
+  test("Claude harness includes CLAUDE_CODE_OAUTH_TOKEN with actual value", () => {
+    const state = makeState({
+      harness: "claude",
+      claudeOAuthToken: "oauth-tok-abc123",
+      apiKey: "my-api-key",
+      services: [{ template: "official/coder", displayName: "Coder", count: 1, role: "coder" }],
+      agentIds: { "worker-coder": "coder-uuid" },
+    });
+    const env = generateEnv(state);
+    expect(env).toContain("CLAUDE_CODE_OAUTH_TOKEN=oauth-tok-abc123");
+  });
+
+  // ── GitHub integration enabled ──
+
+  test("GitHub integration enabled includes GITHUB_TOKEN, GITHUB_EMAIL, GITHUB_NAME", () => {
+    const state = makeState({
+      apiKey: "key",
+      claudeOAuthToken: "tok",
+      integrations: { github: true, slack: false, gitlab: false, sentry: false },
+      githubToken: "ghp_mytoken",
+      githubEmail: "dev@example.com",
+      githubName: "Dev User",
+      services: [{ template: "official/coder", displayName: "Coder", count: 1, role: "coder" }],
+      agentIds: { "worker-coder": "id-1" },
+    });
+    const env = generateEnv(state);
+    expect(env).toContain("GITHUB_TOKEN=ghp_mytoken");
+    expect(env).toContain("GITHUB_EMAIL=dev@example.com");
+    expect(env).toContain("GITHUB_NAME=Dev User");
+    expect(env).toContain("GITHUB_DISABLE=false");
+  });
+
+  // ── Slack integration enabled ──
+
+  test("Slack integration enabled includes SLACK_BOT_TOKEN and SLACK_APP_TOKEN", () => {
+    const state = makeState({
+      apiKey: "key",
+      claudeOAuthToken: "tok",
+      integrations: { github: false, slack: true, gitlab: false, sentry: false },
+      slackBotToken: "xoxb-slack-bot",
+      slackAppToken: "xapp-slack-app",
+      services: [{ template: "official/coder", displayName: "Coder", count: 1, role: "coder" }],
+      agentIds: { "worker-coder": "id-1" },
+    });
+    const env = generateEnv(state);
+    expect(env).toContain("SLACK_BOT_TOKEN=xoxb-slack-bot");
+    expect(env).toContain("SLACK_APP_TOKEN=xapp-slack-app");
+    expect(env).toContain("SLACK_DISABLE=false");
+  });
+
+  // ── No integrations: only core section ──
+
+  test("no integrations outputs disable flags and no integration credentials", () => {
+    const state = makeState({
+      apiKey: "key-123",
+      claudeOAuthToken: "tok-456",
+      services: [{ template: "official/coder", displayName: "Coder", count: 1, role: "coder" }],
+      agentIds: { "worker-coder": "id-1" },
+    });
+    const env = generateEnv(state);
+    // Core values present
+    expect(env).toContain("API_KEY=key-123");
+    expect(env).toContain("CLAUDE_CODE_OAUTH_TOKEN=tok-456");
+    // Integrations disabled
+    expect(env).toContain("GITHUB_DISABLE=true");
+    expect(env).toContain("SLACK_DISABLE=true");
+    // No integration credentials
+    expect(env).not.toContain("GITHUB_TOKEN=");
+    expect(env).not.toContain("SLACK_BOT_TOKEN=");
+    expect(env).not.toContain("GITLAB_TOKEN=");
+    expect(env).not.toContain("SENTRY_AUTH_TOKEN=");
+  });
+
+  // ── Actual credential values appear (not placeholder text) ──
+
+  test("actual credential values appear, not placeholder text", () => {
+    const state = makeState({
+      apiKey: "real-api-key-789",
+      claudeOAuthToken: "real-oauth-token-xyz",
+      integrations: { github: true, slack: true, gitlab: true, sentry: true },
+      githubToken: "ghp_realtoken",
+      githubEmail: "real@mail.com",
+      githubName: "Real Name",
+      slackBotToken: "xoxb-real",
+      slackAppToken: "xapp-real",
+      gitlabToken: "glpat-real",
+      gitlabEmail: "gl@mail.com",
+      sentryToken: "sntrys_real",
+      sentryOrg: "my-org",
+      services: [{ template: "official/coder", displayName: "Coder", count: 1, role: "coder" }],
+      agentIds: { "worker-coder": "id-1" },
+    });
+    const env = generateEnv(state);
+    expect(env).toContain("API_KEY=real-api-key-789");
+    expect(env).toContain("CLAUDE_CODE_OAUTH_TOKEN=real-oauth-token-xyz");
+    expect(env).toContain("GITHUB_TOKEN=ghp_realtoken");
+    expect(env).toContain("SLACK_BOT_TOKEN=xoxb-real");
+    expect(env).toContain("GITLAB_TOKEN=glpat-real");
+    expect(env).toContain("SENTRY_AUTH_TOKEN=sntrys_real");
+    expect(env).toContain("SENTRY_ORG=my-org");
+    // No placeholder text like "your-token-here"
+    expect(env).not.toContain("your-");
+    expect(env).not.toContain("<");
+    expect(env).not.toContain("placeholder");
+  });
+
+  // ── Agent IDs appear as comments ──
+
+  test("agent IDs appear as comments in Agent IDs section", () => {
+    const state = makeState({
+      apiKey: "key",
+      claudeOAuthToken: "tok",
+      services: [
+        { template: "official/lead", displayName: "Lead", count: 1, role: "lead", isLead: true },
+        { template: "official/coder", displayName: "Coder", count: 2, role: "coder" },
+      ],
+      agentIds: {
+        lead: "lead-uuid-111",
+        "worker-coder-1": "coder-uuid-222",
+        "worker-coder-2": "coder-uuid-333",
+      },
+    });
+    const env = generateEnv(state);
+    expect(env).toContain("# === Agent IDs (for reference) ===");
+    expect(env).toContain("# lead = lead-uuid-111");
+    expect(env).toContain("# worker-coder-1 = coder-uuid-222");
+    expect(env).toContain("# worker-coder-2 = coder-uuid-333");
+  });
+
+  // ── GitLab integration ──
+
+  test("GitLab integration enabled includes GITLAB_TOKEN and GITLAB_EMAIL", () => {
+    const state = makeState({
+      apiKey: "key",
+      claudeOAuthToken: "tok",
+      integrations: { github: false, slack: false, gitlab: true, sentry: false },
+      gitlabToken: "glpat-abc",
+      gitlabEmail: "gl@example.com",
+      services: [{ template: "official/coder", displayName: "Coder", count: 1, role: "coder" }],
+      agentIds: { "worker-coder": "id-1" },
+    });
+    const env = generateEnv(state);
+    expect(env).toContain("GITLAB_TOKEN=glpat-abc");
+    expect(env).toContain("GITLAB_EMAIL=gl@example.com");
+  });
+
+  // ── Sentry integration ──
+
+  test("Sentry integration enabled includes SENTRY_AUTH_TOKEN and SENTRY_ORG", () => {
+    const state = makeState({
+      apiKey: "key",
+      claudeOAuthToken: "tok",
+      integrations: { github: false, slack: false, gitlab: false, sentry: true },
+      sentryToken: "sntrys-tok",
+      sentryOrg: "sentry-org",
+      services: [{ template: "official/coder", displayName: "Coder", count: 1, role: "coder" }],
+      agentIds: { "worker-coder": "id-1" },
+    });
+    const env = generateEnv(state);
+    expect(env).toContain("SENTRY_AUTH_TOKEN=sntrys-tok");
+    expect(env).toContain("SENTRY_ORG=sentry-org");
+  });
+});

package/src/tests/onboard-manifest.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, test } from "bun:test";
+import { generateManifest } from "../commands/onboard/manifest.ts";
+import { INITIAL_STATE, type OnboardState } from "../commands/onboard/types.ts";
+
+function makeState(overrides: Partial<OnboardState>): OnboardState {
+  return { ...INITIAL_STATE, ...overrides };
+}
+
+describe("generateManifest", () => {
+  const devState = makeState({
+    presetId: "dev",
+    deployType: "local",
+    harness: "claude",
+    services: [
+      { template: "official/lead", displayName: "Lead", count: 1, role: "lead", isLead: true },
+      { template: "official/coder", displayName: "Coder", count: 2, role: "coder" },
+    ],
+    agentIds: {
+      lead: "lead-uuid",
+      "worker-coder-1": "coder-uuid-1",
+      "worker-coder-2": "coder-uuid-2",
+    },
+    integrations: { github: true, slack: false, gitlab: false, sentry: true },
+  });
+
+  // ── Schema shape ──
+
+  test("manifest has required top-level fields", () => {
+    const manifest = generateManifest(devState) as Record<string, unknown>;
+    expect(manifest).toHaveProperty("version");
+    expect(manifest).toHaveProperty("createdAt");
+    expect(manifest).toHaveProperty("deployType");
+    expect(manifest).toHaveProperty("preset");
+    expect(manifest).toHaveProperty("harness");
+    expect(manifest).toHaveProperty("services");
+    expect(manifest).toHaveProperty("integrations");
+    expect(manifest).toHaveProperty("composePath");
+    expect(manifest).toHaveProperty("envPath");
+    expect(manifest).toHaveProperty("apiUrl");
+    expect(manifest).toHaveProperty("dashboardUrl");
+  });
+
+  test("version is 1", () => {
+    const manifest = generateManifest(devState) as Record<string, unknown>;
+    expect(manifest.version).toBe(1);
+  });
+
+  test("createdAt is a valid ISO date string", () => {
+    const manifest = generateManifest(devState) as Record<string, unknown>;
+    const date = new Date(manifest.createdAt as string);
+    expect(date.toISOString()).toBe(manifest.createdAt);
+  });
+
+  // ── Dev preset services ──
+
+  test("dev preset produces correct services array", () => {
+    const manifest = generateManifest(devState) as Record<string, unknown>;
+    const services = manifest.services as Array<Record<string, unknown>>;
+    expect(services).toHaveLength(3);
+
+    // Lead service
+    expect(services[0].name).toBe("lead");
+    expect(services[0].templateId).toBe("official/lead");
+    expect(services[0].agentId).toBe("lead-uuid");
+    expect(services[0].role).toBe("lead");
+    expect(services[0].displayName).toBe("Lead");
+
+    // Coder 1
+    expect(services[1].name).toBe("worker-coder-1");
+    expect(services[1].templateId).toBe("official/coder");
+    expect(services[1].agentId).toBe("coder-uuid-1");
+    expect(services[1].role).toBe("worker");
+    expect(services[1].displayName).toBe("Coder 1");
+
+    // Coder 2
+    expect(services[2].name).toBe("worker-coder-2");
+    expect(services[2].agentId).toBe("coder-uuid-2");
+    expect(services[2].displayName).toBe("Coder 2");
+  });
+
+  // ── State values propagate ──
+
+  test("deployType, preset, and harness match state", () => {
+    const manifest = generateManifest(devState) as Record<string, unknown>;
+    expect(manifest.deployType).toBe("local");
+    expect(manifest.preset).toBe("dev");
+    expect(manifest.harness).toBe("claude");
+  });
+
+  // ── Integration flags match state ──
+
+  test("integration flags match state", () => {
+    const manifest = generateManifest(devState) as Record<string, unknown>;
+    const integrations = manifest.integrations as Record<string, boolean>;
+    expect(integrations.github).toBe(true);
+    expect(integrations.slack).toBe(false);
+    expect(integrations.gitlab).toBe(false);
+    expect(integrations.sentry).toBe(true);
+  });
+
+  test("all integrations false when none enabled", () => {
+    const state = makeState({
+      services: [{ template: "official/coder", displayName: "Coder", count: 1, role: "coder" }],
+      agentIds: { "worker-coder": "id" },
+    });
+    const manifest = generateManifest(state) as Record<string, unknown>;
+    const integrations = manifest.integrations as Record<string, boolean>;
+    expect(integrations.github).toBe(false);
+    expect(integrations.slack).toBe(false);
+    expect(integrations.gitlab).toBe(false);
+    expect(integrations.sentry).toBe(false);
+  });
+
+  // ── Solo preset: single worker, no lead ──
+
+  test("solo preset has one worker service with correct role", () => {
+    const state = makeState({
+      presetId: "solo",
+      services: [{ template: "official/coder", displayName: "Coder", count: 1, role: "coder" }],
+      agentIds: { "worker-coder": "solo-id" },
+    });
+    const manifest = generateManifest(state) as Record<string, unknown>;
+    const services = manifest.services as Array<Record<string, unknown>>;
+    expect(services).toHaveLength(1);
+    expect(services[0].name).toBe("worker-coder");
+    expect(services[0].role).toBe("worker");
+    expect(services[0].displayName).toBe("Coder");
+  });
+
+  // ── Static paths ──
+
+  test("composePath and envPath are set to default values", () => {
+    const manifest = generateManifest(devState) as Record<string, unknown>;
+    expect(manifest.composePath).toBe("./docker-compose.yml");
+    expect(manifest.envPath).toBe("./.env");
+  });
+});

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

@@ -0,0 +1,234 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { PiMonoAdapter } from "../providers/pi-mono-adapter";
+
+describe("PiMonoAdapter", () => {
+  test("name is 'pi'", () => {
+    const adapter = new PiMonoAdapter();
+    expect(adapter.name).toBe("pi");
+  });
+});
+
+describe("AGENTS.md symlink management", () => {
+  const tmpDir = `/tmp/pi-mono-test-${Date.now()}`;
+
+  beforeAll(() => {
+    mkdirSync(tmpDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test("creates symlink when CLAUDE.md exists but AGENTS.md does not", () => {
+    const testDir = join(tmpDir, "symlink-create");
+    mkdirSync(testDir);
+    writeFileSync(join(testDir, "CLAUDE.md"), "# Test");
+
+    // Simulate what createAgentsMdSymlink does
+    const claudeMd = join(testDir, "CLAUDE.md");
+    const agentsMd = join(testDir, "AGENTS.md");
+
+    if (existsSync(claudeMd) && !existsSync(agentsMd)) {
+      symlinkSync("CLAUDE.md", agentsMd);
+    }
+
+    expect(existsSync(agentsMd)).toBe(true);
+  });
+
+  test("does not overwrite existing AGENTS.md", () => {
+    const testDir = join(tmpDir, "no-overwrite");
+    mkdirSync(testDir);
+    writeFileSync(join(testDir, "CLAUDE.md"), "# Claude");
+    writeFileSync(join(testDir, "AGENTS.md"), "# Real AGENTS.md");
+
+    const claudeMd = join(testDir, "CLAUDE.md");
+    const agentsMd = join(testDir, "AGENTS.md");
+
+    // Simulate createAgentsMdSymlink — should NOT overwrite existing AGENTS.md
+    if (existsSync(claudeMd) && !existsSync(agentsMd)) {
+      symlinkSync("CLAUDE.md", agentsMd);
+    }
+
+    // AGENTS.md should still be a real file, not a symlink
+    expect(existsSync(agentsMd)).toBe(true);
+    const content = readFileSync(agentsMd, "utf-8");
+    expect(content).toBe("# Real AGENTS.md");
+  });
+
+  test("no-op when CLAUDE.md does not exist", () => {
+    const testDir = join(tmpDir, "no-claudemd");
+    mkdirSync(testDir);
+
+    const claudeMd = join(testDir, "CLAUDE.md");
+    const agentsMd = join(testDir, "AGENTS.md");
+
+    if (existsSync(claudeMd) && !existsSync(agentsMd)) {
+      symlinkSync("CLAUDE.md", agentsMd);
+    }
+
+    expect(existsSync(agentsMd)).toBe(false);
+  });
+});
+
+describe("Model name mapping", () => {
+  // Test the shortname → full ID mapping logic that resolveModel uses
+  const shortnames: Record<string, [string, string]> = {
+    opus: ["anthropic", "claude-opus-4-20250514"],
+    sonnet: ["anthropic", "claude-sonnet-4-20250514"],
+    haiku: ["anthropic", "claude-haiku-4-5-20251001"],
+  };
+
+  test("opus maps to anthropic/claude-opus-4-20250514", () => {
+    const mapping = shortnames.opus;
+    expect(mapping).toBeDefined();
+    expect(mapping![0]).toBe("anthropic");
+    expect(mapping![1]).toBe("claude-opus-4-20250514");
+  });
+
+  test("sonnet maps to anthropic/claude-sonnet-4-20250514", () => {
+    const mapping = shortnames.sonnet;
+    expect(mapping).toBeDefined();
+    expect(mapping![0]).toBe("anthropic");
+    expect(mapping![1]).toBe("claude-sonnet-4-20250514");
+  });
+
+  test("haiku maps to anthropic/claude-haiku-4-5-20251001", () => {
+    const mapping = shortnames.haiku;
+    expect(mapping).toBeDefined();
+    expect(mapping![0]).toBe("anthropic");
+    expect(mapping![1]).toBe("claude-haiku-4-5-20251001");
+  });
+
+  test("unknown shortname returns undefined", () => {
+    const mapping = shortnames.gpt4;
+    expect(mapping).toBeUndefined();
+  });
+
+  test("provider/model-id format is parseable", () => {
+    const modelStr = "anthropic/claude-opus-4-20250514";
+    expect(modelStr.includes("/")).toBe(true);
+    const [provider, modelId] = modelStr.split("/", 2);
+    expect(provider).toBe("anthropic");
+    expect(modelId).toBe("claude-opus-4-20250514");
+  });
+});
+
+describe("Pi-mono event normalization", () => {
+  test("message_update with text content produces raw_log-style data", () => {
+    // Simulates what PiMonoSession.handleAgentEvent does
+    const event = {
+      type: "message_update" as const,
+      message: {
+        role: "assistant",
+        content: [
+          { type: "text", text: "Hello, world!" },
+          { type: "text", text: " More text." },
+        ],
+      },
+    };
+
+    const content = event.message.content
+      .filter((c) => c.type === "text")
+      .map((c) => c.text || "")
+      .join("");
+
+    expect(content).toBe("Hello, world! More text.");
+  });
+
+  test("tool_execution_start produces tool_use log", () => {
+    const event = {
+      type: "tool_execution_start" as const,
+      toolName: "write",
+      toolCallId: "tc-123",
+    };
+
+    const logEntry = JSON.stringify({
+      type: "tool_use",
+      name: event.toolName,
+      id: event.toolCallId,
+    });
+
+    const parsed = JSON.parse(logEntry);
+    expect(parsed.type).toBe("tool_use");
+    expect(parsed.name).toBe("write");
+    expect(parsed.id).toBe("tc-123");
+  });
+
+  test("tool_execution_end produces tool_result log", () => {
+    const event = {
+      type: "tool_execution_end" as const,
+      toolName: "write",
+      toolCallId: "tc-123",
+      isError: false,
+    };
+
+    const logEntry = JSON.stringify({
+      type: "tool_result",
+      name: event.toolName,
+      id: event.toolCallId,
+      isError: event.isError,
+    });
+
+    const parsed = JSON.parse(logEntry);
+    expect(parsed.type).toBe("tool_result");
+    expect(parsed.isError).toBe(false);
+  });
+});
+
+describe("Cost aggregation from SessionStats", () => {
+  test("builds CostData from SessionStats shape", () => {
+    const stats = {
+      tokens: {
+        input: 5000,
+        output: 2000,
+        cacheRead: 1000,
+        cacheWrite: 500,
+        total: 8500,
+      },
+      cost: 0.0456,
+      userMessages: 1,
+      assistantMessages: 4,
+    };
+
+    const cost = {
+      sessionId: "",
+      taskId: "task-1",
+      agentId: "agent-1",
+      totalCostUsd: stats.cost || 0,
+      inputTokens: stats.tokens.input,
+      outputTokens: stats.tokens.output,
+      cacheReadTokens: stats.tokens.cacheRead,
+      cacheWriteTokens: stats.tokens.cacheWrite,
+      durationMs: 0,
+      numTurns: stats.userMessages + stats.assistantMessages,
+      model: "opus",
+      isError: false,
+    };
+
+    expect(cost.totalCostUsd).toBe(0.0456);
+    expect(cost.inputTokens).toBe(5000);
+    expect(cost.outputTokens).toBe(2000);
+    expect(cost.cacheReadTokens).toBe(1000);
+    expect(cost.cacheWriteTokens).toBe(500);
+    expect(cost.numTurns).toBe(5);
+  });
+
+  test("handles zero-cost stats", () => {
+    const stats = {
+      tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+      cost: 0,
+      userMessages: 0,
+      assistantMessages: 0,
+    };
+
+    const cost = {
+      totalCostUsd: stats.cost || 0,
+      numTurns: stats.userMessages + stats.assistantMessages,
+    };
+
+    expect(cost.totalCostUsd).toBe(0);
+    expect(cost.numTurns).toBe(0);
+  });
+});