@polderlabs/bizar 6.3.0 → 7.0.1

package/packages/sdk/tests/federation/pii.test.ts

@@ -0,0 +1,106 @@
+/**
+ * federation/pii.test.ts — F-038 PII pipeline tests.
+ *
+ * Covers:
+ *   - soc2 mode redacts emails + SSNs + IPs, blocks credit cards.
+ *   - gdpr mode also redacts names + addresses.
+ *   - hipaa mode is the strictest (redacts everything sensitive).
+ *   - permissive mode only blocks the highest-severity categories.
+ *   - PiiPipeline class wrapper setMode / process flow.
+ */
+
+import { describe, test, expect } from "vitest";
+import {
+  PII_MODES,
+  PiiPipeline,
+  apply,
+  isPiiMode,
+  type PiiMode,
+} from "../../src/federation/pii.js";
+
+describe("federation/pii — apply() per mode", () => {
+  test("soc2 redacts emails + IPs + SSNs, blocks credit cards", () => {
+    const r = apply("contact alice@example.com or 192.168.1.1, SSN 123-45-6789, CC 4111-1111-1111-1111", "soc2");
+    expect(r.blocked).toBe(true);
+    // Even though we blocked CC, the transformed text is empty.
+    expect(r.transformed).toBe("");
+    expect(r.detections.length).toBeGreaterThanOrEqual(3);
+  });
+
+  test("soc2 non-CC text returns redacted output", () => {
+    const r = apply("contact alice@example.com from 10.0.0.1", "soc2");
+    expect(r.blocked).toBe(false);
+    expect(r.transformed).toContain("[REDACTED:email]");
+    expect(r.transformed).toContain("[REDACTED:ip_address]");
+    expect(r.transformed).not.toContain("alice@example.com");
+    expect(r.transformed).not.toContain("10.0.0.1");
+  });
+
+  test("gdpr redacts emails, IPs, names, addresses", () => {
+    const r = apply("Dr. Alice Smith at alice@example.com from 10 Downing St", "gdpr");
+    expect(r.transformed).toContain("[REDACTED:email]");
+    expect(r.transformed).not.toContain("alice@example.com");
+  });
+
+  test("hipaa is the strictest — emails + SSNs + IPs + phones redacted", () => {
+    const r = apply("call 555-123-4567 or email alice@example.com, SSN 123-45-6789", "hipaa");
+    expect(r.transformed).not.toContain("alice@example.com");
+    expect(r.transformed).not.toContain("123-45-6789");
+    expect(r.transformed).not.toContain("555-123-4567");
+  });
+
+  test("permissive passes emails + IPs but blocks AWS keys + private keys + github tokens", () => {
+    const clean = apply("contact alice@example.com from 10.0.0.1", "permissive");
+    expect(clean.blocked).toBe(false);
+    expect(clean.transformed).toContain("alice@example.com");
+    expect(clean.transformed).toContain("10.0.0.1");
+
+    const awsKey = apply("AWS key: AKIAIOSFODNN7EXAMPLE", "permissive");
+    expect(awsKey.blocked).toBe(true);
+
+    const priv = apply("-----BEGIN RSA PRIVATE KEY-----", "permissive");
+    expect(priv.blocked).toBe(true);
+
+    const gh = apply("github token: ghp_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "permissive");
+    expect(gh.blocked).toBe(true);
+  });
+
+  test("unknown mode throws", () => {
+    expect(() => apply("text", "unknown" as unknown as PiiMode)).toThrow(/unknown mode/);
+  });
+
+  test("each declared mode is accepted by isPiiMode", () => {
+    for (const m of PII_MODES) {
+      expect(isPiiMode(m)).toBe(true);
+    }
+    expect(isPiiMode(null)).toBe(false);
+    expect(isPiiMode("xx")).toBe(false);
+  });
+});
+
+describe("federation/pii — PiiPipeline class", () => {
+  test("defaults to soc2 mode", () => {
+    const p = new PiiPipeline();
+    expect(p.getMode()).toBe("soc2");
+  });
+
+  test("setMode accepts the 4 documented modes", () => {
+    const p = new PiiPipeline();
+    for (const m of PII_MODES) {
+      p.setMode(m);
+      expect(p.getMode()).toBe(m);
+    }
+  });
+
+  test("setMode throws on unknown mode", () => {
+    const p = new PiiPipeline();
+    expect(() => p.setMode("nope" as unknown as PiiMode)).toThrow(/unknown mode/);
+  });
+
+  test("process() returns the same shape as apply()", () => {
+    const p = new PiiPipeline({ mode: "gdpr" });
+    const r = p.process("alice@example.com");
+    expect(r.transformed).toContain("[REDACTED:email]");
+    expect(r.mode).toBe("gdpr");
+  });
+});

package/packages/sdk/tests/federation/policy.test.ts

@@ -0,0 +1,140 @@
+/**
+ * federation/policy.test.ts — F-038 PolicyEngine tests.
+ *
+ * Covers:
+ *   - maxHops enforcement: hopCount >= maxHops denies.
+ *   - Action allowlist: unknown + disallowed message kinds denied.
+ *   - Peer blocklist: blocked source node denied.
+ *   - Budget validation: missing + invalid budget denied.
+ *   - Runtime mutators: allowMessageType / denyMessageType / setBlocked.
+ */
+
+import { describe, test, expect, beforeEach } from "vitest";
+import { PolicyEngine, DEFAULT_MAX_HOPS } from "../../src/federation/policy.js";
+import {
+  emptyScanResult,
+  type EnvelopeBudget,
+  type FederationEnvelope,
+} from "../../src/federation/envelope.js";
+
+function makeEnvelope(overrides: Partial<FederationEnvelope> = {}): FederationEnvelope {
+  return {
+    envelopeId: "env-1",
+    sourceNodeId: "node-A",
+    targetNodeId: "node-B",
+    sessionId: "sess-1",
+    messageType: "heartbeat",
+    payload: null,
+    timestamp: new Date().toISOString(),
+    nonce: "nonce-1",
+    hmacSignature: "sig-1",
+    piiScanResult: emptyScanResult(),
+    hopCount: 0,
+    ...overrides,
+  };
+}
+
+const defaultBudget: EnvelopeBudget = { maxTokens: 1000, maxUsd: 1.0, maxHops: 3 };
+
+describe("federation/policy — enforce()", () => {
+  let engine: PolicyEngine;
+
+  beforeEach(() => {
+    engine = new PolicyEngine();
+  });
+
+  test("admits a fresh envelope with default budget", () => {
+    const e = makeEnvelope();
+    const r = engine.enforce(e, defaultBudget);
+    expect(r.allowed).toBe(true);
+  });
+
+  test("denies when hopCount >= maxHops", () => {
+    const e = makeEnvelope({ hopCount: 3 });
+    const r = engine.enforce(e, defaultBudget);
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("max_hops_exceeded");
+  });
+
+  test("denies when hopCount exceeds the engine ceiling (default 3)", () => {
+    const e = makeEnvelope({ hopCount: 4, budget: { maxTokens: 10, maxUsd: 1, maxHops: 100 } });
+    const r = engine.enforce(e, { maxTokens: 10, maxUsd: 1, maxHops: 100 });
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("max_hops_exceeded");
+  });
+
+  test("admits hopCount=2 with maxHops=3 budget", () => {
+    const e = makeEnvelope({ hopCount: 2 });
+    const r = engine.enforce(e, defaultBudget);
+    expect(r.allowed).toBe(true);
+  });
+
+  test("denies unknown message kind", () => {
+    const e = makeEnvelope({ messageType: "not-a-kind" as never });
+    const r = engine.enforce(e, defaultBudget);
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("message_type_not_allowed");
+  });
+
+  test("denies message kind outside the configured allowlist", () => {
+    const strict = new PolicyEngine({ allowedMessageTypes: ["heartbeat"] });
+    const e = makeEnvelope({ messageType: "agent-spawn" });
+    const r = strict.enforce(e, defaultBudget);
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("message_type_not_allowed");
+  });
+
+  test("denies peer in the blocklist", () => {
+    const strict = new PolicyEngine({ peerBlocklist: ["node-A"] });
+    const e = makeEnvelope();
+    const r = strict.enforce(e, defaultBudget);
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("peer_blocked");
+  });
+
+  test("denies when budget is missing", () => {
+    const r = engine.enforce(makeEnvelope(), undefined);
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("budget_missing");
+  });
+
+  test("denies when budget has invalid maxHops", () => {
+    const r = engine.enforce(makeEnvelope(), { maxTokens: 1, maxUsd: 1, maxHops: Number.NaN });
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("budget_invalid");
+  });
+});
+
+describe("federation/policy — runtime mutators", () => {
+  test("allowMessageType / denyMessageType mutate the allowlist", () => {
+    const engine = new PolicyEngine({ allowedMessageTypes: ["heartbeat"] });
+    const e = makeEnvelope({ messageType: "agent-spawn" });
+    expect(engine.enforce(e, defaultBudget).allowed).toBe(false);
+    engine.allowMessageType("agent-spawn");
+    expect(engine.enforce(e, defaultBudget).allowed).toBe(true);
+    engine.denyMessageType("heartbeat");
+    expect(engine.enforce(makeEnvelope({ messageType: "heartbeat" }), defaultBudget).allowed).toBe(false);
+  });
+
+  test("setBlocked mutates the blocklist", () => {
+    const engine = new PolicyEngine();
+    const e = makeEnvelope();
+    expect(engine.enforce(e, defaultBudget).allowed).toBe(true);
+    engine.setBlocked("node-A", true);
+    expect(engine.enforce(e, defaultBudget).allowed).toBe(false);
+    engine.setBlocked("node-A", false);
+    expect(engine.enforce(e, defaultBudget).allowed).toBe(true);
+  });
+
+  test("DEFAULT_MAX_HOPS is 3 per spec", () => {
+    expect(DEFAULT_MAX_HOPS).toBe(3);
+  });
+
+  test("engine ceiling override is respected", () => {
+    const strict = new PolicyEngine({ maxHops: 1 });
+    const e = makeEnvelope({ hopCount: 1 });
+    const r = strict.enforce(e, { maxTokens: 10, maxUsd: 1, maxHops: 99 });
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.denialReason).toBe("max_hops_exceeded");
+  });
+});

