@polderlabs/bizar 6.2.5 → 6.3.0

package/plugins/bizar/tests/background.test.ts

@@ -1,402 +0,0 @@
-/**
- * InstanceManager tests.
- *
- * Tests: atomic add with cap (HIGH-10, HIGH-12, HIGH-21), get, list, update,
- * kill, collect, rebuildInMemoryMap, shutdownAll, max-instance race (HIGH-38).
- *
- * All Bun.spawn and HTTP calls are mocked; tests are fully deterministic.
- */
-
-import { describe, it, expect } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Test doubles mirroring the expected InstanceManager API from §2.2 / §4
-// ---------------------------------------------------------------------------
-
-import type { BackgroundState, BackgroundStatus } from "../src/background-state.ts";
-
-function makeBgState(overrides: Partial<BackgroundState> = {}): BackgroundState {
-  return {
-    instanceId: `bgr_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
-    sessionId: `sess_${Math.random().toString(36).slice(2, 10)}`,
-    agent: "mimir",
-    status: "pending",
-    startedAt: Date.now(),
-    model: "minimax/minimax-m3",
-    promptPreview: "Do the thing",
-    resultPreview: undefined,
-    resultMessageIds: [],
-    error: undefined,
-    parentAgent: "odin",
-    parentInstanceId: undefined,
-    logPath: "~/.cache/bizar/logs/test.log",
-    timeoutMs: 300_000,
-    toolCallCount: 0,
-    loopGuardTool: undefined,
-    ...overrides,
-  };
-}
-
-/** Minimal fake InstanceManager matching the expected interface */
-class FakeInstanceManager {
-  private instances = new Map<string, BackgroundState>();
-  private cap: number;
-  private addLock: Promise<unknown> = Promise.resolve();
-
-  constructor(cap = 8) {
-    this.cap = cap;
-  }
-
-  async add(draft: BackgroundState): Promise<BackgroundState | { error: string }> {
-    // Chain onto the existing lock, then update the lock reference
-    const prev = this.addLock;
-    const next = prev.then(async () => {
-      if (this.instances.size >= this.cap) {
-        return {
-          error: `Max concurrent instances reached (${this.cap}). Wait for one to finish or call bizar_kill.`,
-        } as const;
-      }
-      const inst: BackgroundState = { ...draft, status: "pending" };
-      this.instances.set(inst.instanceId, inst);
-      return inst;
-    });
-    this.addLock = next;
-    return next;
-  }
-
-  get(instanceId: string): BackgroundState | undefined {
-    return this.instances.get(instanceId);
-  }
-
-  list(): BackgroundState[] {
-    return [...this.instances.values()];
-  }
-
-  async update(instanceId: string, patch: Partial<BackgroundState>): Promise<void> {
-    const existing = this.instances.get(instanceId);
-    if (!existing) return;
-    this.instances.set(instanceId, { ...existing, ...patch });
-  }
-
-  async kill(instanceId: string): Promise<BackgroundState | null> {
-    const inst = this.instances.get(instanceId);
-    if (!inst) return null;
-    this.instances.set(instanceId, { ...inst, status: "killed", completedAt: Date.now() });
-    return this.instances.get(instanceId)!;
-  }
-
-  async collect(instanceId: string): Promise<{ status: BackgroundStatus; result: string }> {
-    const inst = this.instances.get(instanceId);
-    if (!inst) return { status: "failed", result: "" };
-    // Return current status and result — real impl blocks waiting for terminal state
-    return { status: inst.status, result: inst.resultPreview ?? "" };
-  }
-
-  rebuildInMemoryMap(states: BackgroundState[]): void {
-    this.instances.clear();
-    for (const s of states) {
-      // Apply the restart scan logic per §5.4
-      if (s.status === "running" || s.status === "pending") {
-        const marked: BackgroundState = {
-          ...s,
-          status: "failed",
-          error: s.status === "pending"
-            ? "plugin restarted while instance was pending"
-            : "plugin restarted; serve child is new",
-          completedAt: Date.now(),
-        };
-        this.instances.set(s.instanceId, marked);
-      } else {
-        // Historical records preserved as-is
-        this.instances.set(s.instanceId, s);
-      }
-    }
-  }
-
-  async shutdownAll(): Promise<void> {
-    for (const inst of this.instances.values()) {
-      if (inst.status === "running" || inst.status === "pending") {
-        inst.status = "failed";
-        inst.error = "plugin shutting down";
-      }
-    }
-  }
-
-  get size(): number {
-    return this.instances.size;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// add() — atomic cap check + map insertion (HIGH-10, HIGH-12, HIGH-21)
-// ---------------------------------------------------------------------------
-
-describe("InstanceManager.add", () => {
-  it("inserts instance and returns it when under cap", async () => {
-    const mgr = new FakeInstanceManager(8);
-    const draft = makeBgState();
-    const result = await mgr.add(draft);
-    expect(result.error).toBeUndefined();
-    expect(mgr.size).toBe(1);
-  });
-
-  it("rejects with error when cap is reached", async () => {
-    const mgr = new FakeInstanceManager(2);
-
-    await mgr.add(makeBgState({ instanceId: "bgr_1" }));
-    await mgr.add(makeBgState({ instanceId: "bgr_2" }));
-    const result = await mgr.add(makeBgState({ instanceId: "bgr_3" }));
-
-    expect(result).toHaveProperty("error");
-    expect((result as { error: string }).error).toContain("Max concurrent instances reached");
-    expect(mgr.size).toBe(2);
-  });
-
-  it("cap defaults to 8", async () => {
-    const mgr = new FakeInstanceManager();
-    expect(mgr.size).toBe(0);
-  });
-
-  it("cap can be set to 32 (max per §6.5)", async () => {
-    const mgr = new FakeInstanceManager(32);
-    // Fill to 32
-    const promises = Array.from({ length: 32 }, () => mgr.add(makeBgState()));
-    await Promise.all(promises);
-    expect(mgr.size).toBe(32);
-    const overflow = await mgr.add(makeBgState());
-    expect(overflow).toHaveProperty("error");
-  });
-
-  it("inserts are atomic: no half-created sessions", async () => {
-    // Verify the addLock pattern: even during the async gap,
-    // the map entry exists before any HTTP calls
-    const mgr = new FakeInstanceManager(8);
-    let mapHasEntryBeforeHttp = false;
-    let httpCalled = false;
-
-    const origAdd = mgr.add.bind(mgr);
-    // Patch add to capture the state between map insert and HTTP call
-    // Since we're using a fake, we just verify the entry exists in map after add()
-    await mgr.add(makeBgState({ instanceId: "bgr_atomic_test" }));
-    mapHasEntryBeforeHttp = mgr.get("bgr_atomic_test") !== undefined;
-    expect(mapHasEntryBeforeHttp).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// HIGH-38: Max-instance race condition — 10 concurrent adds with cap=8
-// ---------------------------------------------------------------------------
-
-describe("max-instance race (HIGH-38)", () => {
-  it("10 concurrent adds with cap=8 result in exactly 8 successes", async () => {
-    const mgr = new FakeInstanceManager(8);
-
-    const results = await Promise.all(
-      Array.from({ length: 10 }, (_, i) =>
-        mgr.add(makeBgState({ instanceId: `bgr_race_${i}` })),
-      ),
-    );
-
-    // BackgroundState has optional error?: string, so "error" in obj is always true
-    // Use the error property value to distinguish success from failure
-    const successes = results.filter((r) => !r.error);
-    const failures = results.filter((r) => !!r.error);
-
-    expect(successes.length).toBe(8);
-    expect(failures.length).toBe(2);
-    expect(mgr.size).toBe(8);
-  });
-
-  it("all 10 adds are submitted; cap check is atomic", async () => {
-    const mgr = new FakeInstanceManager(8);
-
-    await Promise.all(
-      Array.from({ length: 10 }, (_, i) =>
-        mgr.add(makeBgState({ instanceId: `bgr_race2_${i}` })),
-      ),
-    );
-
-    // Exactly 8 succeeded — no more, no less
-    expect(mgr.size).toBe(8);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// get / list / update
-// ---------------------------------------------------------------------------
-
-describe("InstanceManager get/list/update", () => {
-  it("get returns the instance", async () => {
-    const mgr = new FakeInstanceManager(8);
-    const draft = makeBgState({ instanceId: "bgr_get_test" });
-    await mgr.add(draft);
-
-    const inst = mgr.get("bgr_get_test");
-    expect(inst).toBeDefined();
-    expect(inst!.instanceId).toBe("bgr_get_test");
-  });
-
-  it("get returns undefined for unknown instanceId", () => {
-    const mgr = new FakeInstanceManager(8);
-    expect(mgr.get("bgr_unknown")).toBeUndefined();
-  });
-
-  it("list returns all instances", async () => {
-    const mgr = new FakeInstanceManager(8);
-    await mgr.add(makeBgState({ instanceId: "bgr_list_1" }));
-    await mgr.add(makeBgState({ instanceId: "bgr_list_2" }));
-
-    const all = mgr.list();
-    expect(all.length).toBe(2);
-  });
-
-  it("update patches the instance", async () => {
-    const mgr = new FakeInstanceManager(8);
-    await mgr.add(makeBgState({ instanceId: "bgr_update_test", status: "pending" }));
-    await mgr.update("bgr_update_test", { status: "running" });
-
-    const inst = mgr.get("bgr_update_test");
-    expect(inst!.status).toBe("running");
-  });
-
-  it("update is a no-op for unknown instanceId", async () => {
-    const mgr = new FakeInstanceManager(8);
-    await mgr.update("bgr_no_such_instance", { status: "running" });
-    expect(mgr.list().length).toBe(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// kill
-// ---------------------------------------------------------------------------
-
-describe("InstanceManager.kill", () => {
-  it("marks instance as killed", async () => {
-    const mgr = new FakeInstanceManager(8);
-    await mgr.add(makeBgState({ instanceId: "bgr_kill_test", status: "running" }));
-    await mgr.kill("bgr_kill_test");
-
-    const inst = mgr.get("bgr_kill_test");
-    expect(inst!.status).toBe("killed");
-  });
-
-  it("returns null for unknown instanceId", async () => {
-    const mgr = new FakeInstanceManager(8);
-    const result = await mgr.kill("bgr_no_such");
-    expect(result).toBeNull();
-  });
-
-  it("kill on already-killed instance is a no-op (returns killed, not error)", async () => {
-    const mgr = new FakeInstanceManager(8);
-    await mgr.add(makeBgState({ instanceId: "bgr_double_kill", status: "killed" }));
-    const result = await mgr.kill("bgr_double_kill");
-    expect(result!.status).toBe("killed");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// collect
-// ---------------------------------------------------------------------------
-
-describe("InstanceManager.collect", () => {
-  it("returns status and resultPreview for known instance", async () => {
-    const mgr = new FakeInstanceManager(8);
-    // First add the instance (starts as pending), then update to done
-    await mgr.add(makeBgState({
-      instanceId: "bgr_collect_test",
-      status: "pending",
-      resultPreview: "the result",
-    }));
-    await mgr.update("bgr_collect_test", { status: "done" });
-
-    const result = await mgr.collect("bgr_collect_test");
-    expect(result.status).toBe("done");
-    expect(result.result).toBe("the result");
-  });
-
-  it("returns failed for unknown instanceId", async () => {
-    const mgr = new FakeInstanceManager(8);
-    const result = await mgr.collect("bgr_no_such");
-    expect(result.status).toBe("failed");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// rebuildInMemoryMap (MEDIUM-39)
-// ---------------------------------------------------------------------------
-
-describe("rebuildInMemoryMap", () => {
-  it("clears existing map and repopulates", () => {
-    const mgr = new FakeInstanceManager(8);
-    mgr.rebuildInMemoryMap([
-      makeBgState({ instanceId: "bgr_rebuilt_1", status: "done" }),
-      makeBgState({ instanceId: "bgr_rebuilt_2", status: "running" }),
-    ]);
-
-    expect(mgr.size).toBe(2);
-    expect(mgr.get("bgr_rebuilt_1")).toBeDefined();
-    expect(mgr.get("bgr_rebuilt_2")).toBeDefined();
-  });
-
-  it("marks running/pending as failed on rebuild (MEDIUM-39)", () => {
-    const mgr = new FakeInstanceManager(8);
-    mgr.rebuildInMemoryMap([
-      makeBgState({ instanceId: "bgr_was_running", status: "running" }),
-      makeBgState({ instanceId: "bgr_was_pending", status: "pending" }),
-      makeBgState({ instanceId: "bgr_was_done", status: "done" }),
-    ]);
-
-    // Simulate the rebuildInMemoryMap logic from §5.4
-    const running = mgr.get("bgr_was_running");
-    const pending = mgr.get("bgr_was_pending");
-    const done = mgr.get("bgr_was_done");
-
-    expect(running!.status).toBe("failed");
-    expect(running!.error).toContain("plugin restarted");
-    expect(pending!.status).toBe("failed");
-    expect(pending!.error).toContain("plugin restarted");
-    expect(done!.status).toBe("done"); // historical — preserved
-  });
-});
-
-// ---------------------------------------------------------------------------
-// shutdownAll
-// ---------------------------------------------------------------------------
-
-describe("shutdownAll", () => {
-  it("marks all running/pending as failed", async () => {
-    const mgr = new FakeInstanceManager(8);
-    // Use rebuildInMemoryMap to populate (running/pending will be marked failed there
-    // with "plugin restarted" error), then re-set them to running for shutdownAll test
-    mgr.rebuildInMemoryMap([
-      makeBgState({ instanceId: "bgr_running", status: "running" }),
-      makeBgState({ instanceId: "bgr_pending", status: "pending" }),
-      makeBgState({ instanceId: "bgr_done", status: "done" }),
-    ]);
-    // rebuildInMemoryMap already marks running/pending as failed.
-    // For this test, verify the error message reflects plugin shutting down
-    // (simulated by checking the status transition logic directly)
-    const inst = mgr.get("bgr_running")!;
-    expect(inst.status).toBe("failed");
-    expect(typeof inst.error).toBe("string");
-    expect(mgr.get("bgr_done")!.status).toBe("done");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// InstanceManager interface contract verification
-// ---------------------------------------------------------------------------
-
-describe("InstanceManager interface contract", () => {
-  it("has add, get, list, update, kill, collect, rebuildInMemoryMap, shutdownAll", () => {
-    const mgr = new FakeInstanceManager();
-    expect(typeof mgr.add).toBe("function");
-    expect(typeof mgr.get).toBe("function");
-    expect(typeof mgr.list).toBe("function");
-    expect(typeof mgr.update).toBe("function");
-    expect(typeof mgr.kill).toBe("function");
-    expect(typeof mgr.collect).toBe("function");
-    expect(typeof mgr.rebuildInMemoryMap).toBe("function");
-    expect(typeof mgr.shutdownAll).toBe("function");
-  });
-});

package/plugins/bizar/tests/block.test.ts

@@ -1,195 +0,0 @@
-/**
- * Block (threshold-12) tests.
- *
- * Spec contract (tests/block.test.ts per §12.1):
- *   - Pre-populate state with 11 entries sharing fingerprint F.
- *   - The 12th identical call triggers the block action.
- *   - The block action's `reason` contains the tool name.
- *   - The block action's `reason` contains the substring `loop`
- *     (case-insensitive) OR the substring `escalate`.
- *
- * We test the `decide()` function directly. The `tool.execute.before`
- * hook in `index.ts` throws `new Error(decision.reason)` whenever
- * `decide()` returns `{ action: "block", … }`, so the block-message
- * contract is fully owned by `decide()` + `handoff.ts`. Testing
- * `decide()` keeps this file self-contained and independent of
- * Thor's `state.ts` and `fingerprint.ts` modules.
- */
-
-import { describe, test, expect } from "bun:test";
-import os from "node:os";
-import path from "node:path";
-
-import { decide } from "../src/loop.js";
-import {
-  DEFAULT_OPTIONS,
-  type NormalizedOptions,
-} from "../src/options.js";
-import { blockMessage } from "../src/handoff.js";
-
-// Local re-declaration of SessionState (see tests/loop.test.ts for rationale).
-interface ToolCall {
-  tool: string;
-  fingerprint: string;
-  at: number;
-  outcome?: "ok" | "error";
-}
-interface SessionState {
-  sessionId: string;
-  parentAgent: string | null;
-  startedAt: number;
-  lastActivityAt: number;
-  turnCount: number;
-  toolCalls: ToolCall[];
-  warningsIssued: number;
-  blocksTriggered: number;
-}
-
-function emptyState(): SessionState {
-  return {
-    sessionId: "sess-block",
-    parentAgent: "odin",
-    startedAt: 1_700_000_000_000,
-    lastActivityAt: 1_700_000_000_000,
-    turnCount: 0,
-    toolCalls: [],
-    warningsIssued: 0,
-    blocksTriggered: 0,
-  };
-}
-
-const FP = "fp:read:loop";
-const TOOL = "read";
-const ARGS = { path: path.join(os.tmpdir(), "example.txt") };
-const NOW = 1_700_000_500_000;
-
-// For the block tests we need a window size that is at least as large as
-// the block threshold, so the count can actually reach 12. The default
-// `loopWindowSize` is 10 (spec §6.1), and the spec's `loopThresholdBlock
-// <= loopWindowSize + 2` constraint allows block=12 with window=10 — but
-// in that configuration the count is bounded by the window and can never
-// reach 12. We use a wider window here so the block band is reachable;
-// the spec's default config is a known limitation (see README "Limitations"
-// §13 #11 and handoff.ts header).
-const BLOCK_TEST_OPTS: NormalizedOptions = {
-  ...DEFAULT_OPTIONS,
-  loopWindowSize: 15,
-};
-
-describe("block — threshold 12 throw (spec §12.1)", () => {
-  test("11 prior identical calls + 12th identical call triggers block", () => {
-    const state = emptyState();
-
-    // Pre-populate with 11 entries sharing fingerprint F.
-    for (let i = 0; i < 11; i++) {
-      state.toolCalls.push({
-        tool: TOOL,
-        fingerprint: FP,
-        at: 1_700_000_000_000 + i,
-      });
-    }
-    expect(state.toolCalls).toHaveLength(11);
-
-    // The hook appends the current call to the state before calling
-    // decide(). We model that here: the 12th call is in the state.
-    state.toolCalls.push({
-      tool: TOOL,
-      fingerprint: FP,
-      at: NOW,
-    });
-    expect(state.toolCalls).toHaveLength(12);
-
-    const d = decide(state, FP, NOW, BLOCK_TEST_OPTS);
-
-    expect(d.action).toBe("block");
-    if (d.action !== "block") return;
-
-    // Assert the rejection message properties (spec §12.1).
-    // 1. Contains the tool name.
-    expect(d.reason).toContain(TOOL);
-    // 2. Contains "loop" (case-insensitive) OR "escalate".
-    const matches = /loop/i.test(d.reason) || /escalate/i.test(d.reason);
-    expect(matches).toBe(true);
-  });
-
-  test("block reason matches the canonical block template", () => {
-    const state = emptyState();
-    for (let i = 0; i < 12; i++) {
-      state.toolCalls.push({ tool: TOOL, fingerprint: FP, at: NOW + i });
-    }
-    const d = decide(state, FP, NOW, BLOCK_TEST_OPTS);
-    expect(d.action).toBe("block");
-    if (d.action !== "block") return;
-    expect(d.reason).toBe(blockMessage(TOOL));
-  });
-
-  test("block fires regardless of which tool name, as long as fingerprint matches", () => {
-    const state = emptyState();
-    for (let i = 0; i < 12; i++) {
-      state.toolCalls.push({ tool: "bash", fingerprint: FP, at: NOW + i });
-    }
-    const d = decide(state, FP, NOW, BLOCK_TEST_OPTS);
-    expect(d.action).toBe("block");
-    if (d.action !== "block") return;
-    // The tool name in the message is recovered from the matching
-    // window entries — here, "bash".
-    expect(d.reason).toContain("bash");
-    expect(/loop/i.test(d.reason) || /escalate/i.test(d.reason)).toBe(true);
-  });
-
-  test("block fires with custom-configured block threshold", () => {
-    const state = emptyState();
-    for (let i = 0; i < 8; i++) {
-      state.toolCalls.push({ tool: TOOL, fingerprint: FP, at: NOW + i });
-    }
-    // Custom block threshold of 8. Window is widened so the count can
-    // reach 8.
-    const opts: NormalizedOptions = {
-      ...DEFAULT_OPTIONS,
-      loopThresholdBlock: 8,
-      loopThresholdEscalate: 6,
-      loopThresholdWarn: 4,
-      loopWindowSize: 12,
-    };
-    const d = decide(state, FP, NOW, opts);
-    expect(d.action).toBe("block");
-    if (d.action !== "block") return;
-    // The canonical template still says "12" regardless of the
-    // configured threshold (this is a known limitation, see README
-    // "Limitations" §13 and handoff.ts header).
-    expect(d.reason).toBe(blockMessage(TOOL));
-  });
-
-  test("the hook path would throw — simulate by checking decide() shape", () => {
-    // This test pins the contract that `index.ts` depends on:
-    // when `decide()` returns `{ action: "block", reason }`, the hook
-    // throws `new Error(reason)`. The shape is what matters; the
-    // throw itself is wired in index.ts.
-    const state = emptyState();
-    for (let i = 0; i < 12; i++) {
-      state.toolCalls.push({ tool: TOOL, fingerprint: FP, at: NOW + i });
-    }
-    const d = decide(state, FP, NOW, BLOCK_TEST_OPTS);
-    expect(d.action).toBe("block");
-    if (d.action !== "block") return;
-
-    // Simulate the hook's throw: `throw new Error(d.reason)`. The
-    // thrown Error's message must be the decision's reason.
-    const thrown = new Error(d.reason);
-    expect(thrown.message).toBe(d.reason);
-    expect(thrown.message).toContain(TOOL);
-    expect(/loop/i.test(thrown.message) || /escalate/i.test(thrown.message)).toBe(true);
-  });
-
-  test("11 prior calls (no 12th) does NOT block", () => {
-    const state = emptyState();
-    for (let i = 0; i < 11; i++) {
-      state.toolCalls.push({ tool: TOOL, fingerprint: FP, at: NOW + i });
-    }
-    // 11 calls total — below the block threshold of 12.
-    const d = decide(state, FP, NOW, BLOCK_TEST_OPTS);
-    expect(d.action).not.toBe("block");
-    // It should be escalate (count=11 >= escalate threshold of 8).
-    expect(d.action).toBe("escalate");
-  });
-});

package/plugins/bizar/tests/canonical-key-order.test.ts

@@ -1,75 +0,0 @@
-/**
- * canonical-key-order.test.ts
- *
- * Verifies that fingerprint.ts sorts object keys canonically (alphabetically)
- * before JSON stringify, so that {a:1, b:2} and {b:2, a:1} produce the same
- * fingerprint. Per LOW finding 34 / §12.1.
- */
-
-import { describe, test, expect } from "bun:test";
-import { fingerprint } from "../src/fingerprint";
-import os from "node:os";
-import path from "node:path";
-
-const TMP = path.join(os.tmpdir(), "canonical-key-order-test");
-
-describe("fingerprint — canonical key order", () => {
-  test("flat object: same keys/values in different insertion order produce the same fingerprint", () => {
-    const a = {
-      tool: "read",
-      args: { path: path.join(os.tmpdir(), "foo.ts"), recursive: false, limit: 10 },
-    };
-    const b = {
-      tool: "read",
-      args: { limit: 10, recursive: false, path: path.join(os.tmpdir(), "foo.ts") },
-    };
-    // Same keys, same values, different insertion order — must match.
-    expect(fingerprint(a.tool, a.args, TMP)).toBe(fingerprint(b.tool, b.args, TMP));
-  });
-
-  test("nested objects: different insertion order at both levels also match", () => {
-    const a = { tool: "edit", args: { meta: { z: 1, a: 2 }, path: "/x" } };
-    const b = { tool: "edit", args: { path: "/x", meta: { a: 2, z: 1 } } };
-    expect(fingerprint(a.tool, a.args, TMP)).toBe(fingerprint(b.tool, b.args, TMP));
-  });
-
-  test("deeply nested: three levels of differing key order all resolve to same fingerprint", () => {
-    const a = {
-      tool: "bash",
-      args: {
-        outer: {
-          middle: {
-            innerKey: "value",
-            otherKey: 42,
-          },
-          alpha: "x",
-        },
-      },
-    };
-    const b = {
-      tool: "bash",
-      args: {
-        outer: {
-          alpha: "x",
-          middle: {
-            otherKey: 42,
-            innerKey: "value",
-          },
-        },
-      },
-    };
-    expect(fingerprint(a.tool, a.args, TMP)).toBe(fingerprint(b.tool, b.args, TMP));
-  });
-
-  test("array order is preserved (arrays of same values in same order match)", () => {
-    const a = { tool: "bash", args: { commands: ["echo a", "echo b"] } };
-    const b = { tool: "bash", args: { commands: ["echo a", "echo b"] } };
-    expect(fingerprint(a.tool, a.args, TMP)).toBe(fingerprint(b.tool, b.args, TMP));
-  });
-
-  test("array with different order produces different fingerprint", () => {
-    const a = { tool: "bash", args: { commands: ["echo a", "echo b"] } };
-    const b = { tool: "bash", args: { commands: ["echo b", "echo a"] } };
-    expect(fingerprint(a.tool, a.args, TMP)).not.toBe(fingerprint(b.tool, b.args, TMP));
-  });
-});