@polderlabs/bizar 6.2.5 → 7.0.0

package/bizar-dash/src/server/task-delegator.mjs

@@ -1,7 +1,7 @@
 /**
  * src/server/task-delegator.mjs
  *
- * v3.5.2 — Odin task delegation.
+ * v6.3.0 — Odin task delegation, REWRITTEN for Claude Code.
  *
  * Accepts a single "natural language" task from the user. Splits it into
  * 1-5 subtasks via heuristic rules (an LLM call would replace this in
@@ -18,23 +18,18 @@
  * Subtasks are always persisted to the regular tasks store first; the
  * background dispatch is best-effort.
  *
- * v3.5.4 (bug: dispatch stuck) — Dispatch path replaced. The previous
- * implementation shell-executed `node plugins/bizar/dist/cli.js bg enqueue`,
- * but the plugin is a Bun-native TS project with no compiled `dist/`,
- * so the exec always failed. The silent try/catch around execSync meant
- * the failure was invisible to both the user and the dashboard log.
+ * v6.3.0 — Dispatch path replaced. The previous Cline path shell-executed
+ * `node plugins/bizar/dist/cli.js bg enqueue`, then `cline run` via
+ * cline-runner.mjs. Claude Code has no equivalent `serve` child — the
+ * new path spawns `claude -p "<prompt>"` per subtask via
+ * `claude-runner.mjs` (in-process when the SDK is available,
+ * subprocess otherwise). The dispatch is gated on `pingClaudeSdk()`
+ * (in-process SDK reachable) OR the `claude` binary on PATH.
  *
- * New path:
- *   1. Read the plugin's serve-info file (port + password + worktree).
- *   2. POST /api/session on the plugin's cline serve child.
- *   3. POST /api/session/{id}/prompt to fire the task prompt.
- *   4. Write a state file under ~/.cache/bizar/bg/ so the dashboard's
- *      background-store can list and kill it.
- *
- * If serve-info is missing (plugin not running) we log a clear warning
- * at startup AND surface the dispatch failure in the `/submit` response,
- * so the user can re-dispatch manually with `/api/tasks/:id/start`
- * after the plugin is up.
+ * If neither is available we log a clear warning at startup AND
+ * surface the dispatch failure in the `/submit` response, so the
+ * user can re-dispatch manually with `/api/tasks/:id/start`
+ * once the runtime is up.
  */
 
 import { tasksStore, ALLOWED_TASK_STATUSES } from './tasks-store.mjs';
@@ -84,6 +79,7 @@ function buildPromptText(sub) {
   parts.push(`Subtask ID: ${sub.id}`);
   parts.push(`Assigned agent: ${sub.assignee || 'tyr'}`);
   parts.push(`Parent task ID: ${sub.parent || '(none)'}`);
+  parts.push(`Runtime: Claude Code (claude -p)`);
   return parts.join('\n');
 }
 
@@ -460,23 +456,25 @@ export const taskDelegator = {
   },
 
   /**
-   * v3.5.4 (bug: dispatch stuck) — Best-effort dispatch to the background
-   * agent infrastructure. Talks to the plugin's cline serve child via
-   * HTTP (createSession + sendPrompt) and writes a per-instance state
-   * file under BG_DIRS so the dashboard's `backgroundStore.list()` and
-   * `kill()` paths find the instance.
+   * v6.3.0 — Best-effort dispatch to the Claude Code runtime.
+   * Replaces the v3.5.4 Cline HTTP-serve path. Spawns one
+   * `claude -p "<prompt>"` subprocess per subtask via
+   * `claude-runner.mjs` (or, when the SDK is available,
+   * `claude-bg-spawner.mjs`'s SDK-backed path).
    *
-   * Replaces the previous `execSync('node plugins/bizar/dist/cli.js …')`
-   * path which silently failed because the plugin is a Bun-native TS
-   * project with no compiled `dist/`.
+   * The runner writes its output to the LogWriter's log file under
+   * `~/.cache/bizar/logs/<sessionId>.log`. The dashboard's
+   * `backgroundStore.list()` and `kill()` paths find the instance
+   * via the per-instance state file at
+   * `~/.cache/bizar/bg/<instanceId>.json`.
    *
    * Returns a structured `{ dispatched: string[], errors: Array<…>, warnings: Array<…> }`
-   * so the caller (and `/api/tasks/submit`) can surface failures to the
-   * user instead of swallowing them.
+   * so the caller (and `/api/tasks/submit`) can surface failures to
+   * the user instead of swallowing them.
    *
-   * v3.5.1 — Respects agents.maxParallel: caps concurrent dispatches to
-   * the configured limit; overflow subtasks are queued until a slot
-   * frees up.
+   * v3.5.1 — Respects agents.maxParallel: caps concurrent dispatches
+   * to the configured limit; overflow subtasks are queued until a
+   * slot frees up.
    *
    * @returns {Promise<{ dispatched: string[], errors: Array<{ subtaskId: string, kind: string, message: string }>, warnings: string[] }>}
    */
