@synergenius/flow-weaver-pack-weaver 0.9.53 → 0.9.55

package/dist/ui/bot-workspace.js

@@ -0,0 +1,1087 @@
+"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/approval-card.tsx
+var React5 = require("react");
+var { useState: useState5, useCallback: useCallback5 } = React5;
+var {
+  CollapsibleBlock: CollapsibleBlock2,
+  Flex: Flex5,
+  Typography: Typography4,
+  Badge: Badge3,
+  Tag: Tag2,
+  Button: Button4,
+  toast: toast5
+} = require("@fw/plugin-ui-kit");
+function ApprovalCard({ plan, callTool, onDecision }) {
+  const [deciding, setDeciding] = useState5(false);
+  const [decided, setDecided] = useState5(null);
+  const handleDecision = useCallback5(
+    async (approved) => {
+      setDeciding(true);
+      try {
+        await callTool("fw_weaver_approve", { approved });
+        setDecided(approved);
+        onDecision?.(approved);
+        toast5(approved ? "Plan approved" : "Plan rejected", {
+          type: approved ? "success" : "info"
+        });
+      } catch (err) {
+        toast5(err instanceof Error ? err.message : "Failed to send decision", { type: "error" });
+      } finally {
+        setDeciding(false);
+      }
+    },
+    [callTool, onDecision]
+  );
+  if (decided !== null) {
+    return React5.createElement(CollapsibleBlock2, {
+      status: decided ? "completed" : "error",
+      label: React5.createElement(Typography4, {
+        variant: "caption-bold",
+        color: decided ? "color-status-positive" : "color-status-negative"
+      }, decided ? "Plan Approved" : "Plan Rejected"),
+      expanded: false,
+      canExpand: false
+    });
+  }
+  return React5.createElement(
+    CollapsibleBlock2,
+    {
+      status: "pending",
+      label: React5.createElement(
+        Flex5,
+        { variant: "row-center-start-nowrap-8" },
+        React5.createElement(Badge3, { variant: "warning" }, "Approval Needed"),
+        React5.createElement(
+          Typography4,
+          { variant: "caption-bold", color: "color-text-high" },
+          plan.summary || `${plan.steps.length} step plan`
+        )
+      ),
+      expanded: true,
+      canExpand: false
+    },
+    React5.createElement(
+      Flex5,
+      {
+        variant: "column-start-start-nowrap-6",
+        style: { padding: "10px 12px" }
+      },
+      ...plan.steps.map(
+        (step, i) => React5.createElement(
+          Flex5,
+          {
+            key: step.id || i,
+            variant: "row-center-start-nowrap-6",
+            style: { fontSize: "11px" }
+          },
+          React5.createElement(Tag2, { size: "small", color: "info" }, step.operation),
+          React5.createElement(Typography4, {
+            variant: "smallCaption-regular",
+            color: "color-text-medium"
+          }, step.description)
+        )
+      )
+    ),
+    React5.createElement(
+      Flex5,
+      {
+        variant: "row-center-start-nowrap-8",
+        style: { padding: "10px 12px", borderTop: "1px solid var(--color-border-default)" }
+      },
+      React5.createElement(Button4, {
+        variant: "fill",
+        color: "primary",
+        size: "xs",
+        onClick: () => handleDecision(true),
+        loading: deciding,
+        disabled: deciding
+      }, "Approve"),
+      React5.createElement(Button4, {
+        variant: "outlined",
+        color: "danger",
+        size: "xs",
+        onClick: () => handleDecision(false),
+        loading: deciding,
+        disabled: deciding
+      }, "Reject")
+    )
+  );
+}
+
+// src/ui/use-stream-timeline.ts
+var React6 = require("react");
+var { useMemo, useState: useState6, useEffect: useEffect3, useRef: useRef2 } = React6;
+function useStreamTimeline(events, isDone) {
+  const [elapsed, setElapsed] = useState6(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 completed = {
+            id: `s-${idCounter++}`,
+            timestamp: new Date(startTs ?? event.timestamp),
+            type: "node-completed",
+            nodeId,
+            label: d.label ?? d.nodeType ?? nodeId ?? "Node",
+            duration
+          };
+          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 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
+          };
+          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
+        });
+        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 React7 = require("react");
+var { useRef: useRef3, useEffect: useEffect4, useState: useState7, useCallback: useCallback6, useMemo: useMemo2 } = React7;
+var {
+  Flex: Flex6,
+  ScrollArea,
+  EmptyState,
+  TaskBlock,
+  toast: toast6,
+  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] = useState7(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] = useState7(false);
+  const [stopping, setStopping] = useState7(false);
+  const handlePause = useCallback6(async () => {
+    setPausing(true);
+    try {
+      await sendSteerCommand(callTool, "pause");
+      toast6("Pause signal sent", { type: "info" });
+    } catch (err) {
+      toast6(err instanceof Error ? err.message : "Failed to pause", { type: "error" });
+    }
+    setPausing(false);
+  }, [callTool]);
+  const handleStop = useCallback6(async () => {
+    setStopping(true);
+    try {
+      await sendSteerCommand(callTool, "cancel");
+      toast6("Stopping \u2014 will take effect after current node completes", { type: "info" });
+    } catch (err) {
+      toast6(err instanceof Error ? err.message : "Failed to stop", { type: "error" });
+      setStopping(false);
+    }
+  }, [callTool]);
+  const [history, setHistory] = useState7([]);
+  const [genesisCycles, setGenesisCycles] = useState7([]);
+  const [queuedTasks, setQueuedTasks] = useState7([]);
+  const [removingIds, setRemovingIds] = useState7(/* @__PURE__ */ new Set());
+  const [expandedRunId, setExpandedRunId] = useState7(
+    highlightRunId && !isLive ? highlightRunId : null
+  );
+  const [liveExpanded, setLiveExpanded] = useState7(true);
+  const refreshData = useCallback6(() => {
+    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 = useCallback6(async (id) => {
+    setRemovingIds((prev) => new Set(prev).add(id));
+    try {
+      await callTool("fw_weaver_queue", { action: "remove", id });
+      refreshData();
+      toast6("Task removed", { type: "warning" });
+    } catch (err) {
+      toast6(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 = useCallback6((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 approvalSlot = awaitingApproval && plan ? React7.createElement(ApprovalCard, { plan, callTool }) : null;
+  return React7.createElement(
+    Flex6,
+    {
+      variant: "column-stretch-start-nowrap-0",
+      style: { width: "100%", height: "100%", overflow: "hidden" }
+    },
+    // Session bar
+    React7.createElement(SessionBar, { callTool, dispatchEvent }),
+    // Settings
+    React7.createElement(SettingsSection, { callTool, dispatchEvent }),
+    // Main scrollable timeline
+    React7.createElement(
+      Flex6,
+      { variant: "column-stretch-start-nowrap-0", style: { flex: 1, minHeight: 0 } },
+      React7.createElement(
+        ScrollArea,
+        { ref: scrollRef },
+        React7.createElement(
+          Flex6,
+          { variant: "column-stretch-start-nowrap-8", style: { padding: "12px 16px" } },
+          // Empty state
+          !hasContent && React7.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 React7.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 React7.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 && React7.createElement(TaskBlock, {
+            state: "running",
+            instruction: liveInstruction ?? windowData?.instruction ?? "Running...",
+            timeline: liveTimeline,
+            phase: livePhase,
+            elapsed,
+            cost,
+            plan,
+            error: stream.error,
+            approvalSlot,
+            onPause: handlePause,
+            onStop: handleStop,
+            pauseLoading: pausing,
+            stopLoading: stopping,
+            expanded: liveExpanded,
+            onToggleExpand: () => setLiveExpanded((v) => !v)
+          }),
+          ...(isStreaming ? queuedTasks.filter((t) => t.status !== "running") : queuedTasks).map(
+            (task) => React7.createElement(TaskBlock, {
+              key: task.id,
+              state: "pending",
+              instruction: task.instruction,
+              onRemove: () => handleRemoveTask(task.id),
+              removeLoading: removingIds.has(task.id)
+            })
+          )
+        )
+      )
+    ),
+    // Input bar
+    React7.createElement(QueueInput, { callTool, onTaskAdded: refreshData })
+  );
+}
+module.exports = BotWorkspace;