@polderlabs/bizar 6.2.5 → 7.0.0

package/plugins/bizar/tests/tools/wait-for-feedback.test.ts

@@ -1,390 +0,0 @@
-/**
- * wait-for-feedback.test.ts
- *
- * Tests for `waitForFeedback` in src/tools/wait-for-feedback.ts.
- *
- * We test the core function (extracted from the tool factory) directly
- * with an injectable `sleep` and `now` so tests run instantly. The
- * tool factory's wrapper is thin and adds no behavior.
- *
- * Groups:
- *   1. timeout (no feedback → status: "timed_out")
- *   2. immediate feedback (comments already present)
- *   3. delayed feedback (comments added while polling)
- *   4. approved status (meta.json)
- *   5. rejected status (meta.json)
- *   6. sinceTimestamp filter (only newer comments count)
- *   7. invalid slug → error
- *   8. missing plan → error
- */
-
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import {
-  mkdtempSync,
-  rmSync,
-  mkdirSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { waitForFeedback } from "../../src/tools/wait-for-feedback.js";
-
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-
-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 }); }
-}
-
-let worktree: string;
-
-beforeAll(() => {
-  worktree = mkdtempSync(join(tmpdir(), "bizar-wait-feedback-test-"));
-});
-
-afterAll(() => {
-  if (worktree) rmSync(worktree, { recursive: true, force: true });
-});
-
-function planDir(slug: string) {
-  return join(worktree, "plans", slug);
-}
-function planJsonPath(slug: string) {
-  return join(planDir(slug), "plan.json");
-}
-function metaJsonPath(slug: string) {
-  return join(planDir(slug), "meta.json");
-}
-function seedCanvas(slug: string, canvas: unknown) {
-  mkdirSync(planDir(slug), { recursive: true });
-  writeFileSync(planJsonPath(slug), JSON.stringify(canvas), "utf-8");
-}
-function seedMeta(slug: string, meta: unknown) {
-  mkdirSync(planDir(slug), { recursive: true });
-  writeFileSync(metaJsonPath(slug), JSON.stringify(meta), "utf-8");
-}
-
-/** Make a sleep function that just bumps a fake clock by `ms` instead of
- *  actually waiting. Tests stay fast even with big timeout values. */
-function fakeSleep(now: { t: number }) {
-  return (ms: number) => {
-    now.t += ms;
-    return Promise.resolve();
-  };
-}
-
-// ===========================================================================
-// Group 1 — timeout
-// ===========================================================================
-
-describe("waitForFeedback — timeout", () => {
-  test("returns timed_out when no feedback arrives", async () => {
-    const slug = "timeout-no-feedback";
-    seedCanvas(slug, { schemaVersion: 2, comments: [] });
-    const now = { t: 1000 };
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep: fakeSleep(now),
-        now: () => now.t,
-      },
-      { planSlug: slug, timeoutMs: 50 },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      expect(r.status).toBe("timed_out");
-      expect(r.newComments).toEqual([]);
-      expect(r.planStatus).toBe("draft");
-    }
-  });
-
-  test("clamps timeout to minimum 5000ms", async () => {
-    const slug = "timeout-clamp";
-    seedCanvas(slug, { schemaVersion: 2, comments: [] });
-    const now = { t: 0 };
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep: fakeSleep(now),
-        now: () => now.t,
-      },
-      { planSlug: slug, timeoutMs: 100 }, // way below min
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      // Waited exactly the clamped minimum (5000ms), no feedback → timed out
-      expect(r.status).toBe("timed_out");
-      expect(r.waitedMs).toBeGreaterThanOrEqual(5000);
-    }
-  });
-});
-
-// ===========================================================================
-// Group 2 — immediate feedback (comments already present)
-// ===========================================================================
-
-describe("waitForFeedback — immediate feedback", () => {
-  test("returns feedback_received on first tick when comments exist", async () => {
-    const slug = "immediate-comments";
-    seedCanvas(slug, {
-      schemaVersion: 2,
-      comments: [
-        { id: "c_1", text: "Hello", created: "2026-06-18T10:00:00Z", author: "DrB0rk" },
-      ],
-    });
-    const now = { t: 0 };
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep: fakeSleep(now),
-        now: () => now.t,
-      },
-      { planSlug: slug, timeoutMs: 60_000 },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      expect(r.status).toBe("feedback_received");
-      expect(r.newComments).toHaveLength(1);
-      expect(r.newComments[0]!.id).toBe("c_1");
-    }
-  });
-});
-
-// ===========================================================================
-// Group 3 — delayed feedback (comments added while polling)
-// ===========================================================================
-
-describe("waitForFeedback — delayed feedback", () => {
-  test("returns feedback_received when comments appear during polling", async () => {
-    const slug = "delayed-comments";
-    seedCanvas(slug, { schemaVersion: 2, comments: [] });
-    const now = { t: 0 };
-
-    // Sleep that injects a comment after 2 ticks
-    let sleepCount = 0;
-    const sleep = (ms: number) => {
-      sleepCount++;
-      now.t += ms;
-      // After 2 sleeps (i.e. during the 3rd tick), add a comment.
-      if (sleepCount === 2) {
-        const canvas = {
-          schemaVersion: 2,
-          comments: [
-            { id: "c_late", text: "Late", created: "2026-06-18T12:00:00Z" },
-          ],
-        };
-        writeFileSync(planJsonPath(slug), JSON.stringify(canvas), "utf-8");
-      }
-      return Promise.resolve();
-    };
-
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep,
-        now: () => now.t,
-      },
-      { planSlug: slug, timeoutMs: 60_000 },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      expect(r.status).toBe("feedback_received");
-      expect(r.newComments).toHaveLength(1);
-      expect(r.newComments[0]!.id).toBe("c_late");
-    }
-  });
-});
-
-// ===========================================================================
-// Group 4 — approved status
-// ===========================================================================
-
-describe("waitForFeedback — approved", () => {
-  test("returns approved when meta.json status is approved (on first tick)", async () => {
-    const slug = "approved-first-tick";
-    seedCanvas(slug, { schemaVersion: 2, comments: [] });
-    seedMeta(slug, { status: "approved" });
-    const now = { t: 0 };
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep: fakeSleep(now),
-        now: () => now.t,
-      },
-      { planSlug: slug, timeoutMs: 60_000 },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      expect(r.status).toBe("approved");
-      expect(r.planStatus).toBe("approved");
-    }
-  });
-
-  test("returns approved when meta.json becomes approved during polling", async () => {
-    const slug = "approved-during";
-    seedCanvas(slug, { schemaVersion: 2, comments: [] });
-    const now = { t: 0 };
-    let sleepCount = 0;
-    const sleep = (ms: number) => {
-      sleepCount++;
-      now.t += ms;
-      if (sleepCount === 2) {
-        writeFileSync(metaJsonPath(slug), JSON.stringify({ status: "approved" }));
-      }
-      return Promise.resolve();
-    };
-    const r = await waitForFeedback(
-      { worktree, logger: new MockLogger(), pollIntervalMs: 5, sleep, now: () => now.t },
-      { planSlug: slug, timeoutMs: 60_000 },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.status).toBe("approved");
-  });
-});
-
-// ===========================================================================
-// Group 5 — rejected status
-// ===========================================================================
-
-describe("waitForFeedback — rejected", () => {
-  test("returns rejected when meta.json status is rejected", async () => {
-    const slug = "rejected-ok";
-    seedCanvas(slug, { schemaVersion: 2, comments: [] });
-    seedMeta(slug, { status: "rejected" });
-    const now = { t: 0 };
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep: fakeSleep(now),
-        now: () => now.t,
-      },
-      { planSlug: slug, timeoutMs: 60_000 },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      expect(r.status).toBe("rejected");
-      expect(r.planStatus).toBe("rejected");
-    }
-  });
-});
-
-// ===========================================================================
-// Group 6 — sinceTimestamp filter
-// ===========================================================================
-
-describe("waitForFeedback — sinceTimestamp filter", () => {
-  test("only counts comments strictly after sinceTimestamp", async () => {
-    const slug = "since-ts";
-    seedCanvas(slug, {
-      schemaVersion: 2,
-      comments: [
-        { id: "c_old", text: "Old", created: "2026-06-18T09:00:00Z" },
-        { id: "c_new", text: "New", created: "2026-06-18T11:00:00Z" },
-      ],
-    });
-    const now = { t: 0 };
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep: fakeSleep(now),
-        now: () => now.t,
-      },
-      {
-        planSlug: slug,
-        timeoutMs: 60_000,
-        sinceTimestamp: "2026-06-18T10:00:00Z",
-      },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      expect(r.status).toBe("feedback_received");
-      expect(r.newComments).toHaveLength(1);
-      expect(r.newComments[0]!.id).toBe("c_new");
-    }
-  });
-
-  test("returns timed_out when all comments are older than sinceTimestamp", async () => {
-    const slug = "since-ts-no-new";
-    seedCanvas(slug, {
-      schemaVersion: 2,
-      comments: [
-        { id: "c_old", text: "Old", created: "2026-06-18T09:00:00Z" },
-      ],
-    });
-    const now = { t: 0 };
-    const r = await waitForFeedback(
-      {
-        worktree,
-        logger: new MockLogger(),
-        pollIntervalMs: 5,
-        sleep: fakeSleep(now),
-        now: () => now.t,
-      },
-      {
-        planSlug: slug,
-        timeoutMs: 60_000,
-        sinceTimestamp: "2026-06-18T12:00:00Z",
-      },
-    );
-    expect(r.ok).toBe(true);
-    if (r.ok) {
-      expect(r.status).toBe("timed_out");
-      expect(r.newComments).toEqual([]);
-    }
-  });
-});
-
-// ===========================================================================
-// Group 7 — invalid slug
-// ===========================================================================
-
-describe("waitForFeedback — invalid slug", () => {
-  test("returns error result for invalid slug", async () => {
-    const r = await waitForFeedback(
-      { worktree, logger: new MockLogger(), pollIntervalMs: 5, sleep: fakeSleep({ t: 0 }), now: () => 0 },
-      { planSlug: "UPPERCASE", timeoutMs: 60_000 },
-    );
-    expect(r.ok).toBe(false);
-    if (!r.ok) {
-      expect(r.error).toMatch(/Invalid planSlug/);
-    }
-  });
-});
-
-// ===========================================================================
-// Group 8 — missing plan
-// ===========================================================================
-
-describe("waitForFeedback — missing plan", () => {
-  test("returns error result when plan directory does not exist", async () => {
-    const r = await waitForFeedback(
-      { worktree, logger: new MockLogger(), pollIntervalMs: 5, sleep: fakeSleep({ t: 0 }), now: () => 0 },
-      { planSlug: "does-not-exist", timeoutMs: 60_000 },
-    );
-    expect(r.ok).toBe(false);
-    if (!r.ok) {
-      expect(r.error).toMatch(/Plan not found/);
-    }
-  });
-});

