@polderlabs/bizar 6.2.5 → 7.0.0

package/plugins/bizar/tests/tools/bg-kill.test.ts

@@ -1,235 +0,0 @@
-/**
- * bizar_kill tool tests.
- *
- * Tests: bizarre_kill calls POST /session/{id}/abort not DELETE (HIGH-4),
- * kill on already-finished instance is a no-op (MEDIUM-40),
- * kill on already-killed instance is a no-op.
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-type BackgroundStatus = "pending" | "running" | "done" | "failed" | "killed" | "timed_out";
-
-interface BackgroundState {
-  instanceId: string;
-  sessionId: string;
-  status: BackgroundStatus;
-  error?: string;
-  completedAt?: number;
-}
-
-// ---------------------------------------------------------------------------
-// HTTP call tracker — verifies POST /session/{id}/abort is called, not DELETE
-// ---------------------------------------------------------------------------
-
-const httpCalls: Array<{ method: string; path: string }> = [];
-
-function trackCall(method: string, path: string) {
-  httpCalls.push({ method, path });
-}
-
-function clearCalls() {
-  httpCalls.length = 0;
-}
-
-// ---------------------------------------------------------------------------
-// Fake bizar_kill implementation
-// ---------------------------------------------------------------------------
-
-function bizar_kill(
-  args: { instanceId: string },
-  instances: Map<string, BackgroundState>,
-): { instanceId: string; status: BackgroundStatus } | { error: string } {
-  const inst = instances.get(args.instanceId);
-  if (!inst) {
-    return { error: `Instance ${args.instanceId} not found` };
-  }
-
-  // HIGH-4: Kill calls POST /session/{id}/abort, NOT DELETE /session/{id}
-  // MEDIUM-40: Killing an already-finished instance is a no-op (return current status)
-  if (inst.status === "done" || inst.status === "failed" || inst.status === "killed" || inst.status === "timed_out") {
-    // No HTTP call — just return current status
-    return { instanceId: inst.instanceId, status: inst.status };
-  }
-
-  // Running or pending — call POST /session/{id}/abort
-  trackCall("POST", `/session/${inst.sessionId}/abort`);
-
-  // Update state
-  inst.status = "killed";
-  inst.completedAt = Date.now();
-
-  return { instanceId: inst.instanceId, status: "killed" };
-}
-
-// ---------------------------------------------------------------------------
-// In-memory test data
-// ---------------------------------------------------------------------------
-
-function makeInstances(): Map<string, BackgroundState> {
-  const m = new Map<string, BackgroundState>();
-  m.set("bgr_running", {
-    instanceId: "bgr_running",
-    sessionId: "sess_running",
-    status: "running",
-  });
-  m.set("bgr_pending", {
-    instanceId: "bgr_pending",
-    sessionId: "sess_pending",
-    status: "pending",
-  });
-  m.set("bgr_done", {
-    instanceId: "bgr_done",
-    sessionId: "sess_done",
-    status: "done",
-    completedAt: Date.now() - 60_000,
-  });
-  m.set("bgr_failed", {
-    instanceId: "bgr_failed",
-    sessionId: "sess_failed",
-    status: "failed",
-    error: "Loop protection: 12 identical calls to read",
-    completedAt: Date.now() - 60_000,
-  });
-  m.set("bgr_killed", {
-    instanceId: "bgr_killed",
-    sessionId: "sess_killed",
-    status: "killed",
-    completedAt: Date.now() - 30_000,
-  });
-  m.set("bgr_timed_out", {
-    instanceId: "bgr_timed_out",
-    sessionId: "sess_timed_out",
-    status: "timed_out",
-    completedAt: Date.now() - 30_000,
-  });
-  return m;
-}
-
-// ---------------------------------------------------------------------------
-// bizarre_kill calls POST /session/{id}/abort (HIGH-4)
-// ---------------------------------------------------------------------------
-
-describe("bizar_kill — POST /session/{id}/abort (HIGH-4)", () => {
-  beforeEach(() => clearCalls());
-
-  it("calls POST /session/{id}/abort for running instance", () => {
-    const instances = makeInstances();
-    bizar_kill({ instanceId: "bgr_running" }, instances);
-    expect(httpCalls).toHaveLength(1);
-    const first = httpCalls[0];
-    expect(first).toBeDefined();
-    expect(first?.method).toBe("POST");
-    expect(first?.path).toContain("/abort");
-  });
-
-  it("calls POST /session/{id}/abort for pending instance", () => {
-    const instances = makeInstances();
-    bizar_kill({ instanceId: "bgr_pending" }, instances);
-    expect(httpCalls).toHaveLength(1);
-    const first = httpCalls[0];
-    expect(first).toBeDefined();
-    expect(first?.method).toBe("POST");
-    expect(first?.path).toContain("/abort");
-  });
-
-  it("does NOT call DELETE /session/{id} (HIGH-4)", () => {
-    const instances = makeInstances();
-    bizar_kill({ instanceId: "bgr_running" }, instances);
-    const deleteCalls = httpCalls.filter((c) => c.method === "DELETE");
-    expect(deleteCalls).toHaveLength(0);
-  });
-
-  it("returns { instanceId, status: 'killed' }", () => {
-    const instances = makeInstances();
-    const result = bizar_kill({ instanceId: "bgr_running" }, instances);
-    expect(result).toHaveProperty("instanceId");
-    expect(result).toHaveProperty("status");
-    expect((result as { status: string }).status).toBe("killed");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Kill on already-finished instance (MEDIUM-40)
-// ---------------------------------------------------------------------------
-
-describe("bizar_kill — already-finished instance (MEDIUM-40)", () => {
-  beforeEach(() => clearCalls());
-
-  it("kill on done instance returns status: done (no HTTP call)", () => {
-    const instances = makeInstances();
-    const result = bizar_kill({ instanceId: "bgr_done" }, instances);
-    expect((result as { status: string }).status).toBe("done");
-    expect(httpCalls).toHaveLength(0);
-  });
-
-  it("kill on failed instance returns status: failed (no HTTP call)", () => {
-    const instances = makeInstances();
-    const result = bizar_kill({ instanceId: "bgr_failed" }, instances);
-    expect((result as { status: string }).status).toBe("failed");
-    expect(httpCalls).toHaveLength(0);
-  });
-
-  it("kill on killed instance returns status: killed (no HTTP call)", () => {
-    const instances = makeInstances();
-    const result = bizar_kill({ instanceId: "bgr_killed" }, instances);
-    expect((result as { status: string }).status).toBe("killed");
-    expect(httpCalls).toHaveLength(0);
-  });
-
-  it("kill on timed_out instance returns status: timed_out (no HTTP call)", () => {
-    const instances = makeInstances();
-    const result = bizar_kill({ instanceId: "bgr_timed_out" }, instances);
-    expect((result as { status: string }).status).toBe("timed_out");
-    expect(httpCalls).toHaveLength(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Kill on running/pending
-// ---------------------------------------------------------------------------
-
-describe("bizar_kill — running and pending instances", () => {
-  beforeEach(() => clearCalls());
-
-  it("running instance is marked killed after kill", () => {
-    const instances = makeInstances();
-    const result = bizar_kill({ instanceId: "bgr_running" }, instances);
-    expect(instances.get("bgr_running")!.status).toBe("killed");
-    expect((result as { status: string }).status).toBe("killed");
-  });
-
-  it("pending instance is marked killed after kill", () => {
-    const instances = makeInstances();
-    const result = bizar_kill({ instanceId: "bgr_pending" }, instances);
-    expect(instances.get("bgr_pending")!.status).toBe("killed");
-    expect((result as { status: string }).status).toBe("killed");
-  });
-
-  it("kill sets completedAt", () => {
-    const instances = makeInstances();
-    const before = Date.now();
-    bizar_kill({ instanceId: "bgr_running" }, instances);
-    const after = Date.now();
-    const completedAt = instances.get("bgr_running")!.completedAt!;
-    expect(completedAt).toBeGreaterThanOrEqual(before);
-    expect(completedAt).toBeLessThanOrEqual(after);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Unknown instance
-// ---------------------------------------------------------------------------
-
-describe("bizar_kill — unknown instance", () => {
-  it("returns error for unknown instanceId", () => {
-    const instances = makeInstances();
-    const result = bizar_kill({ instanceId: "bgr_no_such" }, instances);
-    expect(result).toHaveProperty("error");
-    expect((result as { error: string }).error).toContain("not found");
-  });
-});

package/plugins/bizar/tests/tools/bg-pause.test.ts

@@ -1,61 +0,0 @@
-/**
- * bg-pause.test.ts — `bizar_pause` tool tests.
- */
-
-import { describe, it, expect } from "bun:test";
-
-import type { Logger } from "../../src/logger";
-import { createBgPauseTool } from "../../src/tools/bg-pause";
-
-const silentLogger: Logger = {
-  debug() {},
-  info() {},
-  warn() {},
-  error() {},
-  log() {},
-};
-
-/** Extract a JSON-decoded payload from `ToolResult = string | { output: string }`. */
-function decode(result: unknown): any { const r = result as any; if (r && typeof r === "object" && "output" in r) { return typeof r.output === "string" ? JSON.parse(r.output) : r.output; } if (typeof result === "string") return JSON.parse(result); return result; }
-
-describe("bg-pause tool", () => {
-  it("rejects non-Odin callers", async () => {
-    const mgr = {
-      isBgOnly: false,
-      pause: async () => ({ ok: true }),
-    } as any;
-    const tool = createBgPauseTool({
-      instanceManager: mgr,
-      logger: silentLogger,
-    });
-    const r = await tool.execute({ instanceId: "bgr_x" } as any, { metadata: { parentAgent: "frigg" } } as any);
-    const payload = decode(r);
-    expect(payload.error).toContain("Only Odin");
-  });
-
-  it("returns paused status on success", async () => {
-    const mgr = {
-      isBgOnly: false,
-      pause: async () => ({ ok: true }),
-    } as any;
-    const tool = createBgPauseTool({
-      instanceManager: mgr,
-      logger: silentLogger,
-    });
-    const r = await tool.execute({ instanceId: "bgr_x" } as any, { metadata: { parentAgent: "odin" } } as any);
-    expect(decode(r)).toEqual({ ok: true, instanceId: "bgr_x", status: "paused" });
-  });
-
-  it("propagates errors", async () => {
-    const mgr = {
-      isBgOnly: false,
-      pause: async () => ({ ok: false, error: "no_subprocess" }),
-    } as any;
-    const tool = createBgPauseTool({
-      instanceManager: mgr,
-      logger: silentLogger,
-    });
-    const r = await tool.execute({ instanceId: "bgr_x" } as any, { metadata: { parentAgent: "odin" } } as any);
-    expect(decode(r)).toMatchObject({ error: "no_subprocess" });
-  });
-});

