@polderlabs/bizar 4.3.0 → 4.4.0

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

@@ -37,10 +37,11 @@
  * after the plugin is up.
  */
 
-import { tasksStore } from './tasks-store.mjs';
+import { tasksStore, ALLOWED_TASK_STATUSES } from './tasks-store.mjs';
 import { agentsStore } from './agents-store.mjs';
 import { notificationsStore } from './notifications-store.mjs';
 import { backgroundStore } from './background-store.mjs';
+import { projectsStore } from './projects-store.mjs';
 import { getActualBgLogPath } from './lib/path-safe.mjs';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
@@ -161,6 +162,12 @@ function autoTitleFromContent(body, fallback = true) {
   return (lastSpace > 20 ? cut.slice(0, lastSpace) : cut).trimEnd() + '…';
 }
 
+// v3.22 — Shared helper: count running + pending bg instances.
+async function runningBgCount() {
+  const list = await backgroundStore.list();
+  return list.filter((b) => b.status === 'running' || b.status === 'pending').length;
+}
+
 export const taskDelegator = {
   /**
    * Submit a task to Odin. Odin analyzes, splits, and dispatches.
@@ -492,13 +499,8 @@ export const taskDelegator = {
       maxParallel = 6;
     }
 
-    // Count currently running bg instances across all candidate dirs.
-    // v3.5.4 (bug #5) — `list()` is now async because it merges
-    // opencode-direct sessions via fetch.
-    const runningInstances = (await backgroundStore.list()).filter(
-      (b) => b.status === 'running' || b.status === 'pending',
-    );
-    const runningCount = runningInstances.length;
+    // v3.22 — Reuse the shared runningBgCount helper.
+    const runningCount = await runningBgCount();
     const slotsAvailable = Math.max(0, maxParallel - runningCount);
 
     // v3.5.4 (bug: dispatch stuck) — Resolve the opencode serve child
@@ -770,6 +772,150 @@ export const taskDelegator = {
 
   /** For tests / introspection. */
   _BG_DIRS: BG_DIRS,
+
+  // v3.22 — Expose runningBgCount so callers can check dispatch capacity.
+  async runningBgCount() {
+    return runningBgCount();
+  },
+
+  /**
+   * Odin-pick: drain backlog into queued slots.
+   *
+   * Algorithm:
+   *  1. Determine active project. If none, return zeros + warning.
+   *  2. Read agents.maxParallel (default 6).
+   *  3. Compute running bg count via runningBgCount().
+   *  4. Compute slotsAvailable = max(0, maxParallel - runningCount). If 0, bail.
+   *  5. Load all non-archived tasks. Collect queued (parent or subtask, not yet
+   *     dispatched) and backlog items as candidates.
+   *  6. Sort: priority high>normal>low; tiebreak createdAt ASC; backlog items
+   *     sort after queued at the same priority (drain queue first).
+   *  7. Promote backlog items to fill candidate pool up to slotsAvailable.
+   *  8. Dispatch each candidate via dispatchToBackground.
+   *
+   * @param {object} ctx - { logLine?, broadcast? }
+   * @returns {{ promoted: number, dispatched: number, skipped: string[], warnings: string[] }}
+   */
+  async tickBacklog(ctx = {}) {
+    const logLine = ctx.logLine || (() => {});
+    const broadcast = ctx.broadcast || (() => {});
+    const warnings = [];
+    const skipped = [];
+
+    // 1. Active project or bail.
+    const active = projectsStore.active();
+    if (!active) {
+      warnings.push('no active project — tickBacklog skipped');
+      return { promoted: 0, dispatched: 0, skipped, warnings };
+    }
+    const projectId = active.id;
+    const projectRoot = active.path || process.cwd();
+
+    // 2. Read maxParallel.
+    const SETTINGS_FILE = join(HOME, '.config', 'bizar', 'settings.json');
+    let maxParallel = 6;
+    try {
+      if (existsSync(SETTINGS_FILE)) {
+        const raw = readFileSync(SETTINGS_FILE, 'utf8');
+        const settings = JSON.parse(raw);
+        maxParallel = settings?.agents?.maxParallel ?? 6;
+      }
+    } catch {
+      maxParallel = 6;
+    }
+
+    // 3 & 4. Running count and slots check.
+    const runningCount = await runningBgCount();
+    const slotsAvailable = Math.max(0, maxParallel - runningCount);
+    if (slotsAvailable === 0) {
+      skipped.push('no slots available');
+      return { promoted: 0, dispatched: 0, skipped, warnings };
+    }
+
+    // 5. Collect candidates.
+    const allTasks = tasksStore.loadTasks(projectId, { includeArchived: false });
+
+    const queuedCandidates = allTasks.filter((t) => {
+      if (t.status !== 'queued' || t.archived) return false;
+      // Parent tasks need subtasks; subtasks need a parent; both need to NOT already be dispatched.
+      const isSubtask = !!t.parent;
+      const hasSubtasks = Array.isArray(t.subtasks) && t.subtasks.length > 0;
+      if (isSubtask && !hasSubtasks) return false;
+      if (!isSubtask && hasSubtasks) return false;
+      const meta = t.metadata || {};
+      if (meta.bgInstanceId || meta.dispatchPending) return false;
+      return true;
+    });
+
+    const backlogItems = allTasks.filter((t) => t.status === 'backlog' && !t.archived);
+
+    // 6. Sort: priority ASC, createdAt ASC. Backlog items go after queued at same priority.
+    const priorityWeight = { high: 0, normal: 1, low: 2 };
+    const sortKey = (t, source) => {
+      const pw = priorityWeight[t.priority] ?? 1;
+      const src = source === 'backlog' ? 1 : 0;
+      return [pw, src, t.createdAt];
+    };
+    const allCandidates = [
+      ...queuedCandidates.map((t) => ({ task: t, source: 'queued' })),
+      ...backlogItems.map((t) => ({ task: t, source: 'backlog' })),
+    ];
+    allCandidates.sort((a, b) => {
+      const [pwA, srcA, ca] = sortKey(a.task, a.source);
+      const [pwB, srcB, cb] = sortKey(b.task, b.source);
+      if (pwA !== pwB) return pwA - pwB;
+      if (srcA !== srcB) return srcA - srcB;
+      return new Date(ca).getTime() - new Date(cb).getTime();
+    });
+
+    // 7. Promote backlog items to fill slots.
+    let promoted = 0;
+    const toPromote = allCandidates.filter((c) => c.source === 'backlog');
+    const toDispatch = [
+      ...allCandidates.filter((c) => c.source === 'queued'),
+      ...toPromote,
+    ].slice(0, slotsAvailable);
+
+    for (const c of toPromote) {
+      if (toDispatch.includes(c)) {
+        const updated = await tasksStore.promote(projectId, c.task.id);
+        if (updated) {
+          broadcast({ type: 'tasks:change', task: updated });
+          promoted++;
+        }
+      }
+    }
+
+    // 8. Dispatch each candidate.
+    let dispatched = 0;
+    for (const c of toDispatch) {
+      if (c.source === 'backlog') {
+        // Already promoted above.
+        continue;
+      }
+      const asSubtask = {
+        id: c.task.id,
+        title: c.task.title,
+        description: c.task.description,
+        assignee: c.task.assignee || 'tyr',
+        parent: c.task.parent || null,
+      };
+      const synthMain = { id: c.task.id };
+      try {
+        const result = await this.dispatchToBackground(synthMain, [asSubtask], { projectRoot, projectId, state: {}, broadcast }, broadcast);
+        if (result && Array.isArray(result.dispatched) && result.dispatched.length > 0) {
+          dispatched++;
+        } else if (result && result.warnings?.length) {
+          warnings.push(...result.warnings);
+        }
+      } catch (err) {
+        skipped.push(c.task.id);
+        warnings.push(`dispatch failed for ${c.task.id}: ${err.message}`);
+      }
+    }
+
+    return { promoted, dispatched, skipped, warnings };
+  },
 };
 
 // ── Public helpers for routes that need to walk bg state ─────────────

