@polderlabs/bizar-plugin 0.6.2 → 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

@@ -98,6 +98,7 @@ import type { Plugin, Hooks, PluginInput, PluginOptions } from "@opencode-ai/plu
 import { createLogger, type Logger } from "./src/logger.js";
 import { decide, isLogOnlyWarn } from "./src/loop.js";
 import { fingerprint } from "./src/fingerprint.js";
+import { createDashboardPublisher, type DashboardPublisher } from "./src/dashboard-client.js";
 import { StateStore, type SessionState } from "./src/state.js";
 import { LogWriter } from "./src/report.js";
 import {
@@ -244,6 +245,10 @@ interface RuntimeContext {
   seenMessageIds: Map<string, Set<string>>;
   /** sessionID → pending system-transform message, set at warn/escalate. */
   pendingInjections: Map<string, string>;
+  /** v0.7.0-alpha.1 — Dashboard publisher (or null if disabled/not started).
+   *  Used by the `event` hook to forward opencode session lifecycle
+   *  events to the v2 dashboard via the @polderlabs/bizar-sdk. */
+  dashboardPublisher: DashboardPublisher | null;
 }
 
 /**
@@ -333,10 +338,11 @@ async function init(
 
   // --- Background agents (v0.4.2) -----------------------------------------
 
-  let instanceManager: InstanceManager | null = null;
-  let serve: ServeLifecycle | null = null;
-  let stream: EventStream | null = null;
-  let bgAvailable = false;
+let instanceManager: InstanceManager | null = null;
+let serve: ServeLifecycle | null = null;
+let stream: EventStream | null = null;
+let dashboardPublisher: DashboardPublisher | null = null;
+let bgAvailable = false;
 
   if (readServeDisabled()) {
     logger.info("bizar: background agents disabled via BIZAR_SERVE_DISABLE=1");
@@ -394,11 +400,50 @@ async function init(
       });
       streamHandle = stream;
 
+      // v0.7.0-alpha.1 — Wire dashboard publisher to the EventStream so
+      // every opencode SSE event is also published to the v2 dashboard.
+      // The publisher gracefully degrades if the dashboard is unreachable
+      // (queues, retries, warns; never throws into the plugin).
+      try {
+        const pub = createDashboardPublisher({
+          logger,
+        });
+        await pub.start();
+        dashboardPublisher = pub;
+        stream.onEvent((event) => {
+          // Translate opencode StreamEvent → DashboardEvent shape.
+          // The dashboard only cares about the wire-level (type, properties)
+          // so we forward { type, properties } directly. Cast through
+          // `unknown` because the opencode event shape doesn't exactly
+          // match the SDK's discriminated DashboardEvent — it's a
+          // forward-compatible passthrough.
+          const dashEvent = {
+            type: event.type,
+            properties: { ...event },
+          } as unknown as Parameters<DashboardPublisher["publish"]>[0];
+          void pub.publish(dashEvent);
+        });
+        // Stop the publisher when the stream is disposed.
+        const origDisconnect = stream.disconnect.bind(stream);
+        stream.disconnect = async () => {
+          await origDisconnect();
+          pub.stop();
+        };
+        logger.info("bizar: dashboard publisher wired to EventStream (v2 protocol)");
+      } catch (err) {
+        logger.warn(
+          `bizar: dashboard publisher failed to start: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+        );
+      }
+
       instanceManager = new InstanceManager({
         stateStore: bgStateStore,
         maxConcurrent,
         toolCallCap,
         logger,
+        worktree: input.worktree,
         serve,
         http,
         stream,
@@ -469,6 +514,7 @@ async function init(
     directory: input.directory,
     seenMessageIds: new Map(),
     pendingInjections: new Map(),
+    dashboardPublisher,
   };
 
   return buildHooks(ctx, { instanceManager, bgAvailable });
@@ -772,9 +818,13 @@ function buildHooks(ctx: RuntimeContext, bg: BgDeps): Hooks {
   const tools = bg.instanceManager
     ? {
         ...basePlanTools,
+        // v0.8.0 — bg-spawn no longer needs the HTTP client. It
+        // spawns an `opencode run` subprocess per agent (see
+        // src/opencode-runner.ts). The serve child is still
+        // available for the dashboard's v2 protocol and for any
+        // TUI/web client that wants to attach to it.
         bizar_spawn_background: createBgSpawnTool({
           instanceManager: bg.instanceManager,
-          http: (bg.instanceManager as unknown as { http: HttpClient }).http,
           worktree: ctx.worktree,
           logger: ctx.logger,
         }),
@@ -859,10 +909,37 @@ function buildHooks(ctx: RuntimeContext, bg: BgDeps): Hooks {
     // `chat.message` seed, per spec §4.5.1).
     event: async ({ event }) => {
       try {
-        const ev = event as { type?: string; sessionID?: string };
+        // v0.7.0-alpha.1 — opencode's event object has { type: string,
+        // properties: { sessionID: string, ... } }. The legacy plugin
+        // assumed `event.sessionID` was top-level (which is wrong), so
+        // the hook returned early for every event. We extract from
+        // BOTH locations to be robust across opencode versions, and
+        // publish to the dashboard regardless.
+        const ev = event as {
+          type?: string;
+          sessionID?: string;
+          properties?: { sessionID?: string; [k: string]: unknown };
+        };
         const type = ev.type;
-        const sessionID = ev.sessionID;
-        if (!type || !sessionID) return;
+        const sessionID = ev.sessionID ?? ev.properties?.sessionID;
+        if (!type) return;
+
+        // v0.7.0-alpha.1 — Forward every opencode event to the dashboard.
+        // The plugin SDK does NOT translate opencode events to the SDK's
+        // discriminated DashboardEvent shape (it's a forward-compatible
+        // passthrough — the dashboard is happy with any {type, properties}
+        // event object). The publish is fire-and-forget; failures are
+        // logged and swallowed inside the publisher.
+        if (ctx.dashboardPublisher !== null) {
+          const dashEvent = {
+            type,
+            properties: { ...ev },
+          } as unknown as Parameters<DashboardPublisher["publish"]>[0];
+          void ctx.dashboardPublisher.publish(dashEvent);
+        }
+
+        // Legacy logic below: only runs when we have a sessionID.
+        if (!sessionID) return;
 
         if (type === "session.deleted") {
           await ctx.stateStore.withLock(sessionID, async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar-plugin",
-  "version": "0.6.2",
+  "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",
@@ -26,6 +26,7 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@polderlabs/bizar-sdk": "*",
     "zod": "4.1.8"
   },
   "devDependencies": {

package/src/background-state.ts

@@ -107,8 +107,32 @@ export type BackgroundStatus =
  *   - `restartCount` — number of times this instance has been
  *     auto-restarted (not including the original spawn). Default 0.
  *   - `maxRestarts` — cap; default 3.
- *   - `lastRestartAt` — epoch ms of the most recent auto-restart.
- */
+   * - `lastRestartAt` — epoch ms of the most recent auto-restart.
+   * - `processId` (v0.8.0) — PID of the opencode run subprocess. Set
+   *   by the opencode-runner after `Bun.spawn` returns. Optional
+   *   for backward compat.
+   * - `exitCode` (v0.8.0) — exit code of the opencode run
+   *   subprocess. Populated when the process exits.
+   * - `runnerState` (v0.8.0) — free-form status from the runner
+   *   ("starting" | "running" | "done" | "failed" | "killed").
+   *   Allows the dashboard to show runner-level state separately
+   *   from the higher-level `status`.
+   * - `runnerError` (v0.8.0) — opencode run subprocess error (e.g.
+   *   "opencode run exited with code 1").
+   * - `spawnMessage` (v0.8.0) — "you can continue" message returned
+   *   to the LLM by the spawn tool. Surfaces in the dashboard.
+   * - `spawnNextSteps` (v0.8.0) — list of next-step hints returned
+   *   to the LLM by the spawn tool.
+   * - `sessionIdAt` (v0.8.0) — when the opencode sessionId was
+   *   first observed in the subprocess stderr.
+   * - `runnerStartedAt` / `runnerEndedAt` — when the subprocess
+   *   started / ended (subset of `startedAt`/`completedAt`).
+   * - `spawnedAt` — when the bg-spawn tool recorded the instance.
+   *   Distinct from `startedAt` because the runner starts a
+   *   tick or two later.
+   * - `exitSignal` — exit signal name (e.g. "SIGTERM",
+   *   "SIGKILL") if the subprocess was killed.
+   */
 export interface BackgroundState {
   instanceId: string;
   sessionId: string;
@@ -153,6 +177,18 @@ export interface BackgroundState {
    * `{ ok: false }`. Cleared on a successful restart.
    */
   restartError?: string;
+  // v0.8.0 — process tracking (see opencode-runner.ts).
+  processId?: number;
+  exitCode?: number;
+  runnerState?: string;
+  runnerError?: string;
+  spawnMessage?: string;
+  spawnNextSteps?: string[];
+  sessionIdAt?: number;
+  runnerStartedAt?: number;
+  runnerEndedAt?: number;
+  spawnedAt?: number;
+  exitSignal?: string;
 }
 
 /**

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);
     };
@@ -866,6 +978,19 @@ export class InstanceManager {
     }
   }
 
+  /**
+   * v0.8.0 — Public version of `_maybeAutoRestart`. The opencode-runner
+   * (see src/opencode-runner.ts) calls this from its onExit callback
+   * when a `bizar_spawn_background` subprocess exits. Without this,
+   * persistent instances would never auto-restart under the new
+   * subprocess-based path (the SSE event handler that previously
+   * triggered auto-restart is no longer wired up because we don't
+   * subscribe to per-session events anymore).
+   */
+  async maybeAutoRestart(instanceId: string): Promise<void> {
+    await this._maybeAutoRestart(instanceId);
+  }
+
   /** v0.5.5 — Attempt an auto-restart for a persistent failed instance. */
   private async _maybeAutoRestart(instanceId: string): Promise<void> {
     const inst = this.instances.get(instanceId);
@@ -922,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();
@@ -982,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}`);