@polderlabs/bizar-plugin 0.6.0 → 0.6.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: "minimax/MiniMax-M3",     // optional: override model
+  model: "openrouter/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

@@ -125,9 +125,12 @@ 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";
 
 // v0.5.0 — visual plan wiring: side-effect executor + plan-fs
 import { executeSideEffect, type ExecuteOptions } from "./src/commands-impl.js";
+import { join as pathJoin } from "node:path";
+import { homedir } from "node:os";
 
 // --- Env-var constants (per spec §8) -------------------------------------
 
@@ -697,6 +700,47 @@ async function listPlanSlugs(worktree: string, logger: Logger): Promise<string[]
  * delegates to the runtime context and the supporting modules.
  */
 function buildHooks(ctx: RuntimeContext, bg: BgDeps): Hooks {
+  // ────────────────────────────────────────────────────────────────────
+  // v0.6.2 — Reasoning directive
+  // ────────────────────────────────────────────────────────────────────
+  // Some reasoning models (notably MiniMax M3 via OpenRouter) emit
+  // their chain-of-thought in BOTH the structured `reasoning` /
+  // `reasoning_details` field AND inline as `` blocks inside
+  // `message.content`. opencode's openrouter SDK extracts the structured
+  // reasoning correctly and renders it as a separate "Thought" panel,
+  // but it does NOT strip the inline blocks from `content`, so the user
+  // 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:
+  //
+  //   1. `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
+  //      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.
+  const REASONING_DIRECTIVE_MARKER = "BIZAR_REASONING_DIRECTIVE_v0.6.2";
+  const REASONING_DIRECTIVE = [
+    REASONING_DIRECTIVE_MARKER,
+    "",
+    "When reasoning is enabled for this conversation, output your thinking",
+    "ONLY in the model's structured reasoning field. Do NOT emit `` blocks",
+    "inline inside your message content — the opencode host extracts the",
+    "reasoning field and renders it as a separate, collapsable \"Thought\"",
+    "panel. If you also emit the same text inline, the user will see your",
+    "thinking twice (once in the panel and once as visible message body).",
+    "Keep the actual response text in the normal content stream.",
+  ].join(" ");
+
   // Build the 7 tools. We always register them; if the serve child is
   // not available, the background tools return a clear error. The
   // bizar_get_plan_comments, bizar_plan_action, and
@@ -704,7 +748,7 @@ function buildHooks(ctx: RuntimeContext, bg: BgDeps): Hooks {
   // work regardless of the serve child's state.
   //
   // v0.4.0 — added `bizar_plan_action` (CRUD on the v2 canvas) and
-  // `bizar_wait_for_feedback` (poll until feedback). Both are pure
+  // bizar_wait_for_feedback (poll until feedback). Both are pure
   // file I/O — no serve child required.
   //
   // v0.5.0 — renamed `bizarre_*` → `bizar_*` (single `r`) to match
@@ -753,9 +797,61 @@ function buildHooks(ctx: RuntimeContext, bg: BgDeps): Hooks {
       };
 
   return {
-    // §3.1 — config: no mutation. We already resolved options in init().
-    config: async () => {
-      // intentionally empty — options are resolved at init time
+    // Push a persistent system-prompt directive that tells reasoning
+    // models to put their thinking in the structured reasoning field
+    // (rendered as a separate "Thought" panel by opencode) rather than
+    // also emitting it inline as `` blocks in the content. The openrouter
+    // SDK does not strip the inline `` blocks, so without this
+    // directive the user sees the reasoning twice — once in the proper
+    // panel and once as visible message text.
+    //
+    // We push the directive only when the marker is absent so we don't
+    // append it on every turn.
+    "experimental.chat.system.transform": async (input, output) => {
+      const sessionID = input.sessionID;
+      if (!sessionID) return;
+      if (!output.system.some((s) => s.includes(REASONING_DIRECTIVE_MARKER))) {
+        output.system.push(REASONING_DIRECTIVE);
+      }
+      // §3.1, §5.4 — handoff injection point. We push a single string
+      // onto `output.system` if a pending injection is queued for this
+      // session.
+      const pending = ctx.pendingInjections.get(sessionID);
+      if (pending) {
+        output.system.push(pending);
+        ctx.pendingInjections.delete(sessionID);
+      }
+    },
+
+    // Before the model is called, strip `` blocks from
+    // any text content in previous assistant messages. This keeps the
+    // model's view of its own history clean of the duplicated thinking
+    // it emitted earlier, reducing the chance it will keep emitting
+    // inline `` on subsequent turns.
+    "experimental.chat.messages.transform": async (_input, output) => {
+      try {
+        const messages = (output as { messages?: unknown }).messages;
+        if (!Array.isArray(messages)) return;
+        for (const msg of messages) {
+          if (!msg || typeof msg !== "object") continue;
+          const m = msg as { role?: unknown; parts?: unknown };
+          if (m.role !== "assistant") continue;
+          if (!Array.isArray(m.parts)) continue;
+          for (const part of m.parts) {
+            if (!part || typeof part !== "object") continue;
+            const p = part as { type?: unknown; text?: unknown };
+            if (p.type === "text" && typeof p.text === "string" && p.text.includes("<think>")) {
+              p.text = stripInlineThinkBlocks(p.text);
+            }
+          }
+        }
+      } catch (err) {
+        ctx.logger.warn(
+          `bizar: messages.transform failed (passing through): ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+        );
+      }
     },
 
     // §3.1, §4.5.1 — event: track session boundaries. We do NOT create
@@ -862,6 +958,29 @@ function buildHooks(ctx: RuntimeContext, bg: BgDeps): Hooks {
                 finalResponse = `Command failed: ${msg}`;
               }
             }
+            // --- v0.5.1: dialog support.
+            // If the command emitted a dialog descriptor, persist it to disk
+            // so Tyr's dialog-poller can broadcast it to the dashboard.
+            // We return without throwing so no chat bubble is shown.
+            if (result.dialog) {
+              // S4 — defense-in-depth: validate ID shape before touching disk.
+              if (!/^dlg_[a-zA-Z0-9_-]{1,64}$/.test(result.dialog.id)) {
+                return; // silently drop malformed dialog IDs
+              }
+              try {
+                const { mkdir, writeFile } = await import("node:fs/promises");
+                const dialogDir = pathJoin(homedir(), ".cache", "bizar", "dialogs");
+                await mkdir(dialogDir, { recursive: true });
+                await writeFile(
+                  pathJoin(dialogDir, `${result.dialog.id}.json`),
+                  JSON.stringify({ ...result.dialog, createdAt: new Date().toISOString() }, null, 2),
+                );
+              } catch (dialogErr: unknown) {
+                const msg = dialogErr instanceof Error ? dialogErr.message : String(dialogErr);
+                ctx.logger.warn(`bizar: failed to write dialog file: ${msg}`);
+              }
+              return;
+            }
             // Surface the response to the user/host. We throw so the
             // message is treated as handled; the LLM does not process
             // it further. The host renders the throw message.
@@ -1045,18 +1164,6 @@ function buildHooks(ctx: RuntimeContext, bg: BgDeps): Hooks {
       }
     },
 
-    // §3.1, §5.4 — handoff injection point. We push a single string onto
-    // `output.system` if a pending injection is queued for this session.
-    "experimental.chat.system.transform": async (input, output) => {
-      const sessionID = input.sessionID;
-      if (!sessionID) return;
-      const pending = ctx.pendingInjections.get(sessionID);
-      if (pending) {
-        output.system.push(pending);
-        ctx.pendingInjections.delete(sessionID);
-      }
-    },
-
     // v0.4.2 — register the 4 background tools.
     tool: tools,
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar-plugin",
-  "version": "0.6.0",
+  "version": "0.6.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",

package/src/background-state.ts

@@ -99,6 +99,15 @@ export type BackgroundStatus =
  *   - `interventionAt` — epoch ms of the most recent intervention.
  *   - `interventionReason` — short human-readable description of the
  *     intervention, e.g. `"thinking loop (5m 12s without tool/text)"`.
+ *
+ * v0.5.5 — persistent auto-restart. These are typed as optional so
+ * existing state files on disk remain valid after upgrade.
+ *   - `persistent` — when true, the manager auto-restarts on terminal
+ *     failure (up to maxRestarts). Default false.
+ *   - `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.
  */
 export interface BackgroundState {
   instanceId: string;
@@ -127,6 +136,23 @@ export interface BackgroundState {
   interventionCount?: number;
   interventionAt?: number;
   interventionReason?: string;
+  // v0.5.5 — persistent auto-restart
+  persistent?: boolean;
+  restartCount?: number;
+  maxRestarts?: number;
+  lastRestartAt?: string;
+  /**
+   * Full original prompt text, stored so the instance can be restarted
+   * with the same input. Optional for backward compat; always set on
+   * new spawns from v0.5.5+.
+   */
+  prompt?: string;
+  /**
+   * Human-readable error from the last failed restart attempt.
+   * Set only when `_maybeAutoRestart` calls `restart()` and it returns
+   * `{ ok: false }`. Cleared on a successful restart.
+   */
+  restartError?: string;
 }
 
 /**
@@ -159,6 +185,10 @@ export const EMPTY_BACKGROUND_STATE: Omit<
   lastEventAt: 0,
   lastToolOrTextAt: 0,
   interventionCount: 0,
+  // v0.5.5 — persistent auto-restart defaults
+  persistent: false,
+  restartCount: 0,
+  maxRestarts: 3,
 };
 
 /**
@@ -314,6 +344,17 @@ function readState(
     if (typeof parsed.interventionCount !== "number") {
       parsed.interventionCount = 0;
     }
+    // v0.5.5 — backfill persistent/restart fields for files written by
+    // older versions. These are optional but the restarter needs them.
+    if (typeof parsed.persistent !== "boolean") {
+      parsed.persistent = false;
+    }
+    if (typeof parsed.restartCount !== "number") {
+      parsed.restartCount = 0;
+    }
+    if (typeof parsed.maxRestarts !== "number") {
+      parsed.maxRestarts = 3;
+    }
     return parsed;
   } catch (err: unknown) {
     logger.log({

package/src/background.ts

@@ -278,6 +278,30 @@ export class InstanceManager {
     }
   }
 
+  // --- Internal dispatch (shared by add() and restart()) ------------------
+
+  /**
+   * Insert a fully-constructed BackgroundState into the in-memory map
+   * and persist to disk asynchronously. Does NOT check the concurrency
+   * cap — the caller handles that.
+   *
+   * This is extracted from `add()` so `restart()` can reuse the same
+   * insert-and-persist path without duplicating the logic.
+   */
+  private dispatchInternal(full: BackgroundState): BackgroundState {
+    this.instances.set(full.instanceId, full);
+    // Persist asynchronously; failure is logged but does not roll back
+    // the in-memory insert (the instance is "tracked" either way).
+    this.stateStore.save(full).catch((err: unknown) => {
+      this.logger.warn(
+        `bizar: failed to persist new instance ${full.instanceId}: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    });
+    return full;
+  }
+
   // --- Atomic add (spec §2.2) ---------------------------------------------
 
   /**
@@ -315,16 +339,7 @@ export class InstanceManager {
         lastToolOrTextAt: now,
         interventionCount: 0,
       };
-      this.instances.set(draft.instanceId, full);
-      // Persist asynchronously; failure is logged but does not roll back
-      // the in-memory insert (the instance is "tracked" either way).
-      this.stateStore.save(full).catch((err: unknown) => {
-        this.logger.warn(
-          `bizar: failed to persist new instance ${draft.instanceId}: ${
-            err instanceof Error ? err.message : String(err)
-          }`,
-        );
-      });
+      this.dispatchInternal(full);
       // BUGFIX (v0.5.1): Do NOT call attachEventHandler() here. The
       // instance was just added with sessionId="" (filled in later by
       // POST /session). EventStream.onSessionEvent rejects empty strings,
@@ -426,6 +441,86 @@ export class InstanceManager {
     });
     this.logger.info(`bizar: killed background instance ${instanceId}`);
   }
+
+  // --- Restart (v0.5.5 — persistent auto-restart) ------------------------
+
+  /**
+   * Re-spawn a failed persistent instance with the same prompt, agent,
+   * and model config. The new instance gets a fresh `instanceId` and is
+   * linked to the original via `parentInstanceId`.
+   *
+   * Returns `{ ok: true, newInstanceId }` on success, or
+   * `{ ok: false, error: "..." }` on failure. Does NOT check the
+   * concurrency cap — the original instance is terminal, so its slot
+   * is already freed.
+   */
+  async restart(instanceId: string): Promise<{
+    ok: boolean;
+    newInstanceId?: string;
+    error?: string;
+  }> {
+    const existing = this.instances.get(instanceId);
+    if (!existing) return { ok: false, error: "instance_not_found" };
+    const totalRestarts = this.getTotalRestartCount(instanceId);
+    if (totalRestarts >= (existing.maxRestarts ?? 3)) {
+      return { ok: false, error: "max_restarts_reached" };
+    }
+
+    const now = Date.now();
+    const newInstanceId = generateInstanceId();
+    const full: BackgroundState = {
+      instanceId: newInstanceId,
+      sessionId: "",
+      agent: existing.agent,
+      model: existing.model,
+      promptPreview: (existing.prompt ?? existing.promptPreview ?? "").slice(0, PROMPT_PREVIEW_MAX),
+      prompt: existing.prompt,
+      parentAgent: existing.parentAgent,
+      parentInstanceId: instanceId,
+      logPath: `${this.worktree}/.opencode/log/${newInstanceId}.log`,
+      timeoutMs: existing.timeoutMs,
+      toolCallCount: 0,
+      // v0.5.5 — persist the auto-restart fields
+      persistent: existing.persistent,
+      maxRestarts: existing.maxRestarts,
+      restartCount: (existing.restartCount ?? 0) + 1,
+      status: "pending",
+      startedAt: now,
+      lastEventAt: now,
+      lastToolOrTextAt: now,
+      interventionCount: 0,
+    };
+
+    this.dispatchInternal(full);
+    this.logger.info(
+      `bizar: restarted instance ${instanceId} as ${newInstanceId} (restart #${full.restartCount})`,
+    );
+    return { ok: true, newInstanceId };
+  }
+
+  /**
+   * Walk the parent chain to compute the true restart count for this
+   * instance (Forseti C4). `restartCount` alone only reflects the child's
+   * own counter, so a chain of restarts can exceed `maxRestarts`. This
+   * helper sums the counters across the entire chain (parent + all
+   * descendants) and returns the total.
+   */
+  private getTotalRestartCount(instanceId: string): number {
+    let current = this.instances.get(instanceId);
+    if (!current) return 0;
+    let count = current.restartCount ?? 0;
+    let parentId = current.parentInstanceId;
+    const visited = new Set<string>([instanceId]);
+    while (parentId && !visited.has(parentId)) {
+      visited.add(parentId);
+      const parent = this.instances.get(parentId);
+      if (!parent) break;
+      count += parent.restartCount ?? 0;
+      parentId = parent.parentInstanceId;
+    }
+    return count;
+  }
+
   // --- Collect ------------------------------------------------------------
 
   /**
@@ -634,6 +729,8 @@ export class InstanceManager {
       error: `No activity for ${this.stallTimeoutMs}ms — LLM appears stalled`,
       completedAt: Date.now(),
     });
+    // v0.5.5 — persistent auto-restart on stall
+    await this._maybeAutoRestart(inst.instanceId);
   }
 
   /**
@@ -704,6 +801,8 @@ export class InstanceManager {
       error: `Thinking loop detected: ${formatDuration(sinceMs)} of thinking without tool calls or output. Spawn a Mimir agent for research.`,
       completedAt: Date.now(),
     });
+    // v0.5.5 — persistent auto-restart on thinking-loop exhaustion
+    await this._maybeAutoRestart(inst.instanceId);
   }
 
   // --- Internal: per-session event handler -------------------------------
@@ -759,6 +858,37 @@ export class InstanceManager {
         error: errMsg,
         completedAt: Date.now(),
       });
+      // v0.5.5 — persistent auto-restart. If the instance is persistent
+      // and was not explicitly killed, try to restart.
+      if (inst.persistent && inst.status !== "killed") {
+        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);
+    if (!inst || !inst.persistent) return;
+    if (inst.status === "killed") return; // user killed it — do not restart
+    this.logger.info(
+      `bizar: persistent instance ${instanceId} failed; auto-restarting`,
+    );
+    const result = await this.restart(instanceId);
+    if (result.ok) {
+      // Clear any previous restartError on the parent so the operator
+      // sees a clean state.
+      await this.update(instanceId, { restartError: undefined });
+      this.logger.info(
+        `bizar: auto-restart complete: ${instanceId} -> ${result.newInstanceId}`,
+      );
+    } else {
+      // Persist a human-readable error so the operator can see why the
+      // restart was rejected (e.g. max_restarts_reached).
+      await this.update(instanceId, { restartError: result.error || "unknown" });
+      this.logger.warn(
+        `bizar: auto-restart failed for ${instanceId}: ${result.error}`,
+      );
     }
   }
 
@@ -800,7 +930,11 @@ export class InstanceManager {
         patch.completedAt = Date.now();
       }
       await this.update(instanceId, patch);
-      if (patch.status === "failed") return;
+      // v0.5.5 — persistent auto-restart on tool-call cap
+      if (patch.status === "failed") {
+        await this._maybeAutoRestart(instanceId);
+        return;
+      }
     }
 
     // --- Loop-guard threshold-12 detection (spec §4.1) ---
@@ -816,6 +950,8 @@ export class InstanceManager {
             loopGuardTool: tool,
             completedAt: Date.now(),
           });
+          // v0.5.5 — persistent auto-restart on loop-guard
+          await this._maybeAutoRestart(instanceId);
           return;
         }
       }

package/src/commands-impl.ts

@@ -112,7 +112,7 @@ export interface ExecuteResult {
  *                    list so we can include status + lastEdited).
  * `open_plan_url` — just returns the parser's response (the parser
  *                    already built the URL). No I/O.
- * `launch_dashboard` — spawns `bizar dashboard start` as a detached
+ * `launch_dashboard` — spawns `bizar dash start` as a detached
  *                    child process. Reads the port file back and
  *                    appends the URL to the parser's response.
  * `tool_invocation` — delegates to `executeToolInvocation`.
@@ -196,7 +196,7 @@ async function executeListPlans(
 /**
  * Launch the Bizar dashboard as a detached child process.
  *
- * We spawn `bizar dashboard start` with `detached: true` and `unref()`
+  * We spawn `bizar dash start` with `detached: true` and `unref()`
  * so the child's lifetime is independent of the plugin host. We then
  * poll the port file (written by the child) for up to ~3s and append
  * the URL to the parser's response. If anything goes wrong we surface
@@ -234,7 +234,7 @@ async function executeLaunchDashboard(
     // `bizar` is on $PATH for global installs; for npx / local installs
     // we'd want to resolve to the package's bin. Spawn `bizar` directly
     // for now — the user's $PATH is the source of truth.
-    const child = spawn("bizar", ["dashboard", "start"], {
+    const child = spawn("bizar", ["dash", "start"], {
       detached: true,
       stdio: "ignore",
       cwd: ctx.worktree,
@@ -248,7 +248,7 @@ async function executeLaunchDashboard(
     return {
       responseOverride:
         `Could not launch the Bizar dashboard: ${msg}\n` +
-        `Try running \`bizar dashboard start\` in your terminal.`,
+        `Try running \`bizar dash start\` in your terminal.`,
     };
   }