package/packages/sdk/tests/federation/trust.test.ts

@@ -0,0 +1,124 @@
+/**
+ * federation/trust.test.ts — F-038 TrustEvaluator tests.
+ *
+ * Covers:
+ *   - evaluate() allows allowlisted peer with fresh envelope.
+ *   - evaluate() denies non-allowlisted peer.
+ *   - evaluate() denies too-old envelope.
+ *   - recordOutcome() updates the recent fail rate.
+ *   - Low score (high fail rate) triggers denial.
+ *   - setAllowlisted mutates the runtime allowlist.
+ */
+
+import { describe, test, expect, beforeEach } from "vitest";
+import {
+  MAX_TRUST_AGE_MS,
+  MIN_TRUST_SCORE,
+  TrustEvaluator,
+  type PeerState,
+} from "../../src/federation/trust.js";
+import {
+  emptyScanResult,
+  type FederationEnvelope,
+} from "../../src/federation/envelope.js";
+
+function makeEnvelope(overrides: Partial<FederationEnvelope> = {}): FederationEnvelope {
+  return {
+    envelopeId: "env-1",
+    sourceNodeId: "node-A",
+    targetNodeId: "node-B",
+    sessionId: "sess-1",
+    messageType: "heartbeat",
+    payload: null,
+    timestamp: new Date().toISOString(),
+    nonce: "nonce-1",
+    hmacSignature: "sig-1",
+    piiScanResult: emptyScanResult(),
+    ...overrides,
+  };
+}
+
+function allowlistedPeer(nodeId = "node-A"): PeerState {
+  return { nodeId, allowlisted: true, recentFailRate: 0, lastSeenMs: Date.now() };
+}
+
+describe("federation/trust — evaluate()", () => {
+  let te: TrustEvaluator;
+
+  beforeEach(() => {
+    te = new TrustEvaluator({ allowlist: ["node-A"] });
+  });
+
+  test("allows an allowlisted peer with a fresh envelope", () => {
+    const r = te.evaluate(makeEnvelope(), allowlistedPeer());
+    expect(r.allowed).toBe(true);
+    expect(r.score).toBeGreaterThanOrEqual(MIN_TRUST_SCORE);
+  });
+
+  test("denies a non-allowlisted peer", () => {
+    const peer: PeerState = { nodeId: "node-X", allowlisted: false, recentFailRate: 0 };
+    const r = te.evaluate(makeEnvelope(), peer);
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.reason).toMatch(/allowlist/);
+  });
+
+  test("denies an envelope older than MAX_TRUST_AGE_MS", () => {
+    const old = makeEnvelope({
+      timestamp: new Date(Date.now() - MAX_TRUST_AGE_MS - 1000).toISOString(),
+    });
+    const r = te.evaluate(old, allowlistedPeer());
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.reason).toMatch(/too_old/);
+  });
+
+  test("denies when score falls below MIN_TRUST_SCORE (high fail rate)", () => {
+    te.recordOutcome("node-A", false);
+    te.recordOutcome("node-A", false);
+    te.recordOutcome("node-A", false);
+    te.recordOutcome("node-A", false);
+    const peer = te.getPeerState("node-A");
+    const r = te.evaluate(makeEnvelope(), peer);
+    expect(r.allowed).toBe(false);
+    if (!r.allowed) expect(r.reason).toMatch(/score_below_floor/);
+  });
+
+  test("allows when only successes are recorded", () => {
+    for (let i = 0; i < 5; i++) te.recordOutcome("node-A", true);
+    const peer = te.getPeerState("node-A");
+    expect(peer.recentFailRate).toBe(0);
+    const r = te.evaluate(makeEnvelope(), peer);
+    expect(r.allowed).toBe(true);
+  });
+});
+
+describe("federation/trust — runtime mutations", () => {
+  test("setAllowlisted adds a new peer at runtime", () => {
+    const te = new TrustEvaluator({ allowlist: [] });
+    expect(te.isAllowlisted("node-A")).toBe(false);
+    te.setAllowlisted("node-A", true);
+    expect(te.isAllowlisted("node-A")).toBe(true);
+  });
+
+  test("setAllowlisted(false) removes a peer at runtime", () => {
+    const te = new TrustEvaluator({ allowlist: ["node-A"] });
+    expect(te.isAllowlisted("node-A")).toBe(true);
+    te.setAllowlisted("node-A", false);
+    expect(te.isAllowlisted("node-A")).toBe(false);
+  });
+
+  test("getPeerState returns default zeros for an unknown peer", () => {
+    const te = new TrustEvaluator();
+    const peer = te.getPeerState("never-seen");
+    expect(peer.allowlisted).toBe(false);
+    expect(peer.recentFailRate).toBe(0);
+    expect(peer.lastSeenMs).toBeUndefined();
+  });
+
+  test("computeScore is in [0, 1] for the corner cases", () => {
+    const te = new TrustEvaluator({ allowlist: ["node-A"] });
+    const env = makeEnvelope();
+    expect(te.computeScore(env, { nodeId: "node-A", allowlisted: true, recentFailRate: 0 })).toBeLessThanOrEqual(1);
+    expect(te.computeScore(env, { nodeId: "node-A", allowlisted: true, recentFailRate: 1 })).toBeGreaterThanOrEqual(0);
+    expect(te.computeScore(env, { nodeId: "node-A", allowlisted: false, recentFailRate: 0 })).toBe(0);
+  });
+});