@@ -503,29 +501,32 @@ export const taskDelegator = {
     const runningCount = await runningBgCount();
     const slotsAvailable = Math.max(0, maxParallel - runningCount);
 
-    // v3.5.4 (bug: dispatch stuck) — Resolve the cline serve child
-    // the plugin owns. If the plugin is not running we record a warning
-    // and skip the actual spawn (subtasks still flip to `doing` so the
-    // user can see them, but `metadata.dispatchPending = true` tells
-    // them to retry via `/api/tasks/:id/start` once the plugin is up).
-    let serveInfo = null;
-    let serveReachable = false;
+    // v6.3.0 — Verify the Claude Code runtime is reachable. We
+    // accept either the in-process SDK or the `claude` binary on
+    // PATH. `pingClaudeSdk()` probes the SDK; `claude -v` on PATH
+    // is the subprocess fallback. When neither is available we
+    // mark subtasks as `dispatchPending: true` so the UI surfaces
+    // "Awaiting dispatch" and `/api/tasks/:id/start` can retry
+    // after the user installs Claude Code.
+    let claudeAvailable = false;
     try {
-      const { readServeInfo, pingClineServe } = await import('./serve-info.mjs');
-      serveInfo = readServeInfo();
-      if (!serveInfo) {
-        result.warnings.push('serve-info not found — the bizar plugin is not running. Tasks will be marked queued; retry via POST /api/tasks/:id/start once the plugin is up.');
-        console.warn('[task-delegator] serve-info missing — plugin may not be running. Dispatch will be deferred.');
-      } else {
-        serveReachable = await pingClineServe(serveInfo);
-        if (!serveReachable) {
-          result.warnings.push(`cline serve at ${serveInfo.baseUrl} is not reachable. Tasks will be marked queued; retry via POST /api/tasks/:id/start.`);
-          console.warn(`[task-delegator] cline serve not reachable at ${serveInfo.baseUrl}`);
-        }
+      const { pingClaudeSdk } = await import('./claude-sdk.mjs');
+      claudeAvailable = await pingClaudeSdk();
+    } catch {
+      claudeAvailable = false;
+    }
+    if (!claudeAvailable) {
+      try {
+        const { spawnSync } = await import('node:child_process');
+        const probe = spawnSync('claude', ['-v'], { stdio: 'ignore', timeout: 1500 });
+        claudeAvailable = probe.status === 0;
+      } catch {
+        claudeAvailable = false;
       }
-    } catch (err) {
-      result.warnings.push(`could not load serve-info helper: ${err.message}`);
-      console.warn('[task-delegator] serve-info helper failed:', err.message);
+    }
+    if (!claudeAvailable) {
+      result.warnings.push('claude runtime not reachable — neither the @anthropic-ai/claude-agent-sdk nor the `claude` binary on PATH. Tasks will be marked queued; retry via POST /api/tasks/:id/start once Claude Code is installed.');
+      console.warn('[task-delegator] claude runtime unreachable — dispatch will be deferred.');
     }
 
     // Split: first N get dispatched now, rest are queued.
@@ -549,13 +550,13 @@ export const taskDelegator = {
       });
     }
 
