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

package/dist/ui/bot-workspace.js

@@ -1,1015 +0,0 @@
-"use strict";
-
-// src/ui/session-bar.tsx
-var React = require("react");
-var { useState, useEffect, useCallback, useRef } = React;
-var { Flex, Typography, Icon, Button, Badge, toast, formatDuration, formatCost } = require("@fw/plugin-ui-kit");
-function SessionBar({ callTool, dispatchEvent }) {
-  const [session, setSession] = useState(null);
-  const [elapsed, setElapsed] = useState(0);
-  const [starting, setStarting] = useState(false);
-  const [stopping, setStopping] = useState(false);
-  const [pausing, setPausing] = useState(false);
-  const prevActiveRef = useRef(false);
-  const pollStatus = useCallback(async () => {
-    try {
-      const result = await callTool("fw_weaver_session", { action: "status" });
-      const isActive2 = result.status !== "no active session" && result.status !== "idle";
-      setSession(isActive2 ? result : null);
-      if (prevActiveRef.current && !isActive2) {
-        dispatchEvent("fw:refresh-bot-workspace");
-      }
-      prevActiveRef.current = isActive2;
-    } catch {
-    }
-  }, [callTool, dispatchEvent]);
-  useEffect(() => {
-    pollStatus();
-    const interval = setInterval(pollStatus, 5e3);
-    return () => clearInterval(interval);
-  }, [pollStatus]);
-  useEffect(() => {
-    if (!session?.startedAt || session.status === "idle") return;
-    const tick = () => setElapsed(Date.now() - (session.startedAt ?? Date.now()));
-    tick();
-    const interval = setInterval(tick, 1e3);
-    return () => clearInterval(interval);
-  }, [session?.startedAt, session?.status]);
-  const [startError, setStartError] = useState(null);
-  const handleStart = useCallback(async () => {
-    setStarting(true);
-    setStartError(null);
-    try {
-      const result = await callTool("fw_weaver_session", { action: "start" });
-      const data = result;
-      if (data?.error) {
-        setStartError(data.error);
-        toast(data.error, { type: "error" });
-        setStarting(false);
-        return;
-      }
-      toast("Session started", { type: "success" });
-      dispatchEvent("fw:refresh-bot-workspace");
-      await pollStatus();
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : "Failed to start session";
-      setStartError(msg);
-      toast(msg, { type: "error" });
-    }
-    setStarting(false);
-  }, [callTool, pollStatus, dispatchEvent]);
-  const handleStop = useCallback(async () => {
-    setStopping(true);
-    try {
-      await callTool("fw_weaver_session", { action: "stop" });
-      toast("Session ended", { type: "info" });
-      await pollStatus();
-    } catch (err) {
-      toast(err instanceof Error ? err.message : "Failed to stop session", { type: "error" });
-    }
-    setStopping(false);
-  }, [callTool, pollStatus]);
-  const handlePause = useCallback(async () => {
-    setPausing(true);
-    try {
-      await callTool("fw_weaver_steer", { command: "pause" });
-      toast("Session paused", { type: "info" });
-    } catch (err) {
-      toast(err instanceof Error ? err.message : "Failed to pause session", { type: "error" });
-    }
-    setPausing(false);
-  }, [callTool]);
-  const isActive = session && session.status !== "idle" && session.status !== "no active session";
-  if (!isActive) {
-    return React.createElement(
-      Flex,
-      {
-        variant: "row-center-space-between-nowrap-10",
-        style: { flexShrink: 0, padding: "8px 16px", backgroundColor: "transparent", borderBottom: "1px solid var(--color-border-default)" }
-      },
-      React.createElement(Icon, { name: "smartToy", size: 14, color: "color-text-subtle" }),
-      React.createElement(
-        Flex,
-        { variant: "row-center-start-nowrap-12", style: { flex: 1, fontSize: "12px" } },
-        React.createElement(Typography, {
-          variant: "caption-regular",
-          color: startError ? "color-status-negative" : "color-text-subtle"
-        }, startError ?? "No active session")
-      ),
-      React.createElement(
-        Flex,
-        { variant: "row-center-start-nowrap-6", style: { flexShrink: 0 } },
-        React.createElement(Button, {
-          size: "sm",
-          variant: "clear",
-          onClick: handleStart,
-          loading: starting,
-          disabled: starting
-        }, "Start Session")
-      )
-    );
-  }
-  return React.createElement(
-    Flex,
-    {
-      variant: "row-center-space-between-nowrap-10",
-      style: { flexShrink: 0, padding: "8px 16px", backgroundColor: "var(--color-brand-main-alpha-10)", borderBottom: "1px solid var(--color-brand-main)" }
-    },
-    React.createElement(Badge, { variant: "success" }, "Session"),
-    React.createElement(
-      Flex,
-      {
-        variant: "row-center-start-nowrap-12",
-        style: { flex: 1, fontSize: "12px", color: "var(--color-text-medium)" }
-      },
-      session.completedTasks != null && React.createElement("span", null, `${session.completedTasks} tasks done`),
-      session.totalCost != null && session.totalCost > 0 && React.createElement("span", null, formatCost(session.totalCost)),
-      session.startedAt && React.createElement("span", null, `${formatDuration(elapsed)} elapsed`),
-      session.currentTask && React.createElement("span", { style: { opacity: 0.7 } }, `\xB7 ${session.currentTask}`)
-    ),
-    React.createElement(
-      Flex,
-      { variant: "row-center-start-nowrap-6", style: { flexShrink: 0 } },
-      React.createElement(Button, {
-        size: "sm",
-        variant: "clear",
-        onClick: handlePause,
-        loading: pausing,
-        disabled: pausing || stopping
-      }, "Pause"),
-      React.createElement(Button, {
-        size: "sm",
-        variant: "clear",
-        color: "danger",
-        onClick: handleStop,
-        loading: stopping,
-        disabled: stopping || pausing
-      }, "End")
-    )
-  );
-}
-
-// src/ui/settings-section.tsx
-var React2 = require("react");
-var { useState: useState2, useEffect: useEffect2, useCallback: useCallback2 } = React2;
-var { Flex: Flex2, Typography: Typography2, Button: Button2, CollapsibleSection, KeyValueRow, toast: toast2 } = require("@fw/plugin-ui-kit");
-function SettingsSection({ callTool, dispatchEvent }) {
-  const [providers, setProviders] = useState2([]);
-  const [insights, setInsights] = useState2(null);
-  const handleClear = useCallback2(() => {
-    if (!confirm("Clear all bot run history? This action cannot be undone.")) return;
-    callTool("fw_weaver_history", { clear: true }).then(() => {
-      dispatchEvent("fw:refresh-bot-workspace");
-      toast2("Run history cleared", { type: "success" });
-    }).catch(() => {
-      toast2("Failed to clear history", { type: "error" });
-    });
-  }, [callTool, dispatchEvent]);
-  useEffect2(() => {
-    Promise.all([
-      callTool("fw_weaver_providers"),
-      callTool("fw_weaver_insights")
-    ]).then(([prov, ins]) => {
-      if (prov) setProviders(Array.isArray(prov) ? prov : []);
-      if (ins) setInsights(ins);
-    });
-  }, [callTool]);
-  const activeProvider = providers.find((p) => p.envVarsSet) ?? providers[0];
-  const trustScore = insights?.trust?.score;
-  const trustDisplay = trustScore != null ? (trustScore <= 1 ? (trustScore * 100).toFixed(0) : Math.round(trustScore)) + "%" : "\u2014";
-  return React2.createElement(
-    CollapsibleSection,
-    {
-      title: "Settings",
-      variant: "list",
-      defaultExpanded: false
-    },
-    React2.createElement(
-      Flex2,
-      { variant: "column-start-start-nowrap-4", style: { width: "100%" } },
-      activeProvider && React2.createElement(KeyValueRow, {
-        keyName: "Provider",
-        value: `${activeProvider.name} (${activeProvider.source})`,
-        size: "small"
-      }),
-      insights?.trust && React2.createElement(KeyValueRow, {
-        keyName: "Trust",
-        value: `Phase ${insights.trust.phase} \xB7 ${trustDisplay}`,
-        size: "small"
-      }),
-      insights?.health && React2.createElement(KeyValueRow, {
-        keyName: "Health",
-        value: `${insights.health.overall}/100`,
-        size: "small"
-      }),
-      insights?.cost && React2.createElement(KeyValueRow, {
-        keyName: "Cost (7d)",
-        value: `$${insights.cost.last7Days?.toFixed(2) ?? "0.00"} \xB7 ${insights.cost.trend ?? "stable"}`,
-        size: "small"
-      }),
-      React2.createElement(
-        Flex2,
-        {
-          variant: "row-center-space-between-nowrap-8",
-          style: { width: "100%", marginTop: "4px" }
-        },
-        React2.createElement(Button2, {
-          size: "xs",
-          variant: "outlined",
-          color: "danger",
-          onClick: handleClear
-        }, "Clear Run History"),
-        React2.createElement(Typography2, {
-          variant: "smallCaption-regular",
-          color: "color-text-subtle"
-        }, "Edit settings in .weaver.json")
-      )
-    )
-  );
-}
-
-// src/ui/queue-input.tsx
-var React3 = require("react");
-var { useState: useState3, useCallback: useCallback3 } = React3;
-var { Flex: Flex3, IconButton, Input, toast: toast3 } = require("@fw/plugin-ui-kit");
-function QueueInput({ callTool, onTaskAdded }) {
-  const [newTask, setNewTask] = useState3("");
-  const [adding, setAdding] = useState3(false);
-  const handleAdd = useCallback3(async () => {
-    const instruction = newTask.trim();
-    if (!instruction) return;
-    setAdding(true);
-    try {
-      await callTool("fw_weaver_queue", { action: "add", task: instruction });
-      setNewTask("");
-      onTaskAdded?.();
-      toast3("Task added to queue", { type: "success" });
-    } catch (err) {
-      toast3(err instanceof Error ? err.message : "Failed to add task", { type: "error" });
-    }
-    setAdding(false);
-  }, [callTool, newTask, onTaskAdded]);
-  return React3.createElement(
-    Flex3,
-    {
-      variant: "row-center-start-nowrap-6",
-      style: {
-        flexShrink: 0,
-        padding: "8px 16px",
-        borderTop: "1px solid var(--color-border-default)",
-        width: "100%",
-        boxSizing: "border-box"
-      }
-    },
-    React3.createElement(Input, {
-      type: "text",
-      size: "medium",
-      placeholder: "Add a task...",
-      value: newTask,
-      onChange: setNewTask,
-      onEnter: handleAdd,
-      disabled: adding,
-      defaultBoxStyle: { flex: 1, minWidth: 0 },
-      inputBoxStyle: { maxWidth: "none" }
-    }),
-    React3.createElement(IconButton, {
-      icon: "add",
-      size: "md",
-      variant: "fill",
-      color: "primary",
-      "aria-label": "Add task",
-      onClick: handleAdd,
-      loading: adding,
-      disabled: adding || !newTask.trim()
-    })
-  );
-}
-
-// src/ui/genesis-block.tsx
-var React4 = require("react");
-var { useState: useState4, useCallback: useCallback4 } = React4;
-var { CollapsibleBlock, Flex: Flex4, Typography: Typography3, Icon: Icon2, Badge: Badge2, Tag, Button: Button3, toast: toast4, formatTimestamp } = require("@fw/plugin-ui-kit");
-var OUTCOME_BADGE_VARIANTS = {
-  applied: "success",
-  "rolled-back": "error",
-  rejected: "warning",
-  stabilized: "success",
-  "no-change": "default",
-  error: "error"
-};
-var OUTCOME_STATUS = {
-  applied: "completed",
-  stabilized: "completed",
-  "rolled-back": "error",
-  rejected: "error",
-  error: "error",
-  "no-change": "completed"
-};
-function GenesisBlock({ cycle, callTool }) {
-  const [expanded, setExpanded] = useState4(false);
-  const [rollingBack, setRollingBack] = useState4(false);
-  const handleRollback = useCallback4(async () => {
-    setRollingBack(true);
-    try {
-      await callTool("fw_weaver_genesis_rollback", { cycleId: cycle.id });
-      toast4("Genesis cycle rolled back", { type: "success" });
-    } catch (err) {
-      toast4(err instanceof Error ? err.message : "Failed to rollback", { type: "error" });
-    }
-    setRollingBack(false);
-  }, [callTool, cycle.id]);
-  const summary = cycle.proposal?.summary ?? `Genesis cycle ${cycle.id.slice(0, 8)}`;
-  const badgeVariant = OUTCOME_BADGE_VARIANTS[cycle.outcome] ?? "default";
-  const status = OUTCOME_STATUS[cycle.outcome] ?? "pending";
-  return React4.createElement(
-    CollapsibleBlock,
-    {
-      status,
-      icon: React4.createElement(Icon2, { name: "autorenew", size: 14, color: "color-brand-main" }),
-      label: React4.createElement(Typography3, {
-        variant: "caption-thick",
-        color: "color-text-high",
-        style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap", minWidth: 0 }
-      }, summary),
-      headerSuffix: React4.createElement(
-        Flex4,
-        { variant: "row-center-start-nowrap-8" },
-        React4.createElement(Typography3, { variant: "smallCaption-regular", color: "color-text-subtle" }, formatTimestamp(cycle.timestamp)),
-        React4.createElement(Badge2, { variant: badgeVariant }, cycle.outcome)
-      ),
-      expanded,
-      onToggle: () => setExpanded((v) => !v)
-    },
-    // Proposal
-    cycle.proposal && React4.createElement(
-      Flex4,
-      {
-        variant: "column-start-start-nowrap-6",
-        style: { padding: "10px 12px", borderBottom: "1px solid var(--color-border-default)" }
-      },
-      React4.createElement(
-        Typography3,
-        { variant: "caption-bold", color: "color-text-subtle" },
-        `Proposal \xB7 ${cycle.proposal.impactLevel}`
-      ),
-      React4.createElement(
-        Typography3,
-        { variant: "smallCaption-regular", color: "color-text-medium" },
-        cycle.proposal.rationale
-      ),
-      ...cycle.proposal.operations.map(
-        (op, i) => React4.createElement(
-          Flex4,
-          { key: i, variant: "row-center-start-nowrap-6", style: { fontSize: "11px" } },
-          React4.createElement(Tag, { size: "small", color: "info" }, op.type),
-          React4.createElement(Typography3, { variant: "smallCaption-regular", color: "color-text-medium" }, op.rationale)
-        )
-      )
-    ),
-    // Diff
-    cycle.diffSummary && React4.createElement(
-      Flex4,
-      {
-        variant: "column-start-start-nowrap-6",
-        style: { padding: "10px 12px", borderBottom: "1px solid var(--color-border-default)" }
-      },
-      React4.createElement(Typography3, { variant: "caption-bold", color: "color-text-subtle" }, "Changes"),
-      React4.createElement("pre", {
-        style: {
-          fontSize: "11px",
-          fontFamily: "monospace",
-          lineHeight: 1.4,
-          padding: "8px",
-          borderRadius: "var(--border-radius-compact, 4px)",
-          backgroundColor: "var(--color-surface-raised)",
-          color: "var(--color-text-medium)",
-          whiteSpace: "pre-wrap",
-          wordBreak: "break-word",
-          maxHeight: "200px",
-          overflow: "auto",
-          margin: 0,
-          width: "100%"
-        }
-      }, cycle.diffSummary)
-    ),
-    // Error
-    cycle.error && React4.createElement("div", {
-      style: { padding: "10px 12px", borderBottom: "1px solid var(--color-border-default)" }
-    }, React4.createElement(Typography3, { variant: "smallCaption-regular", color: "color-status-negative" }, cycle.error)),
-    // Rollback action
-    cycle.outcome === "applied" && React4.createElement(
-      Flex4,
-      {
-        variant: "row-center-start-nowrap-8",
-        style: { padding: "10px 12px" }
-      },
-      React4.createElement(Button3, {
-        size: "xs",
-        variant: "outlined",
-        color: "danger",
-        onClick: handleRollback,
-        loading: rollingBack,
-        disabled: rollingBack
-      }, "Rollback")
-    )
-  );
-}
-
-// src/ui/use-stream-timeline.ts
-var React5 = require("react");
-var { useMemo, useState: useState5, useEffect: useEffect3, useRef: useRef2 } = React5;
-function useStreamTimeline(events, isDone) {
-  const [elapsed, setElapsed] = useState5(0);
-  const startTimeRef = useRef2(null);
-  useEffect3(() => {
-    if (events.length === 0) {
-      startTimeRef.current = null;
-      setElapsed(0);
-    } else if (startTimeRef.current === null) {
-      startTimeRef.current = events[0].timestamp;
-    }
-  }, [events.length]);
-  useEffect3(() => {
-    if (isDone || !startTimeRef.current) return;
-    const tick = () => setElapsed(Date.now() - (startTimeRef.current ?? Date.now()));
-    tick();
-    const interval = setInterval(tick, 1e3);
-    return () => clearInterval(interval);
-  }, [isDone, events.length]);
-  const timeline = useMemo(() => {
-    const entries = [];
-    const nodeEntryIndex = /* @__PURE__ */ new Map();
-    const nodeStarts = /* @__PURE__ */ new Map();
-    let idCounter = 0;
-    for (const event of events) {
-      const d = event.data ?? {};
-      switch (event.type) {
-        case "bot-started":
-          entries.push({
-            id: `s-${idCounter++}`,
-            timestamp: new Date(event.timestamp),
-            type: "task-started",
-            label: "Task started",
-            detail: d.instruction
-          });
-          break;
-        case "node-start": {
-          const nodeId = d.nodeId;
-          if (nodeId) nodeStarts.set(nodeId, event.timestamp);
-          const idx = entries.length;
-          nodeEntryIndex.set(nodeId, idx);
-          entries.push({
-            id: `s-${idCounter++}`,
-            timestamp: new Date(event.timestamp),
-            type: "node-started",
-            nodeId,
-            label: d.label ?? d.nodeType ?? nodeId ?? "Node"
-          });
-          break;
-        }
-        case "node-complete": {
-          const nodeId = d.nodeId;
-          const startTs = nodeStarts.get(nodeId);
-          const duration = d.durationMs ?? (startTs ? event.timestamp - startTs : void 0);
-          if (nodeId) nodeStarts.delete(nodeId);
-          const rawOutputs = d.outputs;
-          const completed = {
-            id: `s-${idCounter++}`,
-            timestamp: new Date(startTs ?? event.timestamp),
-            type: "node-completed",
-            nodeId,
-            label: d.label ?? d.nodeType ?? nodeId ?? "Node",
-            duration,
-            outputs: rawOutputs && rawOutputs.length > 0 ? rawOutputs : void 0
-          };
-          const existingIdx = nodeEntryIndex.get(nodeId);
-          if (existingIdx != null && entries[existingIdx]) {
-            entries[existingIdx] = completed;
-            nodeEntryIndex.delete(nodeId);
-          } else {
-            entries.push(completed);
-          }
-          break;
-        }
-        case "node-error": {
-          const nodeId = d.nodeId;
-          const startTs = nodeStarts.get(nodeId);
-          const duration = d.durationMs ?? (startTs ? event.timestamp - startTs : void 0);
-          if (nodeId) nodeStarts.delete(nodeId);
-          const rawOutputs = d.outputs;
-          const failed = {
-            id: `s-${idCounter++}`,
-            timestamp: new Date(startTs ?? event.timestamp),
-            type: "node-failed",
-            nodeId,
-            label: d.label ?? d.nodeType ?? nodeId ?? "Node",
-            detail: d.error,
-            duration,
-            outputs: rawOutputs && rawOutputs.length > 0 ? rawOutputs : void 0
-          };
-          const existingIdx = nodeEntryIndex.get(nodeId);
-          if (existingIdx != null && entries[existingIdx]) {
-            entries[existingIdx] = failed;
-            nodeEntryIndex.delete(nodeId);
-          } else {
-            entries.push(failed);
-          }
-          break;
-        }
-        case "bot-completed":
-          entries.push({
-            id: `s-${idCounter++}`,
-            timestamp: new Date(event.timestamp),
-            type: "task-completed",
-            label: d.success ? "Task completed" : "Task finished",
-            detail: d.summary
-          });
-          break;
-        case "bot-failed":
-          entries.push({
-            id: `s-${idCounter++}`,
-            timestamp: new Date(event.timestamp),
-            type: "task-failed",
-            label: "Task failed",
-            detail: d.error
-          });
-          break;
-        // Skip audit, cost-update, done — they're used for metadata, not timeline
-        default:
-          break;
-      }
-    }
-    return entries;
-  }, [events]);
-  const { phase, instruction, cost, plan, awaitingApproval } = useMemo(() => {
-    let phase2 = "idle";
-    let instruction2 = null;
-    let cost2 = null;
-    let plan2 = null;
-    let awaitingApproval2 = false;
-    for (const event of events) {
-      const d = event.data ?? {};
-      if (event.type === "bot-started") {
-        phase2 = "planning";
-        instruction2 = d.instruction ?? null;
-      } else if (event.type === "node-start" && phase2 !== "completed" && phase2 !== "failed") {
-        phase2 = "executing";
-      } else if (event.type === "bot-completed") {
-        phase2 = d.success ? "completed" : "failed";
-      } else if (event.type === "bot-failed") {
-        phase2 = "failed";
-      } else if (event.type === "cost-update") {
-        cost2 = d.totalCost ?? cost2;
-      } else if (event.type === "audit:plan-created" || event.type === "plan-created") {
-        const planData = d.plan ?? d;
-        const summary = planData.summary ?? "";
-        const steps = planData.steps ?? [];
-        if (summary || steps.length > 0) {
-          plan2 = { summary, steps };
-        }
-      } else if (event.type === "approval-needed") {
-        awaitingApproval2 = true;
-      } else if (event.type === "audit:approval-decision") {
-        awaitingApproval2 = false;
-      }
-    }
-    if (isDone && phase2 !== "completed" && phase2 !== "failed") {
-      phase2 = "completed";
-    }
-    return { phase: phase2, instruction: instruction2, cost: cost2, plan: plan2, awaitingApproval: awaitingApproval2 };
-  }, [events, isDone]);
-  return { timeline, phase, instruction, elapsed, cost, plan, awaitingApproval };
-}
-
-// src/ui/trace-to-timeline.ts
-function traceToTimeline(run) {
-  const entries = [];
-  let idCounter = 0;
-  const meta = run.nodeMeta ?? {};
-  if (run.trace && run.trace.length > 0) {
-    const nodeStarts = /* @__PURE__ */ new Map();
-    for (const event of run.trace) {
-      if (event.type === "node-start") {
-        nodeStarts.set(event.nodeId, event);
-      } else if (event.type === "node-complete" || event.type === "node-error") {
-        const start = nodeStarts.get(event.nodeId);
-        const duration = event.durationMs ?? (start ? event.timestamp - start.timestamp : void 0);
-        const nm = meta[event.nodeId] ?? (event.nodeType ? meta[event.nodeType] : void 0);
-        entries.push({
-          id: `trace-${idCounter++}`,
-          timestamp: new Date(event.timestamp),
-          type: event.type === "node-complete" ? "node-completed" : "node-failed",
-          nodeId: event.nodeId,
-          label: nm?.label ?? event.nodeType ?? event.nodeId,
-          detail: event.error,
-          duration,
-          color: nm?.color,
-          icon: nm?.icon,
-          outputs: event.outputs && event.outputs.length > 0 ? event.outputs : void 0
-        });
-        nodeStarts.delete(event.nodeId);
-      }
-    }
-    for (const [nodeId, event] of nodeStarts) {
-      const nm = meta[nodeId] ?? (event.nodeType ? meta[event.nodeType] : void 0);
-      entries.push({
-        id: `trace-${idCounter++}`,
-        timestamp: new Date(event.timestamp),
-        type: "node-started",
-        nodeId,
-        label: nm?.label ?? event.nodeType ?? nodeId,
-        color: nm?.color,
-        icon: nm?.icon
-      });
-    }
-  } else if (run.stepLog && run.stepLog.length > 0) {
-    for (const step of run.stepLog) {
-      const type = step.status === "ok" ? "node-completed" : step.status === "error" ? "node-failed" : "node-completed";
-      entries.push({
-        id: `step-${idCounter++}`,
-        timestamp: new Date(run.startedAt ?? Date.now()),
-        type,
-        label: step.step,
-        detail: step.detail,
-        icon: step.status === "ok" ? "success" : step.status === "error" ? "error" : "warning"
-      });
-    }
-  }
-  if (run.outcome === "failed" || run.outcome === "error") {
-    let errorDetail = "";
-    if (run.auditTrail) {
-      for (const a of run.auditTrail) {
-        if (a.type === "step-complete" && a.data) {
-          const errors = a.data.errors;
-          if (errors && errors.length > 0) {
-            errorDetail = errors.map((e) => e.length > 120 ? e.slice(0, 117) + "..." : e).join("\n");
-            break;
-          }
-        }
-      }
-    }
-    if (!errorDetail && run.summary) {
-      const parts = run.summary.split("|").map((p) => p.trim());
-      const outcomePart = parts.find((p) => p.startsWith("Outcome:"));
-      const summaryPart = parts.find((p) => p.startsWith("Summary:"));
-      errorDetail = summaryPart?.replace("Summary:", "").trim() ?? outcomePart ?? run.summary;
-    }
-    entries.push({
-      id: `result-${idCounter++}`,
-      timestamp: new Date(run.finishedAt ?? run.startedAt ?? Date.now()),
-      type: "task-failed",
-      label: "Task failed",
-      detail: errorDetail || "Unknown failure",
-      icon: "error"
-    });
-  } else if (run.outcome === "completed" && run.success) {
-    entries.push({
-      id: `result-${idCounter++}`,
-      timestamp: new Date(run.finishedAt ?? run.startedAt ?? Date.now()),
-      type: "task-completed",
-      label: "Task completed",
-      detail: run.summary?.includes("|") ? run.summary.split("|").find((p) => p.trim().startsWith("Summary:"))?.replace("Summary:", "").trim() : void 0
-    });
-  }
-  entries.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-  return entries;
-}
-
-// src/ui/steer-api.ts
-async function sendSteerCommand(callTool, command, payload) {
-  await callTool("fw_weaver_steer", {
-    command,
-    ...payload ? { payload } : {}
-  });
-}
-
-// src/ui/bot-workspace.tsx
-var React6 = require("react");
-var { useRef: useRef3, useEffect: useEffect4, useState: useState6, useCallback: useCallback5, useMemo: useMemo2 } = React6;
-var {
-  Flex: Flex5,
-  ScrollArea,
-  EmptyState,
-  TaskBlock,
-  toast: toast5,
-  usePackWorkspace,
-  useEventStream
-} = require("@fw/plugin-ui-kit");
-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;
-  const stream = useEventStream();
-  const {
-    timeline: liveTimeline,
-    phase: livePhase,
-    instruction: liveInstruction,
-    elapsed,
-    cost,
-    plan,
-    awaitingApproval
-  } = useStreamTimeline(stream.events, stream.isDone);
-  useEffect4(() => {
-    if (!isLive || !windowData?.runId) return;
-    stream.start(packId, "fw_weaver_events", windowData.runId);
-    return () => stream.stop();
-  }, [isLive, packId, windowData?.runId]);
-  const [sessionRunId, setSessionRunId] = useState6(null);
-  useEffect4(() => {
-    if (isLive) return;
-    const poll = async () => {
-      try {
-        const status = await callTool("fw_weaver_status");
-        const runId = status?.currentRunId ?? null;
-        const alive = status?.alive;
-        if (runId && alive === false) {
-          setSessionRunId(null);
-        } else {
-          setSessionRunId(runId);
-        }
-      } catch {
-      }
-    };
-    poll();
-    const interval = setInterval(poll, 3e3);
-    return () => clearInterval(interval);
-  }, [isLive, callTool]);
-  useEffect4(() => {
-    if (!sessionRunId || isLive) return;
-    stream.start(packId, "fw_weaver_events", sessionRunId);
-    return () => stream.stop();
-  }, [sessionRunId, packId, isLive]);
-  const scrollRef = useRef3(null);
-  useEffect4(() => {
-    const el = scrollRef.current;
-    if (el) el.scrollTop = el.scrollHeight;
-  }, [liveTimeline.length, stream.events.length]);
-  const [pausing, setPausing] = useState6(false);
-  const [stopping, setStopping] = useState6(false);
-  const handlePause = useCallback5(async () => {
-    setPausing(true);
-    try {
-      await sendSteerCommand(callTool, "pause");
-      toast5("Pause signal sent", { type: "info" });
-    } catch (err) {
-      toast5(err instanceof Error ? err.message : "Failed to pause", { type: "error" });
-    }
-    setPausing(false);
-  }, [callTool]);
-  const handleStop = useCallback5(async () => {
-    setStopping(true);
-    try {
-      await sendSteerCommand(callTool, "cancel");
-      toast5("Stopping \u2014 will take effect after current node completes", { type: "info" });
-    } catch (err) {
-      toast5(err instanceof Error ? err.message : "Failed to stop", { type: "error" });
-      setStopping(false);
-    }
-  }, [callTool]);
-  const [history, setHistory] = useState6([]);
-  const [genesisCycles, setGenesisCycles] = useState6([]);
-  const [queuedTasks, setQueuedTasks] = useState6([]);
-  const [removingIds, setRemovingIds] = useState6(/* @__PURE__ */ new Set());
-  const [expandedRunId, setExpandedRunId] = useState6(
-    highlightRunId && !isLive ? highlightRunId : null
-  );
-  const [liveExpanded, setLiveExpanded] = useState6(true);
-  const refreshData = useCallback5(() => {
-    callTool("fw_weaver_history", { limit: 20 }).then((data) => {
-      if (Array.isArray(data)) {
-        setHistory(
-          data.map((r) => {
-            const costObj = r.cost && typeof r.cost === "object" ? r.cost : void 0;
-            return { ...r, costDetail: costObj, cost: costObj?.totalCost };
-          })
-        );
-      } else {
-        setHistory([]);
-      }
-    });
-    callTool("fw_weaver_insights").then((data) => {
-      const d = data;
-      if (d?.evolution) {
-        const evo = d.evolution;
-        if (Array.isArray(evo.recentCycles)) {
-          setGenesisCycles(evo.recentCycles.slice(0, 10));
-        }
-      }
-    });
-    callTool("fw_weaver_queue", { action: "list" }).then((data) => {
-      const visible = (Array.isArray(data) ? data : []).filter(
-        (t) => t.status === "pending" || t.status === "running"
-      );
-      setQueuedTasks(visible);
-    });
-  }, [callTool]);
-  useEffect4(() => {
-    refreshData();
-  }, [refreshData]);
-  useEffect4(() => {
-    const interval = setInterval(() => {
-      callTool("fw_weaver_queue", { action: "list" }).then((data) => {
-        const visible = (Array.isArray(data) ? data : []).filter(
-          (t) => t.status === "pending" || t.status === "running"
-        );
-        setQueuedTasks(visible);
-      });
-    }, 1e4);
-    return () => clearInterval(interval);
-  }, [callTool]);
-  useEffect4(() => {
-    return onRefresh(() => refreshData());
-  }, [refreshData, onRefresh]);
-  useEffect4(() => {
-    if (sessionRunId !== null) refreshData();
-  }, [sessionRunId, refreshData]);
-  const handleRemoveTask = useCallback5(async (id) => {
-    setRemovingIds((prev) => new Set(prev).add(id));
-    try {
-      await callTool("fw_weaver_queue", { action: "remove", id });
-      refreshData();
-      toast5("Task removed", { type: "warning" });
-    } catch (err) {
-      toast5(err instanceof Error ? err.message : "Failed to remove task", { type: "error" });
-    }
-    setRemovingIds((prev) => {
-      const next = new Set(prev);
-      next.delete(id);
-      return next;
-    });
-  }, [callTool, refreshData]);
-  const timelineItems = useMemo2(() => {
-    const items = [];
-    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, b) => a.timestamp - b.timestamp);
-    return items;
-  }, [history, genesisCycles]);
-  const toggleExpand = useCallback5((id) => {
-    setExpandedRunId((prev) => prev === id ? null : id);
-  }, []);
-  const isStreaming = isLive || !!sessionRunId;
-  const hasContent = isStreaming || timelineItems.length > 0 || queuedTasks.length > 0;
-  function extractInstruction(run) {
-    let text = "";
-    if (run.params) {
-      try {
-        const taskJson = run.params.taskJson;
-        if (taskJson) {
-          const task = JSON.parse(taskJson);
-          if (task.instruction) text = task.instruction;
-        }
-      } catch {
-      }
-    }
-    if (!text && run.summary) {
-      const summary = run.summary;
-      if (summary.includes("|")) {
-        const parts = summary.split("|").map((p) => p.trim());
-        const taskPart = parts.find((p) => p.startsWith("Task:"));
-        const summaryPart = parts.find((p) => 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;
-  }
-  const [approvalStatus, setApprovalStatus] = useState6(null);
-  const [approvalLoading, setApprovalLoading] = useState6(false);
-  useEffect4(() => {
-    if (awaitingApproval) setApprovalStatus("pending");
-  }, [awaitingApproval]);
-  useEffect4(() => {
-    if (stream.events.length === 0) setApprovalStatus(null);
-  }, [stream.events.length]);
-  const handleApprove = useCallback5(async () => {
-    setApprovalLoading(true);
-    try {
-      await callTool("fw_weaver_approve", { approved: true });
-      setApprovalStatus("approved");
-      toast5("Plan approved", { type: "success" });
-    } catch (err) {
-      toast5(err instanceof Error ? err.message : "Failed to approve", { type: "error" });
-    }
-    setApprovalLoading(false);
-  }, [callTool]);
-  const handleReject = useCallback5(async () => {
-    setApprovalLoading(true);
-    try {
-      await callTool("fw_weaver_approve", { approved: false });
-      setApprovalStatus("rejected");
-      toast5("Plan rejected", { type: "info" });
-    } catch (err) {
-      toast5(err instanceof Error ? err.message : "Failed to reject", { type: "error" });
-    }
-    setApprovalLoading(false);
-  }, [callTool]);
-  return React6.createElement(
-    Flex5,
-    {
-      variant: "column-stretch-start-nowrap-0",
-      style: { width: "100%", height: "100%", overflow: "hidden" }
-    },
-    // Session bar
-    React6.createElement(SessionBar, { callTool, dispatchEvent }),
-    // Settings
-    React6.createElement(SettingsSection, { callTool, dispatchEvent }),
-    // Main scrollable timeline
-    React6.createElement(
-      Flex5,
-      { variant: "column-stretch-start-nowrap-0", style: { flex: 1, minHeight: 0 } },
-      React6.createElement(
-        ScrollArea,
-        { ref: scrollRef },
-        React6.createElement(
-          Flex5,
-          { variant: "column-stretch-start-nowrap-8", style: { padding: "12px 16px" } },
-          // Empty state
-          !hasContent && React6.createElement(EmptyState, {
-            icon: "smartToy",
-            message: "No bot runs yet",
-            description: "Ask the AI assistant to run a task, or add tasks below."
-          }),
-          ...timelineItems.map((item) => {
-            if (item.kind === "genesis" && item.genesis) {
-              return React6.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 React6.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 ?? null,
-                plan: run.plan,
-                startedAt: run.startedAt,
-                durationMs: run.durationMs ?? run.duration,
-                expanded: isExpanded,
-                onToggleExpand: () => toggleExpand(runId)
-              });
-            }
-            return null;
-          }),
-          // Live execution
-          isStreaming && React6.createElement(TaskBlock, {
-            state: "running",
-            instruction: liveInstruction ?? windowData?.instruction ?? "Running...",
-            timeline: liveTimeline,
-            phase: livePhase,
-            elapsed,
-            cost,
-            plan,
-            error: stream.error,
-            approval: approvalStatus ?? void 0,
-            approvalLoading,
-            onApprove: handleApprove,
-            onReject: handleReject,
-            onPause: handlePause,
-            onStop: handleStop,
-            pauseLoading: pausing,
-            stopLoading: stopping,
-            expanded: liveExpanded,
-            onToggleExpand: () => setLiveExpanded((v) => !v)
-          }),
-          ...(isStreaming ? queuedTasks.filter((t) => t.status !== "running") : queuedTasks).map(
-            (task) => React6.createElement(TaskBlock, {
-              key: task.id,
-              state: "pending",
-              instruction: task.instruction,
-              onRemove: () => handleRemoveTask(task.id),
-              removeLoading: removingIds.has(task.id)
-            })
-          )
-        )
-      )
-    ),
-    // Input bar
-    React6.createElement(QueueInput, { callTool, onTaskAdded: refreshData })
-  );
-}
-module.exports = BotWorkspace;