@polderlabs/bizar 6.2.5 → 6.3.0

package/plugins/bizar/tests/init-helpers.test.ts

@@ -1,203 +0,0 @@
-/**
- * Init-helpers regression tests (v0.5.2).
- *
- * Covers the postmortem-2026-06-18 Layer 1 fix: `client.session.list()`
- * is now raced against a 1-second timeout. Without this, a slow or
- * broken session store would hang the plugin's `init()` forever and
- * stall the UI on a blank screen.
- *
- * Two layers of test:
- *   1) `withTimeout` — pure unit tests on the timeout helper itself.
- *   2) `readValidSessionIds` — integration-style test that passes a
- *      fake `PluginInput` whose `client.session.list()` never resolves
- *      and verifies that the function returns within ~1.1s.
- *
- * The second test is what would have caught the original bug: the
- * function must NOT block forever on a slow session store.
- */
-
-import { describe, test, expect } from "bun:test";
-
-import {
-  withTimeout,
-  readValidSessionIds,
-} from "../index.js";
-
-// ---------------------------------------------------------------------------
-// `withTimeout` — pure unit tests
-// ---------------------------------------------------------------------------
-
-describe("withTimeout", () => {
-  test("resolves with the promise's value when it completes in time", async () => {
-    const result = await withTimeout(
-      Promise.resolve("ok"),
-      1000,
-      "test",
-    );
-    expect(result).toBe("ok");
-  });
-
-  test("rejects with a labeled error when the promise takes too long", async () => {
-    const hanging = new Promise<string>(() => {
-      // never resolves
-    });
-    const start = Date.now();
-    let caught: Error | null = null;
-    try {
-      await withTimeout(hanging, 100, "hanging-promise");
-    } catch (err) {
-      caught = err as Error;
-    }
-    const elapsed = Date.now() - start;
-    expect(caught).not.toBeNull();
-    expect(caught?.message).toContain("hanging-promise");
-    expect(caught?.message).toContain("100ms");
-    // Should fire within ~100ms (allow 50ms of slack for event-loop jitter).
-    expect(elapsed).toBeGreaterThanOrEqual(95);
-    expect(elapsed).toBeLessThan(500);
-  });
-
-  test("propagates rejections from the underlying promise", async () => {
-    const failing = Promise.reject(new Error("underlying failure"));
-    let caught: Error | null = null;
-    try {
-      await withTimeout(failing, 1000, "test");
-    } catch (err) {
-      caught = err as Error;
-    }
-    expect(caught).not.toBeNull();
-    expect(caught?.message).toBe("underlying failure");
-  });
-
-  test("clears the timer on success (no late rejection)", async () => {
-    // Resolve after 50ms, well within the 1000ms timeout. The timer
-    // should be cleared; we can't directly observe the cleanup, but
-    // the test verifies the function returns the value without ever
-    // throwing (the cleared timer's callback never fires).
-    const result = await withTimeout(
-      new Promise((resolve) => setTimeout(() => resolve("late"), 50)),
-      1000,
-      "test",
-    );
-    expect(result).toBe("late");
-    // Wait long enough that a leaked timer would have fired.
-    await new Promise((r) => setTimeout(r, 100));
-  });
-});
-
-// ---------------------------------------------------------------------------
-// `readValidSessionIds` — the postmortem Layer 1 fix
-// ---------------------------------------------------------------------------
-
-/**
- * Minimal `PluginInput` shape for testing `readValidSessionIds`. We
- * only need `client`; the other fields are never read by the
- * function under test.
- */
-function makeInput(client: unknown): { client: unknown } {
-  return { client } as never;
-}
-
-describe("readValidSessionIds — postmortem Layer 1 fix (v0.5.2)", () => {
-  test("returns the session IDs when client.session.list() resolves", async () => {
-    const input = makeInput({
-      session: {
-        list: async () => ({
-          data: [
-            { id: "ses_a" },
-            { id: "ses_b" },
-          ],
-        }),
-      },
-    });
-    const ids = await readValidSessionIds(input as never);
-    expect(ids).toBeInstanceOf(Set);
-    expect([...ids].sort()).toEqual(["ses_a", "ses_b"]);
-  });
-
-  test("returns the session IDs when client.session.list() returns an array directly", async () => {
-    const input = makeInput({
-      session: {
-        list: async () => [{ id: "ses_x" }, { id: "ses_y" }],
-      },
-    });
-    const ids = await readValidSessionIds(input as never);
-    expect([...ids].sort()).toEqual(["ses_x", "ses_y"]);
-  });
-
-  test("returns empty set when client.session is missing", async () => {
-    const input = makeInput({});
-    const ids = await readValidSessionIds(input as never);
-    expect(ids.size).toBe(0);
-  });
-
-  test("returns empty set when client.session.list is not a function", async () => {
-    const input = makeInput({ session: { list: "not-a-function" } });
-    const ids = await readValidSessionIds(input as never);
-    expect(ids.size).toBe(0);
-  });
-
-  test("returns empty set when client.session.list() rejects", async () => {
-    const input = makeInput({
-      session: {
-        list: async () => {
-          throw new Error("session store down");
-        },
-      },
-    });
-    const ids = await readValidSessionIds(input as never);
-    expect(ids.size).toBe(0);
-  });
-
-  test(
-    "REGRESSION: returns within 1.5s when client.session.list() hangs forever (postmortem Layer 1)",
-    async () => {
-      // This is the actual bug from the 2026-06-18 postmortem. Before
-      // the fix, the call would hang forever and the plugin's `init()`
-      // would never resolve.
-      const input = makeInput({
-        session: {
-          list: () => new Promise(() => {
-            // never resolves — simulates a stuck session store
-          }),
-        },
-      });
-      const start = Date.now();
-      const ids = await readValidSessionIds(input as never);
-      const elapsed = Date.now() - start;
-      // The function should return within ~1s (the timeout). We allow
-      // 500ms of slack for event-loop jitter.
-      expect(elapsed).toBeLessThan(1500);
-      // The fallback is an empty set — the age-based cleanup still
-      // runs (spec §4.6).
-      expect(ids.size).toBe(0);
-    },
-  );
-
-  test(
-    "REGRESSION: late rejection from hanging list() does not crash the process",
-    async () => {
-      // After the 1s timeout fires, the original `list()` call may
-      // eventually reject (or it may never). The function attaches a
-      // no-op `.catch(() => undefined)` to suppress the unhandled-
-      // rejection. We can't directly observe unhandled rejections in
-      // bun:test, but we can verify the function returns cleanly.
-      let rejectFn: ((err: Error) => void) | undefined;
-      const input = makeInput({
-        session: {
-          list: () => new Promise((_, reject: (err: Error) => void) => {
-            rejectFn = reject;
-          }),
-        },
-      });
-      const ids = await readValidSessionIds(input as never);
-      expect(ids.size).toBe(0);
-      // Now reject the hanging promise AFTER the function returned.
-      // If the no-op catch is missing, this would be an unhandled
-      // rejection. With it, the process keeps running.
-      rejectFn?.(new Error("late rejection"));
-      // Give the microtask queue a chance to run.
-      await new Promise((r) => setTimeout(r, 10));
-    },
-  );
-});