package/bizar-dash/src/server/tasks-store.mjs

@@ -16,6 +16,10 @@ import { homedir } from 'node:os';
 import { randomBytes } from 'node:crypto';
 import { projectsStore } from './projects-store.mjs';
 
+// v3.22 — Canonical status list. All status checks flow through this
+// constant so a new status needs a change in only this one place.
+export const ALLOWED_TASK_STATUSES = ['backlog', 'queued', 'doing', 'done', 'blocked', 'archived'];
+
 const HOME = homedir();
 const LEGACY_FILE = join(HOME, '.config', 'bizar', 'tasks.json');
 
@@ -154,7 +158,7 @@ export const tasksStore = {
         id: genId(),
         title: input.title,
         description: input.description || '',
-        status: ['queued', 'doing', 'done', 'blocked', 'archived'].includes(input.status) ? input.status : 'queued',
+        status: ALLOWED_TASK_STATUSES.includes(input.status) ? input.status : 'queued',
         tags: Array.isArray(input.tags) ? input.tags : [],
         priority: ['low', 'normal', 'high'].includes(input.priority) ? input.priority : 'normal',
         assignee: input.assignee || null,
@@ -196,7 +200,7 @@ export const tasksStore = {
 
       if (typeof patch.title === 'string') task.title = patch.title.slice(0, 200);
       if (typeof patch.description === 'string') task.description = patch.description;
-      if (['queued', 'doing', 'done', 'blocked', 'archived'].includes(patch.status)) {
+      if (ALLOWED_TASK_STATUSES.includes(patch.status)) {
         if (patch.status !== task.status) {
           appendActivity(task, 'status', { from: task.status, to: patch.status });
         }
@@ -505,4 +509,48 @@ export const tasksStore = {
     }
     return created;
   },
+
+  // v3.22 — Backlog helpers. Tasks in `backlog` are parked; Odin
+  // promotes them to `queued` via tickBacklog when slots are free.
+
+  /**
+   * List all backlog tasks for a project.
+   * @returns {Task[]}
+   */
+  listBacklog(projectId) {
+    return this.loadTasks(projectId).filter((t) => t.status === 'backlog' && !t.archived);
+  },
+
+  /**
+   * Promote a single backlog task to queued.
+   * @returns {Task | null}
+   */
+  async promote(projectId, id) {
+    return this.update(projectId, id, { status: 'queued' });
+  },
+
+  /**
+   * Demote a queued task back to backlog.
+   * @returns {Task | null}
+   */
+  async demote(projectId, id) {
+    return this.update(projectId, id, { status: 'backlog' });
+  },
+
+  /**
+   * Bulk-promote multiple backlog tasks to queued.
+   * @returns {{ affected: object[] }}
+   */
+  async promoteBatch(projectId, ids) {
+    const affected = [];
+    for (const id of ids) {
+      try {
+        const t = await this.update(projectId, id, { status: 'queued' });
+        affected.push({ id, ok: !!t });
+      } catch (err) {
+        affected.push({ id, ok: false, error: err.message });
+      }
+    }
+    return { affected };
+  },
 };

package/bizar-dash/src/web/components/background/AttachButton.tsx

@@ -0,0 +1,96 @@
+// src/components/background/AttachButton.tsx — small reusable tmux attach button
+// v3.22.0
+//
+// Renders a primary button with two affordances:
+//   1. "Run" — POST /api/background/:id/open-terminal to spawn the system
+//      terminal emulator with the tmux attach command.
+//   2. "Copy" — ghost button to copy the command to clipboard.
+//
+// Safety: the "run" endpoint only accepts commands that start with
+// `tmux attach -t ` (server-side whitelist). The `command` prop is
+// only used for clipboard copy; the POST endpoint reconstructs the
+// command server-side from the tmux session name.
+
+import { useState } from 'react';
+import { Copy, ExternalLink } from 'lucide-react';
+import { Button } from '../Button';
+import { useToast } from '../Toast';
+import { api } from '../../lib/api';
+
+type AttachButtonProps = {
+  /** The full `tmux attach -t <session>` command. Used for clipboard copy. */
+  command: string;
+  /** Button label. Defaults to "Attach". */
+  label?: string;
+  /** Instance id, sent in the POST body so the server validates the session. */
+  instanceId: string;
+};
+
+export function AttachButton({
+  command,
+  label = 'Attach',
+  instanceId,
+}: AttachButtonProps) {
+  const toast = useToast();
+  const [opening, setOpening] = useState(false);
+
+  // Client-side pre-check: only allow tmux attach commands.
+  const valid = /^tmux attach -t /.test(command);
+
+  const copyCommand = async () => {
+    try {
+      await navigator.clipboard.writeText(command);
+      toast.success('Command copied');
+    } catch {
+      toast.error('Could not copy');
+    }
+  };
+
+  const runInTerminal = async () => {
+    if (!valid || !instanceId) return;
+    setOpening(true);
+    try {
+      const res = await api.post<{ ok: boolean; error?: string }>(
+        `/background/${encodeURIComponent(instanceId)}/open-terminal`,
+        { emulator: 'system' },
+      );
+      if (res.ok) {
+        toast.success('Opening terminal…');
+      } else {
+        toast.error(res.error || 'Failed to open terminal');
+        // Fallback: copy the command.
+        await copyCommand();
+      }
+    } catch (err) {
+      toast.error(`Failed: ${(err as Error).message}`);
+      // Fallback: copy on network error.
+      await copyCommand();
+    } finally {
+      setOpening(false);
+    }
+  };
+
+  return (
+    <div className="attach-button-group">
+      <Button
+        variant="primary"
+        size="sm"
+        onClick={runInTerminal}
+        loading={opening}
+        disabled={!valid}
+        title={valid ? 'Open in system terminal' : 'Invalid attach command'}
+      >
+        <ExternalLink size={14} /> {label}
+      </Button>
+      <Button
+        variant="ghost"
+        size="sm"
+        onClick={copyCommand}
+        disabled={!command}
+        title="Copy attach command"
+      >
+        <Copy size={14} />
+      </Button>
+    </div>
+  );
+}

package/bizar-dash/src/web/components/background/TmuxAttachCard.tsx

@@ -0,0 +1,122 @@
+// src/components/background/TmuxAttachCard.tsx — per-instance tmux attach card
+// v3.22.0
+//
+// Shows the tmux session name, a "Copy attach command" button, and
+// an "Open in terminal" button that POSTs to /api/background/:id/open-terminal.
+// When tmux is missing on the host, shows a friendly warning instead.
+
+import { useState } from 'react';
+import { Copy, Terminal, AlertTriangle } from 'lucide-react';
+import { Button } from '../Button';
+import { Card } from '../Card';
+import { useToast } from '../Toast';
+import { api } from '../../lib/api';
+import type { BgInstance } from '../../lib/types';
+
+type TmuxAttachCardProps = {
+  instance: BgInstance;
+};
+
+export function TmuxAttachCard({ instance }: TmuxAttachCardProps) {
+  const toast = useToast();
+  const [opening, setOpening] = useState(false);
+
+  const sessionName = instance.tmuxSession;
+  const attachCommand = sessionName ? `tmux attach -t ${sessionName}` : null;
+
+  const copyCommand = async () => {
+    if (!attachCommand) return;
+    try {
+      await navigator.clipboard.writeText(attachCommand);
+      toast.success('Attach command copied');
+    } catch {
+      toast.error('Could not copy to clipboard');
+    }
+  };
+
+  const openTerminal = async () => {
+    if (!instance.instanceId || !sessionName) return;
+    setOpening(true);
+    try {
+      const result = await api.post<{ ok: boolean; command: string; error?: string }>(
+        `/background/${encodeURIComponent(instance.instanceId)}/open-terminal`,
+        { emulator: 'system' },
+      );
+      if (result.ok) {
+        toast.success('Opening terminal…');
+      } else {
+        toast.error(result.error || 'Failed to open terminal');
+        // Fallback: copy the command so the user can paste it manually.
+        if (attachCommand) {
+          try {
+            await navigator.clipboard.writeText(attachCommand);
+            toast.success('Command copied to clipboard');
+          } catch { /* noop */ }
+        }
+      }
+    } catch (err) {
+      toast.error(`Failed: ${(err as Error).message}`);
+      // Fallback: copy command on network error.
+      if (attachCommand) {
+        try {
+          await navigator.clipboard.writeText(attachCommand);
+          toast.success('Command copied to clipboard');
+        } catch { /* noop */ }
+      }
+    } finally {
+      setOpening(false);
+    }
+  };
+
+  // Don't render anything if there's no tmux session to attach to.
+  if (!sessionName) {
+    return (
+      <Card variant="outlined" className="bg-tmux-card bg-tmux-card-warn">
+        <div className="bg-tmux-card-header">
+          <AlertTriangle size={14} />
+          <span>No tmux session</span>
+        </div>
+        <p className="bg-tmux-hint muted">
+          This instance does not have a tmux session attached.
+          Sessions are created automatically when a background agent starts.
+        </p>
+      </Card>
+    );
+  }
+
+  return (
+    <Card variant="outlined" className="bg-tmux-card">
+      <div className="bg-tmux-card-header">
+        <Terminal size={14} />
+        <span>tmux session</span>
+        {instance.tmuxActive !== false ? (
+          <span className="badge badge-success">live</span>
+        ) : (
+          <span className="badge badge-warning">inactive</span>
+        )}
+      </div>
+
+      <code className="mono bg-tmux-session-name">{sessionName}</code>
+
+      <p className="muted bg-tmux-hint">
+        Attach to the agent's tmux session from a terminal on the host
+        running the dashboard.
+      </p>
+
+      <div className="bg-tmux-card-actions">
+        <Button variant="ghost" size="sm" onClick={copyCommand} title="Copy attach command">
+          <Copy size={14} /> Copy
+        </Button>
+        <Button
+          variant="primary"
+          size="sm"
+          onClick={openTerminal}
+          loading={opening}
+          title="Open in system terminal"
+        >
+          <Terminal size={14} /> Open terminal
+        </Button>
+      </div>
+    </Card>
+  );
+}

package/bizar-dash/src/web/components/chat/AgentNode.tsx

@@ -0,0 +1,127 @@
+// src/components/chat/AgentNode.tsx — single card in the agent orchestration tree.
+//
+// Two modes:
+//   collapsible=true  — header is a button with a chevron; toggles its
+//                       own summary + children visibility.
+//   collapsible=false — header is a static div (no chevron / no toggle).
+//                       Children render if present but cannot be
+//                       collapsed by the user.
+//
+// FIX #1 (session-collapsed-by-default) is handled at the *parent*
+// (SubAgentList / AgentTree) which decides whether to mount this
+// node's children at all. This component is purely presentational.
+
+import { useState } from 'react';
+
+export type AgentStatus = 'idle' | 'streaming' | 'done' | 'blocked' | 'awaiting';
+
+export interface AgentTreeNode {
+  id: string;
+  name: string;
+  role?: string;
+  status: AgentStatus;
+  summary?: string;
+  children?: AgentTreeNode[];
+}
+
+interface Props {
+  node: AgentTreeNode;
+  depth?: number;
+  collapsible?: boolean;
+  isLast?: boolean;
+  /** Controlled open state — used by SubAgentList so the parent rail
+   *  row's tree-chevron is the single source of truth for collapse. */
+  open?: boolean;
+  onToggle?: (next: boolean) => void;
+}
+
+export function AgentNode({
+  node,
+  depth = 0,
+  collapsible = false,
+  isLast = true,
+  open: controlledOpen,
+  onToggle,
+}: Props) {
+  const [internalOpen, setInternalOpen] = useState<boolean>(collapsible);
+  const isControlled = controlledOpen !== undefined;
+  const open = isControlled ? controlledOpen : internalOpen;
+  const setOpen = (next: boolean) => {
+    if (!isControlled) setInternalOpen(next);
+    onToggle?.(next);
+  };
+
+  const hasChildren = (node.children?.length ?? 0) > 0;
+
+  const headContent = (
+    <>
+      {collapsible && (
+        <span
+          className={`agent-node-chevron ${open ? 'open' : ''}`}
+          aria-hidden
+        >
+          ›
+        </span>
+      )}
+      <span
+        className={`agent-node-dot status-${node.status}`}
+        aria-hidden
+      />
+      <span className="agent-node-name">{node.name}</span>
+      {node.role && <span className="agent-node-role chat-mono">{node.role}</span>}
+      <span className={`agent-node-pill status-${node.status}`}>{node.status}</span>
+    </>
+  );
+
+  return (
+    <div
+      className={[
+        'agent-node',
+        `depth-${depth}`,
+        `status-${node.status}`,
+        open ? 'open' : 'closed',
+        isLast ? 'last' : '',
+      ]
+        .filter(Boolean)
+        .join(' ')}
+    >
+      {collapsible ? (
+        <button
+          type="button"
+          className={`agent-node-head status-${node.status} collapsible`}
+          onClick={(e) => {
+            e.stopPropagation();
+            setOpen(!open);
+          }}
+          aria-expanded={open}
+        >
+          {headContent}
+        </button>
+      ) : (
+        <div className={`agent-node-head status-${node.status}`}>
+          {headContent}
+        </div>
+      )}
+      {open && (
+        <>
+          {node.summary && (
+            <div className="agent-node-summary">{node.summary}</div>
+          )}
+          {hasChildren && (
+            <div className="agent-node-children">
+              {node.children!.map((child, i) => (
+                <AgentNode
+                  key={child.id}
+                  node={child}
+                  depth={depth + 1}
+                  collapsible={false}
+                  isLast={i === node.children!.length - 1}
+                />
+              ))}
+            </div>
+          )}
+        </>
+      )}
+    </div>
+  );
+}

package/bizar-dash/src/web/components/chat/AgentTree.tsx

@@ -0,0 +1,80 @@
+// src/components/chat/AgentTree.tsx — vertical chain of session cards connected by
+// backbone+L-stub connectors. Two modes:
+//
+//   full tree (variant="full") — renders the root card and all its children.
+//     Used inside the thread head when the active session has sub-agents.
+//
+//   children-only (variant="rail" via SubAgentList) — renders only the children
+//     of the root; the rail row above already shows the root card, so
+//     re-rendering it would duplicate. Children hang directly off the
+//     rail row via standard backbone + L-stub connectors.
+//
+// FIX #1 — the parent (ChatRail) passes `open=false` by default for a
+// freshly-clicked session so the tree is collapsed on first click; the
+// user can open it via the chevron in the row.
+
+import { Fragment } from 'react';
+import { AgentNode, type AgentTreeNode } from './AgentNode';
+
+interface FullTreeProps {
+  tree: { root: AgentTreeNode };
+  variant?: 'full';
+  open?: boolean;
+}
+
+interface ChildrenOnlyProps {
+  children: AgentTreeNode[];
+  variant: 'rail' | 'thread';
+  open?: boolean;
+}
+
+function isFullTree(props: FullTreeProps | ChildrenOnlyProps): props is FullTreeProps {
+  return (props as FullTreeProps).tree !== undefined;
+}
+
+export function AgentTree(props: FullTreeProps | ChildrenOnlyProps) {
+  const open = props.open ?? true;
+
+  if (isFullTree(props)) {
+    return (
+      <div className={`agent-tree variant-${props.variant ?? 'full'}`}>
+        <AgentNode node={props.tree.root} depth={0} open={open} />
+      </div>
+    );
+  }
+
+  // Children-only path (used by SubAgentList hanging off the rail row).
+  const list = props.children ?? [];
+  return (
+    <div className={`agent-tree variant-${props.variant} agent-tree-children-only`}>
+      <div className="agent-tree-children-body">
+        {list.map((child, i) => (
+          <Fragment key={child.id}>
+            <AgentNode
+              node={child}
+              depth={0}
+              collapsible={false}
+              open={open}
+              isLast={i === list.length - 1}
+            />
+          </Fragment>
+        ))}
+      </div>
+    </div>
+  );
+}
+
+/* ── SubAgentList — convenience wrapper used by the ChatRail to render
+   the children of a session's tree directly under the active row. ── */
+export function SubAgentList({
+  children,
+  variant = 'rail',
+  open = true,
+}: {
+  children: AgentTreeNode[];
+  variant?: 'rail' | 'thread';
+  open?: boolean;
+}) {
+  if (!open) return null;
+  return <AgentTree variant={variant} open={open} children={children} />;
+}