package/plugins/bizar/tests/tools/bg-report-progress.test.ts

@@ -1,79 +0,0 @@
-/**
- * bg-report-progress.test.ts — `bizar_report_progress` tool tests.
- */
-
-import { describe, it, expect } from "bun:test";
-import type { Logger } from "../../src/logger";
-import { createBgReportProgressTool } from "../../src/tools/bg-report-progress";
-
-const silentLogger: Logger = {
-  debug() {},
-  info() {},
-  warn() {},
-  error() {},
-  log() {},
-};
-
-function decode(result: unknown): any { const r = result as any; if (r && typeof r === "object" && "output" in r) { return typeof r.output === "string" ? JSON.parse(r.output) : r.output; } if (typeof result === "string") return JSON.parse(result); return result; }
-
-describe("bg-report-progress tool", () => {
-  it("computes progress percent", async () => {
-    const mgr = {
-      updateProgress: async (_id: string, step: number, total: number) => ({
-        ok: true,
-        progress: Math.round((step / total) * 100),
-      }),
-    } as any;
-    const tool = createBgReportProgressTool({ instanceManager: mgr, logger: silentLogger });
-    const r = await tool.execute(
-      { instanceId: "bgr_x", step: 3, total: 10, message: "step 3 of 10" } as any,
-      { metadata: { parentAgent: "mimir" } } as any,
-    );
-    expect(decode(r)).toEqual({ ok: true, instanceId: "bgr_x", progress: 30 });
-  });
-
-  it("caps at 100", async () => {
-    const mgr = {
-      updateProgress: async (_id: string, _step: number, total: number) => {
-        const step = 200;
-        const pct = Math.max(0, Math.min(100, Math.round((step / total) * 100)));
-        return { ok: true, progress: pct };
-      },
-    } as any;
-    const tool = createBgReportProgressTool({ instanceManager: mgr, logger: silentLogger });
-    const r = await tool.execute(
-      { instanceId: "bgr_x", step: 200, total: 100 } as any,
-      { metadata: { parentAgent: "mimir" } } as any,
-    );
-    expect(decode(r)).toMatchObject({ progress: 100 });
-  });
-
-  it("returns -1 for indeterminate", async () => {
-    let captured = 999;
-    const mgr = {
-      updateProgress: async (_id: string, _step: number, _total: number, _m: unknown, indet: boolean) => {
-        captured = indet ? -1 : 50;
-        return { ok: true, progress: captured };
-      },
-    } as any;
-    const tool = createBgReportProgressTool({ instanceManager: mgr, logger: silentLogger });
-    const r = await tool.execute(
-      { instanceId: "bgr_x", step: 1, total: 10, indeterminate: true } as any,
-      { metadata: { parentAgent: "mimir" } } as any,
-    );
-    expect(decode(r)).toMatchObject({ progress: -1 });
-    expect(captured).toBe(-1);
-  });
-
-  it("propagates errors", async () => {
-    const mgr = {
-      updateProgress: async () => ({ ok: false, error: "instance_not_found" }),
-    } as any;
-    const tool = createBgReportProgressTool({ instanceManager: mgr, logger: silentLogger });
-    const r = await tool.execute(
-      { instanceId: "bgr_x", step: 1, total: 10 } as any,
-      { metadata: { parentAgent: "mimir" } } as any,
-    );
-    expect(decode(r)).toMatchObject({ error: "instance_not_found" });
-  });
-});

