@polderlabs/bizar-plugin 0.8.0 → 0.8.1

package/README.md

@@ -155,7 +155,7 @@ The plugin starts one `opencode serve` process on init (single-serve, multi-sess
 const result = await bizarre_spawn_background({
   agent: "mimir",                  // which agent to run
   prompt: "Research X and return findings",  // what to do
-  model: "openrouter/minimax-m3",  // optional: override model
+  model: "minimax/minimax-m3",  // optional: override model
   timeoutMs: 300_000,              // optional: default 5 min, max 30 min
 }, ctx);
 console.log(result.instanceId);    // "bgr_01ARSH3J5V..."

package/index.ts

@@ -443,6 +443,7 @@ let bgAvailable = false;
         maxConcurrent,
         toolCallCap,
         logger,
+        worktree: input.worktree,
         serve,
         http,
         stream,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar-plugin",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Bizar opencode plugin — loop detection, status reporting, handoff signal, background agents, and slash commands + visual plan flow for subagent activity",
   "type": "module",
   "main": "./index.ts",
@@ -11,7 +11,7 @@
   "scripts": {
     "check:imports": "bash scripts/check-forbidden-imports.sh",
     "typecheck": "tsc --noEmit",
-    "test": "npm run check:imports && bun test tests/loop.test.ts tests/block.test.ts tests/stall-think.test.ts tests/tools/bg-get-comments.test.ts tests/settings.test.ts tests/commands.test.ts tests/commands-impl.test.ts tests/tools/plan-action.test.ts tests/tools/wait-for-feedback.test.ts"
+    "test": "npm run check:imports && bun test tests/loop.test.ts tests/block.test.ts tests/stall-think.test.ts tests/tools/bg-get-comments.test.ts tests/tools/opencode-runner.test.ts tests/settings.test.ts tests/commands.test.ts tests/commands-impl.test.ts tests/tools/plan-action.test.ts tests/tools/wait-for-feedback.test.ts"
   },
   "keywords": [
     "opencode",

package/src/background.ts

@@ -145,9 +145,16 @@ export class InstanceManager {
   private maxConcurrent: number;
   private toolCallCap: number;
   private logger: Logger;
-  private serve: ServeLifecycle;
-  private http: HttpClient;
-  private stream: EventStream;
+  // v0.8.0 — `serve`, `http`, `stream` are nullable to support the
+  // bg-only mode used when the opencode serve child is unavailable
+  // (BIZAR_SERVE_DISABLE=1, startup failure) or when this process IS a
+  // bg-spawned `opencode run` subprocess. In bg-only mode, every method
+  // that would otherwise call `this.http.X` or `this.stream.X` is a
+  // no-op; state transitions still happen via the runner's `onExit`
+  // callback (see src/tools/bg-spawn.ts).
+  private serve: ServeLifecycle | null;
+  private http: HttpClient | null;
+  private stream: EventStream | null;
   private worktree: string;
   // v0.3.0 — stall and thinking-loop protection
   private stallTimeoutMs: number;
@@ -163,9 +170,13 @@ export class InstanceManager {
     maxConcurrent: number;
     toolCallCap: number;
     logger: Logger;
-    serve: ServeLifecycle;
-    http: HttpClient;
-    stream: EventStream;
+    // v0.8.0 — `worktree` is now an explicit param (was previously
+    // derived from `opts.serve.worktree`, which is impossible when
+    // `serve` is null in bg-only mode).
+    worktree: string;
+    serve: ServeLifecycle | null;
+    http: HttpClient | null;
+    stream: EventStream | null;
     // v0.3.0
     stallTimeoutMs?: number;
     thinkingLoopTimeoutMs?: number;
@@ -178,7 +189,7 @@ export class InstanceManager {
     this.serve = opts.serve;
     this.http = opts.http;
     this.stream = opts.stream;
-    this.worktree = opts.serve.worktree;
+    this.worktree = opts.worktree;
     this.stallTimeoutMs = Math.max(
       1_000,
       Math.floor(opts.stallTimeoutMs ?? 180_000),
@@ -188,13 +199,23 @@ export class InstanceManager {
       Math.floor(opts.thinkingLoopTimeoutMs ?? 300_000),
     );
     this.maxInterventions = Math.max(1, Math.floor(opts.maxInterventions ?? 1));
-    // Schedule the periodic stall + thinking-loop checker. The interval
-    // reference is stored so `shutdownAll` / `dispose` can clear it.
-    this.stallCheckerTimer = setInterval(
-      () => void this.runStallAndLoopChecks(),
-      STALL_CHECK_INTERVAL_MS,
-    );
-    this.stallCheckerTimer.unref?.();
+    // Schedule the periodic stall + thinking-loop checker ONLY when we
+    // have a working HTTP client. In bg-only mode the runner owns the
+    // subprocess lifecycle, so the checker has nothing to do.
+    if (this.http !== null) {
+      this.stallCheckerTimer = setInterval(
+        () => void this.runStallAndLoopChecks(),
+        STALL_CHECK_INTERVAL_MS,
+      );
+      this.stallCheckerTimer.unref?.();
+    }
+  }
+
+  /** True iff the manager was constructed without an HTTP client (no
+   *  opencode serve child reachable). HTTP-dependent operations are
+   *  no-ops in this mode. */
+  get isBgOnly(): boolean {
+    return this.http === null;
   }
 
   // --- Getters ------------------------------------------------------------
@@ -238,6 +259,11 @@ export class InstanceManager {
    */
   async runStallAndLoopChecks(): Promise<void> {
     if (this.stallCheckerDisabled) return;
+    // v0.8.0 — bg-only mode has no HTTP client, so stall and
+    // intervention are no-ops. The constructor also skips registering
+    // the interval in this mode, but a stray call from a test or future
+    // caller must still be safe.
+    if (this.http === null) return;
     // Snapshot the instance ids so we do not iterate while the map mutates.
     const ids: string[] = [];
     for (const inst of this.instances.values()) {
@@ -424,6 +450,23 @@ export class InstanceManager {
       );
       return;
     }
+    // v0.8.0 — bg-only mode has no HTTP client. The subprocess is
+    // already owned by opencode-runner.ts (see src/tools/bg-spawn.ts);
+    // mark the instance killed in-memory and let the runner notice the
+    // status change when the process eventually exits. We do NOT try
+    // to kill the OS process from here — that's the runner's job and
+    // we don't have a clean processId reference in bg-only mode
+    // (the runner does, but it lives in a separate module).
+    if (this.http === null) {
+      this.logger.warn(
+        `bizar: kill(${instanceId}) in bg-only mode: marking killed; subprocess will be reaped by opencode-runner.ts on exit`,
+      );
+      await this.update(instanceId, {
+        status: "killed",
+        completedAt: Date.now(),
+      });
+      return;
+    }
     // Abort the opencode session. The next SSE event for this session
     // (EventSessionIdle or EventSessionError) will finalize the status.
     const abort = await this.http.abortSession(inst.sessionId, this.worktree);
@@ -523,6 +566,80 @@ export class InstanceManager {
 
   // --- Collect ------------------------------------------------------------
 
+  /**
+   * Wait for an instance to reach a terminal status, or until `deadline`
+   * (ms epoch) is reached. Returns `true` on terminal, `false` on
+   * timeout.
+   *
+   * Two implementations:
+   *   - **With HTTP+stream** (full mode): subscribe to the SSE session
+   *     event stream AND poll the in-memory map. SSE gives sub-second
+   *     resolution; the in-memory check covers terminal states we set
+   *     ourselves (tool-call cap, loop guard, intervention abort).
+   *   - **Bg-only mode** (no HTTP, no SSE): poll the in-memory map
+   *     every 500 ms. Terminal transitions come from the runner's
+   *     `onExit` callback (see src/tools/bg-spawn.ts) which updates
+   *     the instance state directly.
+   */
+  private async waitForTerminal(
+    instanceId: string,
+    deadline: number,
+  ): Promise<boolean> {
+    // Already terminal?
+    const initial = this.instances.get(instanceId);
+    if (initial && TERMINAL_STATUSES.has(initial.status)) return true;
+
+    if (this.stream === null || initial === undefined) {
+      // Bg-only path: poll the in-memory map.
+      const POLL_MS = 500;
+      while (Date.now() < deadline) {
+        await new Promise<void>((resolve) => setTimeout(resolve, POLL_MS));
+        const cur = this.instances.get(instanceId);
+        if (!cur) return false;
+        if (TERMINAL_STATUSES.has(cur.status)) return true;
+      }
+      return false;
+    }
+
+    // Full path: subscribe to the session event stream AND observe our
+    // own in-memory state changes for terminal transitions we set
+    // ourselves (tool-cap, loop guard, intervention abort).
+    return await new Promise<boolean>((resolve) => {
+      const remaining = Math.max(0, deadline - Date.now());
+      if (remaining === 0) {
+        resolve(false);
+        return;
+      }
+      const timer = setTimeout(() => {
+        unsubscribe();
+        resolve(false);
+      }, remaining);
+      const unsubscribe = this.stream!.onSessionEvent(
+        initial.sessionId,
+        (ev) => {
+          if (ev.type === "session.idle" || ev.type === "session.error") {
+            clearTimeout(timer);
+            unsubscribe();
+            resolve(true);
+            return;
+          }
+          const cur = this.instances.get(instanceId);
+          if (cur && TERMINAL_STATUSES.has(cur.status)) {
+            clearTimeout(timer);
+            unsubscribe();
+            resolve(true);
+          }
+        },
+      );
+      const cur = this.instances.get(instanceId);
+      if (cur && TERMINAL_STATUSES.has(cur.status)) {
+        clearTimeout(timer);
+        unsubscribe();
+        resolve(true);
+      }
+    });
+  }
+
   /**
    * Wait for the instance to reach a terminal state (or until
    * `timeoutMs` elapses), then build the result string per spec §4.4.
@@ -540,42 +657,7 @@ export class InstanceManager {
 
     // 1. Wait for terminal state.
     if (!TERMINAL_STATUSES.has(inst.status)) {
-      const reachedTerminal = await new Promise<boolean>((resolve) => {
-        const remaining = Math.max(0, deadline - Date.now());
-        if (remaining === 0) {
-          resolve(false);
-          return;
-        }
-        const timer = setTimeout(() => {
-          unsubscribe();
-          resolve(false);
-        }, remaining);
-        const unsubscribe = this.stream.onSessionEvent(inst.sessionId, (ev) => {
-          if (
-            ev.type === "session.idle" ||
-            ev.type === "session.error"
-          ) {
-            clearTimeout(timer);
-            unsubscribe();
-            resolve(true);
-            return;
-          }
-          // Also resolve on tool-cap / loop-guard (which we set ourselves).
-          const cur = this.instances.get(instanceId);
-          if (cur && TERMINAL_STATUSES.has(cur.status)) {
-            clearTimeout(timer);
-            unsubscribe();
-            resolve(true);
-          }
-        });
-        // Re-check after subscribing in case the state already changed.
-        const cur = this.instances.get(instanceId);
-        if (cur && TERMINAL_STATUSES.has(cur.status)) {
-          clearTimeout(timer);
-          unsubscribe();
-          resolve(true);
-        }
-      });
+      const reachedTerminal = await this.waitForTerminal(instanceId, deadline);
       if (!reachedTerminal) {
         // Timed out. Return what we have.
         const final = this.instances.get(instanceId);
@@ -599,7 +681,11 @@ export class InstanceManager {
     }
 
     // 2. Build the result. Fetch messages from the opencode server and
-    //    concatenate the assistant text parts.
+    //    concatenate the assistant text parts. In bg-only mode there is
+    //    no HTTP client to ask, so we fall back to whatever
+    //    `resultPreview` was captured during the run (often empty
+    //    because there is no SSE stream in bg-only mode — the runner
+    //    writes the raw output to the log file instead).
     const final = this.instances.get(instanceId);
     if (!final) {
       throw new Error(`collect: instance ${instanceId} disappeared`);
@@ -695,13 +781,19 @@ export class InstanceManager {
         completedAt: Date.now(),
       });
     }
-    // Phase 2: best-effort aborts in parallel, 5s per call.
-    const abortPromises = live.map((inst) =>
-      withTimeout(this.http.abortSession(inst.sessionId, this.worktree), 5_000).catch(
-        () => undefined,
-      ),
-    );
-    await Promise.allSettled(abortPromises);
+    // Phase 2: best-effort aborts in parallel, 5s per call. In bg-only
+    // mode there is no HTTP client to ask — the runner owns the
+    // subprocess lifecycle, so the in-memory status flip is the only
+    // signal we can emit. Skipped cleanly when http is null.
+    if (this.http !== null) {
+      const abortPromises = live.map((inst) =>
+        withTimeout(
+          this.http!.abortSession(inst.sessionId, this.worktree),
+          5_000,
+        ).catch(() => undefined),
+      );
+      await Promise.allSettled(abortPromises);
+    }
     this.logger.info(`bizar: shutdownAll complete (${live.length} instances aborted)`);
   }
 
@@ -721,9 +813,13 @@ export class InstanceManager {
     );
     // Fire-and-forget. If the serve child is dead, this returns a
     // failure result but we still mark the instance failed in-memory.
-    this.http
-      .abortSession(inst.sessionId, this.worktree)
-      .catch(() => undefined);
+    // v0.8.0 — bg-only mode has no HTTP client; the abort is a no-op
+    // there (the runner owns the subprocess).
+    if (this.http !== null) {
+      this.http
+        .abortSession(inst.sessionId, this.worktree)
+        .catch(() => undefined);
+    }
     await this.update(inst.instanceId, {
       status: "failed",
       error: `No activity for ${this.stallTimeoutMs}ms — LLM appears stalled`,
@@ -751,15 +847,25 @@ export class InstanceManager {
       `bizar: instance ${inst.instanceId} thinking loop (${sinceMs}ms without tool/text); sending intervention #${currentCount + 1}/${this.maxInterventions}`,
     );
     try {
-      await this.http.sendPrompt(
-        {
-          sessionId: inst.sessionId,
-          messageID,
-          agent: inst.agent,
-          parts: [{ type: "text", text: prompt }],
-        },
-        this.worktree,
-      );
+      // v0.8.0 — bg-only mode has no HTTP client; interventions are a
+      // no-op there (the runner doesn't expose a "send a user message
+      // mid-run" hook). Logged as a debug so the operator can see why
+      // no intervention went out.
+      if (this.http === null) {
+        this.logger.debug(
+          `bizar: skipping intervention for ${inst.sessionId} (bg-only mode; no HTTP client)`,
+        );
+      } else {
+        await this.http.sendPrompt(
+          {
+            sessionId: inst.sessionId,
+            messageID,
+            agent: inst.agent,
+            parts: [{ type: "text", text: prompt }],
+          },
+          this.worktree,
+        );
+      }
     } catch (err: unknown) {
       // We swallow the error: the periodic checker will try again next
       // tick. The intervention counter is still incremented below so
@@ -793,9 +899,13 @@ export class InstanceManager {
     this.logger.warn(
       `bizar: instance ${inst.instanceId} thinking loop exhausted ${this.maxInterventions} intervention(s) over ${sinceMs}ms; aborting`,
     );
-    this.http
-      .abortSession(inst.sessionId, this.worktree)
-      .catch(() => undefined);
+    // v0.8.0 — bg-only mode has no HTTP client; the abort is a no-op
+    // there (the runner owns the subprocess).
+    if (this.http !== null) {
+      this.http
+        .abortSession(inst.sessionId, this.worktree)
+        .catch(() => undefined);
+    }
     await this.update(inst.instanceId, {
       status: "failed",
       error: `Thinking loop detected: ${formatDuration(sinceMs)} of thinking without tool calls or output. Spawn a Mimir agent for research.`,
@@ -809,6 +919,8 @@ export class InstanceManager {
 
   public attachEventHandler(inst: BackgroundState): () => void {
     this.detachEventHandler(inst.instanceId);
+    // v0.8.0 — bg-only mode has no EventStream; return a no-op unsubscriber.
+    if (!this.stream) return () => {};
     const handler: SessionEventHandler = (ev: StreamEvent) => {
       void this.handleInstanceEvent(inst.instanceId, ev);
     };
@@ -935,9 +1047,13 @@ export class InstanceManager {
       if (nextCount >= this.toolCallCap) {
         // Abort and mark failed. Use a fire-and-forget abort because we
         // do not want to block the handler on a network call.
-        this.http
-          .abortSession(inst.sessionId, this.worktree)
-          .catch(() => undefined);
+        // v0.8.0 — bg-only mode has no HTTP client; the abort is a
+        // no-op there (the runner owns the subprocess).
+        if (this.http !== null) {
+          this.http
+            .abortSession(inst.sessionId, this.worktree)
+            .catch(() => undefined);
+        }
         patch.status = "failed";
         patch.error = `Tool-call cap reached (${nextCount}). Aborted to prevent cost runaway.`;
         patch.completedAt = Date.now();
@@ -995,6 +1111,9 @@ export class InstanceManager {
    *   - If `loopGuardTool` is set, prepend the marker.
    */
   private async buildResultText(inst: BackgroundState): Promise<string> {
+    // v0.8.0 — bg-only mode has no HTTP client; fall back to whatever
+    // text-part preview we've already accumulated.
+    if (!this.http) return inst.resultPreview ?? "";
     const res = await this.http.listMessages(inst.sessionId, this.worktree);
     if (!res.ok) {
       this.logger.warn(`bizar: collect: listMessages failed: ${res.error}`);

package/src/opencode-runner.ts

@@ -105,6 +105,47 @@ const agents = new Map<number, AgentRecord>();
 
 // --- Public API -----------------------------------------------------------
 
+/**
+ * Pure: build the argv array for `opencode run` from SpawnAgentOptions.
+ *
+ * Extracted from spawnAgent so it can be unit-tested without spawning
+ * a real process. Throws when opts.agent is empty — `opencode run`
+ * requires a known agent name; passing an empty string would silently
+ * fall back to opencode's default agent and break session attribution
+ * (the title prefix `bgr:<agent>:...` would also degrade to `bgr::...`).
+ *
+ * Arg layout (matches `opencode run --help`):
+ *   opencode run
+ *     --dir <worktree>
+ *     --print-logs
+ *     --log-level INFO
+ *     --title <title>
+ *     --agent <agent>          ← REQUIRED; was missing pre-v0.8.1
+ *     [--model <providerID>/<modelID>]   ← optional override
+ *     -- <prompt>
+ */
+export function buildOpencodeRunArgs(opts: SpawnAgentOptions): string[] {
+  if (!opts.agent) {
+    throw new Error("bizar_spawn_background: agent is required");
+  }
+  const args: string[] = [
+    "opencode",
+    "run",
+    "--dir", opts.worktree,
+    "--print-logs",
+    "--log-level", "INFO",
+    "--title", opts.title || `bgr:${opts.agent}:${Date.now()}`,
+    "--agent", opts.agent,
+  ];
+  if (opts.model) {
+    args.push("--model", `${opts.model.providerID}/${opts.model.modelID}`);
+  }
+  // `--` separates flags from positional so a prompt starting with
+  // `-` is treated as a message.
+  args.push("--", opts.prompt);
+  return args;
+}
+
 /**
  * Spawn a single `opencode run` process. The promise resolves once
  * the opencode child has reported its session id in the structured
@@ -128,23 +169,10 @@ export async function spawnAgent(opts: SpawnAgentOptions): Promise<SpawnAgentRes
     }
   }
 
-  // 2. Build argv. Note: opencode run takes the prompt as a positional
-  // arg. `--dir` sets the worktree. `--print-logs` ensures the
-  // structured log stream goes to stderr.
-  const args: string[] = [
-    "opencode",
-    "run",
-    "--dir", opts.worktree,
-    "--print-logs",
-    "--log-level", "INFO",
-    "--title", opts.title || `bgr:${opts.agent}:${Date.now()}`,
-  ];
-  if (opts.model) {
-    args.push("--model", `${opts.model.providerID}/${opts.model.modelID}`);
-  }
-  // `--` separates flags from positional so a prompt starting with
-  // `-` is treated as a message.
-  args.push("--", opts.prompt);
+  // 2. Build argv. Pulled into a pure function so tests can assert the
+  //    flag layout (notably the `--agent` flag and the migrated model
+  //    ID format) without spawning a real `opencode run` process.
+  const args = buildOpencodeRunArgs(opts);
 
   // 3. Spawn the process.
   let proc: Subprocess;
@@ -227,8 +255,8 @@ export async function spawnAgent(opts: SpawnAgentOptions): Promise<SpawnAgentRes
   // 6. Stream readers + exit handler — install BEFORE returning the
   //    promise so a fast-exiting process still produces a clean
   //    resolution.
-  const stderrReader = (proc.stderr as ReadableStream<Uint8Array>).getReader();
-  const stdoutReader = (proc.stdout as ReadableStream<Uint8Array>).getReader();
+  const stderrReader = (proc.stderr as ReadableStream<Uint8Array>).getReader() as unknown as ReadableStreamDefaultReader<Uint8Array<ArrayBufferLike>>;
+  const stdoutReader = (proc.stdout as ReadableStream<Uint8Array>).getReader() as unknown as ReadableStreamDefaultReader<Uint8Array<ArrayBufferLike>>;
   void readStream(stderrReader, "stderr");
   void readStream(stdoutReader, "stdout");
 

package/tests/attach-handler-bug.test.ts

@@ -88,7 +88,7 @@ function makeDraft(overrides: Partial<BackgroundState> = {}): BackgroundState {
     agent: "mimir",
     status: "pending",
     startedAt: Date.now(),
-    model: "openrouter/minimax-m3",
+    model: "minimax/minimax-m3",
     promptPreview: "test",
     resultPreview: undefined,
     resultMessageIds: [],
@@ -124,6 +124,7 @@ describe("InstanceManager.add — empty sessionId (BUGFIX v0.5.1)", () => {
         warn: () => {},
         error: () => {},
       } as never,
+      worktree: os.tmpdir(),
       serve: { worktree: os.tmpdir() } as never,
       http: {} as never,
       stream: stream as never,

package/tests/background-state.test.ts

@@ -40,7 +40,7 @@ function makeState(overrides: Partial<BackgroundState> = {}): BackgroundState {
     agent: "mimir",
     status: "running",
     startedAt: Date.now(),
-    model: "openrouter/minimax-m3",
+    model: "minimax/minimax-m3",
     promptPreview: "Do the thing",
     resultPreview: undefined,
     resultMessageIds: [],

package/tests/background.test.ts

@@ -22,7 +22,7 @@ function makeBgState(overrides: Partial<BackgroundState> = {}): BackgroundState
     agent: "mimir",
     status: "pending",
     startedAt: Date.now(),
-    model: "openrouter/minimax-m3",
+    model: "minimax/minimax-m3",
     promptPreview: "Do the thing",
     resultPreview: undefined,
     resultMessageIds: [],

package/tests/stall-think.test.ts

@@ -162,7 +162,7 @@ describe("BackgroundState schema backfill", () => {
       agent: "mimir",
       status: "running",
       startedAt,
-      model: "openrouter/minimax-m3",
+      model: "minimax/minimax-m3",
       promptPreview: "Do the thing",
       toolCallCount: 0,
       parentAgent: "odin",
@@ -189,7 +189,7 @@ describe("BackgroundState schema backfill", () => {
       agent: "mimir",
       status: "running",
       startedAt,
-      model: "openrouter/minimax-m3",
+      model: "minimax/minimax-m3",
       promptPreview: "Do the thing",
       toolCallCount: 0,
       parentAgent: "odin",
@@ -216,7 +216,7 @@ describe("BackgroundState schema backfill", () => {
       agent: "mimir",
       status: "running",
       startedAt,
-      model: "openrouter/minimax-m3",
+      model: "minimax/minimax-m3",
       promptPreview: "Do the thing",
       toolCallCount: 0,
       parentAgent: "odin",
@@ -437,7 +437,7 @@ function makeBgState(overrides: Partial<BackgroundState> = {}): BackgroundState
     agent: "mimir",
     status: "running",
     startedAt: now,
-    model: "openrouter/minimax-m3",
+    model: "minimax/minimax-m3",
     promptPreview: "Do the thing",
     resultPreview: undefined,
     resultMessageIds: [],
@@ -700,7 +700,7 @@ describe("bg-status toView — v0.3.0 fields", () => {
       agent: "mimir",
       status: "running",
       startedAt: now - 600_000,
-      model: "openrouter/minimax-m3",
+      model: "minimax/minimax-m3",
       promptPreview: "Research X",
       toolCallCount: 0,
       parentAgent: "odin",
@@ -729,7 +729,7 @@ describe("bg-status toView — v0.3.0 fields", () => {
       agent: "mimir",
       status: "running",
       startedAt: now,
-      model: "openrouter/minimax-m3",
+      model: "minimax/minimax-m3",
       promptPreview: "Research Y",
       toolCallCount: 0,
       parentAgent: "odin",

package/tests/tools/bg-spawn.test.ts

@@ -27,13 +27,13 @@ function parseModel(model: string | undefined): { providerID: string; modelID: s
   const parts = model.split("/");
   if (parts.length !== 2) {
     throw new Error(
-      `model must be in "providerID/modelID" format (e.g. "openrouter/minimax-m3"). Omit to use the agent's default.`,
+      `model must be in "providerID/modelID" format (e.g. "minimax/minimax-m3"). Omit to use the agent's default.`,
     );
   }
   const [providerID, modelID] = parts;
   if (!providerID || !modelID) {
     throw new Error(
-      `model must be in "providerID/modelID" format (e.g. "openrouter/minimax-m3"). Omit to use the agent's default.`,
+      `model must be in "providerID/modelID" format (e.g. "minimax/minimax-m3"). Omit to use the agent's default.`,
     );
   }
   return { providerID, modelID };
@@ -132,9 +132,9 @@ describe("bizar_spawn_background — Odin-only", () => {
 // ---------------------------------------------------------------------------
 
 describe("bizar_spawn_background — model parsing (HIGH-3, LOW-34)", () => {
-  it('"openrouter/minimax-m3" parses to { providerID: "openrouter", modelID: "minimax-m3" }', () => {
-    const result = parseModel("openrouter/minimax-m3");
-    expect(result).toEqual({ providerID: "openrouter", modelID: "minimax-m3" });
+  it('"minimax/minimax-m3" parses to { providerID: "minimax", modelID: "minimax-m3" }', () => {
+    const result = parseModel("minimax/minimax-m3");
+    expect(result).toEqual({ providerID: "minimax", modelID: "minimax-m3" });
   });
 
   it('"opencode/deepseek-v4-flash-free" parses correctly', () => {
@@ -168,7 +168,7 @@ describe("bizar_spawn_background — model parsing (HIGH-3, LOW-34)", () => {
 
   it("spawn tool includes parsed model in POST /session body", () => {
     const result = bizarre_spawn_background(
-      { agent: "mimir", prompt: "Do X", model: "openrouter/minimax-m3" },
+      { agent: "mimir", prompt: "Do X", model: "minimax/minimax-m3" },
       { agent: "odin", sessionID: "sess_parent", worktree: "/tmp" },
     );
     expect(result).not.toHaveProperty("error");

package/tests/tools/opencode-runner.test.ts

@@ -0,0 +1,115 @@
+/**
+ * plugins/bizar/tests/tools/opencode-runner.test.ts
+ *
+ * Unit tests for `buildOpencodeRunArgs` — the pure helper extracted
+ * from `plugins/bizar/src/opencode-runner.ts` so the argv passed to
+ * `Bun.spawn(["opencode", "run", ...])` can be asserted without
+ * spawning a real process.
+ *
+ * These tests pin the two regressions that motivated the extraction:
+ *
+ *   1. Bug 1 (HIGH): the `--agent` flag was missing from the args list,
+ *      so `opencode run` silently fell back to the opencode default
+ *      agent and broke session attribution.
+ *
+ *   2. Bug 2 (HIGH): the OpenRouter model IDs were renamed. Tests assert
+ *      the new `minimax/minimax-m3` / `minimax/minimax-m2.7` format so
+ *      a stale `openrouter/minimax-m3` reference is caught immediately.
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+  buildOpencodeRunArgs,
+  type SpawnAgentOptions,
+} from "../../src/opencode-runner";
+
+function baseOpts(overrides: Partial<SpawnAgentOptions> = {}): SpawnAgentOptions {
+  return {
+    agent: "thor",
+    prompt: "Investigate the auth module",
+    worktree: "/tmp/worktree",
+    logPath: "/tmp/worktree/.bgr/log.log",
+    ...overrides,
+  };
+}
+
+describe("buildOpencodeRunArgs — Bug 1 regression: --agent flag", () => {
+  it("argv contains the --agent flag followed by the agent name", () => {
+    const args = buildOpencodeRunArgs(baseOpts({ agent: "thor" }));
+    const i = args.indexOf("--agent");
+    expect(i).toBeGreaterThanOrEqual(0);
+    expect(args[i + 1]).toBe("thor");
+  });
+
+  it("--agent value matches opts.agent exactly (no default fallback)", () => {
+    for (const agent of ["mimir", "thor", "tyr", "heimdall", "hermod"]) {
+      const args = buildOpencodeRunArgs(baseOpts({ agent }));
+      expect(args[args.indexOf("--agent") + 1]).toBe(agent);
+    }
+  });
+
+  it("throws a clear error when opts.agent is empty", () => {
+    expect(() => buildOpencodeRunArgs(baseOpts({ agent: "" }))).toThrow(
+      /agent is required/,
+    );
+  });
+});
+
+describe("buildOpencodeRunArgs — Bug 2 regression: migrated model ID", () => {
+  it("emits --model with the migrated 'minimax/minimax-m3' ID", () => {
+    const args = buildOpencodeRunArgs(
+      baseOpts({
+        model: { providerID: "minimax", modelID: "minimax-m3" },
+      }),
+    );
+    const i = args.indexOf("--model");
+    expect(i).toBeGreaterThanOrEqual(0);
+    expect(args[i + 1]).toBe("minimax/minimax-m3");
+    // The full flag pair proves the migration target — the OLD ID would
+    // be 'openrouter/minimax-m3'; the NEW ID is 'minimax/minimax-m3'.
+    expect(args[i + 1]).not.toBe("openrouter/minimax-m3");
+  });
+
+  it("emits --model with the migrated 'minimax/minimax-m2.7' ID", () => {
+    const args = buildOpencodeRunArgs(
+      baseOpts({
+        model: { providerID: "minimax", modelID: "minimax-m2.7" },
+      }),
+    );
+    expect(args[args.indexOf("--model") + 1]).toBe("minimax/minimax-m2.7");
+  });
+
+  it("omits --model entirely when opts.model is not provided", () => {
+    const args = buildOpencodeRunArgs(baseOpts({ model: undefined }));
+    expect(args).not.toContain("--model");
+  });
+});
+
+describe("buildOpencodeRunArgs — arg layout", () => {
+  it("starts with 'opencode' 'run'", () => {
+    const args = buildOpencodeRunArgs(baseOpts());
+    expect(args[0]).toBe("opencode");
+    expect(args[1]).toBe("run");
+  });
+
+  it("appends prompt after the -- separator", () => {
+    const args = buildOpencodeRunArgs(baseOpts({ prompt: "do the thing" }));
+    const sep = args.indexOf("--");
+    expect(sep).toBeGreaterThanOrEqual(0);
+    expect(args[sep + 1]).toBe("do the thing");
+  });
+
+  it("uses opts.title when provided, else defaults to bgr:<agent>:<ts>", () => {
+    const a = buildOpencodeRunArgs(baseOpts({ title: "custom title" }));
+    expect(a[a.indexOf("--title") + 1]).toBe("custom title");
+
+    const b = buildOpencodeRunArgs(baseOpts({ agent: "mimir" }));
+    expect(b[b.indexOf("--title") + 1]).toMatch(/^bgr:mimir:\d+$/);
+  });
+
+  it("wires --dir to opts.worktree and --log-level to INFO", () => {
+    const args = buildOpencodeRunArgs(baseOpts({ worktree: "/srv/repo" }));
+    expect(args[args.indexOf("--dir") + 1]).toBe("/srv/repo");
+    expect(args[args.indexOf("--log-level") + 1]).toBe("INFO");
+  });
+});

package/tests/update-deadlock.test.ts

@@ -75,6 +75,7 @@ function createManager(stateDir: string): {
     maxConcurrent: 8,
     toolCallCap: 250,
     logger,
+    worktree: "/tmp",
     serve: { worktree: "/tmp" } as never,
     http: {} as never,
     stream: new FakeEventStream() as never,