@glrs-dev/cli 2.3.0 → 2.4.1

package/dist/chunk-2VMFXAJH.js

@@ -0,0 +1,795 @@
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
+
+// src/commands/autopilot-tui.ts
+import React3 from "react";
+import { render } from "ink";
+
+// src/tui/components/AutopilotPicker.tsx
+import { useState, useMemo } from "react";
+import { Box, Text, useInput } from "ink";
+import * as fs from "fs";
+import * as path from "path";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function shortenHome(p) {
+  const home = process.env.HOME ?? "";
+  if (home && p.startsWith(home)) return "~" + p.slice(home.length);
+  return p;
+}
+function isPlanDir(dirPath) {
+  if (fs.existsSync(path.join(dirPath, "main.md"))) return "md";
+  if (fs.existsSync(path.join(dirPath, "spec", "main.yaml"))) return "yaml";
+  return false;
+}
+function readDir(dir) {
+  try {
+    const raw = fs.readdirSync(dir, { withFileTypes: true });
+    const dirs = [];
+    const files = [];
+    for (const entry of raw) {
+      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git" || entry.name === "target") continue;
+      if (entry.name.startsWith(".") && entry.name !== ".glrs" && entry.name !== ".opencode" && entry.name !== ".agent" && entry.name !== ".claude") continue;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const planType = isPlanDir(fullPath);
+        dirs.push({
+          name: planType ? `${entry.name}/` : `${entry.name}/`,
+          isDir: true,
+          path: fullPath,
+          isPlan: !!planType
+        });
+      } else if (entry.name.endsWith(".md") || entry.name.endsWith(".yaml") || entry.name.endsWith(".yml")) {
+        files.push({ name: entry.name, isDir: false, path: fullPath });
+      }
+    }
+    dirs.sort((a, b) => {
+      if (a.isPlan && !b.isPlan) return -1;
+      if (!a.isPlan && b.isPlan) return 1;
+      return a.name.localeCompare(b.name);
+    });
+    files.sort((a, b) => a.name.localeCompare(b.name));
+    return [...dirs, ...files];
+  } catch {
+    return [];
+  }
+}
+var VIEWPORT = 15;
+function AutopilotPicker({ startDir, onSelect, onCancel }) {
+  const [cwd, setCwd] = useState(startDir);
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const entries = useMemo(() => readDir(cwd), [cwd]);
+  useInput((_input, key) => {
+    if (key.escape) {
+      if (cwd === startDir) {
+        onCancel();
+      } else {
+        setCwd(path.dirname(cwd));
+        setSelectedIndex(0);
+      }
+      return;
+    }
+    if (key.return && entries[selectedIndex]) {
+      const entry = entries[selectedIndex];
+      if (entry.isPlan) {
+        onSelect(entry.path);
+      } else if (entry.isDir) {
+        setCwd(entry.path);
+        setSelectedIndex(0);
+      } else {
+        onSelect(entry.path);
+      }
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((i) => Math.max(0, i - 1));
+    }
+    if (key.downArrow) {
+      setSelectedIndex((i) => Math.min(entries.length - 1, i + 1));
+    }
+  });
+  const halfWindow = Math.floor(VIEWPORT / 2);
+  let windowStart = Math.max(0, selectedIndex - halfWindow);
+  const windowEnd = Math.min(entries.length, windowStart + VIEWPORT);
+  if (windowEnd - windowStart < VIEWPORT) {
+    windowStart = Math.max(0, windowEnd - VIEWPORT);
+  }
+  const visible = entries.slice(windowStart, windowEnd);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Select a plan" }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        " \u2014 ",
+        shortenHome(cwd)
+      ] })
+    ] }),
+    entries.length === 0 ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Empty directory." }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      windowStart > 0 && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "  \u2191 ",
+        windowStart,
+        " more"
+      ] }),
+      visible.map((entry, i) => {
+        const globalIndex = windowStart + i;
+        const isSelected = globalIndex === selectedIndex;
+        return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: isSelected ? "blue" : void 0, children: [
+          isSelected ? "\u25B6 " : "  ",
+          entry.isPlan ? /* @__PURE__ */ jsx(Text, { bold: true, color: "green", children: entry.name }) : entry.isDir ? /* @__PURE__ */ jsx(Text, { color: "cyan", children: entry.name }) : /* @__PURE__ */ jsx(Text, { children: entry.name }),
+          entry.isPlan && /* @__PURE__ */ jsx(Text, { color: "green", children: " \u2190 plan" })
+        ] }) }, `${entry.path}-${globalIndex}`);
+      }),
+      windowEnd < entries.length && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "  \u2193 ",
+        entries.length - windowEnd,
+        " more"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "\u2191\u2193 navigate \xB7 Enter ",
+      entries[selectedIndex]?.isPlan ? "select plan" : entries[selectedIndex]?.isDir ? "open" : "select",
+      " \xB7 Esc ",
+      cwd === startDir ? "quit" : "back"
+    ] }) })
+  ] });
+}
+
+// src/tui/components/AutopilotExecution.tsx
+import { useState as useState2, useEffect } from "react";
+import { Box as Box2, Text as Text2, useStdout, useInput as useInput2 } from "ink";
+import { Spinner } from "@inkjs/ui";
+import * as path2 from "path";
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var MAX_LOG_ENTRIES = 5e3;
+function initialState() {
+  return {
+    planPath: "",
+    executionMode: "unknown",
+    startedAt: Date.now(),
+    totalCost: 0,
+    _lastReportedCost: 0,
+    tokensIn: 0,
+    tokensOut: 0,
+    _lastMsgTokensIn: 0,
+    _lastMsgTokensOut: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    phases: [],
+    currentPhaseIndex: -1,
+    currentIteration: 0,
+    maxIterations: 0,
+    totalTurns: 0,
+    retryCount: 0,
+    enriching: false,
+    enrichedFiles: 0,
+    totalEnrichFiles: 0,
+    enrichDone: false,
+    logEntries: [],
+    done: false
+  };
+}
+function formatCost(usd) {
+  if (usd === 0) return "$0.00";
+  return `$${usd.toFixed(2)}`;
+}
+function formatElapsed(ms) {
+  const totalSec = Math.floor(ms / 1e3);
+  const m = Math.floor(totalSec / 60);
+  const s = totalSec % 60;
+  if (m === 0) return `${s}s`;
+  return `${m}m ${s.toString().padStart(2, "0")}s`;
+}
+function formatTokens(n) {
+  if (n === 0) return "\u2014";
+  if (n >= 1e3) return `${Math.round(n / 1e3)}K`;
+  return String(n);
+}
+function formatDuration(ms) {
+  const s = Math.round(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  return `${Math.floor(s / 60)}m${(s % 60).toString().padStart(2, "0")}s`;
+}
+function planName(planPath) {
+  if (!planPath) return "";
+  return path2.basename(planPath);
+}
+function truncateArg(s, max = 40) {
+  if (!s) return "";
+  if (s.length <= max) return s;
+  return `\u2026${s.slice(-(max - 1))}`;
+}
+function nowHHMMSS() {
+  const d = /* @__PURE__ */ new Date();
+  const hh = d.getHours().toString().padStart(2, "0");
+  const mm = d.getMinutes().toString().padStart(2, "0");
+  const ss = d.getSeconds().toString().padStart(2, "0");
+  return `${hh}:${mm}:${ss}`;
+}
+function appendLog(entries, text, color) {
+  const entry = { time: nowHHMMSS(), text, color };
+  return [...entries, entry].slice(-MAX_LOG_ENTRIES);
+}
+function AutopilotExecution({ emitter }) {
+  const [state, setState] = useState2(initialState);
+  const [elapsedMs, setElapsedMs] = useState2(0);
+  const { stdout } = useStdout();
+  const [, setResizeTick] = useState2(0);
+  useEffect(() => {
+    const onResize = () => setResizeTick((n) => n + 1);
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  useEffect(() => {
+    const handler = (event) => {
+      setState((prev) => applyEvent(prev, event));
+    };
+    emitter.on("event", handler);
+    return () => {
+      emitter.off("event", handler);
+    };
+  }, [emitter]);
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setState((prev) => {
+        setElapsedMs(Date.now() - prev.startedAt);
+        return prev;
+      });
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, []);
+  const [scrollOffset, setScrollOffset] = useState2(null);
+  useInput2((input, key) => {
+    if (input === "c" && key.ctrl) {
+      process.kill(process.pid, "SIGINT");
+      return;
+    }
+    const totalEntries = state.logEntries.length;
+    const termH = stdout.rows ?? 24;
+    const viewHeight = Math.max(4, termH - 8);
+    if (key.upArrow || input === "k") {
+      setScrollOffset((prev) => {
+        const current = prev ?? Math.max(0, totalEntries - viewHeight);
+        return Math.max(0, current - 1);
+      });
+    } else if (key.downArrow || input === "j") {
+      setScrollOffset((prev) => {
+        const current = prev ?? Math.max(0, totalEntries - viewHeight);
+        const maxOffset = Math.max(0, totalEntries - viewHeight);
+        const next = Math.min(maxOffset, current + 1);
+        return next >= maxOffset ? null : next;
+      });
+    } else if (input === "G") {
+      setScrollOffset(null);
+    } else if (input === "g") {
+      setScrollOffset(0);
+    } else if (input === "c") {
+      const text = state.logEntries.map((e) => `${e.time} ${e.text}`).join("\n");
+      const proc = __require("child_process").spawn(
+        process.platform === "darwin" ? "pbcopy" : "xclip",
+        process.platform === "darwin" ? [] : ["-selection", "clipboard"],
+        { stdio: ["pipe", "ignore", "ignore"] }
+      );
+      proc.stdin.write(text);
+      proc.stdin.end();
+    }
+  });
+  const termWidth = stdout.columns ?? 80;
+  const {
+    planPath,
+    totalCost,
+    tokensIn,
+    tokensOut,
+    executionMode,
+    phases,
+    currentPhaseIndex,
+    currentIteration,
+    maxIterations,
+    totalTurns,
+    retryCount,
+    enriching,
+    enrichedFiles,
+    totalEnrichFiles,
+    enrichDone,
+    logEntries,
+    lastError,
+    done,
+    exitReason
+  } = state;
+  const elapsed = formatElapsed(elapsedMs);
+  const costStr = formatCost(totalCost);
+  const tokInStr = formatTokens(tokensIn);
+  const tokOutStr = formatTokens(tokensOut);
+  const name = planName(planPath);
+  const termHeight = stdout.rows ?? 24;
+  const logHeight = Math.max(4, termHeight - 8);
+  const visibleLogs = scrollOffset === null ? logEntries.slice(-logHeight) : logEntries.slice(scrollOffset, scrollOffset + logHeight);
+  const isPinned = scrollOffset === null;
+  const scrollIndicator = !isPinned ? ` \u2191${scrollOffset}/${logEntries.length}` : "";
+  const phaseBar = phases.map((p, i) => {
+    const icon = p.status === "complete" ? "\u2713" : p.status === "failed" ? "\u2717" : p.status === "running" ? "\u25CF" : p.status === "skipped" ? "\u2014" : "\u25CB";
+    const color = p.status === "complete" ? "green" : p.status === "failed" ? "red" : p.status === "running" ? "yellow" : void 0;
+    return /* @__PURE__ */ jsx2(Text2, { color, dimColor: !color, children: icon }, `phase-${i}`);
+  });
+  const currentPhaseName = currentPhaseIndex >= 0 && phases[currentPhaseIndex] ? phases[currentPhaseIndex].name : "";
+  const statusIcon = done ? exitReason === "sentinel" ? /* @__PURE__ */ jsx2(Text2, { color: "green", bold: true, children: "\u2713" }) : /* @__PURE__ */ jsx2(Text2, { color: "red", bold: true, children: "\u2717" }) : enriching ? /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "\u25D0" }) : /* @__PURE__ */ jsx2(Text2, { color: "cyan", bold: true, children: "\u25B6" });
+  const enrichStr = enriching ? `enrich ${enrichedFiles}/${totalEnrichFiles}` : enrichDone ? `enrich \u2713` : "";
+  const innerWidth = Math.max(20, termWidth - 4);
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", width: termWidth, children: [
+    /* @__PURE__ */ jsxs2(
+      Box2,
+      {
+        borderStyle: "single",
+        borderTop: true,
+        borderLeft: true,
+        borderRight: true,
+        borderBottom: false,
+        borderColor: "gray",
+        paddingX: 1,
+        children: [
+          /* @__PURE__ */ jsxs2(Box2, { flexGrow: 1, children: [
+            statusIcon,
+            /* @__PURE__ */ jsxs2(Text2, { bold: true, children: [
+              " ",
+              name || "autopilot"
+            ] }),
+            executionMode !== "unknown" && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+              " ",
+              executionMode === "fast" ? "fast" : "deep"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx2(Text2, { children: elapsed })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs2(
+      Box2,
+      {
+        borderStyle: "single",
+        borderTop: false,
+        borderLeft: true,
+        borderRight: true,
+        borderBottom: true,
+        borderColor: "gray",
+        paddingX: 1,
+        gap: 2,
+        children: [
+          phases.length > 0 && /* @__PURE__ */ jsxs2(Box2, { gap: 0, children: [
+            phaseBar,
+            currentPhaseName && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+              " ",
+              currentPhaseName
+            ] })
+          ] }),
+          phases.length === 0 && !enriching && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "starting\u2026" }),
+          enrichStr && /* @__PURE__ */ jsx2(Text2, { color: enriching ? "yellow" : "green", children: enrichStr }),
+          /* @__PURE__ */ jsx2(Box2, { flexGrow: 1 }),
+          /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: costStr }),
+          /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+            tokInStr,
+            "\u2191 ",
+            tokOutStr,
+            "\u2193"
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs2(
+      Box2,
+      {
+        flexDirection: "column",
+        borderStyle: "single",
+        borderTop: false,
+        borderLeft: true,
+        borderRight: true,
+        borderBottom: false,
+        borderColor: "gray",
+        paddingX: 1,
+        height: logHeight + 2,
+        children: [
+          visibleLogs.length === 0 && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "waiting for events\u2026" }),
+          visibleLogs.map((entry, i) => /* @__PURE__ */ jsx2(LogRow, { entry, maxWidth: innerWidth }, `${entry.time}-${i}`))
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs2(
+      Box2,
+      {
+        borderStyle: "single",
+        borderColor: "gray",
+        paddingX: 1,
+        justifyContent: "space-between",
+        children: [
+          /* @__PURE__ */ jsxs2(Box2, { gap: 2, children: [
+            lastError && /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+              "\u2717 ",
+              lastError.length > innerWidth - 20 ? lastError.slice(0, innerWidth - 23) + "\u2026" : lastError
+            ] }),
+            done && !lastError && (exitReason === "sentinel" ? /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+              "\u2713 complete \xB7 ",
+              costStr,
+              " \xB7 ",
+              totalTurns,
+              " tool calls"
+            ] }) : /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
+              "\u2717 ",
+              exitReason ?? "stopped"
+            ] })),
+            !done && !lastError && /* @__PURE__ */ jsxs2(Fragment2, { children: [
+              currentPhaseName && /* @__PURE__ */ jsx2(Text2, { bold: true, children: currentPhaseName }),
+              maxIterations > 0 && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+                "iter ",
+                currentIteration,
+                "/",
+                maxIterations
+              ] }),
+              totalTurns > 0 && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+                "turns ",
+                totalTurns
+              ] }),
+              retryCount > 0 && /* @__PURE__ */ jsxs2(Text2, { color: "yellow", children: [
+                "retries ",
+                retryCount
+              ] }),
+              enriching && /* @__PURE__ */ jsx2(Spinner, {})
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+            scrollIndicator ? scrollIndicator + "  " : "",
+            "c:copy \u2191\u2193:scroll  Ctrl+C"
+          ] })
+        ]
+      }
+    )
+  ] });
+}
+function LogRow({ entry, maxWidth }) {
+  const textMax = Math.max(10, maxWidth - 9);
+  const text = entry.text.length > textMax ? entry.text.slice(0, textMax - 1) + "\u2026" : entry.text;
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      entry.time,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx2(Text2, { color: entry.color, children: text })
+  ] });
+}
+function applyEvent(prev, event) {
+  switch (event.type) {
+    case "session:start":
+      return {
+        ...prev,
+        planPath: event.planPath,
+        startedAt: Date.now(),
+        executionMode: event.fast ? "fast" : "deep",
+        logEntries: appendLog(prev.logEntries, `session started (enrich: ${event.enrichModel ?? "prime"} \xB7 execute: ${event.executeModel ?? "build"})`)
+      };
+    case "enrich:start":
+      return {
+        ...prev,
+        enriching: true,
+        totalEnrichFiles: event.fileCount,
+        enrichedFiles: 0,
+        logEntries: appendLog(
+          prev.logEntries,
+          `enrichment started (${event.fileCount} files)`,
+          "yellow"
+        )
+      };
+    case "enrich:file:start":
+      return {
+        ...prev,
+        logEntries: appendLog(prev.logEntries, `enriching ${event.file}\u2026`)
+      };
+    case "enrich:file:done": {
+      const specRef = event.specFile ? ` \u2192 ${event.specFile}` : "";
+      return {
+        ...prev,
+        enrichedFiles: prev.enrichedFiles + 1,
+        logEntries: appendLog(
+          prev.logEntries,
+          `\u2713 ${event.file}${specRef}`,
+          "green"
+        )
+      };
+    }
+    case "enrich:file:skip":
+      return {
+        ...prev,
+        // Count skipped files toward the enrichment progress so the
+        // counter reflects total files processed, not just enriched.
+        enrichedFiles: prev.enrichedFiles + 1,
+        logEntries: appendLog(
+          prev.logEntries,
+          `${event.file} skipped: ${event.reason}`,
+          "yellow"
+        )
+      };
+    case "enrich:file:error":
+      return {
+        ...prev,
+        enrichedFiles: prev.enrichedFiles + 1,
+        logEntries: appendLog(
+          prev.logEntries,
+          `\u2717 ${event.file}: ${event.error}`,
+          "red"
+        )
+      };
+    case "enrich:done":
+      return {
+        ...prev,
+        enriching: false,
+        enrichDone: true,
+        logEntries: appendLog(prev.logEntries, "enrichment complete", "green")
+      };
+    case "phase:start": {
+      if (event.current === 0) {
+        const phases2 = Array.from({ length: event.total }, () => ({
+          name: "",
+          status: "pending",
+          iterations: 0,
+          cost: 0
+        }));
+        return {
+          ...prev,
+          phases: phases2,
+          logEntries: appendLog(
+            prev.logEntries,
+            `plan loaded: ${event.total} phases`
+          )
+        };
+      }
+      const phaseIdx = event.current - 1;
+      let phases = prev.phases.map((p, i) => {
+        if (i === phaseIdx) {
+          return { ...p, name: event.phase, status: "running" };
+        }
+        return p;
+      });
+      if (phaseIdx >= phases.length) {
+        const grown = [...prev.phases];
+        while (grown.length <= phaseIdx) {
+          grown.push({ name: "", status: "pending", iterations: 0, cost: 0 });
+        }
+        grown[phaseIdx] = { name: event.phase, status: "running", iterations: 0, cost: 0 };
+        phases = grown;
+      }
+      return {
+        ...prev,
+        phases,
+        currentPhaseIndex: phaseIdx,
+        logEntries: appendLog(
+          prev.logEntries,
+          `phase:start ${event.phase} ${event.current}/${event.total}`
+        )
+      };
+    }
+    case "phase:done": {
+      const phases = prev.phases.map((p) => {
+        if (p.name === event.phase) {
+          return {
+            ...p,
+            status: event.completed ? "complete" : "failed",
+            iterations: event.iterations,
+            cost: event.costUsd
+          };
+        }
+        return p;
+      });
+      const statusIcon = event.completed ? "\u2713" : "\u2717";
+      return {
+        ...prev,
+        phases,
+        logEntries: appendLog(
+          prev.logEntries,
+          `phase:done ${event.phase} ${statusIcon} (${event.iterations} iter, ${formatCost(event.costUsd)})`,
+          event.completed ? "green" : "red"
+        )
+      };
+    }
+    case "iteration:start":
+      return {
+        ...prev,
+        currentIteration: event.iteration,
+        maxIterations: event.maxIterations,
+        logEntries: appendLog(
+          prev.logEntries,
+          `iter ${event.iteration}/${event.maxIterations} start`
+        )
+      };
+    case "iteration:done": {
+      const dur = formatDuration(event.durationMs);
+      const costPart = event.costUsd != null ? ` ${formatCost(event.costUsd)}` : "";
+      const filesPart = event.filesChanged != null ? ` ${event.filesChanged} files` : "";
+      return {
+        ...prev,
+        logEntries: appendLog(
+          prev.logEntries,
+          `iter ${event.iteration} done ${dur}${costPart}${filesPart}`
+        )
+      };
+    }
+    case "tool:call": {
+      const argStr = event.firstArg ? ` ${truncateArg(event.firstArg)}` : "";
+      return {
+        ...prev,
+        totalTurns: prev.totalTurns + 1,
+        logEntries: appendLog(
+          prev.logEntries,
+          `\u2699 ${event.toolName}${argStr}`
+        )
+      };
+    }
+    case "thinking": {
+      const label = event.elapsedSec < 60 ? `\u{1F4AD} thinking\u2026 ${event.elapsedSec}s \xB7 ${event.chars} chars` : `\u{1F4AD} thinking\u2026 ${Math.floor(event.elapsedSec / 60)}m${(event.elapsedSec % 60).toString().padStart(2, "0")}s \xB7 ${event.chars} chars`;
+      const entries = [...prev.logEntries];
+      const lastIdx = entries.length - 1;
+      if (lastIdx >= 0 && entries[lastIdx].text.startsWith("\u{1F4AD} thinking")) {
+        entries[lastIdx] = { ...entries[lastIdx], text: label };
+      } else {
+        const now = nowHHMMSS();
+        entries.push({ time: now, text: label });
+        if (entries.length > MAX_LOG_ENTRIES) entries.shift();
+      }
+      return { ...prev, logEntries: entries };
+    }
+    case "cost:update": {
+      const reportedCost = event.cumulativeCostUsd;
+      let newCost = prev.totalCost;
+      if (reportedCost < prev._lastReportedCost) {
+        newCost = prev.totalCost + reportedCost;
+      } else {
+        newCost = prev.totalCost - prev._lastReportedCost + reportedCost;
+      }
+      let newIn = prev.tokensIn;
+      let newOut = prev.tokensOut;
+      if (event.tokensIn != null) {
+        if (event.tokensIn < prev._lastMsgTokensIn) {
+          newIn = prev.tokensIn + event.tokensIn;
+        } else {
+          newIn = prev.tokensIn - prev._lastMsgTokensIn + event.tokensIn;
+        }
+      }
+      if (event.tokensOut != null) {
+        if (event.tokensOut < prev._lastMsgTokensOut) {
+          newOut = prev.tokensOut + event.tokensOut;
+        } else {
+          newOut = prev.tokensOut - prev._lastMsgTokensOut + event.tokensOut;
+        }
+      }
+      return {
+        ...prev,
+        totalCost: newCost,
+        _lastReportedCost: reportedCost,
+        tokensIn: newIn,
+        tokensOut: newOut,
+        _lastMsgTokensIn: event.tokensIn ?? prev._lastMsgTokensIn,
+        _lastMsgTokensOut: event.tokensOut ?? prev._lastMsgTokensOut
+      };
+    }
+    case "error":
+      return {
+        ...prev,
+        lastError: event.message,
+        logEntries: appendLog(prev.logEntries, `\u2717 ${event.message}`, "red")
+      };
+    case "credential:expired":
+      return {
+        ...prev,
+        lastError: `Credentials expired (${event.provider}). Run gs-assume to refresh.`,
+        logEntries: appendLog(
+          prev.logEntries,
+          `\u2717 credentials expired (${event.provider})`,
+          "red"
+        )
+      };
+    case "verify:start":
+      return {
+        ...prev,
+        logEntries: appendLog(
+          prev.logEntries,
+          `verify:start ${event.itemCount} commands`
+        )
+      };
+    case "verify:result":
+      return {
+        ...prev,
+        logEntries: appendLog(
+          prev.logEntries,
+          `verify ${event.passed ? "\u2713" : "\u2717"} ${event.command}`,
+          event.passed ? "green" : "red"
+        )
+      };
+    case "verify:done":
+      return {
+        ...prev,
+        logEntries: appendLog(
+          prev.logEntries,
+          `verify done: ${event.passed}/${event.passed + event.failed}`,
+          event.failed === 0 ? "green" : "red"
+        )
+      };
+    case "session:done":
+      return {
+        ...prev,
+        done: true,
+        exitReason: event.exitReason,
+        totalCost: event.cumulativeCostUsd ?? prev.totalCost,
+        logEntries: appendLog(
+          prev.logEntries,
+          `session done: ${event.exitReason}`,
+          event.exitReason === "sentinel" ? "green" : "yellow"
+        )
+      };
+    default:
+      return prev;
+  }
+}
+
+// src/commands/autopilot-tui.ts
+import { SessionRunner } from "@glrs-dev/autopilot";
+import { OpenCodeAdapter } from "@glrs-dev/adapter-opencode";
+async function runAutopilot() {
+  const cwd = process.cwd();
+  if (!process.stderr.isTTY) {
+    process.stderr.write("glrs autopilot requires a TTY.\n");
+    process.exit(1);
+  }
+  const planPath = await pickPlan(cwd);
+  if (!planPath) {
+    return;
+  }
+  const adapter = new OpenCodeAdapter();
+  const runner = new SessionRunner({
+    planPath,
+    cwd,
+    fast: true,
+    adapter
+  });
+  const app = render(
+    React3.createElement(AutopilotExecution, { emitter: runner.events }),
+    { stdout: process.stderr, exitOnCtrlC: false }
+  );
+  const sigintHandler = () => {
+    runner.abort();
+  };
+  process.on("SIGINT", sigintHandler);
+  await new Promise((resolve) => setTimeout(resolve, 50));
+  try {
+    await runner.run();
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`
+\x1B[31m\u2717 Fatal error: ${message}\x1B[0m
+`);
+  } finally {
+    process.removeListener("SIGINT", sigintHandler);
+    app.unmount();
+    app.clear();
+  }
+}
+function pickPlan(startDir) {
+  return new Promise((resolve) => {
+    const app = render(
+      React3.createElement(AutopilotPicker, {
+        startDir,
+        onSelect: (planPath) => {
+          app.unmount();
+          app.clear();
+          resolve(planPath);
+        },
+        onCancel: () => {
+          app.unmount();
+          app.clear();
+          resolve(null);
+        }
+      }),
+      { stdout: process.stderr, exitOnCtrlC: true }
+    );
+  });
+}
+
+export {
+  runAutopilot
+};