@synergenius/flow-weaver-pack-weaver 0.9.59 → 0.9.77

package/src/bot/task-queue.ts

@@ -1,262 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as crypto from 'node:crypto';
-import { withFileLock } from './file-lock.js';
-import { parseNdjson } from './safe-json.js';
-import { resolveWeaverDir } from './paths.js';
-
-export interface QueuedTask {
-  id: string;
-  instruction: string;
-  mode?: 'create' | 'modify' | 'read' | 'batch';
-  targets?: string[];
-  options?: Record<string, unknown>;
-  priority: number;
-  addedAt: number;
-  status: 'pending' | 'running' | 'completed' | 'no-op' | 'failed' | 'cancelled';
-  /** PID of the process running this task (set when status becomes 'running'). */
-  runnerId?: number;
-  /** Error reason (set on failure) */
-  failureReason?: string;
-}
-
-export interface AddResult {
-  id: string;
-  duplicate: boolean;
-}
-
-/** Max pending tasks before queue rejects new additions. */
-const MAX_PENDING = 200;
-/** Don't re-queue tasks completed within this window (ms). */
-const CYCLE_DEDUP_WINDOW = 3600_000; // 1 hour
-
-export class TaskQueue {
-  readonly filePath: string;
-
-  constructor(dir?: string) {
-    const base = dir ?? resolveWeaverDir();
-    this.filePath = path.join(base, 'task-queue.ndjson');
-  }
-
-  async add(task: Omit<QueuedTask, 'id' | 'addedAt' | 'status'>): Promise<AddResult> {
-    return withFileLock(this.filePath, () => {
-      const existing = this.readAll();
-
-      // Dedup: skip if a pending task with the same instruction exists
-      const pendingDup = existing.find(
-        t => t.status === 'pending' && t.instruction === task.instruction,
-      );
-      if (pendingDup) return { id: pendingDup.id, duplicate: true };
-
-      // Cycle-aware dedup: skip if same instruction was completed recently
-      const recentDup = existing.find(
-        t => (t.status === 'completed' || t.status === 'no-op')
-          && t.instruction === task.instruction
-          && Date.now() - t.addedAt < CYCLE_DEDUP_WINDOW,
-      );
-      if (recentDup) return { id: recentDup.id, duplicate: true };
-
-      // Queue size cap
-      const pendingCount = existing.filter(t => t.status === 'pending').length;
-      if (pendingCount >= MAX_PENDING) {
-        throw new Error(`Queue full (${MAX_PENDING} pending tasks). Use queue_retry to resume failed tasks, or queue_list to review.`);
-      }
-
-      const entry: QueuedTask = {
-        ...task,
-        id: crypto.randomUUID().slice(0, 8),
-        addedAt: Date.now(),
-        status: 'pending',
-      };
-      const dir = path.dirname(this.filePath);
-      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-      fs.appendFileSync(this.filePath, JSON.stringify(entry) + '\n', 'utf-8');
-      return { id: entry.id, duplicate: false };
-    });
-  }
-
-  async next(): Promise<QueuedTask | null> {
-    return withFileLock(this.filePath, () => {
-      const tasks = this.readAll().filter(t => t.status === 'pending');
-      tasks.sort((a, b) => b.priority - a.priority || a.addedAt - b.addedAt);
-      return tasks[0] ?? null;
-    });
-  }
-
-  async list(): Promise<QueuedTask[]> {
-    return withFileLock(this.filePath, () => this.readAll());
-  }
-
-  async remove(id: string): Promise<boolean> {
-    return withFileLock(this.filePath, () => {
-      const tasks = this.readAll();
-      const filtered = tasks.filter(t => t.id !== id);
-      if (filtered.length === tasks.length) return false;
-      this.writeAll(filtered);
-      return true;
-    });
-  }
-
-  async clear(): Promise<number> {
-    return withFileLock(this.filePath, () => {
-      const tasks = this.readAll();
-      if (tasks.length === 0) return 0;
-      try { fs.unlinkSync(this.filePath); } catch { /* ignore */ }
-      return tasks.length;
-    });
-  }
-
-  async markRunning(id: string): Promise<void> {
-    return withFileLock(this.filePath, () => {
-      const tasks = this.readAll();
-      const task = tasks.find(t => t.id === id);
-      if (task) {
-        task.status = 'running';
-        task.runnerId = process.pid;
-        this.writeAll(tasks);
-      }
-    });
-  }
-
-  async markComplete(id: string): Promise<void> {
-    await this.updateStatus(id, 'completed');
-  }
-
-  async markNoOp(id: string): Promise<void> {
-    await this.updateStatus(id, 'no-op');
-  }
-
-  async markFailed(id: string, reason?: string): Promise<void> {
-    return withFileLock(this.filePath, () => {
-      const tasks = this.readAll();
-      const task = tasks.find(t => t.id === id);
-      if (task) {
-        task.status = 'failed';
-        if (reason) task.failureReason = reason.slice(0, 500);
-        this.writeAll(tasks);
-      }
-    });
-  }
-
-  /** Reset a failed or running task back to pending. */
-  async retry(id: string): Promise<boolean> {
-    return withFileLock(this.filePath, () => {
-      const tasks = this.readAll();
-      const task = tasks.find(t => t.id === id && (t.status === 'failed' || t.status === 'running'));
-      if (!task) return false;
-      task.status = 'pending';
-      task.failureReason = undefined;
-      this.writeAll(tasks);
-      return true;
-    });
-  }
-
-  /** Reset ALL failed tasks back to pending. Returns count reset. */
-  async retryAll(): Promise<number> {
-    return withFileLock(this.filePath, () => {
-      const tasks = this.readAll();
-      let count = 0;
-      for (const t of tasks) {
-        if (t.status === 'failed') {
-          t.status = 'pending';
-          t.failureReason = undefined;
-          count++;
-        }
-      }
-      if (count > 0) this.writeAll(tasks);
-      return count;
-    });
-  }
-
-  /** Reset orphaned "running" tasks to pending (crash recovery).
-   *  Resets tasks whose runner PID is dead, OR whose PID is current process
-   *  but the run is no longer tracked in the in-memory registry. */
-  async recoverOrphans(activeRunIds?: Set<string>): Promise<number> {
-    return withFileLock(this.filePath, () => {
-      const tasks = this.readAll();
-      let count = 0;
-      const currentPid = process.pid;
-      for (const t of tasks) {
-        if (t.status === 'running') {
-          // If we have a registry, check it — definitive alive/dead
-          if (activeRunIds && t.runnerId === currentPid) {
-            // Same process but run not in registry = dead
-            // (We don't have the runId on the task, so if this process's
-            //  registry is empty, all its running tasks are orphans)
-            if (activeRunIds.size === 0) {
-              t.status = 'pending';
-              t.runnerId = undefined;
-              count++;
-            }
-            continue;
-          }
-          // Different process or no registry — check PID
-          if (t.runnerId != null) {
-            let alive = false;
-            try { process.kill(t.runnerId, 0); alive = true; } catch { /* process gone */ }
-            if (alive) continue;
-          }
-          t.status = 'pending';
-          t.runnerId = undefined;
-          count++;
-        }
-      }
-      if (count > 0) this.writeAll(tasks);
-      return count;
-    });
-  }
-
-  async reorder(id: string, priority: number): Promise<boolean> {
-    return withFileLock(this.filePath, () => {
-      const tasks = this.readAll();
-      const task = tasks.find(t => t.id === id);
-      if (!task) return false;
-      task.priority = priority;
-      this.writeAll(tasks);
-      return true;
-    });
-  }
-
-  private async updateStatus(id: string, status: QueuedTask['status']): Promise<void> {
-    return withFileLock(this.filePath, () => {
-      const tasks = this.readAll();
-      const task = tasks.find(t => t.id === id);
-      if (task) {
-        task.status = status;
-        this.writeAll(tasks);
-      }
-    });
-  }
-
-  private readAll(): QueuedTask[] {
-    if (!fs.existsSync(this.filePath)) return [];
-    const content = fs.readFileSync(this.filePath, 'utf-8').trim();
-    if (!content) return [];
-    const { records } = parseNdjson<QueuedTask>(content, 'task-queue');
-    return records;
-  }
-
-  /** Atomically claim the next pending task: selects highest-priority and marks it running in one lock. */
-  async claimNext(): Promise<QueuedTask | null> {
-    return withFileLock(this.filePath, () => {
-      const tasks = this.readAll();
-      const pending = tasks.filter(t => t.status === 'pending');
-      pending.sort((a, b) => b.priority - a.priority || a.addedAt - b.addedAt);
-      const chosen = pending[0];
-      if (!chosen) return null;
-      chosen.status = 'running';
-      chosen.runnerId = process.pid;
-      this.writeAll(tasks);
-      return chosen;
-    });
-  }
-
-  private writeAll(tasks: QueuedTask[]): void {
-    const dir = path.dirname(this.filePath);
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    // Atomic write: write to temp file then rename to avoid partial reads on crash
-    const tmpPath = this.filePath + '.tmp.' + process.pid;
-    fs.writeFileSync(tmpPath, tasks.map(t => JSON.stringify(t)).join('\n') + (tasks.length > 0 ? '\n' : ''), 'utf-8');
-    fs.renameSync(tmpPath, this.filePath);
-  }
-}