package/plugins/bizar/tests/tools/bg-resume.test.ts

@@ -1,40 +0,0 @@
-/**
- * bg-resume.test.ts — `bizar_resume` tool tests.
- */
-
-import { describe, it, expect } from "bun:test";
-import type { Logger } from "../../src/logger";
-import { createBgResumeTool } from "../../src/tools/bg-resume";
-
-const silentLogger: Logger = {
-  debug() {},
-  info() {},
-  warn() {},
-  error() {},
-  log() {},
-};
-
-function decode(result: unknown): any { const r = result as any; if (r && typeof r === "object" && "output" in r) { return typeof r.output === "string" ? JSON.parse(r.output) : r.output; } if (typeof result === "string") return JSON.parse(result); return result; }
-
-describe("bg-resume tool", () => {
-  it("rejects non-Odin callers", async () => {
-    const mgr = { resume: async () => ({ ok: true }) } as any;
-    const tool = createBgResumeTool({ instanceManager: mgr, logger: silentLogger });
-    const r = await tool.execute({ instanceId: "bgr_x" } as any, { metadata: { parentAgent: "frigg" } } as any);
-    expect(decode(r).error).toContain("Only Odin");
-  });
-
-  it("returns running status on success", async () => {
-    const mgr = { resume: async () => ({ ok: true }) } as any;
-    const tool = createBgResumeTool({ instanceManager: mgr, logger: silentLogger });
-    const r = await tool.execute({ instanceId: "bgr_x" } as any, { metadata: { parentAgent: "odin" } } as any);
-    expect(decode(r)).toEqual({ ok: true, instanceId: "bgr_x", status: "running" });
-  });
-
-  it("propagates errors", async () => {
-    const mgr = { resume: async () => ({ ok: false, error: "unsupported_on_win32" }) } as any;
-    const tool = createBgResumeTool({ instanceManager: mgr, logger: silentLogger });
-    const r = await tool.execute({ instanceId: "bgr_x" } as any, { metadata: { parentAgent: "odin" } } as any);
-    expect(decode(r)).toMatchObject({ error: "unsupported_on_win32" });
-  });
-});