package/plugins/bizar/tests/integration/slash-command.test.ts

@@ -1,349 +0,0 @@
-import { type AgentTool } from "@cline/sdk";
-/**
- * slash-command.test.ts — Integration tests for the full slash-command
- * hook → parser → side-effect → file-I/O path.
- *
- * Exercises:
- *   - `/plan new foo` → `plans/foo/meta.json` + `plans/foo/plan.json` on disk
- *   - `/plan list` → response contains slugs of seeded plans
- *   - `/plan add foo --title X --type task` → element written to `plan.json`
- *   - `/plan status foo approved` → `meta.json` status updated
- *   - `/plan delete foo <elementId>` → element removed from `plan.json`
- *   - `/plan wait foo` → deferred response (< 100 ms, no blocking)
- *   - `/plan new foo` on existing slug → refusal, no clobber
- *   - `/plan comment foo "text"` → comment written to `plan.json`
- *   - `/plan comments foo` → response lists the comment
- */
-
-import { describe, test, expect, beforeEach, afterEach, afterAll } from "bun:test";
-import {
-  mkdtempSync,
-  rmSync,
-  existsSync,
-  readFileSync,
-  writeFileSync,
-  mkdirSync,
-} from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { parseSlashCommand } from "../../src/commands";
-import {
-  executeSideEffect,
-  type ExecutorContext,
-  type ExecuteOptions,
-} from "../../src/commands-impl";
-import { createPlanActionTool } from "../../src/tools/plan-action";
-import { createBgGetCommentsTool } from "../../src/tools/bg-get-comments";
-import { createWaitForFeedbackTool } from "../../src/tools/wait-for-feedback";
-import { DEFAULT_PLAN_SETTINGS, type PlanSettings } from "../../src/settings";
-
-// ---------------------------------------------------------------------------
-// Mock logger
-// ---------------------------------------------------------------------------
-
-class MockLogger {
-  messages: Array<{ level: string; message: string }> = [];
-  log(opts: { level: string; message: string }) { this.messages.push(opts); }
-  debug(m: string) { this.messages.push({ level: "debug", message: m }); }
-  info(m: string) { this.messages.push({ level: "info", message: m }); }
-  warn(m: string) { this.messages.push({ level: "warn", message: m }); }
-  error(m: string) { this.messages.push({ level: "error", message: m }); }
-}
-
-// ---------------------------------------------------------------------------
-// Per-test temp worktree
-// ---------------------------------------------------------------------------
-
-let worktree: string;
-let logger: MockLogger;
-
-beforeEach(() => {
-  worktree = mkdtempSync(join(tmpdir(), "bizar-integration-"));
-  logger = new MockLogger();
-});
-
-afterEach(() => {
-  if (worktree) rmSync(worktree, { recursive: true, force: true });
-});
-
-afterAll(() => {
-  // already cleaned in afterEach, but keep for safety
-  if (worktree) rmSync(worktree, { recursive: true, force: true });
-});
-
-// ---------------------------------------------------------------------------
-// Helper: build minimal ExecutorContext + ExecuteOptions
-// ---------------------------------------------------------------------------
-
-function makeCtx(): ExecutorContext {
-  return { worktree, directory: worktree, logger };
-}
-
-function makeOpts(): ExecuteOptions {
-  return {
-    tools: {
-      bizar_plan_action: createPlanActionTool({ worktree, logger }) as unknown as AgentTool<unknown, unknown>,
-      bizar_get_plan_comments: createBgGetCommentsTool({ worktree, logger }) as unknown as AgentTool<unknown, unknown>,
-      bizar_wait_for_feedback: createWaitForFeedbackTool({ worktree, logger }) as unknown as AgentTool<unknown, unknown>,
-    },
-    defaultTemplate: "blank",
-    defaultPort: 4321,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Test cases
-// ---------------------------------------------------------------------------
-
-describe("integration: /plan new", () => {
-  test("/plan new foo → creates plans/foo/meta.json and plan.json with correct content", async () => {
-    const result = parseSlashCommand("/plan new foo", {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: [],
-      defaultPort: 4321,
-    });
-    expect(result).not.toBeNull();
-    expect(result!.sideEffect!.kind).toBe("create_plan");
-
-    await executeSideEffect(result!.sideEffect!, makeCtx(), makeOpts());
-
-    const metaPath = join(worktree, "plans", "foo", "meta.json");
-    const planPath = join(worktree, "plans", "foo", "plan.json");
-    expect(existsSync(metaPath)).toBe(true);
-    expect(existsSync(planPath)).toBe(true);
-
-    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
-    expect(meta.status).toBe("draft");
-    expect(meta.slug).toBeUndefined(); // slug not stored, title is titleCase
-    expect(typeof meta.lastEdited).toBe("string");
-
-    const canvas = JSON.parse(readFileSync(planPath, "utf-8"));
-    expect(canvas.schemaVersion).toBe(2);
-    expect(canvas.elements).toEqual([]);
-    expect(canvas.connections).toEqual([]);
-    expect(canvas.comments).toEqual([]);
-  });
-});
-
-describe("integration: /plan list", () => {
-  test("/plan list after creating foo and bar → response contains both slugs", async () => {
-    // Seed two plans
-    for (const slug of ["foo", "bar"]) {
-      const r = parseSlashCommand(`/plan new ${slug}`, {
-        currentSettings: DEFAULT_PLAN_SETTINGS,
-        availablePlanSlugs: [],
-        defaultPort: 4321,
-      });
-      await executeSideEffect(r!.sideEffect!, makeCtx(), makeOpts());
-    }
-
-    const listResult = parseSlashCommand("/plan list", {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: ["foo", "bar"],
-      defaultPort: 4321,
-    });
-    expect(listResult).not.toBeNull();
-    const execResult = await executeSideEffect(listResult!.sideEffect!, makeCtx(), makeOpts());
-    const response = execResult.responseOverride ?? listResult!.response;
-    expect(response).toMatch(/foo/);
-    expect(response).toMatch(/bar/);
-  });
-});
-
-describe("integration: /plan add", () => {
-  test("/plan add foo --title X --type task → plan.json contains the element", async () => {
-    // First create the plan
-    const newR = parseSlashCommand("/plan new foo", {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: [],
-      defaultPort: 4321,
-    });
-    await executeSideEffect(newR!.sideEffect!, makeCtx(), makeOpts());
-
-    // Now add an element
-    const addR = parseSlashCommand('/plan add foo --title X --type task', {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: ["foo"],
-      defaultPort: 4321,
-    });
-    expect(addR).not.toBeNull();
-    expect(addR!.sideEffect!.kind).toBe("tool_invocation");
-    const execR = await executeSideEffect(addR!.sideEffect!, makeCtx(), makeOpts());
-
-    const planPath = join(worktree, "plans", "foo", "plan.json");
-    const canvas = JSON.parse(readFileSync(planPath, "utf-8"));
-    expect(canvas.elements).toHaveLength(1);
-    expect(canvas.elements[0]!.title).toBe("X");
-    expect(canvas.elements[0]!.type).toBe("task");
-  });
-});
-
-describe("integration: /plan status", () => {
-  test("/plan status foo approved → meta.json status is approved", async () => {
-    // Create the plan first
-    const newR = parseSlashCommand("/plan new foo", {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: [],
-      defaultPort: 4321,
-    });
-    await executeSideEffect(newR!.sideEffect!, makeCtx(), makeOpts());
-
-    const statusR = parseSlashCommand("/plan status foo approved", {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: ["foo"],
-      defaultPort: 4321,
-    });
-    await executeSideEffect(statusR!.sideEffect!, makeCtx(), makeOpts());
-
-    const metaPath = join(worktree, "plans", "foo", "meta.json");
-    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
-    expect(meta.status).toBe("approved");
-  });
-});
-
-describe("integration: /plan delete", () => {
-  test("/plan delete foo <elementId> → element removed from plan.json", async () => {
-    // Create plan and add an element
-    const newR = parseSlashCommand("/plan new foo", {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: [],
-      defaultPort: 4321,
-    });
-    await executeSideEffect(newR!.sideEffect!, makeCtx(), makeOpts());
-
-    const addR = parseSlashCommand('/plan add foo --title Elem1 --type task', {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: ["foo"],
-      defaultPort: 4321,
-    });
-    await executeSideEffect(addR!.sideEffect!, makeCtx(), makeOpts());
-
-    // Read back to get element id
-    const planPath = join(worktree, "plans", "foo", "plan.json");
-    let canvas = JSON.parse(readFileSync(planPath, "utf-8")) as {
-      elements: Array<{ id: string; title: string }>;
-    };
-    expect(canvas.elements).toHaveLength(1);
-    const elementId = canvas.elements[0]!.id;
-
-    // Now delete it
-    const delR = parseSlashCommand(`/plan delete foo ${elementId}`, {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: ["foo"],
-      defaultPort: 4321,
-    });
-    await executeSideEffect(delR!.sideEffect!, makeCtx(), makeOpts());
-
-    canvas = JSON.parse(readFileSync(planPath, "utf-8"));
-    expect(canvas.elements).toHaveLength(0);
-  });
-});
-
-describe("integration: /plan wait", () => {
-  test("/plan wait foo → returns deferred response, does NOT block hook (< 100ms)", async () => {
-    const r = parseSlashCommand("/plan wait foo", {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: ["foo"],
-      defaultPort: 4321,
-    });
-    expect(r).not.toBeNull();
-    expect(r!.response).toMatch(/deferred/i);
-    expect(r!.response).toMatch(/bizar_wait_for_feedback/);
-    expect(r!.sideEffect).toBeUndefined(); // wait is NOT a tool_invocation
-
-    // Verify it returns instantly (no async I/O)
-    const start = Date.now();
-    await executeSideEffect({ kind: "list_plans" }, makeCtx(), makeOpts()); // no-op
-    const elapsed = Date.now() - start;
-    expect(elapsed).toBeLessThan(100);
-  });
-});
-
-describe("integration: /plan new on existing slug", () => {
-  test("/plan new foo on existing slug → refusal response, existing files intact", async () => {
-    // Create the plan
-    const r1 = parseSlashCommand("/plan new foo", {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: [],
-      defaultPort: 4321,
-    });
-    await executeSideEffect(r1!.sideEffect!, makeCtx(), makeOpts());
-
-    const planDir = join(worktree, "plans", "foo");
-    const metaBefore = readFileSync(join(planDir, "meta.json"), "utf-8");
-    const planBefore = readFileSync(join(planDir, "plan.json"), "utf-8");
-
-    // Try to create again
-    const r2 = parseSlashCommand("/plan new foo", {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: ["foo"],
-      defaultPort: 4321,
-    });
-    const execR = await executeSideEffect(r2!.sideEffect!, makeCtx(), makeOpts());
-
-    // Should have refused
-    expect(execR.responseOverride).toMatch(/already exists/);
-
-    // Files should be unchanged
-    expect(readFileSync(join(planDir, "meta.json"), "utf-8")).toBe(metaBefore);
-    expect(readFileSync(join(planDir, "plan.json"), "utf-8")).toBe(planBefore);
-  });
-});
-
-describe("integration: /plan comment", () => {
-  test('/plan comment foo "first comment" → plan.json contains the comment', async () => {
-    // Create the plan first
-    const newR = parseSlashCommand("/plan new foo", {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: [],
-      defaultPort: 4321,
-    });
-    await executeSideEffect(newR!.sideEffect!, makeCtx(), makeOpts());
-
-    const commentR = parseSlashCommand('/plan comment foo "first comment"', {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: ["foo"],
-      defaultPort: 4321,
-    });
-    await executeSideEffect(commentR!.sideEffect!, makeCtx(), makeOpts());
-
-    const planPath = join(worktree, "plans", "foo", "plan.json");
-    const canvas = JSON.parse(readFileSync(planPath, "utf-8")) as {
-      comments: Array<{ id: string; text: string; author: string }>;
-    };
-    expect(canvas.comments).toHaveLength(1);
-    expect(canvas.comments[0]!.text).toBe("first comment");
-    expect(canvas.comments[0]!.author).toBe("user");
-  });
-});
-
-describe("integration: /plan comments", () => {
-  test("/plan comments foo → response lists the comment", async () => {
-    // Create the plan first
-    const newR = parseSlashCommand("/plan new foo", {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: [],
-      defaultPort: 4321,
-    });
-    await executeSideEffect(newR!.sideEffect!, makeCtx(), makeOpts());
-
-    // Add a comment
-    const commentR = parseSlashCommand('/plan comment foo "Hello world"', {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: ["foo"],
-      defaultPort: 4321,
-    });
-    await executeSideEffect(commentR!.sideEffect!, makeCtx(), makeOpts());
-
-    // Now list comments
-    const listR = parseSlashCommand("/plan comments foo", {
-      currentSettings: DEFAULT_PLAN_SETTINGS,
-      availablePlanSlugs: ["foo"],
-      defaultPort: 4321,
-    });
-    const execR = await executeSideEffect(listR!.sideEffect!, makeCtx(), makeOpts());
-    const response = execR.responseOverride ?? listR!.response;
-    expect(response).toMatch(/Hello world/);
-  });
-});

package/plugins/bizar/tests/integration/tool-routing.test.ts

@@ -1,98 +0,0 @@
-/**
- * tool-routing.test.ts — Integration tests for the tool_invocation path
- * in slash commands. Phase 2 — Cline SDK port: tests the new
- * `AgentToolContext` shape and the Cline `createTool` API.
- */
-
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import {
-  executeSideEffect,
-  buildSyntheticToolContext,
-  type ExecutorContext,
-  type ExecuteOptions,
-} from "../../src/commands-impl";
-import { createPlanActionTool } from "../../src/tools/plan-action";
-import { createBgGetCommentsTool } from "../../src/tools/bg-get-comments";
-import { createWaitForFeedbackTool } from "../../src/tools/wait-for-feedback";
-import type { SideEffect } from "../../src/commands";
-import type { AgentTool, AgentToolContext } from "@cline/sdk";
-
-class MockLogger {
-  messages: Array<{ level: string; message: string }> = [];
-  debug(m: string) { this.messages.push({ level: "debug", message: m }); }
-  info(m: string) { this.messages.push({ level: "info", message: m }); }
-  warn(m: string) { this.messages.push({ level: "warn", message: m }); }
-  error(m: string) { this.messages.push({ level: "error", message: m }); }
-  log(_o: unknown) { /* swallow */ }
-}
-
-let worktree: string;
-const logger = new MockLogger();
-
-beforeAll(() => { worktree = mkdtempSync(join(tmpdir(), "bizar-tool-routing-")); });
-afterAll(() => { if (worktree) rmSync(worktree, { recursive: true, force: true }); });
-
-function ctx(): ExecutorContext { return { worktree, directory: worktree, logger }; }
-
-function optsWith(tools: Record<string, AgentTool>): ExecuteOptions {
-  return { tools, defaultTemplate: "blank", defaultPort: 4321 };
-}
-
-const planTools = (): Record<string, AgentTool> => ({
-  bizar_plan_action: createPlanActionTool({ worktree, logger }) as unknown as AgentTool,
-  bizar_get_plan_comments: createBgGetCommentsTool({ worktree, logger }) as unknown as AgentTool,
-  bizar_wait_for_feedback: createWaitForFeedbackTool({ worktree, logger }) as unknown as AgentTool,
-});
-
-describe("ToolContext — required fields", () => {
-  test("synthetic context has all required fields", () => {
-    const tctx = buildSyntheticToolContext(ctx()) as unknown as Record<string, unknown>;
-    expect(tctx.sessionId).toBe("slash-command");
-    expect(tctx.agentId).toBe("slash-command");
-    expect(tctx.runId).toBeDefined();
-    expect(tctx.iteration).toBe(0);
-    expect(tctx.signal).toBeDefined();
-    expect(tctx.metadata).toBeDefined();
-  });
-
-  test("abort.signal is NOT aborted", () => {
-    const tctx = buildSyntheticToolContext(ctx()) as unknown as { signal: AbortSignal };
-    expect(tctx.signal.aborted).toBe(false);
-  });
-
-  test("each call gets a fresh AbortSignal (not shared)", () => {
-    const a = buildSyntheticToolContext(ctx()) as unknown as { signal: AbortSignal };
-    const b = buildSyntheticToolContext(ctx()) as unknown as { signal: AbortSignal };
-    expect(a.signal).not.toBe(b.signal);
-  });
-});
-
-describe("ToolInvocation — args validation via Zod", () => {
-  test("malformed args (invalid slug) → refusal response, tool NOT invoked", async () => {
-    const sideEffect: SideEffect = { kind: "tool_invocation", toolName: "bizar_plan_action", args: { action: "get_canvas", planSlug: "UPPERCASE" } };
-    const res = await executeSideEffect(sideEffect, ctx(), optsWith(planTools()));
-    expect(res.responseOverride).toBeDefined();
-    expect(res.responseOverride).toMatch(/Invalid arguments/);
-  });
-
-  test("missing required arg (no planSlug) → refusal response, tool NOT invoked", async () => {
-    const sideEffect: SideEffect = { kind: "tool_invocation", toolName: "bizar_plan_action", args: { action: "get_canvas" } };
-    const res = await executeSideEffect(sideEffect, ctx(), optsWith(planTools()));
-    expect(res.responseOverride).toBeDefined();
-    expect(res.responseOverride).toMatch(/Invalid arguments/);
-  });
-
-  test("valid args → tool IS invoked (spy verifies factory call)", async () => {
-    // Pre-create a plan first.
-    await executeSideEffect({ kind: "create_plan", slug: "routing-spy", template: null }, ctx(), optsWith(planTools()));
-    const sideEffect: SideEffect = { kind: "tool_invocation", toolName: "bizar_plan_action", args: { action: "get_canvas", planSlug: "routing-spy" } };
-    const res = await executeSideEffect(sideEffect, ctx(), optsWith(planTools()));
-    expect(res.responseOverride).toBeDefined();
-    // Should not be a validation error
-    expect(res.responseOverride).not.toMatch(/Invalid arguments/);
-  });
-});