package/src/ui/bot-workspace.tsx

@@ -1,442 +0,0 @@
-/**
- * Weaver Bot Workspace — center dock execution workspace.
- *
- * Pack-contributed component loaded via botUI.workspace manifest slot.
- * Receives PackWorkspaceContext from platform — uses it for all tool calls,
- * event streaming, and window management. Zero platform imports.
- *
- * Single chronological timeline (oldest → newest, like a conversation):
- * - Completed runs at the top
- * - Live execution streaming in the middle
- * - Queued tasks at the bottom
- * - Genesis cycles interleaved with history
- *
- * Layout:
- * - Session bar (top)
- * - Settings (collapsed)
- * - Scrollable timeline (main area)
- * - Input bar (pinned bottom)
- */
-const React = require('react');
-const { useRef, useEffect, useState, useCallback, useMemo } = React;
-const {
-  Flex, ScrollArea, EmptyState, TaskBlock, toast, usePackWorkspace, useEventStream,
-} = require('@fw/plugin-ui-kit');
-
-// Local pack-specific components and utilities (bundled by esbuild)
-import { SessionBar } from './session-bar';
-import { SettingsSection } from './settings-section';
-import { QueueInput } from './queue-input';
-import { GenesisBlock } from './genesis-block';
-// ApprovalCard no longer needed — TaskBlock handles approval UI natively
-import { useStreamTimeline } from './use-stream-timeline';
-import { traceToTimeline } from './trace-to-timeline';
-import { sendSteerCommand } from './steer-api';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-interface QueuedTask {
-  id: string;
-  instruction: string;
-  status: string;
-  priority: number;
-}
-
-interface GenesisCycleData {
-  id: string;
-  timestamp: string;
-  durationMs: number;
-  proposal: Record<string, unknown> | null;
-  outcome: string;
-  diffSummary: string | null;
-  error: string | null;
-}
-
-interface HistoricalRun {
-  id: string;
-  outcome: string;
-  success?: boolean;
-  summary?: string;
-  startedAt?: string;
-  durationMs?: number;
-  duration?: number;
-  cost?: number;
-  costDetail?: Record<string, unknown>;
-  workflowFile?: string;
-  plan?: Record<string, unknown>;
-  trace?: Array<Record<string, unknown>>;
-  nodeMeta?: Record<string, Record<string, unknown>>;
-  auditTrail?: Array<Record<string, unknown>>;
-  params?: Record<string, unknown>;
-  [key: string]: unknown;
-}
-
-interface TimelineItem {
-  kind: 'run' | 'genesis';
-  timestamp: number;
-  run?: HistoricalRun;
-  runTimeline?: Array<Record<string, unknown>>;
-  genesis?: GenesisCycleData;
-}
-
-// ---------------------------------------------------------------------------
-// Component
-// ---------------------------------------------------------------------------
-
-function BotWorkspace() {
-  const ctx = usePackWorkspace();
-  const { callTool, windowData, dispatchEvent, onRefresh } = ctx;
-  const packId = ctx.packId;
-
-  const isLive = windowData?.live === true && !!windowData?.runId;
-  const highlightRunId = windowData?.runId as string | undefined;
-
-  // ── Live execution (SSE stream) ──────────────────────────────
-  const stream = useEventStream();
-  const {
-    timeline: liveTimeline,
-    phase: livePhase,
-    instruction: liveInstruction,
-    elapsed,
-    cost,
-    plan,
-    awaitingApproval,
-  } = useStreamTimeline(stream.events, stream.isDone);
-
-  // Start SSE stream for direct live run (from AI chat)
-  useEffect(() => {
-    if (!isLive || !windowData?.runId) return;
-    stream.start(packId, 'fw_weaver_events', windowData.runId as string);
-    return () => stream.stop();
-  }, [isLive, packId, windowData?.runId]);
-
-  // Auto-detect active session task
-  const [sessionRunId, setSessionRunId] = useState<string | null>(null);
-
-  useEffect(() => {
-    if (isLive) return;
-    const poll = async () => {
-      try {
-        const status = (await callTool('fw_weaver_status')) as Record<string, unknown> | null;
-        const runId = (status?.currentRunId as string) ?? null;
-        const alive = status?.alive as boolean | null;
-        if (runId && alive === false) {
-          setSessionRunId(null);
-        } else {
-          setSessionRunId(runId);
-        }
-      } catch { /* non-fatal */ }
-    };
-    poll();
-    const interval = setInterval(poll, 3_000);
-    return () => clearInterval(interval);
-  }, [isLive, callTool]);
-
-  // Start SSE for session's current task
-  useEffect(() => {
-    if (!sessionRunId || isLive) return;
-    stream.start(packId, 'fw_weaver_events', sessionRunId);
-    return () => stream.stop();
-  }, [sessionRunId, packId, isLive]);
-
-  // Auto-scroll
-  const scrollRef = useRef<HTMLDivElement>(null);
-  useEffect(() => {
-    const el = scrollRef.current;
-    if (el) el.scrollTop = el.scrollHeight;
-  }, [liveTimeline.length, stream.events.length]);
-
-  // Steer controls
-  const [pausing, setPausing] = useState(false);
-  const [stopping, setStopping] = useState(false);
-
-  const handlePause = useCallback(async () => {
-    setPausing(true);
-    try {
-      await sendSteerCommand(callTool, 'pause');
-      toast('Pause signal sent', { type: 'info' });
-    } catch (err: unknown) {
-      toast(err instanceof Error ? err.message : 'Failed to pause', { type: 'error' });
-    }
-    setPausing(false);
-  }, [callTool]);
-
-  const handleStop = useCallback(async () => {
-    setStopping(true);
-    try {
-      await sendSteerCommand(callTool, 'cancel');
-      toast('Stopping — will take effect after current node completes', { type: 'info' });
-    } catch (err: unknown) {
-      toast(err instanceof Error ? err.message : 'Failed to stop', { type: 'error' });
-      setStopping(false);
-    }
-  }, [callTool]);
-
-  // ── History + Genesis + Queue ────────────────────────────────
-  const [history, setHistory] = useState<HistoricalRun[]>([]);
-  const [genesisCycles, setGenesisCycles] = useState<GenesisCycleData[]>([]);
-  const [queuedTasks, setQueuedTasks] = useState<QueuedTask[]>([]);
-  const [removingIds, setRemovingIds] = useState<Set<string>>(new Set());
-  const [expandedRunId, setExpandedRunId] = useState<string | null>(
-    highlightRunId && !isLive ? highlightRunId : null,
-  );
-  const [liveExpanded, setLiveExpanded] = useState(true);
-
-  const refreshData = useCallback(() => {
-    callTool('fw_weaver_history', { limit: 20 }).then((data: unknown) => {
-      if (Array.isArray(data)) {
-        setHistory(
-          data.map((r: Record<string, unknown>) => {
-            const costObj = r.cost && typeof r.cost === 'object' ? (r.cost as Record<string, unknown>) : undefined;
-            return { ...r, costDetail: costObj, cost: costObj?.totalCost } as unknown as HistoricalRun;
-          }),
-        );
-      } else {
-        setHistory([]);
-      }
-    });
-    callTool('fw_weaver_insights').then((data: unknown) => {
-      const d = data as Record<string, unknown> | null;
-      if (d?.evolution) {
-        const evo = d.evolution as Record<string, unknown>;
-        if (Array.isArray(evo.recentCycles)) {
-          setGenesisCycles(evo.recentCycles.slice(0, 10) as GenesisCycleData[]);
-        }
-      }
-    });
-    callTool('fw_weaver_queue', { action: 'list' }).then((data: unknown) => {
-      const visible = (Array.isArray(data) ? (data as QueuedTask[]) : []).filter(
-        (t: QueuedTask) => t.status === 'pending' || t.status === 'running',
-      );
-      setQueuedTasks(visible);
-    });
-  }, [callTool]);
-
-  useEffect(() => { refreshData(); }, [refreshData]);
-
-  // Poll queue every 10s
-  useEffect(() => {
-    const interval = setInterval(() => {
-      callTool('fw_weaver_queue', { action: 'list' }).then((data: unknown) => {
-        const visible = (Array.isArray(data) ? (data as QueuedTask[]) : []).filter(
-          (t: QueuedTask) => t.status === 'pending' || t.status === 'running',
-        );
-        setQueuedTasks(visible);
-      });
-    }, 10_000);
-    return () => clearInterval(interval);
-  }, [callTool]);
-
-  // Listen for refresh events
-  useEffect(() => {
-    return onRefresh(() => refreshData());
-  }, [refreshData, onRefresh]);
-
-  // Refresh when session task changes
-  useEffect(() => {
-    if (sessionRunId !== null) refreshData();
-  }, [sessionRunId, refreshData]);
-
-  const handleRemoveTask = useCallback(async (id: string) => {
-    setRemovingIds((prev: Set<string>) => new Set(prev).add(id));
-    try {
-      await callTool('fw_weaver_queue', { action: 'remove', id });
-      refreshData();
-      toast('Task removed', { type: 'warning' });
-    } catch (err: unknown) {
-      toast(err instanceof Error ? err.message : 'Failed to remove task', { type: 'error' });
-    }
-    setRemovingIds((prev: Set<string>) => {
-      const next = new Set(prev);
-      next.delete(id);
-      return next;
-    });
-  }, [callTool, refreshData]);
-
-  // Build unified timeline
-  const timelineItems = useMemo(() => {
-    const items: TimelineItem[] = [];
-    for (const run of history) {
-      items.push({ kind: 'run', timestamp: new Date(run.startedAt ?? 0).getTime(), run, runTimeline: traceToTimeline(run) });
-    }
-    for (const cycle of genesisCycles) {
-      items.push({ kind: 'genesis', timestamp: new Date(cycle.timestamp).getTime(), genesis: cycle });
-    }
-    items.sort((a: TimelineItem, b: TimelineItem) => a.timestamp - b.timestamp);
-    return items;
-  }, [history, genesisCycles]);
-
-  const toggleExpand = useCallback((id: string) => {
-    setExpandedRunId((prev: string | null) => (prev === id ? null : id));
-  }, []);
-
-  // ── Render ────────────────────────────────────────────────────
-
-  const isStreaming = isLive || !!sessionRunId;
-  const hasContent = isStreaming || timelineItems.length > 0 || queuedTasks.length > 0;
-
-  // Helper to extract instruction text from a run
-  function extractInstruction(run: HistoricalRun): string {
-    let text = '';
-    if (run.params) {
-      try {
-        const taskJson = (run.params as Record<string, unknown>).taskJson as string;
-        if (taskJson) {
-          const task = JSON.parse(taskJson) as Record<string, unknown>;
-          if (task.instruction) text = task.instruction as string;
-        }
-      } catch { /* not JSON */ }
-    }
-    if (!text && run.summary) {
-      const summary = run.summary;
-      if (summary.includes('|')) {
-        const parts = summary.split('|').map((p: string) => p.trim());
-        const taskPart = parts.find((p: string) => p.startsWith('Task:'));
-        const summaryPart = parts.find((p: string) => p.startsWith('Summary:'));
-        text = taskPart?.replace('Task:', '').trim() ?? summaryPart?.replace('Summary:', '').trim() ?? parts[0] ?? '';
-      } else {
-        text = summary;
-      }
-    }
-    if (!text) {
-      const wf = run.workflowFile;
-      if (wf) {
-        const parts = wf.split('/');
-        text = parts[parts.length - 1] ?? 'Bot run';
-      } else {
-        text = 'Bot run';
-      }
-    }
-    if (text.length > 120) text = text.slice(0, 117) + '...';
-    return text;
-  }
-
-  // Approval state for running TaskBlock
-  const [approvalStatus, setApprovalStatus] = useState<'pending' | 'approved' | 'rejected' | null>(null);
-  const [approvalLoading, setApprovalLoading] = useState(false);
-
-  // Sync approval status with stream events
-  useEffect(() => {
-    if (awaitingApproval) setApprovalStatus('pending');
-  }, [awaitingApproval]);
-
-  // Reset approval when stream restarts (new run)
-  useEffect(() => {
-    if (stream.events.length === 0) setApprovalStatus(null);
-  }, [stream.events.length]);
-
-  const handleApprove = useCallback(async () => {
-    setApprovalLoading(true);
-    try {
-      await callTool('fw_weaver_approve', { approved: true });
-      setApprovalStatus('approved');
-      toast('Plan approved', { type: 'success' });
-    } catch (err: unknown) {
-      toast(err instanceof Error ? err.message : 'Failed to approve', { type: 'error' });
-    }
-    setApprovalLoading(false);
-  }, [callTool]);
-
-  const handleReject = useCallback(async () => {
-    setApprovalLoading(true);
-    try {
-      await callTool('fw_weaver_approve', { approved: false });
-      setApprovalStatus('rejected');
-      toast('Plan rejected', { type: 'info' });
-    } catch (err: unknown) {
-      toast(err instanceof Error ? err.message : 'Failed to reject', { type: 'error' });
-    }
-    setApprovalLoading(false);
-  }, [callTool]);
-
-  return React.createElement(Flex, {
-    variant: 'column-stretch-start-nowrap-0',
-    style: { width: '100%', height: '100%', overflow: 'hidden' },
-  },
-    // Session bar
-    React.createElement(SessionBar, { callTool, dispatchEvent }),
-
-    // Settings
-    React.createElement(SettingsSection, { callTool, dispatchEvent }),
-
-    // Main scrollable timeline
-    React.createElement(Flex, { variant: 'column-stretch-start-nowrap-0', style: { flex: 1, minHeight: 0 } },
-      React.createElement(ScrollArea, { ref: scrollRef },
-        React.createElement(Flex, { variant: 'column-stretch-start-nowrap-8', style: { padding: '12px 16px' } },
-          // Empty state
-          !hasContent && React.createElement(EmptyState, {
-            icon: 'smartToy', message: 'No bot runs yet',
-            description: 'Ask the AI assistant to run a task, or add tasks below.',
-          }),
-
-          // History + Genesis
-          ...timelineItems.map((item: TimelineItem) => {
-            if (item.kind === 'genesis' && item.genesis) {
-              return React.createElement(GenesisBlock, {
-                key: `genesis-${item.genesis.id}`, cycle: item.genesis, callTool,
-              });
-            }
-            if (item.kind === 'run' && item.run) {
-              const run = item.run;
-              const runId = run.id;
-              const isExpanded = expandedRunId === runId;
-              const isSuccess = run.outcome === 'completed' || run.success === true;
-              return React.createElement(TaskBlock, {
-                key: `run-${runId}`,
-                state: isSuccess ? 'completed' : 'failed',
-                instruction: extractInstruction(run),
-                timeline: item.runTimeline ?? [],
-                cost: typeof run.cost === 'number' ? run.cost : ((run.costDetail?.totalCost as number) ?? null),
-                plan: run.plan,
-                startedAt: run.startedAt,
-                durationMs: run.durationMs ?? run.duration,
-                expanded: isExpanded,
-                onToggleExpand: () => toggleExpand(runId),
-              });
-            }
-            return null;
-          }),
-
-          // Live execution
-          isStreaming && React.createElement(TaskBlock, {
-            state: 'running',
-            instruction: liveInstruction ?? (windowData?.instruction as string) ?? 'Running...',
-            timeline: liveTimeline,
-            phase: livePhase,
-            elapsed,
-            cost,
-            plan,
-            error: stream.error,
-            approval: approvalStatus ?? undefined,
-            approvalLoading,
-            onApprove: handleApprove,
-            onReject: handleReject,
-            onPause: handlePause,
-            onStop: handleStop,
-            pauseLoading: pausing,
-            stopLoading: stopping,
-            expanded: liveExpanded,
-            onToggleExpand: () => setLiveExpanded((v: boolean) => !v),
-          }),
-
-          // Queued tasks
-          ...(isStreaming ? queuedTasks.filter((t: QueuedTask) => t.status !== 'running') : queuedTasks)
-            .map((task: QueuedTask) =>
-              React.createElement(TaskBlock, {
-                key: task.id, state: 'pending', instruction: task.instruction,
-                onRemove: () => handleRemoveTask(task.id),
-                removeLoading: removingIds.has(task.id),
-              }),
-            ),
-        ),
-      ),
-    ),
-
-    // Input bar
-    React.createElement(QueueInput, { callTool, onTaskAdded: refreshData }),
-  );
-}
-
-module.exports = BotWorkspace;