package/plugins/bizar/tests/update-deadlock.test.ts

@@ -1,151 +0,0 @@
-/**
- * Regression tests for the background-state mutex.
- *
- * BUG: `InstanceManager.update()` acquired the per-instance lock and then
- * called `BackgroundStateStore.save()`, which tried to acquire the same lock
- * again. That nested re-entry never resolved, so startup deadlocked while
- * `rebuildInMemoryMap()` tried to mark pending/running instances failed.
- */
-
-import { afterEach, describe, expect, it } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-import { InstanceManager, type AddDraft } from "../src/background.js";
-import {
-  BackgroundStateStore,
-  type BackgroundState,
-} from "../src/background-state.js";
-
-const TEST_DIRS: string[] = [];
-
-const logger = {
-  log: () => {},
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-};
-
-class FakeEventStream {
-  onSessionEvent(): () => void {
-    return () => {};
-  }
-}
-
-function makeTempStateDir(): string {
-  const dir = mkdtempSync(path.join(os.tmpdir(), "bizar-update-deadlock-"));
-  TEST_DIRS.push(dir);
-  return dir;
-}
-
-function makeDraft(overrides: Partial<AddDraft> = {}): AddDraft {
-  return {
-    instanceId: "bgr_deadlock_test",
-    sessionId: "",
-    agent: "odin",
-    model: "agent-default",
-    promptPreview: "Investigate startup deadlock",
-    resultPreview: undefined,
-    resultMessageIds: undefined,
-    error: undefined,
-    parentAgent: "odin",
-    parentInstanceId: undefined,
-    logPath: path.join(os.tmpdir(), "bgr_deadlock_test.log"),
-    timeoutMs: 30_000,
-    toolCallCount: 0,
-    loopGuardTool: undefined,
-    lastEventAt: undefined,
-    lastToolOrTextAt: undefined,
-    interventionCount: undefined,
-    interventionAt: undefined,
-    interventionReason: undefined,
-    ...overrides,
-  };
-}
-
-function createManager(stateDir: string): {
-  manager: InstanceManager;
-  stateStore: BackgroundStateStore;
-} {
-  const stateStore = new BackgroundStateStore(stateDir, logger);
-  const manager = new InstanceManager({
-    stateStore,
-    maxConcurrent: 8,
-    toolCallCap: 250,
-    logger,
-    worktree: "/tmp",
-    serve: { worktree: "/tmp" } as never,
-    http: {} as never,
-    stream: new FakeEventStream() as never,
-    stallTimeoutMs: 180_000,
-    thinkingLoopTimeoutMs: 300_000,
-    maxInterventions: 1,
-  });
-  manager.disablePeriodicChecks();
-  return { manager, stateStore };
-}
-
-async function settleWithin<T>(promise: Promise<T>, timeoutMs: number): Promise<T | "timeout"> {
-  return await Promise.race([
-    promise,
-    new Promise<"timeout">((resolve) => {
-      setTimeout(() => resolve("timeout"), timeoutMs);
-    }),
-  ]);
-}
-
-afterEach(() => {
-  for (const dir of TEST_DIRS.splice(0)) {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe("InstanceManager.update mutex regression", () => {
-  it("resolves and persists instead of deadlocking on nested save", async () => {
-    const stateDir = makeTempStateDir();
-    const { manager, stateStore } = createManager(stateDir);
-    const draft = makeDraft();
-
-    await manager.add(draft);
-
-    const result = await settleWithin(
-      manager.update(draft.instanceId, {
-        status: "failed",
-        error: "plugin restarted while instance was pending",
-      }),
-      250,
-    );
-
-    expect(result).not.toBe("timeout");
-
-    const stored = await stateStore.load(draft.instanceId);
-    expect(stored?.status).toBe("failed");
-  });
-
-  it("rebuildInMemoryMap marks a pending instance failed without hanging", async () => {
-    const stateDir = makeTempStateDir();
-    const { manager, stateStore } = createManager(stateDir);
-    const pendingState: BackgroundState = {
-      ...makeDraft(),
-      status: "pending",
-      startedAt: Date.now(),
-    };
-
-    await stateStore.save(pendingState);
-
-    const result = await settleWithin(manager.rebuildInMemoryMap(), 250);
-
-    expect(result).not.toBe("timeout");
-
-    const stored = await stateStore.load(pendingState.instanceId);
-    // The implementation reports the actual subprocess status (could be
-    // either "subprocess died during restart" or
-    // "plugin restarted while instance was pending" depending on
-    // whether the subprocess was alive at restart time).
-    expect(stored?.error).toMatch(
-      /subprocess died during restart|plugin restarted while instance was pending/,
-    );
-  });
-});

package/plugins/bizar/tsconfig.json

@@ -1,29 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "lib": ["ES2022"],
-    "strict": true,
-    "noImplicitAny": true,
-    "strictNullChecks": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true,
-    "skipLibCheck": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "verbatimModuleSyntax": false,
-    "types": ["bun"],
-    "outDir": "./dist",
-    "rootDir": "."
-  },
-  "include": ["index.ts", "src/**/*.ts", "tests/**/*.ts"],
-  "exclude": ["node_modules", "dist"]
-}

package/scripts/mirror-agents-md.sh

@@ -1,69 +0,0 @@
-#!/usr/bin/env bash
-#
-# scripts/mirror-agents-md.sh — keep CLAUDE.md in sync with AGENTS.md.
-#
-# Both files are part of the walkinglabs/awesome-harness-engineering
-# convention. AGENTS.md is the canonical source; CLAUDE.md is the
-# mirror for tools that hard-code `CLAUDE.md` as the entry point.
-#
-# Usage: ./scripts/mirror-agents-md.sh [--check]
-#
-# --check exits 1 if CLAUDE.md is out of sync (for CI).
-
-set -euo pipefail
-
-cd "$(dirname "$0")/.."
-
-CHECK=0
-for arg in "$@"; do
-  case "$arg" in
-    --check) CHECK=1 ;;
-    *) echo "unknown arg: $arg" >&2; exit 2 ;;
-  esac
-done
-
-if [[ ! -f AGENTS.md ]]; then
-  echo "AGENTS.md missing — cannot mirror" >&2
-  exit 1
-fi
-
-# Mirror script: extract everything from AGENTS.md past the first `# `
-# heading, prepend a banner. Idempotent.
-BODY=$(awk '/^# / { if (seen) exit; seen=1; next } { print }' AGENTS.md)
-
-TMP=$(mktemp)
-trap "rm -f '$TMP'" EXIT
-
-cat > "$TMP" <<EOF
-# CLAUDE.md — Mirror of AGENTS.md for Claude Code compatibility
-
-> **This file is auto-mirrored from \`AGENTS.md\` for tools that look for
-> \`CLAUDE.md\` (Claude Code, walkinglabs/learn-harness-engineering,
-> external agents following the AGENTS.md convention). DO NOT EDIT THIS
-> FILE DIRECTLY — edit \`AGENTS.md\` and run \`make mirror-agents-md\`.
->
-> Source: \`AGENTS.md\` (canonical)
-> Mirrored: $(date -Iseconds) by \`scripts/mirror-agents-md.sh\`
-
----
-
-$BODY
-EOF
-
-if [[ $CHECK -eq 1 ]]; then
-  if [[ ! -f CLAUDE.md ]] || ! cmp -s "$TMP" CLAUDE.md; then
-    echo "CLAUDE.md is out of sync with AGENTS.md" >&2
-    diff CLAUDE.md "$TMP" | head -40 || true
-    exit 1
-  fi
-  echo "CLAUDE.md is in sync"
-  exit 0
-fi
-
-if [[ ! -f CLAUDE.md ]] || ! cmp -s "$TMP" CLAUDE.md; then
-  mv "$TMP" CLAUDE.md
-  echo "✓ CLAUDE.md updated from AGENTS.md"
-else
-  echo "✓ CLAUDE.md already in sync"
-  rm "$TMP"
-fi