package/plugins/bizar/tests/tools/bg-send-message.test.ts

@@ -1,116 +0,0 @@
-/**
- * bg-send-message.test.ts — `bizar_send_message` tool tests.
- *
- * v5.5.1: the tool now performs TRUE mid-flight steer via the dashboard
- * SDK. Tests mock the dashboard POST so we don't need a real server.
- */
-
-import { describe, it, expect } from "bun:test";
-import type { Logger } from "../../src/logger";
-import { createBgSendMessageTool } from "../../src/tools/bg-send-message";
-
-const silentLogger: Logger = {
-  debug() {},
-  info() {},
-  warn() {},
-  error() {},
-  log() {},
-};
-
-function decode(result: unknown): any { const r = result as any; if (r && typeof r === "object" && "output" in r) { return typeof r.output === "string" ? JSON.parse(r.output) : r.output; } if (typeof result === "string") return JSON.parse(result); return result; }
-
-describe("bg-send-message tool", () => {
-  it("returns instance_not_found for missing", async () => {
-    const mgr = { get: async () => null } as any;
-    const tool = createBgSendMessageTool({ instanceManager: mgr, logger: silentLogger });
-    const r = await tool.execute(
-      { instanceId: "bgr_missing", message: "hi" } as any,
-      { metadata: { parentAgent: "odin" } } as any,
-    );
-    expect(decode(r)).toMatchObject({ error: "instance_not_found" });
-  });
-
-  it("delegates to dashboard POST /api/background/:id/steer (mid-flight)", async () => {
-    const mgr = {
-      get: async () => ({ instanceId: "bgr_x", status: "running", sessionId: "ses_x" }),
-    } as any;
-    let capturedUrl = "";
-    let capturedBody = "";
-    const mockPost = async (
-      url: string,
-      init: { headers: Record<string, string>; body: string },
-    ) => {
-      capturedUrl = url;
-      capturedBody = init.body;
-      return {
-        ok: true,
-        status: 200,
-        json: async () => ({
-          ok: true,
-          mode: "true_midflight",
-          instanceId: "bgr_x",
-          steerCount: 1,
-        }),
-      };
-    };
-    const tool = createBgSendMessageTool({
-      instanceManager: mgr,
-      logger: silentLogger,
-      _dashboardPost: mockPost,
-    } as any);
-    const r = await tool.execute(
-      { instanceId: "bgr_x", message: "go faster" } as any,
-      { metadata: { parentAgent: "odin" } } as any,
-    );
-    // Verify the dashboard was hit with the right URL + body.
-    expect(capturedUrl).toContain("/api/background/bgr_x/steer");
-    expect(JSON.parse(capturedBody).message).toBe("go faster");
-    const out = decode(r);
-    expect(out.ok).toBe(true);
-    expect(out.mode).toBe("true_midflight");
-    expect(out.instanceId).toBe("bgr_x");
-    expect(out.steerCount).toBe(1);
-  });
-
-  it("propagates dashboard errors", async () => {
-    const mgr = {
-      get: async () => ({ instanceId: "bgr_y", status: "running" }),
-    } as any;
-    const mockPost = async () => ({
-      ok: false,
-      status: 502,
-      json: async () => ({ ok: false, error: "dashboard_down" }),
-    });
-    const tool = createBgSendMessageTool({
-      instanceManager: mgr,
-      logger: silentLogger,
-      _dashboardPost: mockPost,
-    } as any);
-    const r = await tool.execute(
-      { instanceId: "bgr_y", message: "halt" } as any,
-      { metadata: { parentAgent: "odin" } } as any,
-    );
-    const out = decode(r);
-    expect(out.error).toContain("dashboard_down");
-  });
-
-  it("propagates network errors", async () => {
-    const mgr = {
-      get: async () => ({ instanceId: "bgr_z", status: "running" }),
-    } as any;
-    const mockPost = async () => {
-      throw new Error("ECONNREFUSED");
-    };
-    const tool = createBgSendMessageTool({
-      instanceManager: mgr,
-      logger: silentLogger,
-      _dashboardPost: mockPost,
-    } as any);
-    const r = await tool.execute(
-      { instanceId: "bgr_z", message: "halt" } as any,
-      { metadata: { parentAgent: "odin" } } as any,
-    );
-    const out = decode(r);
-    expect(out.error).toContain("ECONNREFUSED");
-  });
-});