-    // v3.5.4 (bug: dispatch stuck) — Per-subtask dispatch path. We
-    // collect errors instead of swallowing them. Two failure modes:
-    //   - serveInfo/serveReachable missing: mark dispatchPending so
-    //     the UI shows "Awaiting dispatch" and `/api/tasks/:id/start`
-    //     can retry.
-    //   - HTTP error: record error message so the API response carries
-    //     it.
+    // v6.3.0 — Per-subtask dispatch path. We collect errors instead
+    // of swallowing them. Two failure modes:
+    //   - claudeAvailable=false: mark dispatchPending so the UI
+    //     shows "Awaiting dispatch" and `/api/tasks/:id/start` can
+    //     retry.
+    //   - spawn failure: record error message so the API response
+    //     carries it.
     for (const sub of toDispatch) {
       const startedAt = new Date().toISOString();
       let bgInstanceId = null;
@@ -563,21 +564,19 @@ export const taskDelegator = {
       let dispatchError = null;
       let dispatchPending = false;
 
-      // v3.11.1 — Active dispatch path. We no longer depend on the
-      // cline serve child's HTTP API to drive the agent loop
-      // (per the cline docs, that API is passive — it needs a
-      // TUI/web client connected to actually process prompts).
-      // Instead we spawn one `cline run` subprocess per subtask
-      // and capture its output to the LogWriter's log file. The
-      // plugin's cline-runner.ts and this dashboard's
-      // cline-runner.mjs share the same wire format.
-      if (serveInfo && serveReachable) {
+      // v6.3.0 — Active dispatch path. Spawn one `claude -p` (or
+      // `claude --bg` for long-running sessions) subprocess per
+      // subtask via claude-runner.mjs. Capture the sessionId from
+      // the runner's JSON-line stream.
+      if (claudeAvailable) {
         try {
-          const { spawnAgent } = await import('./cline-runner.mjs');
-          // v3.11.0 — Fall back to projectRoot when serve-info is
-          // missing `worktree` (older plugin builds only wrote
-          // `{password, pid, port}`).
-          const dispatchWorktree = serveInfo.worktree || projectRoot || '';
+          const { spawnAgent } = await import('./claude-runner.mjs');
+          // v6.3.0 — Prefer the bg-spawner's SDK-backed path when
+          // the SDK is reachable; fall back to the print-mode
+          // subprocess otherwise. We always pass `background: false`
+          // here so the runner returns a sessionId synchronously;
+          // the bg-spawner is used separately by the Active tab.
+          const dispatchWorktree = projectRoot || '';
           const promptText = buildPromptText(sub);
 
           // Predict the bg instance id (deterministic, derived from
@@ -597,14 +596,14 @@ export const taskDelegator = {
           });
 
           if (!spawnRes.ok || !spawnRes.sessionId) {
-            dispatchError = spawnRes.error || 'cline run failed before reporting session id';
+            dispatchError = spawnRes.error || 'claude -p failed before reporting session id';
           } else {
             sessionId = spawnRes.sessionId;
             bgInstanceId = predictedInstanceId;
 
             // v3.5.5 — Wrap the agent run in a tmux session so
             // operators can `tmux attach -t bizar-bg-<id>` and watch
-            // the cline process in real time.
+            // the claude process in real time.
             try {
               const tmuxRes = backgroundStore.spawnTmuxFor(
                 `bg_${sessionId.slice(0, 16)}`,
@@ -623,9 +622,9 @@ export const taskDelegator = {
           dispatchError = err instanceof Error ? err.message : String(err);
         }
       } else {
-        // Plugin not running — leave the subtask marked queued with a
-        // dispatchPending flag. The UI surfaces this and the user can
-        // retry via POST /api/tasks/:id/start.
+        // Claude Code not available — leave the subtask marked
+        // queued with a dispatchPending flag. The UI surfaces this
+        // and the user can retry via POST /api/tasks/:id/start.
         dispatchPending = true;
       }
 

package/bizar-dash/src/web/App.tsx

@@ -42,6 +42,8 @@ import { Doctor } from './views/Doctor';
 import { Harness } from './views/Harness';
 import { Eval } from './views/Eval';
 import { EvalReport } from './views/EvalReport';
+// v6.4.0 — F-036 Goal Planner UI.
+import { GoalPlanner } from './views/GoalPlanner';
 import { SettingsNav } from './components/SettingsNav';
 import { Spinner } from './components/Spinner';
 import { Button } from './components/Button';
@@ -108,6 +110,8 @@ const VIEW_MAP: Record<string, (p: ViewProps) => React.ReactNode> = {
   // Eval view's "Open Eval Report" button (full report + diff).
   eval: Eval,
   evalReport: EvalReport,
+  // v6.4.0 — F-036 Goal Planner UI. Plain-English goal → A* plan.
+  'goal-planner': GoalPlanner,
 };
 
 const VERSION = 'v6.0.0';

package/bizar-dash/src/web/components/Tag.tsx

@@ -1,17 +1,30 @@
 // src/components/Tag.tsx — pill for tags.
 
-import type { ReactNode } from 'react';
+import type { HTMLAttributes, ReactNode } from 'react';
 import { cn } from '../lib/utils';
 
-export type TagProps = {
+export type TagVariant =
+  | "neutral"
+  | "info"
+  | "accent"
+  | "primary"
+  | "success"
+  | "warning"
+  | "error";
+
+export type TagProps = HTMLAttributes<HTMLSpanElement> & {
   children: ReactNode;
   className?: string;
+  variant?: TagVariant;
   onRemove?: () => void;
 };
 
-export function Tag({ children, className, onRemove }: TagProps) {
+export function Tag({ children, className, variant, onRemove, ...rest }: TagProps) {
   return (
-    <span className={cn('tag', className)}>
+    <span
+      className={cn('tag', variant ? `tag-${variant}` : undefined, className)}
+      {...rest}
+    >
       {children}
       {onRemove && (
         <button
@@ -25,4 +38,4 @@ export function Tag({ children, className, onRemove }: TagProps) {
       )}
     </span>
   );
-}
+}

package/bizar-dash/src/web/components/Topbar.tsx

@@ -26,6 +26,7 @@ import {
   Brain,
   Stethoscope,
   ClipboardCheck,
+  Target,
   type LucideIcon,
 } from 'lucide-react';
 import { cn } from '../lib/utils';
@@ -66,6 +67,8 @@ export const TABS: TabDef[] = [
   { id: 'doctor', label: 'Doctor', icon: Stethoscope },
   // v6.0.0 — Harness engineering dashboard.
   { id: 'harness', label: 'Harness', icon: Shield },
+  // v6.4.0 — F-036 Goal Planner UI. Plain-English → A* plan.
+  { id: 'goal-planner', label: 'Goals', icon: Target },
   { id: 'settings', label: 'Settings', icon: Sliders },
 ];
 

package/bizar-dash/src/web/components/agents/CommunicationLog.tsx

@@ -0,0 +1,126 @@
+// src/web/components/agents/CommunicationLog.tsx — inter-agent message bus trace.
+//
+// v6.4.0 — F-036 (Goal Planner UI). Subscribes to ws.ts for any
+// event whose type starts with `agent:` and renders the last 200
+// messages with color coding by type. Bounded virtual-list window
+// so a runaway stream can't blow up the page.
+import { useEffect, useState } from 'react';
+import { MessageSquare, ArrowRight } from 'lucide-react';
+import { Ws } from '../../lib/ws';
+import { Card, CardTitle, CardMeta } from '../Card';
+import { Tag } from '../Tag';
+
+const MAX_ROWS = 200;
+
+type Entry = {
+  id: string;
+  ts: number;
+  from: string;
+  to: string;
+  message: string;
+  kind: 'info' | 'request' | 'success' | 'warning' | 'error' | 'status' | 'restarted' | 'stuck' | 'message';
+  raw: unknown;
+};
+
+function classify(t: string): Entry['kind'] {
+  if (t === 'agent:status') return 'status';
+  if (t === 'agent:restarted') return 'restarted';
+  if (t === 'agent:stuck') return 'stuck';
+  if (t === 'agent:message') return 'message';
+  return 'info';
+}
+
+function deriveEntry(t: string, payload: Record<string, unknown> | undefined, ts: number): Entry {
+  const kind = classify(t);
+  const id = `${ts}-${Math.random().toString(36).slice(2, 7)}`;
+  if (t === 'agent:message') {
+    const m = (payload?.message || payload) as Record<string, unknown>;
+    return {
+      id,
+      ts,
+      from: String(m?.from || 'unknown'),
+      to: String(m?.to || 'unknown'),
+      message: String(m?.text || m?.message || JSON.stringify(m).slice(0, 160)),
+      kind,
+      raw: payload,
+    };
+  }
+  const agent = (payload?.agent || payload) as Record<string, unknown>;
+  const name = String(agent?.name || 'agent');
+  return {
+    id,
+    ts,
+    from: name,
+    to: kind === 'stuck' ? 'orchestrator' : 'broadcast',
+    message: `${t} ${agent?.status ? `→ ${agent.status}` : ''}`.trim(),
+    kind,
+    raw: payload,
+  };
+}
+
+interface Props {
+  /** Override the max row count (default 200). */
+  maxRows?: number;
+}
+
+export function CommunicationLog({ maxRows = MAX_ROWS }: Props) {
+  const [rows, setRows] = useState<Entry[]>([]);
+
+  useEffect(() => {
+    const ws = new Ws();
+    const off = ws.on((msg) => {
+      const t = (msg as { type?: string }).type;
+      if (!t || !t.startsWith('agent:')) return;
+      const m = msg as { type: string; ts?: number } & Record<string, unknown>;
+      const ts = Number(m.ts) || Date.now();
+      setRows((prev) => {
+        const next = [...prev, deriveEntry(t, m as Record<string, unknown>, ts)];
+        return next.length > maxRows ? next.slice(next.length - maxRows) : next;
+      });
+    });
+    return () => {
+      off();
+      ws.close();
+    };
+  }, [maxRows]);
+
+  return (
+    <Card className="comm-log" data-testid="communication-log">
+      <div className="comm-log-header">
+        <CardTitle>
+          <MessageSquare size={14} aria-hidden /> Communication log
+        </CardTitle>
+        <Tag variant="neutral" data-testid="communication-log-count">{rows.length}</Tag>
+      </div>
+      <CardMeta>Inter-agent message bus trace · bounded to {maxRows} rows</CardMeta>
+      <ul className="comm-log-list" data-testid="communication-log-list">
+        {rows.length === 0 && (
+          <li className="comm-log-empty" data-testid="communication-log-empty">
+            No agent messages yet. Stream will appear here live.
+          </li>
+        )}
+        {rows.slice().reverse().map((row) => (
+          <li
+            key={row.id}
+            className={`comm-log-row is-${row.kind}`}
+            data-testid="communication-log-row"
+            data-kind={row.kind}
+          >
+            <div className="comm-log-row-meta">
+              <span className="comm-log-from">{row.from}</span>
+              <ArrowRight size={12} aria-hidden />
+              <span className="comm-log-to">{row.to}</span>
+              <Tag variant="neutral" className={`comm-log-kind is-${row.kind}`}>{row.kind}</Tag>
+              <time className="comm-log-time" dateTime={new Date(row.ts).toISOString()}>
+                {new Date(row.ts).toLocaleTimeString()}
+              </time>
+            </div>
+            <div className="comm-log-message">{row.message}</div>
+          </li>
+        ))}
+      </ul>
+    </Card>
+  );
+}
+
+export default CommunicationLog;

package/bizar-dash/src/web/components/agents/DependencyGraph.tsx

@@ -0,0 +1,163 @@
+// src/web/components/agents/DependencyGraph.tsx — DAG of plan step dependencies.
+//
+// v6.4.0 — F-036 (Goal Planner UI). Uses @xyflow/react (already in
+// Bizar deps) to render the plan's step graph. Falls back to a
+// hand-rolled table when no plan is supplied.
+import { useMemo } from 'react';
+import {
+  ReactFlow,
+  Background,
+  Controls,
+  MiniMap,
+  type Node,
+  type Edge,
+  type NodeProps,
+  Handle,
+  Position,
+} from '@xyflow/react';
+import '@xyflow/react/dist/style.css';
+import { GitBranch } from 'lucide-react';
+import { Card, CardTitle, CardMeta } from '../Card';
+import { Tag } from '../Tag';
+import type { Plan } from '../../lib/goapPlanner';
+
+interface Props {
+  plan: Plan | null;
+}
+
+function StepNode({ data }: NodeProps<Node<{ label: string; action: string; agent: string }>>) {
+  return (
+    <div className={`dep-node is-${(data as { action?: string }).action || 'research'}`}>
+      <Handle type="target" position={Position.Left} className="dep-handle" />
+      <div className="dep-node-action">{(data as { action?: string }).action}</div>
+      <div className="dep-node-label">{(data as { label?: string }).label}</div>
+      <div className="dep-node-agent">@{(data as { agent?: string }).agent}</div>
+      <Handle type="source" position={Position.Right} className="dep-handle" />
+    </div>
+  );
+}
+
+const nodeTypes = { step: StepNode };
+
+export function DependencyGraph({ plan }: Props) {
+  const nodes: Node[] = useMemo(() => {
+    if (!plan) return [];
+    const n = plan.steps.length;
+    // Lay out nodes in a horizontal flow based on dep depth.
+    const depths = new Map<string, number>();
+    const computeDepth = (id: string, stack = new Set<string>()): number => {
+      const cached = depths.get(id);
+      if (cached !== undefined) return cached;
+      if (stack.has(id)) return 0;
+      stack.add(id);
+      const step = plan.steps.find((s) => s.id === id);
+      if (!step || step.deps.length === 0) {
+        depths.set(id, 0);
+        stack.delete(id);
+        return 0;
+      }
+      let max = 0;
+      for (const dep of step.deps) {
+        const d = computeDepth(dep, stack);
+        if (d > max) max = d;
+      }
+      depths.set(id, max + 1);
+      stack.delete(id);
+      return max + 1;
+    };
+    for (const s of plan.steps) computeDepth(s.id);
+
+    const byDepth = new Map<number, string[]>();
+    for (const s of plan.steps) {
+      const d = depths.get(s.id) ?? 0;
+      const arr = byDepth.get(d) || [];
+      arr.push(s.id);
+      byDepth.set(d, arr);
+    }
+    const nodesOut: Node[] = [];
+    for (const [depth, ids] of byDepth) {
+      const total = ids.length;
+      ids.forEach((id, i) => {
+        const step = plan.steps.find((s) => s.id === id);
+        if (!step) return;
+        const xOffset = 60 + depth * 220;
+        const yOffset = 40 + (i - (total - 1) / 2) * 90;
+        nodesOut.push({
+          id: step.id,
+          type: 'step',
+          position: { x: xOffset, y: yOffset },
+          data: {
+            label: step.title,
+            action: step.action,
+            agent: step.agent,
+          },
+        });
+      });
+    }
+    void n;
+    return nodesOut;
+  }, [plan]);
+
+  const edges: Edge[] = useMemo(() => {
+    if (!plan) return [];
+    return plan.steps.flatMap((step) =>
+      step.deps.map((dep) => ({
+        id: `${dep}->${step.id}`,
+        source: dep,
+        target: step.id,
+        animated: true,
+      })),
+    );
+  }, [plan]);
+
+  if (!plan) {
+    return (
+      <Card className="dep-graph" data-testid="dep-graph">
+        <CardTitle>
+          <GitBranch size={14} aria-hidden /> Dependency graph
+        </CardTitle>
+        <CardMeta>Submit a goal to render the dependency DAG.</CardMeta>
+      </Card>
+    );
+  }
+
+  if (plan.steps.length === 0) {
+    return (
+      <Card className="dep-graph" data-testid="dep-graph">
+        <CardTitle>
+          <GitBranch size={14} aria-hidden /> Dependency graph
+        </CardTitle>
+        <CardMeta>Empty plan — nothing to render.</CardMeta>
+      </Card>
+    );
+  }
+
+  return (
+    <Card className="dep-graph" data-testid="dep-graph">
+      <div className="dep-graph-header">
+        <CardTitle>
+          <GitBranch size={14} aria-hidden /> Dependency graph
+        </CardTitle>
+        <Tag variant="info">{plan.steps.length} nodes</Tag>
+        <Tag variant="accent">{edges.length} edges</Tag>
+      </div>
+      <CardMeta>Plan step DAG · {plan.goal.slice(0, 80)}</CardMeta>
+      <div className="dep-graph-canvas" data-testid="dep-graph-canvas">
+        <ReactFlow
+          nodes={nodes}
+          edges={edges}
+          nodeTypes={nodeTypes}
+          fitView
+          fitViewOptions={{ padding: 0.15 }}
+          proOptions={{ hideAttribution: true }}
+        >
+          <Background gap={16} size={1} />
+          <Controls showInteractive={false} />
+          <MiniMap pannable zoomable />
+        </ReactFlow>
+      </div>
+    </Card>
+  );
+}
+
+export default DependencyGraph;