@astroanywhere/cli 0.1.0 → 0.2.0

package/dist/tui.js

@@ -0,0 +1,2136 @@
+#!/usr/bin/env node
+import {
+  AstroClient
+} from "./chunk-7H7WD7QX.js";
+
+// src/tui/index.tsx
+import "react";
+import { render } from "ink";
+
+// src/tui/app.tsx
+import { useMemo, useCallback as useCallback5 } from "react";
+
+// src/tui/components/layout/main-layout.tsx
+import "react";
+import { Box as Box10, useStdout } from "ink";
+
+// src/tui/components/layout/status-bar.tsx
+import "react";
+import { Box, Text } from "ink";
+
+// src/tui/stores/tui-store.ts
+import { create } from "zustand";
+var PANEL_ORDER = ["projects", "plan", "machines", "output"];
+var useTuiStore = create((set, get) => ({
+  mode: "normal",
+  commandBuffer: "",
+  searchQuery: "",
+  pendingKeys: "",
+  focusedPanel: "projects",
+  panelOrder: PANEL_ORDER,
+  selectedProjectId: null,
+  selectedNodeId: null,
+  selectedMachineId: null,
+  selectedExecutionId: null,
+  scrollIndex: { projects: 0, plan: 0, machines: 0, output: 0 },
+  showHelp: false,
+  showSearch: false,
+  showDetail: false,
+  detailType: null,
+  detailId: null,
+  connected: false,
+  machineCount: 0,
+  todayCost: 0,
+  lastError: null,
+  setMode: (mode) => set({ mode }),
+  setCommandBuffer: (commandBuffer) => set({ commandBuffer }),
+  setSearchQuery: (searchQuery) => set({ searchQuery }),
+  setPendingKeys: (pendingKeys) => set({ pendingKeys }),
+  focusPanel: (panel) => set({ focusedPanel: panel }),
+  focusNext: () => {
+    const { focusedPanel, panelOrder } = get();
+    const idx = panelOrder.indexOf(focusedPanel);
+    set({ focusedPanel: panelOrder[(idx + 1) % panelOrder.length] });
+  },
+  focusPrev: () => {
+    const { focusedPanel, panelOrder } = get();
+    const idx = panelOrder.indexOf(focusedPanel);
+    set({ focusedPanel: panelOrder[(idx - 1 + panelOrder.length) % panelOrder.length] });
+  },
+  focusByIndex: (idx) => {
+    const { panelOrder } = get();
+    if (idx >= 0 && idx < panelOrder.length) {
+      set({ focusedPanel: panelOrder[idx] });
+    }
+  },
+  setSelectedProject: (selectedProjectId) => set({ selectedProjectId }),
+  setSelectedNode: (selectedNodeId) => set({ selectedNodeId }),
+  setSelectedMachine: (selectedMachineId) => set({ selectedMachineId }),
+  setSelectedExecution: (selectedExecutionId) => set({ selectedExecutionId }),
+  scrollUp: (panel) => {
+    const p = panel ?? get().focusedPanel;
+    set((s) => ({
+      scrollIndex: { ...s.scrollIndex, [p]: Math.max(0, s.scrollIndex[p] - 1) }
+    }));
+  },
+  scrollDown: (panel, max) => {
+    const p = panel ?? get().focusedPanel;
+    set((s) => ({
+      scrollIndex: {
+        ...s.scrollIndex,
+        [p]: max != null ? Math.min(max - 1, s.scrollIndex[p] + 1) : s.scrollIndex[p] + 1
+      }
+    }));
+  },
+  scrollToTop: (panel) => {
+    const p = panel ?? get().focusedPanel;
+    set((s) => ({
+      scrollIndex: { ...s.scrollIndex, [p]: 0 }
+    }));
+  },
+  scrollToBottom: (panel, max) => {
+    const p = panel ?? get().focusedPanel;
+    if (max != null && max > 0) {
+      set((s) => ({
+        scrollIndex: { ...s.scrollIndex, [p]: max - 1 }
+      }));
+    }
+  },
+  pageUp: (panel, pageSize = 10) => {
+    const p = panel ?? get().focusedPanel;
+    set((s) => ({
+      scrollIndex: { ...s.scrollIndex, [p]: Math.max(0, s.scrollIndex[p] - pageSize) }
+    }));
+  },
+  pageDown: (panel, max, pageSize = 10) => {
+    const p = panel ?? get().focusedPanel;
+    set((s) => ({
+      scrollIndex: {
+        ...s.scrollIndex,
+        [p]: max != null ? Math.min(max - 1, s.scrollIndex[p] + pageSize) : s.scrollIndex[p] + pageSize
+      }
+    }));
+  },
+  toggleHelp: () => set((s) => ({ showHelp: !s.showHelp, showSearch: false })),
+  toggleSearch: () => set((s) => ({ showSearch: !s.showSearch, showHelp: false })),
+  openDetail: (type, id) => set({ showDetail: true, detailType: type, detailId: id, showHelp: false, showSearch: false }),
+  closeDetail: () => set({ showDetail: false, detailType: null, detailId: null }),
+  closeOverlays: () => set({ showHelp: false, showSearch: false, showDetail: false, detailType: null, detailId: null }),
+  setConnected: (connected) => set({ connected }),
+  setMachineCount: (machineCount) => set({ machineCount }),
+  setTodayCost: (todayCost) => set({ todayCost }),
+  setLastError: (lastError) => set({ lastError })
+}));
+
+// src/tui/lib/format.ts
+function formatRelativeTime(date) {
+  if (!date) return "\u2014";
+  const d = typeof date === "string" ? new Date(date) : date;
+  const now = Date.now();
+  const diff = now - d.getTime();
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (seconds < 60) return "just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  if (hours < 24) return `${hours}h ago`;
+  if (days < 30) return `${days}d ago`;
+  return d.toLocaleDateString();
+}
+function formatCost(usd) {
+  if (usd == null) return "\u2014";
+  return `$${usd.toFixed(2)}`;
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 1) + "\u2026";
+}
+
+// src/tui/components/layout/status-bar.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function StatusBar() {
+  const connected = useTuiStore((s) => s.connected);
+  const machineCount = useTuiStore((s) => s.machineCount);
+  const todayCost = useTuiStore((s) => s.todayCost);
+  const lastError = useTuiStore((s) => s.lastError);
+  return /* @__PURE__ */ jsxs(Box, { paddingX: 1, justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsxs(Box, { gap: 2, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "Astro TUI" }),
+      /* @__PURE__ */ jsx(Text, { color: connected ? "green" : "red", children: connected ? "\u25CF connected" : "\u25CB disconnected" }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        machineCount,
+        " machine",
+        machineCount !== 1 ? "s" : ""
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        formatCost(todayCost),
+        " today"
+      ] })
+    ] }),
+    lastError && /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: "red", children: lastError.length > 60 ? lastError.slice(0, 57) + "..." : lastError }) })
+  ] });
+}
+
+// src/tui/components/layout/command-line.tsx
+import "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var MODE_LABELS = {
+  normal: { label: "NORMAL", color: "blue" },
+  command: { label: "COMMAND", color: "yellow" },
+  search: { label: "SEARCH", color: "green" },
+  insert: { label: "INSERT", color: "magenta" }
+};
+function CommandLine() {
+  const mode = useTuiStore((s) => s.mode);
+  const commandBuffer = useTuiStore((s) => s.commandBuffer);
+  const searchQuery = useTuiStore((s) => s.searchQuery);
+  const pendingKeys = useTuiStore((s) => s.pendingKeys);
+  const modeInfo = MODE_LABELS[mode] ?? MODE_LABELS.normal;
+  let content = "";
+  let prefix = "";
+  switch (mode) {
+    case "command":
+      prefix = ":";
+      content = commandBuffer;
+      break;
+    case "search":
+      prefix = "/";
+      content = searchQuery;
+      break;
+    case "normal":
+      if (pendingKeys) {
+        content = pendingKeys;
+      } else {
+        content = "Press : for commands, / to search, ? for help";
+      }
+      break;
+    case "insert":
+      content = "-- INSERT MODE -- (Esc to exit)";
+      break;
+  }
+  return /* @__PURE__ */ jsx2(Box2, { paddingX: 1, justifyContent: "space-between", children: /* @__PURE__ */ jsxs2(Box2, { gap: 1, children: [
+    /* @__PURE__ */ jsxs2(Text2, { bold: true, color: modeInfo.color, inverse: true, children: [
+      " ",
+      modeInfo.label,
+      " "
+    ] }),
+    mode === "command" || mode === "search" ? /* @__PURE__ */ jsxs2(Text2, { children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: prefix }),
+      /* @__PURE__ */ jsx2(Text2, { children: content }),
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "\u2588" })
+    ] }) : /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: content })
+  ] }) });
+}
+
+// src/tui/components/layout/help-overlay.tsx
+import "react";
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var KEYBINDINGS = [
+  ["Navigation", [
+    ["j / \u2193", "Move down"],
+    ["k / \u2191", "Move up"],
+    ["h / \u2190", "Focus left panel"],
+    ["l / \u2192", "Focus right panel"],
+    ["Tab", "Cycle panel focus"],
+    ["1-4", "Jump to panel"],
+    ["gg", "Scroll to top"],
+    ["G", "Scroll to bottom"],
+    ["Ctrl+u", "Page up"],
+    ["Ctrl+d", "Page down"],
+    ["Enter", "Select / expand"]
+  ]],
+  ["Actions", [
+    ["d", "Dispatch selected task"],
+    ["c", "Cancel running task"],
+    ["r", "Refresh all data"],
+    ["q", "Quit"]
+  ]],
+  ["Modes", [
+    [":", "Command mode"],
+    ["/", "Search mode"],
+    ["i", "Insert mode (steer)"],
+    ["?", "Toggle this help"],
+    ["Esc", "Return to normal mode"]
+  ]],
+  ["Commands", [
+    [":project list/create/delete", "Project management"],
+    [":plan tree/create-node", "Plan operations"],
+    [":dispatch <nodeId>", "Dispatch task"],
+    [":cancel <execId>", "Cancel execution"],
+    [":steer <message>", "Steer running task"],
+    [":watch <execId>", "Watch execution output"],
+    [":env list/status", "Machine management"],
+    [":activity", "Activity feed"],
+    [":refresh / :r", "Force refresh"],
+    [":quit / :q", "Exit TUI"]
+  ]]
+];
+function HelpOverlay() {
+  return /* @__PURE__ */ jsxs3(
+    Box3,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "yellow",
+      paddingX: 2,
+      paddingY: 1,
+      children: [
+        /* @__PURE__ */ jsx3(Text3, { bold: true, color: "yellow", children: " Keybindings Reference " }),
+        /* @__PURE__ */ jsx3(Text3, { children: " " }),
+        KEYBINDINGS.map(([section, bindings]) => /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginBottom: 1, children: [
+          /* @__PURE__ */ jsx3(Text3, { bold: true, underline: true, children: section }),
+          bindings.map(([key, desc]) => /* @__PURE__ */ jsxs3(Box3, { gap: 2, children: [
+            /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: key.padEnd(28) }),
+            /* @__PURE__ */ jsx3(Text3, { children: desc })
+          ] }, key))
+        ] }, section)),
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Press Esc or ? to close" })
+      ]
+    }
+  );
+}
+
+// src/tui/components/layout/search-overlay.tsx
+import "react";
+import { Box as Box4, Text as Text4, useInput } from "ink";
+
+// src/tui/stores/search-store.ts
+import { create as create2 } from "zustand";
+var useSearchStore = create2((set, get) => ({
+  items: [],
+  query: "",
+  results: [],
+  selectedIndex: 0,
+  isOpen: false,
+  setItems: (items) => set({ items }),
+  setQuery: (query) => set({ query, selectedIndex: 0 }),
+  setResults: (results) => set({ results }),
+  setSelectedIndex: (selectedIndex) => set({ selectedIndex }),
+  moveUp: () => {
+    const { selectedIndex } = get();
+    set({ selectedIndex: Math.max(0, selectedIndex - 1) });
+  },
+  moveDown: () => {
+    const { selectedIndex, results } = get();
+    set({ selectedIndex: Math.min(results.length - 1, selectedIndex + 1) });
+  },
+  open: () => set({ isOpen: true, query: "", results: [], selectedIndex: 0 }),
+  close: () => set({ isOpen: false, query: "", results: [], selectedIndex: 0 })
+}));
+
+// src/tui/lib/status-colors.ts
+var STATUS_COLOR_MAP = {
+  // Project statuses
+  active: "green",
+  archived: "gray",
+  // Plan node statuses
+  planned: "yellow",
+  dispatched: "cyan",
+  in_progress: "cyan",
+  auto_verified: "green",
+  awaiting_approval: "magenta",
+  awaiting_judgment: "magenta",
+  completed: "blue",
+  pruned: "gray",
+  // Execution statuses
+  pending: "yellow",
+  running: "cyan",
+  success: "green",
+  failure: "red",
+  cancelled: "gray",
+  error: "red",
+  timeout: "red",
+  // Machine connection
+  connected: "green",
+  disconnected: "gray",
+  // Health
+  on_track: "green",
+  at_risk: "yellow",
+  off_track: "red"
+};
+function getStatusColor(status) {
+  return STATUS_COLOR_MAP[status] ?? "white";
+}
+function getStatusSymbol(status) {
+  switch (status) {
+    case "completed":
+    case "auto_verified":
+    case "success":
+      return "\u2713";
+    // ✓
+    case "in_progress":
+    case "running":
+    case "dispatched":
+      return "\u25CB";
+    // ○ (spinning handled separately)
+    case "planned":
+    case "pending":
+      return "\u2022";
+    // •
+    case "failure":
+    case "error":
+      return "\u2717";
+    // ✗
+    case "pruned":
+    case "cancelled":
+      return "\u2500";
+    // ─
+    case "awaiting_approval":
+    case "awaiting_judgment":
+      return "?";
+    default:
+      return "\u2022";
+  }
+}
+
+// src/tui/components/layout/search-overlay.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function SearchOverlay() {
+  const isOpen = useSearchStore((s) => s.isOpen);
+  const query = useSearchStore((s) => s.query);
+  const results = useSearchStore((s) => s.results);
+  const selectedIndex = useSearchStore((s) => s.selectedIndex);
+  const { setQuery, moveUp, moveDown, close } = useSearchStore();
+  const { setSelectedProject, setSelectedNode, setSelectedMachine, focusPanel } = useTuiStore();
+  useInput((input, key) => {
+    if (!isOpen) return;
+    if (key.escape) {
+      close();
+      return;
+    }
+    if (key.upArrow) {
+      moveUp();
+      return;
+    }
+    if (key.downArrow) {
+      moveDown();
+      return;
+    }
+    if (key.return && results.length > 0) {
+      const item = results[selectedIndex];
+      if (item) {
+        switch (item.type) {
+          case "project":
+            setSelectedProject(item.id);
+            focusPanel("projects");
+            break;
+          case "task":
+            setSelectedNode(item.id);
+            focusPanel("plan");
+            break;
+          case "machine":
+            setSelectedMachine(item.id);
+            focusPanel("machines");
+            break;
+        }
+      }
+      close();
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setQuery(query.slice(0, -1));
+      return;
+    }
+    if (input && input.length === 1 && !key.ctrl && !key.meta) {
+      setQuery(query + input);
+    }
+  }, { isActive: isOpen });
+  if (!isOpen) return null;
+  return /* @__PURE__ */ jsxs4(
+    Box4,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "cyan",
+      paddingX: 1,
+      paddingY: 0,
+      width: "60%",
+      height: Math.min(results.length + 4, 15),
+      children: [
+        /* @__PURE__ */ jsxs4(Box4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, color: "cyan", children: "Search: " }),
+          /* @__PURE__ */ jsx4(Text4, { children: query }),
+          /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "\u2588" })
+        ] }),
+        /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, children: [
+          results.length === 0 && query.length > 0 && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  No results" }),
+          results.slice(0, 10).map((item, i) => /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(
+            Text4,
+            {
+              inverse: i === selectedIndex,
+              bold: i === selectedIndex,
+              color: i === selectedIndex ? "cyan" : void 0,
+              children: [
+                i === selectedIndex ? " \u25B6 " : "   ",
+                /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+                  "[",
+                  item.type,
+                  "]"
+                ] }),
+                " ",
+                item.title,
+                item.status && /* @__PURE__ */ jsxs4(Text4, { color: getStatusColor(item.status), children: [
+                  " [",
+                  item.status,
+                  "]"
+                ] })
+              ]
+            }
+          ) }, item.id))
+        ] })
+      ]
+    }
+  );
+}
+
+// src/tui/components/panels/projects-panel.tsx
+import "react";
+import { Text as Text8 } from "ink";
+
+// src/tui/components/layout/panel.tsx
+import "react";
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function Panel({ title, isFocused, children, width, height }) {
+  const borderColor = isFocused ? "cyan" : "gray";
+  return /* @__PURE__ */ jsxs5(
+    Box5,
+    {
+      flexDirection: "column",
+      borderStyle: "single",
+      borderColor,
+      width,
+      height,
+      flexGrow: 1,
+      children: [
+        /* @__PURE__ */ jsx5(Box5, { paddingX: 1, children: /* @__PURE__ */ jsx5(Text5, { bold: true, color: isFocused ? "cyan" : "white", children: title }) }),
+        /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", paddingX: 1, flexGrow: 1, children })
+      ]
+    }
+  );
+}
+
+// src/tui/components/shared/scrollable-list.tsx
+import "react";
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function ScrollableList({ items, selectedIndex, height, isFocused }) {
+  if (items.length === 0) {
+    return /* @__PURE__ */ jsx6(Box6, { children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "  No items." }) });
+  }
+  const visibleHeight = Math.max(1, height - 1);
+  let start = 0;
+  if (selectedIndex >= visibleHeight) {
+    start = selectedIndex - visibleHeight + 1;
+  }
+  const visibleItems = items.slice(start, start + visibleHeight);
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+    visibleItems.map((item, i) => {
+      const actualIndex = start + i;
+      const isSelected = actualIndex === selectedIndex && isFocused;
+      return /* @__PURE__ */ jsxs6(Box6, { children: [
+        /* @__PURE__ */ jsxs6(
+          Text6,
+          {
+            color: isSelected ? "cyan" : item.color ?? void 0,
+            bold: isSelected,
+            inverse: isSelected,
+            children: [
+              isSelected ? " \u25B6 " : "   ",
+              item.label,
+              item.sublabel ? ` ${item.sublabel}` : ""
+            ]
+          }
+        ),
+        item.rightLabel && /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+          " ",
+          item.rightLabel
+        ] })
+      ] }, item.id);
+    }),
+    items.length > visibleHeight && /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+      "  [",
+      start + 1,
+      "-",
+      Math.min(start + visibleHeight, items.length),
+      "/",
+      items.length,
+      "]"
+    ] })
+  ] });
+}
+
+// src/tui/components/shared/spinner.tsx
+import { useState, useEffect } from "react";
+import { Text as Text7 } from "ink";
+import { jsxs as jsxs7 } from "react/jsx-runtime";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function Spinner({ label }) {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame((f) => (f + 1) % FRAMES.length);
+    }, 80);
+    return () => clearInterval(timer);
+  }, []);
+  return /* @__PURE__ */ jsxs7(Text7, { color: "cyan", children: [
+    FRAMES[frame],
+    label ? ` ${label}` : ""
+  ] });
+}
+
+// src/tui/stores/projects-store.ts
+import { create as create3 } from "zustand";
+var useProjectsStore = create3((set) => ({
+  projects: [],
+  loading: false,
+  error: null,
+  setProjects: (projects) => set({ projects, loading: false, error: null }),
+  setLoading: (loading) => set({ loading }),
+  setError: (error) => set({ error, loading: false })
+}));
+
+// src/tui/components/panels/projects-panel.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function ProjectsPanel({ height }) {
+  const projects = useProjectsStore((s) => s.projects);
+  const loading = useProjectsStore((s) => s.loading);
+  const error = useProjectsStore((s) => s.error);
+  const focusedPanel = useTuiStore((s) => s.focusedPanel);
+  const scrollIndex = useTuiStore((s) => s.scrollIndex.projects);
+  const selectedProjectId = useTuiStore((s) => s.selectedProjectId);
+  const isFocused = focusedPanel === "projects";
+  const items = projects.map((p) => ({
+    id: p.id,
+    label: p.name,
+    sublabel: p.status,
+    rightLabel: formatRelativeTime(p.updatedAt),
+    color: p.id === selectedProjectId ? "cyan" : getStatusColor(p.status)
+  }));
+  return /* @__PURE__ */ jsx7(Panel, { title: "PROJECTS", isFocused, height, children: loading && projects.length === 0 ? /* @__PURE__ */ jsx7(Spinner, { label: "Loading projects..." }) : error ? /* @__PURE__ */ jsx7(Text8, { color: "red", children: error }) : /* @__PURE__ */ jsx7(
+    ScrollableList,
+    {
+      items,
+      selectedIndex: scrollIndex,
+      height: height - 3,
+      isFocused
+    }
+  ) });
+}
+
+// src/tui/components/panels/plan-panel.tsx
+import "react";
+import { Box as Box7, Text as Text9 } from "ink";
+
+// src/tui/stores/plan-store.ts
+import { create as create4 } from "zustand";
+
+// src/tui/lib/tree-builder.ts
+function buildTree(nodes, edges) {
+  const adj = /* @__PURE__ */ new Map();
+  const hasParent = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    const children = adj.get(edge.source) ?? [];
+    children.push(edge.target);
+    adj.set(edge.source, children);
+    hasParent.add(edge.target);
+  }
+  const lookup = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (!node.deletedAt) lookup.set(node.id, node);
+  }
+  function buildSubtree(nodeId) {
+    const node = lookup.get(nodeId);
+    if (!node) return null;
+    const childIds = adj.get(nodeId) ?? [];
+    const children = [];
+    for (const childId of childIds) {
+      const child = buildSubtree(childId);
+      if (child) children.push(child);
+    }
+    return {
+      id: node.id,
+      title: node.title,
+      status: node.status,
+      type: node.type,
+      children
+    };
+  }
+  const roots = [];
+  for (const node of nodes) {
+    if (!node.deletedAt && !hasParent.has(node.id)) {
+      const tree = buildSubtree(node.id);
+      if (tree) roots.push(tree);
+    }
+  }
+  return roots;
+}
+function renderTreeLines(roots, collapsedSet) {
+  const lines = [];
+  function walk(node, prefix, isLast, depth) {
+    const connector = depth === 0 ? isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 " : isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const symbol = getStatusSymbol(node.status);
+    const collapsed = collapsedSet?.has(node.id) && node.children.length > 0;
+    const expandIcon = node.children.length > 0 ? collapsed ? "\u25B6 " : "\u25BC " : "  ";
+    lines.push({
+      id: node.id,
+      text: `${prefix}${connector}${expandIcon}${symbol} ${node.title} [${node.status}]`,
+      status: node.status,
+      depth,
+      isLeaf: node.children.length === 0,
+      nodeTitle: node.title
+    });
+    if (collapsed) return;
+    const childPrefix = prefix + (isLast ? "    " : "\u2502   ");
+    for (let i = 0; i < node.children.length; i++) {
+      walk(node.children[i], childPrefix, i === node.children.length - 1, depth + 1);
+    }
+  }
+  for (let i = 0; i < roots.length; i++) {
+    walk(roots[i], "", i === roots.length - 1, 0);
+  }
+  return lines;
+}
+
+// src/tui/stores/plan-store.ts
+var usePlanStore = create4((set, get) => ({
+  projectId: null,
+  nodes: [],
+  edges: [],
+  treeRoots: [],
+  treeLines: [],
+  collapsedNodes: /* @__PURE__ */ new Set(),
+  loading: false,
+  error: null,
+  setPlan: (projectId, nodes, edges) => {
+    const { collapsedNodes } = get();
+    const treeRoots = buildTree(nodes, edges);
+    const treeLines = renderTreeLines(treeRoots, collapsedNodes);
+    set({ projectId, nodes, edges, treeRoots, treeLines, loading: false, error: null });
+  },
+  setLoading: (loading) => set({ loading }),
+  setError: (error) => set({ error, loading: false }),
+  toggleCollapse: (nodeId) => {
+    const { collapsedNodes, treeRoots } = get();
+    const next = new Set(collapsedNodes);
+    if (next.has(nodeId)) {
+      next.delete(nodeId);
+    } else {
+      next.add(nodeId);
+    }
+    const treeLines = renderTreeLines(treeRoots, next);
+    set({ collapsedNodes: next, treeLines });
+  },
+  updateNodeStatus: (nodeId, status) => {
+    const { nodes, edges, collapsedNodes } = get();
+    const updated = nodes.map((n) => n.id === nodeId ? { ...n, status } : n);
+    const treeRoots = buildTree(updated, edges);
+    const treeLines = renderTreeLines(treeRoots, collapsedNodes);
+    set({ nodes: updated, treeRoots, treeLines });
+  },
+  clear: () => set({
+    projectId: null,
+    nodes: [],
+    edges: [],
+    treeRoots: [],
+    treeLines: [],
+    loading: false,
+    error: null
+  })
+}));
+
+// src/tui/components/panels/plan-panel.tsx
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function PlanPanel({ height }) {
+  const treeLines = usePlanStore((s) => s.treeLines);
+  const loading = usePlanStore((s) => s.loading);
+  const error = usePlanStore((s) => s.error);
+  const focusedPanel = useTuiStore((s) => s.focusedPanel);
+  const scrollIndex = useTuiStore((s) => s.scrollIndex.plan);
+  const selectedProjectId = useTuiStore((s) => s.selectedProjectId);
+  const projects = useProjectsStore((s) => s.projects);
+  const isFocused = focusedPanel === "plan";
+  const projectName = projects.find((p) => p.id === selectedProjectId)?.name ?? "none";
+  const visibleHeight = Math.max(1, height - 4);
+  let start = 0;
+  if (scrollIndex >= visibleHeight) {
+    start = scrollIndex - visibleHeight + 1;
+  }
+  const visibleLines = treeLines.slice(start, start + visibleHeight);
+  return /* @__PURE__ */ jsx8(Panel, { title: `PLAN (${projectName})`, isFocused, height, children: loading && treeLines.length === 0 ? /* @__PURE__ */ jsx8(Spinner, { label: "Loading plan..." }) : error ? /* @__PURE__ */ jsx8(Text9, { color: "red", children: error }) : !selectedProjectId ? /* @__PURE__ */ jsx8(Text9, { dimColor: true, children: "  Select a project to view its plan" }) : treeLines.length === 0 ? /* @__PURE__ */ jsx8(Text9, { dimColor: true, children: "  No plan nodes. Use :plan create-node <title>" }) : /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", children: [
+    visibleLines.map((line, i) => {
+      const actualIndex = start + i;
+      const isSelected = actualIndex === scrollIndex && isFocused;
+      return /* @__PURE__ */ jsx8(Box7, { children: /* @__PURE__ */ jsx8(
+        Text9,
+        {
+          color: isSelected ? "cyan" : getStatusColor(line.status),
+          bold: isSelected,
+          inverse: isSelected,
+          children: line.text
+        }
+      ) }, line.id + "-" + actualIndex);
+    }),
+    treeLines.length > visibleHeight && /* @__PURE__ */ jsxs8(Text9, { dimColor: true, children: [
+      "  [",
+      start + 1,
+      "-",
+      Math.min(start + visibleHeight, treeLines.length),
+      "/",
+      treeLines.length,
+      "]"
+    ] })
+  ] }) });
+}
+
+// src/tui/components/panels/machines-panel.tsx
+import "react";
+import { Text as Text10 } from "ink";
+
+// src/tui/stores/machines-store.ts
+import { create as create5 } from "zustand";
+var useMachinesStore = create5((set, get) => ({
+  machines: [],
+  loading: false,
+  error: null,
+  setMachines: (machines) => set({ machines, loading: false, error: null }),
+  updateMachine: (id, patch) => {
+    set((s) => ({
+      machines: s.machines.map((m) => m.id === id ? { ...m, ...patch } : m)
+    }));
+  },
+  removeMachine: (id) => {
+    set((s) => ({ machines: s.machines.filter((m) => m.id !== id) }));
+  },
+  addMachine: (machine) => {
+    const { machines } = get();
+    const existing = machines.findIndex((m) => m.id === machine.id);
+    if (existing >= 0) {
+      set({ machines: machines.map((m, i) => i === existing ? machine : m) });
+    } else {
+      set({ machines: [...machines, machine] });
+    }
+  },
+  setLoading: (loading) => set({ loading }),
+  setError: (error) => set({ error, loading: false })
+}));
+
+// src/tui/components/panels/machines-panel.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+function MachinesPanel({ height }) {
+  const machines = useMachinesStore((s) => s.machines);
+  const loading = useMachinesStore((s) => s.loading);
+  const error = useMachinesStore((s) => s.error);
+  const focusedPanel = useTuiStore((s) => s.focusedPanel);
+  const scrollIndex = useTuiStore((s) => s.scrollIndex.machines);
+  const isFocused = focusedPanel === "machines";
+  const activeMachines = machines.filter((m) => !m.isRevoked);
+  const items = activeMachines.map((m) => ({
+    id: m.id,
+    label: m.name,
+    sublabel: m.platform,
+    rightLabel: m.isConnected ? "\u25CF online" : "\u25CB offline",
+    color: m.isConnected ? "green" : "gray"
+  }));
+  return /* @__PURE__ */ jsx9(Panel, { title: "MACHINES", isFocused, height, children: loading && machines.length === 0 ? /* @__PURE__ */ jsx9(Spinner, { label: "Loading machines..." }) : error ? /* @__PURE__ */ jsx9(Text10, { color: "red", children: error }) : /* @__PURE__ */ jsx9(
+    ScrollableList,
+    {
+      items,
+      selectedIndex: scrollIndex,
+      height: height - 3,
+      isFocused
+    }
+  ) });
+}
+
+// src/tui/components/panels/output-panel.tsx
+import "react";
+import { Box as Box8, Text as Text11 } from "ink";
+
+// src/tui/stores/execution-store.ts
+import { create as create6 } from "zustand";
+var MAX_LINES = 5e3;
+function flushToolDots(output) {
+  if (output.pendingToolCount === 0) return output.lines;
+  const dots = "\xB7".repeat(output.pendingToolCount);
+  const line = `[Tool Call] ${dots}`;
+  const lines = [...output.lines, line];
+  output.pendingToolCount = 0;
+  return lines;
+}
+function trimRingBuffer(lines) {
+  if (lines.length > MAX_LINES) {
+    lines.splice(0, lines.length - MAX_LINES);
+  }
+  return lines;
+}
+var useExecutionStore = create6((set, get) => ({
+  outputs: /* @__PURE__ */ new Map(),
+  watchingId: null,
+  initExecution: (executionId, nodeId) => {
+    const { outputs } = get();
+    const next = new Map(outputs);
+    next.set(executionId, {
+      executionId,
+      nodeId,
+      lines: [],
+      status: "running",
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      pendingToolCount: 0
+    });
+    set({ outputs: next });
+  },
+  appendToolCall: (executionId) => {
+    const { outputs } = get();
+    const current = outputs.get(executionId);
+    if (!current) return;
+    const next = new Map(outputs);
+    next.set(executionId, { ...current, pendingToolCount: current.pendingToolCount + 1 });
+    set({ outputs: next });
+  },
+  appendFileChange: (executionId, path, action, added, removed) => {
+    const { outputs } = get();
+    const current = outputs.get(executionId);
+    if (!current) return;
+    const lines = flushToolDots({ ...current });
+    const stats = [
+      added != null && added > 0 ? `+${added}` : null,
+      removed != null && removed > 0 ? `-${removed}` : null
+    ].filter(Boolean).join(" ");
+    lines.push(`[${action}] ${path}${stats ? ` (${stats})` : ""}`);
+    trimRingBuffer(lines);
+    const next = new Map(outputs);
+    next.set(executionId, { ...current, lines, pendingToolCount: 0 });
+    set({ outputs: next });
+  },
+  appendLine: (executionId, line) => {
+    const { outputs } = get();
+    const current = outputs.get(executionId);
+    if (!current) return;
+    const lines = flushToolDots({ ...current });
+    lines.push(line);
+    trimRingBuffer(lines);
+    const next = new Map(outputs);
+    next.set(executionId, { ...current, lines, pendingToolCount: 0 });
+    set({ outputs: next });
+  },
+  appendText: (executionId, text) => {
+    const { outputs } = get();
+    const current = outputs.get(executionId);
+    if (!current) return;
+    const lines = flushToolDots({ ...current });
+    const newLines = text.split("\n");
+    if (lines.length > 0 && newLines.length > 0) {
+      lines[lines.length - 1] += newLines[0];
+      for (let i = 1; i < newLines.length; i++) {
+        lines.push(newLines[i]);
+      }
+    } else {
+      lines.push(...newLines);
+    }
+    trimRingBuffer(lines);
+    const next = new Map(outputs);
+    next.set(executionId, { ...current, lines, pendingToolCount: 0 });
+    set({ outputs: next });
+  },
+  setStatus: (executionId, status) => {
+    const { outputs } = get();
+    const current = outputs.get(executionId);
+    if (!current) return;
+    const lines = flushToolDots({ ...current });
+    const next = new Map(outputs);
+    next.set(executionId, { ...current, lines, status, pendingToolCount: 0 });
+    set({ outputs: next });
+  },
+  setWatching: (watchingId) => set({ watchingId }),
+  clear: (executionId) => {
+    const { outputs } = get();
+    const next = new Map(outputs);
+    next.delete(executionId);
+    set({ outputs: next });
+  }
+}));
+
+// src/tui/components/panels/output-panel.tsx
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+function lineColor(line) {
+  if (line.startsWith("[Tool Call]")) return "gray";
+  if (line.startsWith("[error]")) return "red";
+  if (line.startsWith("[progress]")) return "cyan";
+  if (line.startsWith("[created]") || line.startsWith("[modified]") || line.startsWith("[deleted]")) return "yellow";
+  return void 0;
+}
+function OutputPanel({ height }) {
+  const watchingId = useExecutionStore((s) => s.watchingId);
+  const outputs = useExecutionStore((s) => s.outputs);
+  const focusedPanel = useTuiStore((s) => s.focusedPanel);
+  const scrollIndex = useTuiStore((s) => s.scrollIndex.output);
+  const isFocused = focusedPanel === "output";
+  const execution = watchingId ? outputs.get(watchingId) : null;
+  const visibleHeight = Math.max(1, height - 4);
+  let title = "OUTPUT";
+  if (execution) {
+    const shortId = execution.nodeId.length > 20 ? execution.nodeId.slice(0, 8) + "\u2026" : execution.nodeId;
+    title = `OUTPUT (${shortId}) [${execution.status}]`;
+  }
+  if (!execution) {
+    return /* @__PURE__ */ jsx10(Panel, { title, isFocused, height, children: /* @__PURE__ */ jsx10(Text11, { dimColor: true, children: "  No active execution. Dispatch a task with 'd' or :dispatch" }) });
+  }
+  const lines = execution.lines;
+  const isRunning = execution.status === "running";
+  const hasPendingTools = execution.pendingToolCount > 0;
+  let start;
+  if (scrollIndex >= lines.length - visibleHeight) {
+    start = Math.max(0, lines.length - visibleHeight);
+  } else {
+    start = Math.max(0, scrollIndex);
+  }
+  const visibleLines = lines.slice(start, start + visibleHeight);
+  return /* @__PURE__ */ jsx10(Panel, { title, isFocused, height, children: /* @__PURE__ */ jsxs9(Box8, { flexDirection: "column", children: [
+    visibleLines.map((line, i) => /* @__PURE__ */ jsx10(Text11, { color: lineColor(line), dimColor: line.startsWith("[Tool Call]"), wrap: "truncate", children: truncate(line, 200) }, start + i)),
+    hasPendingTools && /* @__PURE__ */ jsx10(Text11, { dimColor: true, children: "[Tool Call] " + "\xB7".repeat(execution.pendingToolCount) }),
+    isRunning && !hasPendingTools && /* @__PURE__ */ jsx10(Spinner, { label: "Running..." }),
+    lines.length > visibleHeight && /* @__PURE__ */ jsxs9(Text11, { dimColor: true, children: [
+      "  [",
+      start + 1,
+      "-",
+      Math.min(start + visibleHeight, lines.length),
+      "/",
+      lines.length,
+      "]"
+    ] })
+  ] }) });
+}
+
+// src/tui/components/panels/detail-overlay.tsx
+import "react";
+import { Box as Box9, Text as Text12 } from "ink";
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+function DetailOverlay() {
+  const showDetail = useTuiStore((s) => s.showDetail);
+  const detailType = useTuiStore((s) => s.detailType);
+  const detailId = useTuiStore((s) => s.detailId);
+  if (!showDetail || !detailType || !detailId) return null;
+  return /* @__PURE__ */ jsxs10(
+    Box9,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "cyan",
+      paddingX: 2,
+      paddingY: 1,
+      children: [
+        detailType === "project" && /* @__PURE__ */ jsx11(ProjectDetail, { id: detailId }),
+        detailType === "node" && /* @__PURE__ */ jsx11(NodeDetail, { id: detailId }),
+        detailType === "machine" && /* @__PURE__ */ jsx11(MachineDetail, { id: detailId }),
+        /* @__PURE__ */ jsx11(Text12, { dimColor: true, children: "Press Esc to close" })
+      ]
+    }
+  );
+}
+function ProjectDetail({ id }) {
+  const project = useProjectsStore((s) => s.projects.find((p) => p.id === id));
+  if (!project) return /* @__PURE__ */ jsx11(Text12, { color: "red", children: "Project not found" });
+  return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx11(Text12, { bold: true, color: "cyan", children: project.name }),
+    /* @__PURE__ */ jsx11(Text12, { children: " " }),
+    /* @__PURE__ */ jsx11(Field, { label: "ID", value: project.id }),
+    /* @__PURE__ */ jsx11(Field, { label: "Status", value: project.status, color: getStatusColor(project.status) }),
+    /* @__PURE__ */ jsx11(Field, { label: "Description", value: project.description || "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Health", value: project.health ?? "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Progress", value: `${project.progress}%` }),
+    /* @__PURE__ */ jsx11(Field, { label: "Working Dir", value: project.workingDirectory ?? "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Repository", value: project.repository ?? "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Delivery", value: project.deliveryMode ?? "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Start Date", value: project.startDate ?? "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Target Date", value: project.targetDate ?? "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Created", value: formatRelativeTime(project.createdAt) }),
+    /* @__PURE__ */ jsx11(Field, { label: "Updated", value: formatRelativeTime(project.updatedAt) }),
+    /* @__PURE__ */ jsx11(Text12, { children: " " })
+  ] });
+}
+function NodeDetail({ id }) {
+  const node = usePlanStore((s) => s.nodes.find((n) => n.id === id));
+  if (!node) return /* @__PURE__ */ jsx11(Text12, { color: "red", children: "Node not found" });
+  return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx11(Text12, { bold: true, color: "cyan", children: node.title }),
+    /* @__PURE__ */ jsx11(Text12, { children: " " }),
+    /* @__PURE__ */ jsx11(Field, { label: "ID", value: node.id }),
+    /* @__PURE__ */ jsx11(Field, { label: "Type", value: node.type }),
+    /* @__PURE__ */ jsx11(Field, { label: "Status", value: node.status, color: getStatusColor(node.status) }),
+    /* @__PURE__ */ jsx11(Field, { label: "Description", value: node.description || "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Priority", value: node.priority ?? "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Estimate", value: node.estimate ?? "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Start Date", value: node.startDate ?? "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "End Date", value: node.endDate ?? "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Due Date", value: node.dueDate ?? "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Branch", value: node.branchName ?? "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "PR URL", value: node.prUrl ?? "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Execution ID", value: node.executionId ?? "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Exec Started", value: node.executionStartedAt ? formatRelativeTime(node.executionStartedAt) : "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Exec Completed", value: node.executionCompletedAt ? formatRelativeTime(node.executionCompletedAt) : "\u2014" }),
+    /* @__PURE__ */ jsx11(Text12, { children: " " })
+  ] });
+}
+function MachineDetail({ id }) {
+  const machine = useMachinesStore((s) => s.machines.find((m) => m.id === id));
+  if (!machine) return /* @__PURE__ */ jsx11(Text12, { color: "red", children: "Machine not found" });
+  return /* @__PURE__ */ jsxs10(Box9, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx11(Text12, { bold: true, color: "cyan", children: machine.name }),
+    /* @__PURE__ */ jsx11(Text12, { children: " " }),
+    /* @__PURE__ */ jsx11(Field, { label: "ID", value: machine.id }),
+    /* @__PURE__ */ jsx11(Field, { label: "Hostname", value: machine.hostname }),
+    /* @__PURE__ */ jsx11(Field, { label: "Platform", value: machine.platform }),
+    /* @__PURE__ */ jsx11(Field, { label: "Env Type", value: machine.environmentType }),
+    /* @__PURE__ */ jsx11(Field, { label: "Connected", value: machine.isConnected ? "Yes" : "No", color: machine.isConnected ? "green" : "red" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Providers", value: machine.providers.join(", ") || "\u2014" }),
+    /* @__PURE__ */ jsx11(Field, { label: "Registered", value: formatRelativeTime(machine.registeredAt) }),
+    /* @__PURE__ */ jsx11(Field, { label: "Last Seen", value: formatRelativeTime(machine.lastSeenAt) }),
+    /* @__PURE__ */ jsx11(Text12, { children: " " })
+  ] });
+}
+function Field({ label, value, color }) {
+  return /* @__PURE__ */ jsxs10(Box9, { children: [
+    /* @__PURE__ */ jsx11(Text12, { dimColor: true, children: label.padEnd(16) }),
+    color ? /* @__PURE__ */ jsx11(Text12, { color, children: value }) : /* @__PURE__ */ jsx11(Text12, { children: value })
+  ] });
+}
+
+// src/tui/components/layout/main-layout.tsx
+import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+function MainLayout() {
+  const showHelp = useTuiStore((s) => s.showHelp);
+  const showDetail = useTuiStore((s) => s.showDetail);
+  const { stdout } = useStdout();
+  const termHeight = stdout?.rows ?? 24;
+  const termWidth = stdout?.columns ?? 80;
+  const topRowHeight = Math.floor((termHeight - 4) / 2);
+  const bottomRowHeight = termHeight - 4 - topRowHeight;
+  if (showHelp) {
+    return /* @__PURE__ */ jsxs11(Box10, { flexDirection: "column", width: termWidth, height: termHeight, children: [
+      /* @__PURE__ */ jsx12(StatusBar, {}),
+      /* @__PURE__ */ jsx12(HelpOverlay, {}),
+      /* @__PURE__ */ jsx12(CommandLine, {})
+    ] });
+  }
+  if (showDetail) {
+    return /* @__PURE__ */ jsxs11(Box10, { flexDirection: "column", width: termWidth, height: termHeight, children: [
+      /* @__PURE__ */ jsx12(StatusBar, {}),
+      /* @__PURE__ */ jsx12(DetailOverlay, {}),
+      /* @__PURE__ */ jsx12(CommandLine, {})
+    ] });
+  }
+  return /* @__PURE__ */ jsxs11(Box10, { flexDirection: "column", width: termWidth, height: termHeight, children: [
+    /* @__PURE__ */ jsx12(StatusBar, {}),
+    /* @__PURE__ */ jsxs11(Box10, { flexDirection: "row", height: topRowHeight, children: [
+      /* @__PURE__ */ jsx12(Box10, { width: "30%", children: /* @__PURE__ */ jsx12(ProjectsPanel, { height: topRowHeight }) }),
+      /* @__PURE__ */ jsx12(Box10, { flexGrow: 1, children: /* @__PURE__ */ jsx12(PlanPanel, { height: topRowHeight }) })
+    ] }),
+    /* @__PURE__ */ jsxs11(Box10, { flexDirection: "row", height: bottomRowHeight, children: [
+      /* @__PURE__ */ jsx12(Box10, { width: "30%", children: /* @__PURE__ */ jsx12(MachinesPanel, { height: bottomRowHeight }) }),
+      /* @__PURE__ */ jsx12(Box10, { flexGrow: 1, children: /* @__PURE__ */ jsx12(OutputPanel, { height: bottomRowHeight }) })
+    ] }),
+    /* @__PURE__ */ jsx12(SearchOverlay, {}),
+    /* @__PURE__ */ jsx12(CommandLine, {})
+  ] });
+}
+
+// src/tui/hooks/use-vim-mode.ts
+import { useCallback, useRef } from "react";
+import { useInput as useInput2, useApp } from "ink";
+
+// src/tui/lib/vim-state-machine.ts
+function initialVimState() {
+  return {
+    mode: "normal",
+    commandBuffer: "",
+    searchQuery: "",
+    pendingKeys: ""
+  };
+}
+function vimReducer(state, action) {
+  switch (action.type) {
+    case "set_mode":
+      return [{ ...state, mode: action.mode, pendingKeys: "" }, { type: "none" }];
+    case "clear_command":
+      return [{ ...state, commandBuffer: "", mode: "normal", pendingKeys: "" }, { type: "none" }];
+    case "clear_search":
+      return [{ ...state, searchQuery: "", mode: "normal", pendingKeys: "" }, { type: "none" }];
+    case "submit_command":
+      return [
+        { ...state, mode: "normal", pendingKeys: "" },
+        { type: "command", value: state.commandBuffer }
+      ];
+    case "submit_search":
+      return [
+        { ...state, mode: "normal", pendingKeys: "" },
+        { type: "search", value: state.searchQuery }
+      ];
+    case "key":
+      return handleKey(state, action.key, action.ctrl);
+  }
+}
+function handleKey(state, key, ctrl) {
+  if (key === "escape") {
+    return [{ ...state, mode: "normal", pendingKeys: "", commandBuffer: "", searchQuery: "" }, { type: "none" }];
+  }
+  switch (state.mode) {
+    case "normal":
+      return handleNormalMode(state, key, ctrl);
+    case "command":
+      return handleCommandMode(state, key);
+    case "search":
+      return handleSearchMode(state, key);
+    case "insert":
+      return handleInsertMode(state, key);
+  }
+}
+function handleNormalMode(state, key, ctrl) {
+  if (ctrl) {
+    if (key === "u") return [state, { type: "scroll", direction: "page_up" }];
+    if (key === "d") return [state, { type: "scroll", direction: "page_down" }];
+    if (key === "c") return [state, { type: "quit" }];
+    return [state, { type: "none" }];
+  }
+  if (state.pendingKeys === "g") {
+    if (key === "g") {
+      return [{ ...state, pendingKeys: "" }, { type: "scroll", direction: "top" }];
+    }
+    return [{ ...state, pendingKeys: "" }, { type: "none" }];
+  }
+  switch (key) {
+    // Navigation
+    case "j":
+    case "return":
+      if (key === "j") return [state, { type: "scroll", direction: "down" }];
+      return [state, { type: "select" }];
+    case "k":
+      return [state, { type: "scroll", direction: "up" }];
+    case "h":
+      return [state, { type: "focus", direction: "left" }];
+    case "l":
+      return [state, { type: "focus", direction: "right" }];
+    // Panel jump
+    case "1":
+      return [state, { type: "focus", panel: 0 }];
+    case "2":
+      return [state, { type: "focus", panel: 1 }];
+    case "3":
+      return [state, { type: "focus", panel: 2 }];
+    case "4":
+      return [state, { type: "focus", panel: 3 }];
+    case "tab":
+      return [state, { type: "focus", direction: "right" }];
+    // Top/bottom
+    case "g":
+      return [{ ...state, pendingKeys: "g" }, { type: "none" }];
+    case "G":
+      return [state, { type: "scroll", direction: "bottom" }];
+    // Mode switches
+    case ":":
+      return [{ ...state, mode: "command", commandBuffer: "" }, { type: "none" }];
+    case "/":
+      return [{ ...state, mode: "search", searchQuery: "" }, { type: "none" }];
+    case "i":
+      return [{ ...state, mode: "insert" }, { type: "none" }];
+    // Actions
+    case "d":
+      return [state, { type: "dispatch" }];
+    case "c":
+      return [state, { type: "cancel" }];
+    case "r":
+      return [state, { type: "refresh" }];
+    case "q":
+      return [state, { type: "quit" }];
+    case "?":
+      return [state, { type: "help" }];
+    default:
+      return [state, { type: "none" }];
+  }
+}
+function handleCommandMode(state, key) {
+  if (key === "return") {
+    return [
+      { ...state, mode: "normal" },
+      { type: "command", value: state.commandBuffer }
+    ];
+  }
+  if (key === "backspace" || key === "delete") {
+    const newBuffer = state.commandBuffer.slice(0, -1);
+    if (newBuffer.length === 0) {
+      return [{ ...state, mode: "normal", commandBuffer: "" }, { type: "none" }];
+    }
+    return [{ ...state, commandBuffer: newBuffer }, { type: "none" }];
+  }
+  if (key === "tab") {
+    return [state, { type: "command", value: `__autocomplete__${state.commandBuffer}` }];
+  }
+  if (key.length === 1) {
+    return [{ ...state, commandBuffer: state.commandBuffer + key }, { type: "none" }];
+  }
+  return [state, { type: "none" }];
+}
+function handleSearchMode(state, key) {
+  if (key === "return") {
+    return [
+      { ...state, mode: "normal" },
+      { type: "search", value: state.searchQuery }
+    ];
+  }
+  if (key === "backspace" || key === "delete") {
+    const newQuery = state.searchQuery.slice(0, -1);
+    if (newQuery.length === 0) {
+      return [{ ...state, mode: "normal", searchQuery: "" }, { type: "none" }];
+    }
+    return [{ ...state, searchQuery: newQuery }, { type: "search", value: newQuery }];
+  }
+  if (key.length === 1) {
+    const newQuery = state.searchQuery + key;
+    return [{ ...state, searchQuery: newQuery }, { type: "search", value: newQuery }];
+  }
+  return [state, { type: "none" }];
+}
+function handleInsertMode(state, _) {
+  return [state, { type: "none" }];
+}
+
+// src/tui/hooks/use-vim-mode.ts
+function useVimMode(callbacks = {}) {
+  const { exit } = useApp();
+  const vimState = useRef(initialVimState());
+  const store = useTuiStore();
+  const handleEffect = useCallback(
+    (effect) => {
+      switch (effect.type) {
+        case "scroll":
+          switch (effect.direction) {
+            case "up":
+              store.scrollUp();
+              break;
+            case "down":
+              store.scrollDown();
+              break;
+            case "top":
+              store.scrollToTop();
+              break;
+            case "bottom":
+              store.scrollToBottom();
+              break;
+            case "page_up":
+              store.pageUp();
+              break;
+            case "page_down":
+              store.pageDown();
+              break;
+          }
+          break;
+        case "focus":
+          if (effect.panel != null) {
+            store.focusByIndex(effect.panel);
+          } else if (effect.direction === "left") {
+            store.focusPrev();
+          } else if (effect.direction === "right") {
+            store.focusNext();
+          }
+          break;
+        case "select":
+          callbacks.onSelect?.();
+          break;
+        case "command":
+          if (effect.value?.startsWith("__autocomplete__")) {
+          } else if (effect.value) {
+            callbacks.onCommand?.(effect.value);
+          }
+          break;
+        case "search":
+          if (effect.value) {
+            callbacks.onSearch?.(effect.value);
+          }
+          break;
+        case "dispatch":
+          callbacks.onDispatch?.();
+          break;
+        case "cancel":
+          callbacks.onCancel?.();
+          break;
+        case "refresh":
+          callbacks.onRefresh?.();
+          break;
+        case "quit":
+          exit();
+          break;
+        case "help":
+          store.toggleHelp();
+          break;
+        case "none":
+          break;
+      }
+    },
+    [store, callbacks, exit]
+  );
+  useInput2((input, key) => {
+    if (store.showHelp || store.showSearch || store.showDetail) {
+      if (key.escape) {
+        store.closeOverlays();
+        vimState.current = initialVimState();
+        store.setMode("normal");
+        store.setCommandBuffer("");
+        store.setSearchQuery("");
+        store.setPendingKeys("");
+      }
+      return;
+    }
+    let keyStr = input;
+    if (key.escape) keyStr = "escape";
+    else if (key.return) keyStr = "return";
+    else if (key.backspace || key.delete) keyStr = "backspace";
+    else if (key.tab) keyStr = "tab";
+    else if (key.upArrow) keyStr = "k";
+    else if (key.downArrow) keyStr = "j";
+    else if (key.leftArrow) keyStr = "h";
+    else if (key.rightArrow) keyStr = "l";
+    const [nextState, effect] = vimReducer(vimState.current, {
+      type: "key",
+      key: keyStr,
+      ctrl: key.ctrl,
+      shift: key.shift
+    });
+    vimState.current = nextState;
+    store.setMode(nextState.mode);
+    store.setCommandBuffer(nextState.commandBuffer);
+    store.setSearchQuery(nextState.searchQuery);
+    store.setPendingKeys(nextState.pendingKeys);
+    handleEffect(effect);
+  });
+}
+
+// src/tui/hooks/use-polling.ts
+import { useEffect as useEffect2, useCallback as useCallback2 } from "react";
+function usePolling(client, intervalMs = 3e4) {
+  const selectedProjectId = useTuiStore((s) => s.selectedProjectId);
+  const loadProjects = useCallback2(async () => {
+    useProjectsStore.getState().setLoading(true);
+    try {
+      const projects = await client.listProjects();
+      useProjectsStore.getState().setProjects(projects);
+    } catch (err) {
+      useProjectsStore.getState().setError(err instanceof Error ? err.message : String(err));
+    }
+  }, [client]);
+  const loadPlan = useCallback2(async (projectId) => {
+    usePlanStore.getState().setLoading(true);
+    try {
+      const { nodes, edges } = await client.getPlan(projectId);
+      usePlanStore.getState().setPlan(projectId, nodes, edges);
+    } catch (err) {
+      usePlanStore.getState().setError(err instanceof Error ? err.message : String(err));
+    }
+  }, [client]);
+  const loadMachines = useCallback2(async () => {
+    useMachinesStore.getState().setLoading(true);
+    try {
+      const machines = await client.listMachines();
+      useMachinesStore.getState().setMachines(machines);
+      useTuiStore.getState().setMachineCount(machines.filter((m) => m.isConnected).length);
+    } catch (err) {
+      useMachinesStore.getState().setError(err instanceof Error ? err.message : String(err));
+    }
+  }, [client]);
+  const refreshAll2 = useCallback2(async () => {
+    await Promise.allSettled([
+      loadProjects(),
+      loadMachines(),
+      ...selectedProjectId ? [loadPlan(selectedProjectId)] : []
+    ]);
+  }, [loadProjects, loadMachines, loadPlan, selectedProjectId]);
+  useEffect2(() => {
+    refreshAll2();
+  }, [refreshAll2]);
+  useEffect2(() => {
+    if (selectedProjectId) {
+      loadPlan(selectedProjectId);
+    } else {
+      usePlanStore.getState().clear();
+    }
+  }, [selectedProjectId, loadPlan]);
+  useEffect2(() => {
+    const timer = setInterval(refreshAll2, intervalMs);
+    return () => clearInterval(timer);
+  }, [refreshAll2, intervalMs]);
+  return { refreshAll: refreshAll2, loadProjects, loadPlan, loadMachines };
+}
+
+// src/tui/hooks/use-sse-stream.ts
+import { useEffect as useEffect3, useRef as useRef2 } from "react";
+
+// src/tui/sse-client.ts
+var SSEClient = class {
+  client;
+  abortController = null;
+  handler;
+  reconnectDelay = 1e3;
+  maxReconnectDelay = 3e4;
+  _connected = false;
+  _stopped = false;
+  constructor(client, handler) {
+    this.client = client;
+    this.handler = handler;
+  }
+  get connected() {
+    return this._connected;
+  }
+  async start() {
+    this._stopped = false;
+    this.reconnectDelay = 1e3;
+    await this.connect();
+  }
+  stop() {
+    this._stopped = true;
+    this._connected = false;
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+  }
+  async connect() {
+    if (this._stopped) return;
+    try {
+      const response = await this.client.streamEvents();
+      this._connected = true;
+      this.reconnectDelay = 1e3;
+      this.handler({ type: "__connected", data: {} });
+      if (!response.body) return;
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let eventType = "";
+      while (!this._stopped) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.startsWith("event: ")) {
+            eventType = line.slice(7).trim();
+          } else if (line.startsWith("data: ")) {
+            const dataStr = line.slice(6);
+            try {
+              const data = JSON.parse(dataStr);
+              this.handler({ type: eventType || "message", data });
+            } catch {
+              this.handler({ type: eventType || "message", data: { raw: dataStr } });
+            }
+            eventType = "";
+          } else if (line === "") {
+            eventType = "";
+          }
+        }
+      }
+    } catch (err) {
+      this._connected = false;
+      if (this._stopped) return;
+      this.handler({
+        type: "__disconnected",
+        data: { error: err instanceof Error ? err.message : String(err) }
+      });
+    }
+    if (!this._stopped) {
+      this._connected = false;
+      this.handler({ type: "__reconnecting", data: { delay: this.reconnectDelay } });
+      await new Promise((r) => setTimeout(r, this.reconnectDelay));
+      this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
+      await this.connect();
+    }
+  }
+};
+
+// src/tui/hooks/use-sse-stream.ts
+function useSSEStream(client) {
+  const sseRef = useRef2(null);
+  const setConnected = useTuiStore((s) => s.setConnected);
+  const setMachineCount = useTuiStore((s) => s.setMachineCount);
+  const setLastError = useTuiStore((s) => s.setLastError);
+  useEffect3(() => {
+    const handler = (event) => {
+      switch (event.type) {
+        case "__connected":
+          setConnected(true);
+          setLastError(null);
+          break;
+        case "__disconnected":
+          setConnected(false);
+          setLastError(event.data.error);
+          break;
+        case "__reconnecting":
+          setConnected(false);
+          break;
+        case "machines:snapshot": {
+          const machines = event.data ?? [];
+          useMachinesStore.getState().setMachines(machines);
+          setMachineCount(machines.filter((m) => m.isConnected).length);
+          break;
+        }
+        case "machine:connected": {
+          const machine = event.data;
+          useMachinesStore.getState().addMachine(machine);
+          setMachineCount(useMachinesStore.getState().machines.filter((m) => m.isConnected).length);
+          break;
+        }
+        case "machine:disconnected": {
+          const id = event.data.machineId;
+          useMachinesStore.getState().updateMachine(id, { isConnected: false });
+          setMachineCount(useMachinesStore.getState().machines.filter((m) => m.isConnected).length);
+          break;
+        }
+        case "task:stdout":
+        case "task:text": {
+          const taskId = event.data.taskId;
+          const text = event.data.data ?? event.data.output ?? "";
+          if (typeof text === "string" && text.length > 0) {
+            useExecutionStore.getState().appendText(taskId, text);
+          }
+          break;
+        }
+        case "task:progress": {
+          const taskId = event.data.taskId;
+          const message = event.data.message;
+          if (!message) break;
+          if (/^Using tool:/i.test(message)) break;
+          useExecutionStore.getState().appendLine(taskId, `[progress] ${message}`);
+          break;
+        }
+        case "task:result": {
+          const taskId = event.data.taskId;
+          const status = event.data.status;
+          useExecutionStore.getState().setStatus(taskId, status);
+          const nodeId = event.data.nodeId;
+          if (nodeId && status) {
+            const mappedStatus = status === "success" ? "completed" : status === "failure" ? "planned" : status;
+            usePlanStore.getState().updateNodeStatus(nodeId, mappedStatus);
+          }
+          break;
+        }
+        case "task:tool_trace": {
+          const taskId = event.data.taskId;
+          const toolName = event.data.toolName;
+          useExecutionStore.getState().appendToolCall(taskId, toolName);
+          break;
+        }
+        case "task:file_change": {
+          const taskId = event.data.taskId;
+          const path = event.data.path;
+          const action = event.data.action;
+          const added = event.data.linesAdded;
+          const removed = event.data.linesRemoved;
+          useExecutionStore.getState().appendFileChange(taskId, path, action, added, removed);
+          break;
+        }
+        case "task:session_init": {
+          const taskId = event.data.taskId;
+          const nodeId = event.data.nodeId ?? taskId;
+          useExecutionStore.getState().initExecution(taskId, nodeId);
+          useExecutionStore.getState().setWatching(taskId);
+          break;
+        }
+        case "heartbeat":
+          break;
+      }
+    };
+    const sse = new SSEClient(client, handler);
+    sseRef.current = sse;
+    sse.start().catch(() => {
+    });
+    return () => {
+      sse.stop();
+    };
+  }, [client, setConnected, setMachineCount, setLastError]);
+}
+
+// src/tui/hooks/use-fuzzy-search.ts
+import { useEffect as useEffect4, useCallback as useCallback3 } from "react";
+import Fuse from "fuse.js";
+var fuseInstance = null;
+function useFuzzySearch() {
+  const projects = useProjectsStore((s) => s.projects);
+  const nodes = usePlanStore((s) => s.nodes);
+  const machines = useMachinesStore((s) => s.machines);
+  const { setItems, setResults, query } = useSearchStore();
+  useEffect4(() => {
+    const items = [
+      ...projects.map((p) => ({
+        type: "project",
+        id: p.id,
+        title: p.name,
+        subtitle: p.description,
+        status: p.status
+      })),
+      ...nodes.filter((n) => !n.deletedAt).map((n) => ({
+        type: "task",
+        id: n.id,
+        title: n.title,
+        subtitle: n.description,
+        status: n.status
+      })),
+      ...machines.filter((m) => !m.isRevoked).map((m) => ({
+        type: "machine",
+        id: m.id,
+        title: m.name,
+        subtitle: `${m.platform} - ${m.hostname}`,
+        status: m.isConnected ? "connected" : "disconnected"
+      }))
+    ];
+    setItems(items);
+    fuseInstance = new Fuse(items, {
+      keys: ["title", "subtitle", "id"],
+      threshold: 0.4,
+      includeScore: true
+    });
+  }, [projects, nodes, machines, setItems]);
+  const search = useCallback3((q) => {
+    if (!q || !fuseInstance) {
+      setResults([]);
+      return;
+    }
+    const results = fuseInstance.search(q, { limit: 20 });
+    setResults(results.map((r) => r.item));
+  }, [setResults]);
+  useEffect4(() => {
+    search(query);
+  }, [query, search]);
+  return { search };
+}
+
+// src/tui/hooks/use-command-parser.ts
+import { useCallback as useCallback4 } from "react";
+
+// src/tui/commands/handlers.ts
+var handlers = {
+  // ── Quit ──
+  q: async () => {
+    process.exit(0);
+  },
+  quit: async () => {
+    process.exit(0);
+  },
+  // ── Refresh ──
+  r: async (_args, client) => {
+    await refreshAll(client);
+  },
+  refresh: async (_args, client) => {
+    await refreshAll(client);
+  },
+  // ── Project commands ──
+  "project list": async (_args, client) => {
+    const projects = await client.listProjects();
+    useProjectsStore.getState().setProjects(projects);
+  },
+  "project show": async (args, client) => {
+    const id = args[0];
+    if (!id) return;
+    try {
+      const project = await client.resolveProject(id);
+      useTuiStore.getState().openDetail("project", project.id);
+    } catch {
+      useTuiStore.getState().setLastError(`Project not found: ${id}`);
+    }
+  },
+  "project create": async (args, client) => {
+    const name = args.join(" ");
+    if (!name) {
+      useTuiStore.getState().setLastError("Usage: :project create <name>");
+      return;
+    }
+    await client.createProject({ name });
+    const projects = await client.listProjects();
+    useProjectsStore.getState().setProjects(projects);
+  },
+  "project delete": async (args, client) => {
+    const id = args[0];
+    if (!id) return;
+    try {
+      const project = await client.resolveProject(id);
+      await client.deleteProject(project.id);
+      const projects = await client.listProjects();
+      useProjectsStore.getState().setProjects(projects);
+    } catch (err) {
+      useTuiStore.getState().setLastError(err instanceof Error ? err.message : String(err));
+    }
+  },
+  // ── Plan commands ──
+  "plan tree": async (_args, client) => {
+    const projectId = useTuiStore.getState().selectedProjectId;
+    if (!projectId) {
+      useTuiStore.getState().setLastError("No project selected");
+      return;
+    }
+    const { nodes, edges } = await client.getPlan(projectId);
+    usePlanStore.getState().setPlan(projectId, nodes, edges);
+    useTuiStore.getState().focusPanel("plan");
+  },
+  "plan create-node": async (args, client) => {
+    const projectId = useTuiStore.getState().selectedProjectId;
+    if (!projectId) {
+      useTuiStore.getState().setLastError("No project selected");
+      return;
+    }
+    const title = args.join(" ");
+    if (!title) {
+      useTuiStore.getState().setLastError("Usage: :plan create-node <title>");
+      return;
+    }
+    const id = `node-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    await client.createPlanNode({ id, projectId, title });
+    const { nodes, edges } = await client.getPlan(projectId);
+    usePlanStore.getState().setPlan(projectId, nodes, edges);
+  },
+  "plan update-node": async (args, client) => {
+    const [nodeId, field, ...rest] = args;
+    if (!nodeId || !field) {
+      useTuiStore.getState().setLastError("Usage: :plan update-node <nodeId> <field> <value>");
+      return;
+    }
+    const value = rest.join(" ");
+    await client.updatePlanNode(nodeId, { [field]: value });
+    const projectId = useTuiStore.getState().selectedProjectId;
+    if (projectId) {
+      const { nodes, edges } = await client.getPlan(projectId);
+      usePlanStore.getState().setPlan(projectId, nodes, edges);
+    }
+  },
+  // ── Dispatch ──
+  d: async (args, client) => {
+    await handlers.dispatch(args, client);
+  },
+  dispatch: async (args, client) => {
+    const nodeId = args[0] ?? useTuiStore.getState().selectedNodeId;
+    const projectId = useTuiStore.getState().selectedProjectId;
+    if (!nodeId || !projectId) {
+      useTuiStore.getState().setLastError("No node/project selected for dispatch");
+      return;
+    }
+    try {
+      const response = await client.dispatchTask({ nodeId, projectId });
+      const execId = `exec-${Date.now()}`;
+      useExecutionStore.getState().initExecution(execId, nodeId);
+      useExecutionStore.getState().setWatching(execId);
+      useTuiStore.getState().focusPanel("output");
+      if (response.body) {
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              try {
+                const event = JSON.parse(line.slice(6));
+                const eventType = event.type;
+                if (eventType === "text") {
+                  useExecutionStore.getState().appendText(execId, event.content ?? "");
+                } else if (eventType === "tool_use") {
+                  useExecutionStore.getState().appendToolCall(execId, event.name ?? "");
+                } else if (eventType === "result") {
+                  useExecutionStore.getState().setStatus(execId, event.status ?? "completed");
+                } else if (eventType === "error") {
+                  useExecutionStore.getState().appendLine(execId, `[error] ${event.message}`);
+                  useExecutionStore.getState().setStatus(execId, "failure");
+                }
+              } catch {
+              }
+            }
+          }
+        }
+      }
+    } catch (err) {
+      useTuiStore.getState().setLastError(err instanceof Error ? err.message : String(err));
+    }
+  },
+  // ── Cancel ──
+  c: async (args, client) => {
+    await handlers.cancel(args, client);
+  },
+  cancel: async (args, client) => {
+    const executionId = args[0] ?? useExecutionStore.getState().watchingId;
+    if (!executionId) {
+      useTuiStore.getState().setLastError("No execution to cancel");
+      return;
+    }
+    try {
+      await client.cancelTask({ executionId });
+      useExecutionStore.getState().setStatus(executionId, "cancelled");
+    } catch (err) {
+      useTuiStore.getState().setLastError(err instanceof Error ? err.message : String(err));
+    }
+  },
+  // ── Steer ──
+  s: async (args, client) => {
+    await handlers.steer(args, client);
+  },
+  steer: async (args, client) => {
+    const message = args.join(" ");
+    if (!message) {
+      useTuiStore.getState().setLastError("Usage: :steer <message>");
+      return;
+    }
+    const executionId = useExecutionStore.getState().watchingId;
+    const selectedMachineId = useTuiStore.getState().selectedMachineId;
+    if (!executionId || !selectedMachineId) {
+      useTuiStore.getState().setLastError("No active execution/machine to steer");
+      return;
+    }
+    try {
+      await client.steerTask({ taskId: executionId, machineId: selectedMachineId, message });
+    } catch (err) {
+      useTuiStore.getState().setLastError(err instanceof Error ? err.message : String(err));
+    }
+  },
+  // ── Watch ──
+  watch: async (args) => {
+    const executionId = args[0];
+    if (!executionId) {
+      useTuiStore.getState().setLastError("Usage: :watch <executionId>");
+      return;
+    }
+    useExecutionStore.getState().setWatching(executionId);
+    useTuiStore.getState().focusPanel("output");
+  },
+  // ── Env ──
+  "env list": async (_args, client) => {
+    const machines = await client.listMachines();
+    useMachinesStore.getState().setMachines(machines);
+    useTuiStore.getState().focusPanel("machines");
+  },
+  "env status": async (_args, client) => {
+    const status = await client.getRelayStatus();
+    useTuiStore.getState().setLastError(JSON.stringify(status, null, 2));
+  },
+  // ── Search ──
+  search: async (args, client) => {
+    const query = args.join(" ");
+    if (!query) return;
+    try {
+      await client.search(query);
+      useTuiStore.getState().toggleSearch();
+    } catch (err) {
+      useTuiStore.getState().setLastError(err instanceof Error ? err.message : String(err));
+    }
+  },
+  // ── Activity ──
+  activity: async (_args, client) => {
+    const projectId = useTuiStore.getState().selectedProjectId;
+    try {
+      const activities = await client.listActivities(projectId ? { projectId } : void 0);
+      for (const a of activities.slice(0, 20)) {
+        useExecutionStore.getState().appendLine("activity", `[${a.type}] ${a.title}`);
+      }
+      useExecutionStore.getState().setWatching("activity");
+      useTuiStore.getState().focusPanel("output");
+    } catch (err) {
+      useTuiStore.getState().setLastError(err instanceof Error ? err.message : String(err));
+    }
+  },
+  // ── Help ──
+  help: async () => {
+    useTuiStore.getState().toggleHelp();
+  },
+  "?": async () => {
+    useTuiStore.getState().toggleHelp();
+  }
+};
+async function refreshAll(client) {
+  try {
+    const [projects, machines] = await Promise.all([
+      client.listProjects(),
+      client.listMachines()
+    ]);
+    useProjectsStore.getState().setProjects(projects);
+    useMachinesStore.getState().setMachines(machines);
+    useTuiStore.getState().setMachineCount(machines.filter((m) => m.isConnected).length);
+    const projectId = useTuiStore.getState().selectedProjectId;
+    if (projectId) {
+      const { nodes, edges } = await client.getPlan(projectId);
+      usePlanStore.getState().setPlan(projectId, nodes, edges);
+    }
+  } catch (err) {
+    useTuiStore.getState().setLastError(err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/tui/commands/autocomplete.ts
+var PrefixTrie = class {
+  root;
+  constructor() {
+    this.root = { children: /* @__PURE__ */ new Map(), isEnd: false, value: "" };
+  }
+  insert(word) {
+    let node = this.root;
+    for (const char of word) {
+      if (!node.children.has(char)) {
+        node.children.set(char, { children: /* @__PURE__ */ new Map(), isEnd: false, value: "" });
+      }
+      node = node.children.get(char);
+    }
+    node.isEnd = true;
+    node.value = word;
+  }
+  search(prefix) {
+    let node = this.root;
+    for (const char of prefix) {
+      if (!node.children.has(char)) return [];
+      node = node.children.get(char);
+    }
+    return this.collect(node);
+  }
+  collect(node) {
+    const results = [];
+    if (node.isEnd) results.push(node.value);
+    for (const child of node.children.values()) {
+      results.push(...this.collect(child));
+    }
+    return results;
+  }
+};
+
+// src/tui/commands/registry.ts
+var trie = new PrefixTrie();
+for (const key of Object.keys(handlers)) {
+  trie.insert(key);
+}
+async function executeCommand(input, client) {
+  const parts = input.split(/\s+/);
+  if (parts.length >= 2) {
+    const twoWord = `${parts[0]} ${parts[1]}`;
+    if (handlers[twoWord]) {
+      try {
+        await handlers[twoWord](parts.slice(2), client);
+      } catch (err) {
+        useTuiStore.getState().setLastError(err instanceof Error ? err.message : String(err));
+      }
+      return;
+    }
+  }
+  const cmd = parts[0];
+  if (handlers[cmd]) {
+    try {
+      await handlers[cmd](parts.slice(1), client);
+    } catch (err) {
+      useTuiStore.getState().setLastError(err instanceof Error ? err.message : String(err));
+    }
+    return;
+  }
+  useTuiStore.getState().setLastError(`Unknown command: ${cmd}`);
+}
+function getCompletions(partial) {
+  return trie.search(partial);
+}
+
+// src/tui/hooks/use-command-parser.ts
+function useCommandParser(client) {
+  const execute = useCallback4(
+    async (input) => {
+      const trimmed = input.trim();
+      if (!trimmed) return;
+      await executeCommand(trimmed, client);
+    },
+    [client]
+  );
+  const autocomplete = useCallback4(
+    (partial) => {
+      return getCompletions(partial);
+    },
+    []
+  );
+  return { execute, autocomplete };
+}
+
+// src/tui/app.tsx
+import { jsx as jsx13 } from "react/jsx-runtime";
+function App({ serverUrl }) {
+  const client = useMemo(() => new AstroClient({ serverUrl }), [serverUrl]);
+  const { refreshAll: refreshAll2 } = usePolling(client);
+  useSSEStream(client);
+  useFuzzySearch();
+  const { execute } = useCommandParser(client);
+  const onSelect = useCallback5(() => {
+    const { focusedPanel, scrollIndex } = useTuiStore.getState();
+    switch (focusedPanel) {
+      case "projects": {
+        const projects = useProjectsStore.getState().projects;
+        const idx = scrollIndex.projects;
+        if (projects[idx]) {
+          useTuiStore.getState().setSelectedProject(projects[idx].id);
+        }
+        break;
+      }
+      case "plan": {
+        const treeLines = usePlanStore.getState().treeLines;
+        const idx = scrollIndex.plan;
+        const line = treeLines[idx];
+        if (line) {
+          useTuiStore.getState().setSelectedNode(line.id);
+          usePlanStore.getState().toggleCollapse(line.id);
+        }
+        break;
+      }
+      case "machines": {
+        break;
+      }
+    }
+  }, []);
+  const onCommand = useCallback5(
+    (cmd) => {
+      execute(cmd);
+    },
+    [execute]
+  );
+  const onSearch = useCallback5(
+    (query) => {
+      useSearchStore.getState().setQuery(query);
+      if (query.length > 0) {
+        useSearchStore.getState().open();
+      }
+    },
+    []
+  );
+  const onDispatch = useCallback5(async () => {
+    const nodeId = useTuiStore.getState().selectedNodeId;
+    const projectId = useTuiStore.getState().selectedProjectId;
+    if (nodeId && projectId) {
+      await execute(`dispatch ${nodeId}`);
+    }
+  }, [execute]);
+  const onCancel = useCallback5(async () => {
+    await execute("cancel");
+  }, [execute]);
+  const onRefresh = useCallback5(() => {
+    refreshAll2();
+  }, [refreshAll2]);
+  useVimMode({
+    onSelect,
+    onCommand,
+    onSearch,
+    onDispatch,
+    onCancel,
+    onRefresh
+  });
+  return /* @__PURE__ */ jsx13(MainLayout, {});
+}
+
+// src/tui/index.tsx
+import { jsx as jsx14 } from "react/jsx-runtime";
+async function launchTui(serverUrl) {
+  render(/* @__PURE__ */ jsx14(App, { serverUrl }), {
+    exitOnCtrlC: true
+  });
+}
+export {
+  launchTui
+};