package/plugins/bizar/tests/tools/bg-spawn-delegation.test.ts

@@ -1,147 +0,0 @@
-/**
- * Delegation wrapper unit tests.
- *
- * `bizar_spawn_background` silently fell back to odin for any
- * subagent request because cline 1.17.x rejects
- * `cline run --agent <subagent>` with "agent X is a subagent,
- * not a primary agent". The fix routes subagent requests through
- * odin with a directive delegation prompt.
- *
- * These tests cover the pure helpers — `PRIMARY_AGENTS`,
- * `needsDelegationWrapper`, and `buildDelegationPrompt` — exported
- * from src/tools/bg-spawn.ts specifically for testability.
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-  PRIMARY_AGENTS,
-  needsDelegationWrapper,
-  buildDelegationPrompt,
-} from "../../src/tools/bg-spawn";
-
-describe("PRIMARY_AGENTS — set of agents accepted by cline run --agent", () => {
-  it("contains the three primary agents from config/agents/*.md", () => {
-    expect(PRIMARY_AGENTS.has("odin")).toBe(true);
-    expect(PRIMARY_AGENTS.has("quick")).toBe(true);
-    expect(PRIMARY_AGENTS.has("agent-browser")).toBe(true);
-  });
-
-  it("does NOT contain any subagent", () => {
-    for (const sub of [
-      "mimir",
-      "heimdall",
-      "hermod",
-      "thor",
-      "baldr",
-      "tyr",
-      "vidarr",
-      "forseti",
-      "frigg",  // v3.20.11: frigg was demoted to subagent (mode: subagent)
-      "vor",
-      "semble-search",
-    ]) {
-      expect(PRIMARY_AGENTS.has(sub)).toBe(false);
-    }
-  });
-
-  it("is in sync with the on-disk agent configs", async () => {
-    // Read each config/agents/*.md and extract the mode field. The
-    // PRIMARY_AGENTS set must be the exact set of `mode: primary`
-    // agents. This guards against drift when a new agent is added.
-    const { readdirSync, readFileSync } = await import("node:fs");
-    const { join } = await import("node:path");
-    const dir = join(import.meta.dir, "..", "..", "..", "..", "config", "agents");
-    const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
-    const diskPrimary = new Set<string>();
-    for (const f of files) {
-      const text = readFileSync(join(dir, f), "utf8");
-      const m = text.match(/^mode:\s*(\S+)/m);
-      if (m && m[1] === "primary") {
-        diskPrimary.add(f.replace(/\.md$/, ""));
-      }
-    }
-    // The disk set must equal our PRIMARY_AGENTS set exactly.
-    const code = new Set(PRIMARY_AGENTS);
-    expect([...code].sort()).toEqual([...diskPrimary].sort());
-  });
-});
-
-describe("needsDelegationWrapper", () => {
-  it("returns false for primary agents", () => {
-    expect(needsDelegationWrapper("odin")).toBe(false);
-    expect(needsDelegationWrapper("quick")).toBe(false);
-    expect(needsDelegationWrapper("agent-browser")).toBe(false);
-  });
-
-  it("returns true for subagents", () => {
-    expect(needsDelegationWrapper("mimir")).toBe(true);
-    expect(needsDelegationWrapper("heimdall")).toBe(true);
-    expect(needsDelegationWrapper("thor")).toBe(true);
-    expect(needsDelegationWrapper("tyr")).toBe(true);
-    expect(needsDelegationWrapper("vidarr")).toBe(true);
-    expect(needsDelegationWrapper("forseti")).toBe(true);
-  });
-
-  it("returns true for unknown agent names (defensive — let cline reject)", () => {
-    expect(needsDelegationWrapper("xyz-unknown-agent")).toBe(true);
-    expect(needsDelegationWrapper("")).toBe(true);
-  });
-});
-
-describe("buildDelegationPrompt", () => {
-  it("names the requested subagent explicitly", () => {
-    const prompt = buildDelegationPrompt("mimir", "research X");
-    expect(prompt).toContain("Requested subagent: mimir");
-    expect(prompt).toContain('agent="mimir"');
-  });
-
-  it("includes the user prompt verbatim between BEGIN/END markers", () => {
-    const userPrompt = "research MiniMax rate limits and recommend a fallback strategy";
-    const prompt = buildDelegationPrompt("mimir", userPrompt);
-    expect(prompt).toContain("--- BEGIN USER PROMPT ---");
-    expect(prompt).toContain("--- END USER PROMPT ---");
-    expect(prompt).toContain(userPrompt);
-  });
-
-  it("is directive: forbids Odin from performing the work itself", () => {
-    const prompt = buildDelegationPrompt("thor", "implement feature X");
-    expect(prompt).toMatch(/Do NOT/i);
-    expect(prompt).toMatch(/perform the work yourself/i);
-    expect(prompt).toMatch(/Do NOT interpret/i);
-    expect(prompt).toMatch(/Do NOT ask/i);
-    expect(prompt).toMatch(/Do NOT route to any other agent/i);
-  });
-
-  it("instructs Odin to use the task tool (cline's delegation mechanism)", () => {
-    const prompt = buildDelegationPrompt("mimir", "research X");
-    expect(prompt).toMatch(/task tool/i);
-    expect(prompt).toMatch(/agent="mimir"/);
-  });
-
-  it("instructs Odin to report the subagent's output verbatim", () => {
-    const prompt = buildDelegationPrompt("mimir", "research X");
-    expect(prompt).toMatch(/verbatim/i);
-    expect(prompt).toMatch(/Do not summarize/i);
-  });
-
-  it("handles a multi-line user prompt without mangling it", () => {
-    const multiline = "line 1\nline 2\n  indented\n\nparagraph break";
-    const prompt = buildDelegationPrompt("mimir", multiline);
-    expect(prompt).toContain(multiline);
-    // Boundaries preserved
-    const beginIdx = prompt.indexOf("--- BEGIN USER PROMPT ---");
-    const endIdx = prompt.indexOf("--- END USER PROMPT ---");
-    expect(beginIdx).toBeGreaterThan(-1);
-    expect(endIdx).toBeGreaterThan(beginIdx);
-    const between = prompt.slice(beginIdx + "--- BEGIN USER PROMPT ---".length, endIdx);
-    expect(between).toContain("line 1");
-    expect(between).toContain("indented");
-    expect(between).toContain("paragraph break");
-  });
-
-  it("handles a user prompt with special regex characters", () => {
-    const tricky = "find files matching *.test.ts and use $VAR + (a|b)";
-    const prompt = buildDelegationPrompt("mimir", tricky);
-    expect(prompt).toContain(tricky);
-  });
-});