@polderlabs/bizar-plugin 0.8.0 → 0.8.2

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

@@ -126,7 +126,11 @@ import { SettingsStore } from "./src/settings.js";
 import { parseSlashCommand } from "./src/commands.js";
 import { createPlanActionTool } from "./src/tools/plan-action.js";
 import { createWaitForFeedbackTool } from "./src/tools/wait-for-feedback.js";
-import { stripInlineThinkBlocks } from "./src/reasoning-clean.js";
+import {
+  stripInlineThinkBlocks,
+  wrapFetchForReasoningCleanup,
+  type FetchLike,
+} from "./src/reasoning-clean.js";
 
 // v0.5.0 — visual plan wiring: side-effect executor + plan-fs
 import { executeSideEffect, type ExecuteOptions } from "./src/commands-impl.js";
@@ -223,6 +227,45 @@ let streamHandle: EventStream | null = null;
 let loggerHandle: Logger | null = null;
 const signalHandlerRefs = new Map<"SIGTERM" | "SIGINT", () => void>();
 
+/** v0.6.2 — Set to `true` after the first time we wrap `globalThis.fetch`
+ *  with the reasoning-clean wrapper. Subsequent calls in the same process
+ *  are no-ops, so a plugin reload cannot double-wrap. */
+let fetchWrapInstalled = false;
+
+/**
+ * v0.6.2 — Reasoning directive. Install the reasoning-clean fetch wrap
+ * on `globalThis.fetch`. The wrap strips inline ``...</think>` (and the
+ * other recognised variants — see `src/reasoning-clean.ts`) from
+ * chat-completions responses targeting `openrouter`/`minimax`, while
+ * leaving the structured `reasoning` / `reasoning_details` fields
+ * intact.
+ *
+ * This is the workaround for the fact that opencode 1.17.9 does not
+ * fire the `config` hook in this runtime (the SDK type declares it, but
+ * the host never calls it). By the time the host would call `config`,
+ * the plugin would already be past init — and the AI SDK is already
+ * using the unwrapped fetch. So we wrap fetch once, globally, as the
+ * plugin initialises. Subsequent reloads in the same process are a
+ * no-op thanks to the `fetchWrapInstalled` flag.
+ */
+function installFetchReasoningCleanup(logger: Logger): void {
+  if (fetchWrapInstalled) return;
+  const original = globalThis.fetch;
+  if (typeof original !== "function") {
+    logger.warn("bizar: globalThis.fetch is not a function; reasoning-clean wrap skipped");
+    return;
+  }
+  const wrapped = wrapFetchForReasoningCleanup(
+    original.bind(globalThis) as FetchLike,
+    {
+      debug: (msg) => logger.debug(msg),
+    },
+  );
+  globalThis.fetch = wrapped as typeof globalThis.fetch;
+  fetchWrapInstalled = true;
+  logger.info("bizar: reasoning-clean fetch wrap installed (openrouter/minimax)");
+}
+
 // --- Plugin entry point ---------------------------------------------------
 
 /**
@@ -319,6 +362,16 @@ async function init(
     logger.warn(`bizar: ${note}`);
   }
 
+  // v0.6.2 — Reasoning directive. Wrap globalThis.fetch so that inline
+  // ``...</think>` blocks in chat completions responses
+  // from openrouter/minimax providers are stripped from `content` even
+  // when the model also emits structured reasoning. The `config` hook
+  // in the opencode plugin API is declared in the SDK type but does NOT
+  // fire in 1.17.9 (confirmed via debug probe 2026-06-24), so we wrap
+  // fetch globally as a fallback. Idempotent — only the first call in
+  // this process actually wraps.
+  installFetchReasoningCleanup(logger);
+
   const stateStore = new StateStore(options.stateDir, logger);
   const settingsStore = new SettingsStore(options.stateDir, logger);
   const logWriter = new LogWriter(options.logDir, options.logRotationBytes, logger);
@@ -443,6 +496,7 @@ let bgAvailable = false;
         maxConcurrent,
         toolCallCap,
         logger,
+        worktree: input.worktree,
         serve,
         http,
         stream,
@@ -757,22 +811,30 @@ function buildHooks(ctx: RuntimeContext, bg: BgDeps): Hooks {
   // sees the same thinking text twice — once in the proper panel and
   // again as visible message text below it.
   //
-  // The opencode plugin API in this version does NOT trigger a
-  // `config` hook (the `wrap-fetch` workaround from v0.6.1 is dead
-  // code in current builds), so we cannot post-process the response
-  // stream. The only working hooks that can help are:
+  // Defence in depth (three layers, in order of impact):
+  //
+  //   1. `installFetchReasoningCleanup` (init-time) — wraps
+  //      `globalThis.fetch` with `wrapFetchForReasoningCleanup` from
+  //      `src/reasoning-clean.ts`. The wrap strips the inline ``
+  //      blocks from chat-completions responses to `openrouter` /
+  //      `minimax` while leaving the structured reasoning fields
+  //      alone. This is the only layer that fixes the CURRENT
+  //      response in-flight. The opencode plugin API in 1.17.9 declares
+  //      a `config` hook in the SDK type but does not actually fire it
+  //      (confirmed via debug probe 2026-06-24), so we wrap fetch
+  //      globally instead.
   //
-  //   1. `experimental.chat.system.transform` — runs every turn; we
+  //   2. `experimental.chat.system.transform` — runs every turn; we
   //      push a directive telling the model to put thinking in the
   //      structured field only.
-  //   2. `experimental.chat.messages.transform` — runs before each
+  //
+  //   3. `experimental.chat.messages.transform` — runs before each
   //      request; we strip `` blocks from previous assistant
   //      messages so the model sees clean history and is less likely
   //      to keep emitting inline ``.
   //
-  // Neither fixes the CURRENT response (the model has already
-  // returned), but together they strongly reduce — and in many cases
-  // eliminate — the duplication on subsequent turns.
+  // Layers 2 and 3 reduce the frequency of the leak; layer 1 strips
+  // any leak that still slips through.
   const REASONING_DIRECTIVE_MARKER = "BIZAR_REASONING_DIRECTIVE_v0.6.2";
   const REASONING_DIRECTIVE = [
     REASONING_DIRECTIVE_MARKER,
@@ -903,6 +965,40 @@ function buildHooks(ctx: RuntimeContext, bg: BgDeps): Hooks {
       }
     },
 
+    // v0.6.2 — Reasoning directive. Strip inline `` blocks
+    // from the FINAL text of each completed assistant text part. This is
+    // the post-processing layer that fixes the CURRENT response in cases
+    // where the model emits its chain-of-thought in BOTH the structured
+    // `reasoning` field AND inline in `content` (the M3-via-OpenRouter
+    // leak). opencode's openrouter SDK does not strip the inline blocks,
+    // so we do it here at the boundary between the SDK output and the
+    // UI rendering. The `config` hook that the SDK type declares for
+    // fetch-level wrapping does NOT fire in 1.17.9, and the AI SDK
+    // uses `Bun.fetch` (read-only) rather than `globalThis.fetch`, so a
+    // fetch wrap is a no-op in this runtime. `experimental.text.complete`
+    // is the working alternative — it runs on every completed text
+    // part, with mutable `output.text`. Idempotent: stripping already-
+    // cleaned text is a no-op.
+    "experimental.text.complete": async (input, output) => {
+      try {
+        const original = output.text;
+        if (typeof original !== "string" || !original.includes("<think>")) return;
+        const cleaned = stripInlineThinkBlocks(original);
+        if (cleaned !== original) {
+          output.text = cleaned;
+          ctx.logger.debug(
+            `bizar: text.complete stripped think blocks (session=${input.sessionID} message=${input.messageID} part=${input.partID} ${original.length}→${cleaned.length}B)`,
+          );
+        }
+      } catch (err) {
+        ctx.logger.warn(
+          `bizar: text.complete failed (passing through): ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+        );
+      }
+    },
+
     // §3.1, §4.5.1 — event: track session boundaries. We do NOT create
     // the state file here (canonical lifecycle: file is created at the
     // `chat.message` seed, per spec §4.5.1).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar-plugin",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "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 tests/reasoning-clean.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");