package/packages/sdk/tests/mcp-tools.test.ts

@@ -0,0 +1,204 @@
+/**
+ * mcp-tools.test.ts — exercises the 4 new MCP tools (F-032) by calling
+ * each tool's `handler` directly and asserting the return shape.
+ *
+ * The tools live in `packages/sdk/src/mcp/server.ts`; we import the
+ * compiled `BIZAR_TOOLS` array and walk it to find each tool by name.
+ */
+
+import { describe, test, expect, beforeEach } from "vitest";
+import { BIZAR_TOOLS, type SdkMcpToolDef } from "../src/mcp/server.js";
+import { bizarAgentRegistry } from "../src/agent-registry.js";
+import { swarmTopologyRegistry } from "../src/swarm-topology.js";
+
+function findTool(name: string): SdkMcpToolDef {
+  const t = BIZAR_TOOLS.find((x) => x.name === name);
+  if (!t) throw new Error(`tool not found: ${name}`);
+  return t;
+}
+
+async function call(toolName: string, args: unknown): Promise<unknown> {
+  const tool = findTool(toolName);
+  const res = await tool.handler(args, {});
+  // Standard MCP shape: { content: [{ type: 'text', text: '...' }] }
+  if (!Array.isArray(res.content) || res.content.length !== 1) {
+    throw new Error(`unexpected response shape from ${toolName}`);
+  }
+  const block = res.content[0];
+  if (block.type !== "text") throw new Error(`unexpected block type: ${block.type}`);
+  try { return JSON.parse(block.text); }
+  catch { return block.text; }
+}
+
+describe("MCP tools — F-032 swarm/agent lifecycle", () => {
+  beforeEach(() => {
+    // Each test starts from a clean slate so list assertions are deterministic.
+    bizarAgentRegistry.reset();
+    swarmTopologyRegistry.reset();
+  });
+
+  test("BIZAR_TOOLS includes the 4 new tools (total ≥ 17)", () => {
+    const names = new Set(BIZAR_TOOLS.map((t) => t.name));
+    expect(names.has("agent_spawn")).toBe(true);
+    expect(names.has("agent_list")).toBe(true);
+    expect(names.has("agent_terminate")).toBe(true);
+    expect(names.has("swarm_init")).toBe(true);
+    expect(BIZAR_TOOLS.length).toBeGreaterThanOrEqual(17);
+  });
+
+  test("each new tool has the expected inputSchema", () => {
+    const spawn = findTool("agent_spawn");
+    expect(spawn.inputSchema).toMatchObject({
+      type: "string", name: "string", priority: "string", metadata: "string",
+    });
+
+    const list = findTool("agent_list");
+    expect(list.inputSchema).toMatchObject({
+      status: "string", type: "string", limit: "number", offset: "number",
+    });
+
+    const term = findTool("agent_terminate");
+    expect(term.inputSchema).toMatchObject({
+      agentId: "string", graceful: "boolean", reason: "string",
+    });
+
+    const swarm = findTool("swarm_init");
+    expect(swarm.inputSchema).toMatchObject({
+      topology: "string", maxAgents: "number", metadata: "string",
+    });
+  });
+
+  test("agent_spawn returns { agentId, status }", async () => {
+    const r = await call("agent_spawn", { type: "coder", name: "ada" });
+    expect(r).toMatchObject({ status: "active" });
+    expect((r as { agentId: string }).agentId).toMatch(/^agent-/);
+  });
+
+  test("agent_spawn parses metadata JSON when supplied", async () => {
+    const r = await call("agent_spawn", {
+      type: "coder",
+      metadata: JSON.stringify({ region: "us", priority: "high" }),
+    });
+    const id = (r as { agentId: string }).agentId;
+    const got = bizarAgentRegistry.getAgent(id);
+    expect(got?.metadata).toEqual({ region: "us", priority: "high" });
+  });
+
+  test("agent_spawn returns a structured error when metadata is not valid JSON", async () => {
+    const tool = findTool("agent_spawn");
+    const res = await tool.handler({ type: "coder", metadata: "not-json" }, {});
+    const text = (res.content[0] as { text: string }).text;
+    expect(text).toMatch(/^error:/);
+    expect(text).toMatch(/JSON/);
+  });
+
+  test("agent_spawn rejects types outside the AGENT_TYPES allowlist", async () => {
+    const tool = findTool("agent_spawn");
+    const res = await tool.handler({ type: "lawyer" }, {});
+    const text = (res.content[0] as { text: string }).text;
+    expect(text).toMatch(/^error:/);
+    expect(text).toMatch(/must be one of/);
+  });
+
+  test("agent_list returns active agents by default", async () => {
+    await call("agent_spawn", { type: "coder" });
+    await call("agent_spawn", { type: "reviewer" });
+    const r = await call("agent_list", {});
+    expect(r).toMatchObject({ total: 2 });
+    expect((r as { agents: unknown[] }).agents).toHaveLength(2);
+  });
+
+  test("agent_list filters by status", async () => {
+    const a = await call("agent_spawn", { type: "coder" }) as { agentId: string };
+    await call("agent_spawn", { type: "coder" });
+    await call("agent_terminate", { agentId: a.agentId, reason: "test" });
+    const terminated = await call("agent_list", { status: "terminated" });
+    expect(terminated).toMatchObject({ total: 1 });
+    const active = await call("agent_list", { status: "active" });
+    expect(active).toMatchObject({ total: 1 });
+  });
+
+  test("agent_list defaults status to 'all' for unrecognized values", async () => {
+    await call("agent_spawn", { type: "coder" });
+    const r = await call("agent_list", { status: "bogus" });
+    expect(r).toMatchObject({ total: 1 });
+  });
+
+  test("agent_terminate returns { agentId, status, terminatedAt }", async () => {
+    const spawned = await call("agent_spawn", { type: "coder" }) as { agentId: string };
+    const r = await call("agent_terminate", { agentId: spawned.agentId, reason: "done" });
+    expect(r).toMatchObject({
+      agentId: spawned.agentId,
+      status: "terminated",
+    });
+    expect(typeof (r as { terminatedAt: string }).terminatedAt).toBe("string");
+  });
+
+  test("agent_terminate surfaces a structured error for unknown agent", async () => {
+    const tool = findTool("agent_terminate");
+    const res = await tool.handler({ agentId: "agent-nope" }, {});
+    const text = (res.content[0] as { text: string }).text;
+    expect(text).toMatch(/^error:/);
+    expect(text).toMatch(/not found/);
+  });
+
+  test("swarm_init creates a swarm with defaults", async () => {
+    const r = await call("swarm_init", {}) as {
+      swarmId: string; topology: string; maxAgents: number; createdAt: string;
+    };
+    expect(r.swarmId).toMatch(/^swarm-\d+$/);
+    expect(r.topology).toBe("hierarchical-mesh");
+    expect(r.maxAgents).toBe(15);
+    expect(typeof r.createdAt).toBe("string");
+  });
+
+  test("swarm_init respects topology and maxAgents", async () => {
+    const r = await call("swarm_init", {
+      topology: "mesh",
+      maxAgents: 42,
+      metadata: JSON.stringify({ owner: "F-032" }),
+    }) as { topology: string; maxAgents: number; metadata?: Record<string, unknown> };
+    expect(r.topology).toBe("mesh");
+    expect(r.maxAgents).toBe(42);
+    expect(r.metadata).toEqual({ owner: "F-032" });
+  });
+
+  test("swarm_init clamps maxAgents to [1, 1000]", async () => {
+    const lo = await call("swarm_init", { maxAgents: 0 }) as { maxAgents: number };
+    const hi = await call("swarm_init", { maxAgents: 99999 }) as { maxAgents: number };
+    expect(lo.maxAgents).toBe(1);
+    expect(hi.maxAgents).toBe(1000);
+  });
+
+  test("swarm_init returns an error for invalid JSON metadata", async () => {
+    const tool = findTool("swarm_init");
+    const res = await tool.handler({ metadata: "{not-json" }, {});
+    const text = (res.content[0] as { text: string }).text;
+    expect(text).toMatch(/^error:/);
+    expect(text).toMatch(/JSON/);
+  });
+
+  test("end-to-end: spawn → list → terminate → list shows 1 active + 1 terminated", async () => {
+    const spawned = await call("agent_spawn", { type: "coder", name: "ada" }) as {
+      agentId: string;
+    };
+
+    const allAfterSpawn = await call("agent_list", { status: "all" }) as {
+      total: number; agents: { agentId: string; status: string }[];
+    };
+    expect(allAfterSpawn.total).toBe(1);
+    expect(allAfterSpawn.agents[0]?.status).toBe("active");
+    expect(allAfterSpawn.agents[0]?.agentId).toBe(spawned.agentId);
+
+    await call("agent_terminate", { agentId: spawned.agentId, reason: "smoke" });
+
+    const allAfterTerm = await call("agent_list", { status: "all" }) as {
+      total: number; agents: { status: string }[];
+    };
+    expect(allAfterTerm.total).toBe(1);
+    expect(allAfterTerm.agents[0]?.status).toBe("terminated");
+
+    // Sanity: the registry returns the same record (proves state lives in BizarAgentRegistry).
+    expect(bizarAgentRegistry.getAgent(spawned.agentId)?.status).toBe("terminated");
+  });
+});