@polderlabs/bizar-plugin 0.6.1 → 0.8.0

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 {
@@ -125,7 +126,7 @@ 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 { wrapFetchForReasoningCleanup } from "./src/reasoning-clean.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";
@@ -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,6 +400,44 @@ 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,
@@ -469,6 +513,7 @@ async function init(
     directory: input.directory,
     seenMessageIds: new Map(),
     pendingInjections: new Map(),
+    dashboardPublisher,
   };
 
   return buildHooks(ctx, { instanceManager, bgAvailable });
@@ -700,6 +745,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
@@ -707,7 +793,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
@@ -731,9 +817,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,
         }),
@@ -756,36 +846,57 @@ function buildHooks(ctx: RuntimeContext, bg: BgDeps): Hooks {
       };
 
   return {
-    // §3.1 — config: wrap provider fetches to strip duplicated inline
-    // think blocks from responses of reasoning models that emit BOTH a
-    // structured reasoning field (rendered as a thought) AND an inline
-    // `` block (which would otherwise leak into the visible message).
-    // See plugins/bizar/src/reasoning-clean.ts for the full rationale.
-    config: async (cfg) => {
+    // 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 providers = (cfg as { provider?: Record<string, unknown> } | undefined)?.provider;
-        if (!providers || typeof providers !== "object") return;
-        const debug = (msg: string) => ctx.logger.debug(`bizar: ${msg}`);
-        for (const [name, provider] of Object.entries(providers)) {
-          if (!provider || typeof provider !== "object") continue;
-          const prov = provider as { options?: Record<string, unknown> };
-          if (!prov.options || typeof prov.options !== "object") continue;
-          const original = prov.options.fetch;
-          if (typeof original !== "function") continue;
-          // Only wrap once — detect by stamping a sentinel.
-          const wrapped = (original as { __bizarReasoningClean?: boolean })
-            .__bizarReasoningClean;
-          if (wrapped) continue;
-          prov.options.fetch = wrapFetchForReasoningCleanup(
-            original as Parameters<typeof wrapFetchForReasoningCleanup>[0],
-            { debug, providers: [name] },
-          );
-          (prov.options.fetch as { __bizarReasoningClean?: boolean }).__bizarReasoningClean = true;
-          debug(`wrapped provider.fetch for ${name}`);
+        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: config hook failed (passing through): ${
+          `bizar: messages.transform failed (passing through): ${
             err instanceof Error ? err.message : String(err)
           }`,
         );
@@ -797,10 +908,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 () => {
@@ -1102,18 +1240,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.1",
+  "version": "0.8.0",
   "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",
@@ -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

@@ -866,6 +866,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);

package/src/commands.ts

@@ -314,7 +314,7 @@ function handleVisualPlan(arg: string, ctx: ParseContext): SlashCommandResult {
     // No argument — return current state as a dialog
     return {
       handled: true,
-      response: "",
+      response: `Visual plan mode is currently ${currentEnabled ? "on" : "off"}.`,
       dialog: {
         id: generateId(),
         title: "Visual Plan",
@@ -334,7 +334,7 @@ function handleVisualPlan(arg: string, ctx: ParseContext): SlashCommandResult {
   if (lc === "on" || lc === "true" || lc === "1" || lc === "enable") {
     return {
       handled: true,
-      response: "",
+      response: `Visual plan mode is now on.`,
       settingsPatch: { visualPlanEnabled: true },
       dialog: {
         id: generateId(),
@@ -353,7 +353,7 @@ function handleVisualPlan(arg: string, ctx: ParseContext): SlashCommandResult {
   if (lc === "off" || lc === "false" || lc === "0" || lc === "disable") {
     return {
       handled: true,
-      response: "",
+      response: `Visual plan mode is now off.`,
       settingsPatch: { visualPlanEnabled: false },
       dialog: {
         id: generateId(),
@@ -372,7 +372,7 @@ function handleVisualPlan(arg: string, ctx: ParseContext): SlashCommandResult {
   if (lc === "status" || lc === "state" || lc === "?") {
     return {
       handled: true,
-      response: "",
+      response: `Visual plan mode is currently ${currentEnabled ? "on" : "off"}.`,
       dialog: {
         id: generateId(),
         title: "Visual Plan",
@@ -444,7 +444,7 @@ function handlePlan(arg: string, ctx: ParseContext): SlashCommandResult {
 function helpPlan(): SlashCommandResult {
   return {
     handled: true,
-    response: "",
+    response: "Plan commands: /plan new <slug> [template] | /plan list | /plan open <slug> | /plan get <slug> | /plan add <slug> | /plan update <slug> <id> | /plan delete <slug> <id> | /plan comment <slug> [id] \"text\" | /plan comments <slug> [id] | /plan status <slug> <status> | /plan wait <slug> [--timeout N]. Run /plan <subcommand> for details.",
     dialog: {
       id: generateId(),
       title: "Plan Commands",
@@ -477,7 +477,7 @@ function handlePlanNew(args: string[], ctx: ParseContext): SlashCommandResult {
   if (args.length === 0 || args[0] === "") {
     return {
       handled: true,
-      response: "",
+      response: "Usage: /plan new <slug> [template]. Available templates: " + KNOWN_TEMPLATES.join(", ") + ".",
       dialog: {
         id: generateId(),
         title: "Create New Plan",
@@ -520,7 +520,7 @@ function handlePlanNew(args: string[], ctx: ParseContext): SlashCommandResult {
 
   return {
     handled: true,
-    response: "",
+    response: `Created plan "${titleCase(slug)}" with the "${resolvedTemplate}" template. Use /plan open ${slug} to open it.`,
     sideEffect: {
       kind: "create_plan",
       slug,
@@ -544,9 +544,26 @@ function handlePlanNew(args: string[], ctx: ParseContext): SlashCommandResult {
 
 function handlePlanList(ctx: ParseContext): SlashCommandResult {
   const slugs = ctx.availablePlanSlugs ?? [];
+  if (slugs.length === 0) {
+    return {
+      handled: true,
+      response: "No plans found in the current worktree. Use /plan new <slug> to create one.",
+      sideEffect: { kind: "list_plans" },
+      dialog: {
+        id: generateId(),
+        title: "Plans",
+        command: "/plan list",
+        component: "plan-list",
+        data: {
+          plans: slugs,
+          count: slugs.length,
+        },
+      },
+    };
+  }
   return {
     handled: true,
-    response: "",
+    response: `Found ${slugs.length} plan(s) (${slugs.length}): ${slugs.join(", ")}.`,
     sideEffect: { kind: "list_plans" },
     dialog: {
       id: generateId(),
@@ -584,7 +601,7 @@ function handlePlanOpen(args: string[], ctx: ParseContext): SlashCommandResult {
 
   return {
     handled: true,
-    response: "",
+    response: `Opening plan "${slug}" at ${url}.`,
     settingsPatch: { lastUsedSlug: slug },
     sideEffect: {
       kind: "open_plan_url",
@@ -618,7 +635,7 @@ function handlePlanGet(args: string[]): SlashCommandResult {
   }
   return {
     handled: true,
-    response: "",
+    response: `Fetching canvas for plan "${slug}"…`,
     sideEffect: {
       kind: "tool_invocation",
       toolName: "bizar_plan_action",
@@ -1078,7 +1095,7 @@ function handleBizar(arg: string, ctx: ParseContext): SlashCommandResult {
 function helpResult(): SlashCommandResult {
   return {
     handled: true,
-    response: "",
+    response: "Available commands: /visual-plan [on|off|status], /plan new <slug> [template], /plan list, /plan open <slug>, /plan get <slug>, /plan add <slug>, /plan update <slug> <id>, /plan delete <slug> <id>, /plan comment <slug> [id] \"text\", /plan comments <slug> [id], /plan status <slug> <status>, /plan wait <slug> [--timeout N], /bizar, /bizar <args>, /help. See the dialog for full descriptions.",
     dialog: {
       id: generateId(),
       title: "Bizar Commands",