@glrs-dev/cli 2.2.0 → 2.4.0

package/dist/commands/dashboard.js

@@ -0,0 +1,1549 @@
+import {
+  createWorktree
+} from "../chunk-PTIO556V.js";
+import "../chunk-6Y27RQQL.js";
+import "../chunk-LMRDQ4GW.js";
+import "../chunk-YY7EWHMA.js";
+import "../chunk-YBCA3IP6.js";
+import "../chunk-3RG5ZIWI.js";
+
+// src/session-manager.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { spawn } from "child_process";
+import { EventStreamReader as EventStreamReader2 } from "@glrs-dev/autopilot";
+import { deriveState as deriveState2 } from "@glrs-dev/autopilot";
+
+// src/session-discovery.ts
+import * as fs from "fs";
+import * as path from "path";
+import { EventStreamReader } from "@glrs-dev/autopilot";
+import { deriveState } from "@glrs-dev/autopilot";
+var EVENT_FILE_NAME = "autopilot-events.jsonl";
+var STALE_THRESHOLD_MS = 5 * 60 * 1e3;
+function discoverSessions(dirs) {
+  const results = [];
+  const now = Date.now();
+  for (const dir of dirs) {
+    const eventFilePath = path.join(dir, ".agent", EVENT_FILE_NAME);
+    if (!fs.existsSync(eventFilePath)) {
+      continue;
+    }
+    let handle;
+    try {
+      const reader = new EventStreamReader(eventFilePath);
+      const events = reader.readAll();
+      handle = deriveState(events);
+    } catch {
+      continue;
+    }
+    if (!handle) {
+      continue;
+    }
+    const lastEventMs = new Date(handle.lastEventAt).getTime();
+    const isStale = handle.status !== "complete" && now - lastEventMs > STALE_THRESHOLD_MS;
+    const finalHandle = isStale ? { ...handle, status: "stale" } : handle;
+    results.push({ eventFilePath, handle: finalHandle, isStale });
+  }
+  results.sort(
+    (a, b) => new Date(b.handle.lastEventAt).getTime() - new Date(a.handle.lastEventAt).getTime()
+  );
+  return results;
+}
+
+// src/session-manager.ts
+var ACTIVE_POLL_MS = 1e3;
+var IDLE_POLL_MS = 5e3;
+var KILL_ESCALATION_MS = 5e3;
+function resolveCliArgs() {
+  const script = process.argv[1];
+  if (script) {
+    return { bin: process.execPath, preArgs: [script] };
+  }
+  return { bin: "glrs", preArgs: [] };
+}
+var SessionManager = class {
+  constructor(dirs) {
+    this.dirs = dirs;
+  }
+  dirs;
+  sessions = /* @__PURE__ */ new Map();
+  pollInterval = null;
+  lastPollMs = 0;
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  /** Begin polling discovered sessions. */
+  start() {
+    if (this.pollInterval !== null) return;
+    this._discover();
+    this.pollInterval = setInterval(() => {
+      this._poll();
+    }, ACTIVE_POLL_MS);
+  }
+  /** Stop polling. */
+  stop() {
+    if (this.pollInterval !== null) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = null;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  /** Returns a snapshot of all tracked session handles. */
+  getSessions() {
+    return Array.from(this.sessions.values()).map((t) => t.handle);
+  }
+  // ---------------------------------------------------------------------------
+  // Session operations
+  // ---------------------------------------------------------------------------
+  /**
+   * Launch a new autopilot session as a detached subprocess.
+   *
+   * Uses the same CLI binary that's currently running (so glrs-dev spawns
+   * glrs-dev, not the globally installed glrs).
+   *
+   * Returns a provisional SessionHandle (status: "running") immediately.
+   * The handle will be updated on the next poll once the event file appears.
+   */
+  launchSession(opts) {
+    const { planPath, cwd, fast = false } = opts;
+    const { bin, preArgs } = resolveCliArgs();
+    const args = [...preArgs, "oc", "autopilot", "--plan", planPath];
+    if (fast) args.push("--fast");
+    const child = spawn(bin, args, {
+      cwd,
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    const pid = child.pid;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const provisionalHandle = {
+      id: `provisional-${pid ?? Date.now()}`,
+      planPath,
+      cwd,
+      fast,
+      resume: false,
+      status: "running",
+      totalIterations: 0,
+      cost: 0,
+      startedAt: now,
+      lastEventAt: now
+    };
+    const eventFilePath = path2.join(cwd, ".agent", "autopilot-events.jsonl");
+    const reader = new EventStreamReader2(eventFilePath);
+    this.sessions.set(provisionalHandle.id, {
+      handle: provisionalHandle,
+      reader,
+      offset: 0,
+      pid,
+      eventFilePath
+    });
+    return provisionalHandle;
+  }
+  /**
+   * Create a fresh worktree and launch an autopilot session in it.
+   *
+   * Uses `createWorktree({ repo })` which resolves the repo via the
+   * worktree registry, repo index, and filesystem scan — the same
+   * resolution as `glrs wt new <repo>`.
+   *
+   * The plan path is resolved into the new worktree if it's inside the repo,
+   * or passed as an absolute path if it's external (e.g. ~/.glrs/).
+   */
+  launchSessionWithWorktree(opts) {
+    const { repoName: repoName3, planPath, fast = false } = opts;
+    const { wtPath } = createWorktree({ repo: repoName3 });
+    let resolvedPlanPath = planPath;
+    const repoRoot = this._findRepoRoot(wtPath);
+    if (repoRoot && planPath.startsWith(repoRoot)) {
+      const relativePlan = path2.relative(repoRoot, planPath);
+      resolvedPlanPath = path2.join(wtPath, relativePlan);
+    }
+    return this.launchSession({
+      planPath: resolvedPlanPath,
+      cwd: wtPath,
+      fast
+    });
+  }
+  /**
+   * Find the primary clone root from a worktree path by reading .git file.
+   */
+  _findRepoRoot(wtPath) {
+    try {
+      const gitFile = path2.join(wtPath, ".git");
+      const content = fs2.readFileSync(gitFile, "utf8").trim();
+      const match = content.match(/^gitdir:\s*(.+)$/);
+      if (match) {
+        const gitWorktreeDir = match[1];
+        const dotGitDir = path2.resolve(path2.dirname(path2.dirname(gitWorktreeDir)));
+        return path2.dirname(dotGitDir);
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * Send SIGINT to the session's process (graceful kill).
+   * If called a second time within KILL_ESCALATION_MS, escalates to SIGKILL.
+   * No-op if the session was not launched by this manager or PID is unknown.
+   */
+  killSession(id) {
+    const tracked = this.sessions.get(id);
+    if (!tracked?.pid) return;
+    const now = Date.now();
+    const isEscalation = tracked.lastSigintAt !== void 0 && now - tracked.lastSigintAt < KILL_ESCALATION_MS;
+    const signal = isEscalation ? "SIGKILL" : "SIGINT";
+    try {
+      process.kill(tracked.pid, signal);
+    } catch {
+    }
+    tracked.lastSigintAt = now;
+  }
+  /**
+   * Unconditionally send SIGKILL to the session's process.
+   * No-op if the session was not launched by this manager or PID is unknown.
+   */
+  forceKillSession(id) {
+    const tracked = this.sessions.get(id);
+    if (!tracked?.pid) return;
+    try {
+      process.kill(tracked.pid, "SIGKILL");
+    } catch {
+    }
+  }
+  /**
+   * Re-launch the session with --resume.
+   * Finds the session's planPath and cwd, then spawns a new process.
+   */
+  retrySession(id) {
+    const tracked = this.sessions.get(id);
+    if (!tracked) return;
+    const { planPath, cwd, fast } = tracked.handle;
+    const { bin, preArgs } = resolveCliArgs();
+    const args = [...preArgs, "oc", "autopilot", "--plan", planPath, "--resume"];
+    if (fast) args.push("--fast");
+    const child = spawn(bin, args, {
+      cwd,
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    if (child.pid !== void 0) {
+      tracked.pid = child.pid;
+    }
+    tracked.offset = 0;
+  }
+  /**
+   * Delete the event file, checkpoint file, and debug log for a session.
+   * Removes the session from the tracked map.
+   */
+  cleanupSession(id) {
+    const tracked = this.sessions.get(id);
+    if (!tracked) return;
+    const agentDir = path2.dirname(tracked.eventFilePath);
+    const filesToDelete = [
+      path2.join(agentDir, "autopilot-events.jsonl"),
+      path2.join(agentDir, "autopilot-checkpoint.json"),
+      path2.join(agentDir, "autopilot-debug.log"),
+      path2.join(agentDir, "autopilot-status.json")
+    ];
+    for (const f of filesToDelete) {
+      try {
+        fs2.unlinkSync(f);
+      } catch {
+      }
+    }
+    this.sessions.delete(id);
+  }
+  // ---------------------------------------------------------------------------
+  // Internal polling
+  // ---------------------------------------------------------------------------
+  /** Discover new sessions from configured dirs. */
+  _discover() {
+    const discovered = discoverSessions(this.dirs);
+    for (const { eventFilePath, handle } of discovered) {
+      const alreadyTracked = Array.from(this.sessions.values()).some(
+        (t) => t.eventFilePath === eventFilePath
+      );
+      if (alreadyTracked) continue;
+      const reader = new EventStreamReader2(eventFilePath);
+      const { newOffset } = reader.readFrom(0);
+      this.sessions.set(handle.id, {
+        handle,
+        reader,
+        offset: newOffset,
+        eventFilePath
+      });
+    }
+  }
+  /** Poll all tracked sessions for new events. */
+  _poll() {
+    const now = Date.now();
+    if (now - this.lastPollMs >= IDLE_POLL_MS) {
+      this._discover();
+      this.lastPollMs = now;
+    }
+    for (const [id, tracked] of this.sessions) {
+      const isIdle = tracked.handle.status === "complete" || tracked.handle.status === "stale";
+      if (isIdle && now - this.lastPollMs < IDLE_POLL_MS) {
+        continue;
+      }
+      const { events, newOffset } = tracked.reader.readFrom(tracked.offset);
+      if (events.length === 0) continue;
+      tracked.offset = newOffset;
+      const allEvents = tracked.reader.readAll();
+      const newHandle = deriveState2(allEvents);
+      if (newHandle) {
+        this.sessions.set(id, { ...tracked, handle: newHandle, offset: newOffset });
+      }
+    }
+  }
+};
+
+// src/repo-config.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os from "os";
+import { parse as parseYaml } from "yaml";
+var REPOS_CONFIG_PATH = path3.join(os.homedir(), ".config", "glrs", "repos.yaml");
+var WORKTREES_BASE_DIR = path3.join(os.homedir(), ".glrs", "worktrees");
+var OPENCODE_BASE_DIR = path3.join(os.homedir(), ".glrs", "opencode");
+var LEGACY_WORKTREES_BASE_DIR = path3.join(os.homedir(), ".glorious", "worktrees");
+var LEGACY_OPENCODE_BASE_DIR = path3.join(os.homedir(), ".glorious", "opencode");
+var EVENT_FILE_RELATIVE = path3.join(".agent", "autopilot-events.jsonl");
+function readGitBranch(repoPath) {
+  const headFile = path3.join(repoPath, ".git", "HEAD");
+  try {
+    const content = fs3.readFileSync(headFile, "utf8").trim();
+    const match = content.match(/^ref: refs\/heads\/(.+)$/);
+    return match ? match[1] : void 0;
+  } catch {
+    try {
+      const gitFile = path3.join(repoPath, ".git");
+      const content = fs3.readFileSync(gitFile, "utf8").trim();
+      const gitdirMatch = content.match(/^gitdir:\s*(.+)$/);
+      if (gitdirMatch) {
+        const worktreeGitDir = gitdirMatch[1];
+        const headPath = path3.join(worktreeGitDir, "HEAD");
+        const headContent = fs3.readFileSync(headPath, "utf8").trim();
+        const branchMatch = headContent.match(/^ref: refs\/heads\/(.+)$/);
+        return branchMatch ? branchMatch[1] : void 0;
+      }
+    } catch {
+    }
+    return void 0;
+  }
+}
+function hasActiveAutopilot(repoPath) {
+  return fs3.existsSync(path3.join(repoPath, EVENT_FILE_RELATIVE));
+}
+function buildRepoInfo(repoPath, nameOverride) {
+  const name = nameOverride ?? path3.basename(repoPath);
+  return {
+    path: repoPath,
+    name,
+    branch: readGitBranch(repoPath),
+    hasActiveAutopilot: hasActiveAutopilot(repoPath)
+  };
+}
+function parseReposYaml(raw) {
+  try {
+    const parsed = parseYaml(raw);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function readRepos({ reposConfigPath, worktreesBaseDir, legacyWorktreesBaseDir }) {
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  function addRepo(repoPath, nameOverride) {
+    const resolved = path3.resolve(repoPath);
+    if (seen.has(resolved)) return;
+    if (!fs3.existsSync(resolved)) return;
+    seen.add(resolved);
+    results.push(buildRepoInfo(resolved, nameOverride));
+  }
+  try {
+    const raw = fs3.readFileSync(reposConfigPath, "utf8");
+    const config = parseReposYaml(raw);
+    if (Array.isArray(config.repos)) {
+      for (const entry of config.repos) {
+        if (typeof entry === "string") {
+          addRepo(entry);
+        } else if (entry && typeof entry === "object" && typeof entry.path === "string") {
+          addRepo(entry.path, entry.name);
+        }
+      }
+    }
+  } catch {
+  }
+  const worktreesDirs = [worktreesBaseDir];
+  if (legacyWorktreesBaseDir) worktreesDirs.push(legacyWorktreesBaseDir);
+  for (const baseDir of worktreesDirs) {
+    try {
+      if (!fs3.existsSync(baseDir)) continue;
+      const repoGroups = fs3.readdirSync(baseDir, { withFileTypes: true });
+      for (const repoGroup of repoGroups) {
+        if (!repoGroup.isDirectory()) continue;
+        const repoGroupPath = path3.join(baseDir, repoGroup.name);
+        let worktreeEntries;
+        try {
+          worktreeEntries = fs3.readdirSync(repoGroupPath, { withFileTypes: true });
+        } catch {
+          continue;
+        }
+        for (const wt of worktreeEntries) {
+          if (!wt.isDirectory()) continue;
+          const wtPath = path3.join(repoGroupPath, wt.name);
+          addRepo(wtPath, `${repoGroup.name}/${wt.name}`);
+        }
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+function getConfiguredRepos() {
+  return readRepos({
+    reposConfigPath: REPOS_CONFIG_PATH,
+    worktreesBaseDir: WORKTREES_BASE_DIR,
+    legacyWorktreesBaseDir: LEGACY_WORKTREES_BASE_DIR
+  });
+}
+function getUniqueRepos() {
+  return readUniqueRepos({
+    reposConfigPath: REPOS_CONFIG_PATH,
+    worktreesBaseDir: WORKTREES_BASE_DIR,
+    legacyWorktreesBaseDir: LEGACY_WORKTREES_BASE_DIR
+  });
+}
+function readUniqueRepos({ reposConfigPath, worktreesBaseDir, legacyWorktreesBaseDir }) {
+  const byPath = /* @__PURE__ */ new Map();
+  function addOrUpgrade(name, primaryPath) {
+    const resolved = path3.resolve(primaryPath);
+    const existing = byPath.get(resolved);
+    if (existing) {
+      const existingIsSlug = /^wt-\d{6}-/.test(existing.name);
+      const newIsSlug = /^wt-\d{6}-/.test(name);
+      if (existingIsSlug && !newIsSlug) {
+        byPath.set(resolved, { name, primaryPath: resolved });
+      }
+      return;
+    }
+    byPath.set(resolved, { name, primaryPath: resolved });
+  }
+  try {
+    const raw = fs3.readFileSync(reposConfigPath, "utf8");
+    const config = parseReposYaml(raw);
+    if (Array.isArray(config.repos)) {
+      for (const entry of config.repos) {
+        const repoPath = typeof entry === "string" ? entry : entry?.path;
+        const name = typeof entry === "object" && entry?.name ? entry.name : void 0;
+        if (!repoPath) continue;
+        const resolved = path3.resolve(repoPath);
+        if (!fs3.existsSync(resolved)) continue;
+        addOrUpgrade(name ?? path3.basename(resolved), resolved);
+      }
+    }
+  } catch {
+  }
+  const worktreesDirs = [worktreesBaseDir];
+  if (legacyWorktreesBaseDir) worktreesDirs.push(legacyWorktreesBaseDir);
+  for (const baseDir of worktreesDirs) {
+    try {
+      if (!fs3.existsSync(baseDir)) continue;
+      const repoGroups = fs3.readdirSync(baseDir, { withFileTypes: true });
+      for (const repoGroup of repoGroups) {
+        if (!repoGroup.isDirectory()) continue;
+        const groupPath = path3.join(baseDir, repoGroup.name);
+        let primaryPath = groupPath;
+        try {
+          const entries = fs3.readdirSync(groupPath, { withFileTypes: true });
+          for (const entry of entries) {
+            if (!entry.isDirectory()) continue;
+            const wtPath = path3.join(groupPath, entry.name);
+            const gitFile = path3.join(wtPath, ".git");
+            try {
+              const content = fs3.readFileSync(gitFile, "utf8").trim();
+              const match = content.match(/^gitdir:\s*(.+)$/);
+              if (match) {
+                const gitWorktreeDir = match[1];
+                const dotGitDir = path3.resolve(path3.dirname(path3.dirname(gitWorktreeDir)));
+                const cloneRoot = path3.dirname(dotGitDir);
+                if (fs3.existsSync(cloneRoot)) {
+                  primaryPath = cloneRoot;
+                  break;
+                }
+              }
+            } catch {
+            }
+          }
+        } catch {
+        }
+        addOrUpgrade(repoGroup.name, primaryPath);
+      }
+    } catch {
+    }
+  }
+  const opencodeDirs = [OPENCODE_BASE_DIR, LEGACY_OPENCODE_BASE_DIR];
+  for (const opencodeDir of opencodeDirs) {
+    try {
+      if (fs3.existsSync(opencodeDir)) {
+        const entries = fs3.readdirSync(opencodeDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue;
+          if (entry.name.startsWith("tmp") || entry.name.startsWith("costs")) continue;
+          if (entry.name === "default-base" || entry.name === "default-pilot" || entry.name === "pilot-smoke") continue;
+          const repoName3 = entry.name;
+          const alreadyFound = Array.from(byPath.values()).some((r) => r.name === repoName3);
+          if (alreadyFound) continue;
+          addOrUpgrade(repoName3, path3.join(opencodeDir, repoName3));
+        }
+      }
+    } catch {
+    }
+  }
+  return Array.from(byPath.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// src/tui/index.ts
+import React6 from "react";
+import { render } from "ink";
+
+// src/tui/components/Dashboard.tsx
+import { useState as useState5, useEffect as useEffect2 } from "react";
+import { Box as Box8, Text as Text8, useInput as useInput5, useApp } from "ink";
+
+// src/tui/components/SessionCard.tsx
+import { Box, Text } from "ink";
+import { Spinner } from "@inkjs/ui";
+import { jsx, jsxs } from "react/jsx-runtime";
+var STATUS_COLORS = {
+  running: "blue",
+  enriching: "yellow",
+  verifying: "cyan",
+  complete: "green",
+  error: "red",
+  stale: "gray"
+};
+var STATUS_LABELS = {
+  running: "Running",
+  enriching: "Enriching",
+  verifying: "Verifying",
+  complete: "Complete",
+  error: "Error",
+  stale: "Stale"
+};
+function formatElapsed(startedAt) {
+  const ms = Date.now() - new Date(startedAt).getTime();
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+function formatCost(cost) {
+  return `$${cost.toFixed(2)}`;
+}
+function repoName(cwd) {
+  return cwd.split("/").pop() || cwd;
+}
+function SessionCard({ handle, selected }) {
+  const color = STATUS_COLORS[handle.status];
+  const isActive = handle.status === "running" || handle.status === "enriching" || handle.status === "verifying";
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: selected ? "bold" : "single",
+      borderColor: selected ? color : void 0,
+      paddingX: 1,
+      marginBottom: 0,
+      children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { bold: true, children: repoName(handle.cwd) }),
+          /* @__PURE__ */ jsx(Text, { children: " " }),
+          isActive && /* @__PURE__ */ jsx(Spinner, {}),
+          /* @__PURE__ */ jsxs(Text, { color, children: [
+            " ",
+            STATUS_LABELS[handle.status]
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { children: [
+          handle.currentPhase ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            "Phase ",
+            handle.currentPhase.current,
+            "/",
+            handle.currentPhase.total,
+            ":",
+            " ",
+            handle.currentPhase.phase
+          ] }) : /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2014" }),
+          handle.currentIteration && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            " ",
+            "\xB7 iter ",
+            handle.currentIteration.iteration,
+            "/",
+            handle.currentIteration.max
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          formatCost(handle.cost),
+          " \xB7 ",
+          formatElapsed(handle.startedAt),
+          handle.totalIterations > 0 && ` \xB7 ${handle.totalIterations} iterations`
+        ] }) }),
+        handle.error && /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: "red", children: [
+          "\u2717 ",
+          handle.error
+        ] }) })
+      ]
+    }
+  );
+}
+
+// src/tui/components/NewSessionFlow.tsx
+import { useState as useState3, useMemo as useMemo2 } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput3 } from "ink";
+import { Spinner as Spinner2 } from "@inkjs/ui";
+
+// src/tui/components/RepoSelector.tsx
+import { useState } from "react";
+import { Box as Box2, Text as Text2, useInput } from "ink";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var VIEWPORT_SIZE = 10;
+function RepoSelector({ repos, onSelect, onCancel }) {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  useInput((_input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      if (repos[selectedIndex]) {
+        onSelect(repos[selectedIndex]);
+      }
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((i) => Math.max(0, i - 1));
+    }
+    if (key.downArrow) {
+      setSelectedIndex((i) => Math.min(repos.length - 1, i + 1));
+    }
+  });
+  const halfWindow = Math.floor(VIEWPORT_SIZE / 2);
+  let windowStart = Math.max(0, selectedIndex - halfWindow);
+  const windowEnd = Math.min(repos.length, windowStart + VIEWPORT_SIZE);
+  if (windowEnd - windowStart < VIEWPORT_SIZE) {
+    windowStart = Math.max(0, windowEnd - VIEWPORT_SIZE);
+  }
+  const visibleRepos = repos.slice(windowStart, windowEnd);
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs2(Box2, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Select Repository" }),
+      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        " \u2014 ",
+        repos.length,
+        " repos"
+      ] })
+    ] }),
+    repos.length === 0 ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "No repositories found. Add repos to ~/.config/glrs/repos.yaml" }) : /* @__PURE__ */ jsxs2(Fragment, { children: [
+      windowStart > 0 && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "  \u2191 ",
+        windowStart,
+        " more"
+      ] }),
+      visibleRepos.map((repo, i) => {
+        const globalIndex = windowStart + i;
+        const isSelected = globalIndex === selectedIndex;
+        return /* @__PURE__ */ jsx2(Box2, { children: /* @__PURE__ */ jsxs2(Text2, { color: isSelected ? "blue" : void 0, children: [
+          isSelected ? "\u25B6 " : "  ",
+          /* @__PURE__ */ jsx2(Text2, { bold: isSelected, children: repo.name })
+        ] }) }, `${repo.primaryPath}-${globalIndex}`);
+      }),
+      windowEnd < repos.length && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "  \u2193 ",
+        repos.length - windowEnd,
+        " more"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2191\u2193 navigate \xB7 Enter select \xB7 Esc cancel" }) })
+  ] });
+}
+
+// src/tui/components/PlanSelector.tsx
+import { useState as useState2, useMemo } from "react";
+import { Box as Box3, Text as Text3, useInput as useInput2 } from "ink";
+import * as fs4 from "fs";
+import * as path4 from "path";
+import * as os2 from "os";
+import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function countCheckboxes(filePath) {
+  try {
+    const content = fs4.readFileSync(filePath, "utf8");
+    const matches = content.match(/^\s*-\s*\[[ x]\]/gm);
+    return matches?.length ?? 0;
+  } catch {
+    return 0;
+  }
+}
+function getMtimeMs(filePath) {
+  try {
+    return fs4.statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function countPlanEntries(dir) {
+  try {
+    if (!fs4.existsSync(dir)) return 0;
+    const entries = fs4.readdirSync(dir, { withFileTypes: true });
+    let count = 0;
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const mainMd = path4.join(dir, entry.name, "main.md");
+        const specYaml = path4.join(dir, entry.name, "spec", "main.yaml");
+        if (fs4.existsSync(mainMd) || fs4.existsSync(specYaml)) count++;
+      } else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "README.md") {
+        count++;
+      }
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+function scanPlanDir(dir) {
+  const results = [];
+  try {
+    if (!fs4.existsSync(dir)) return results;
+    const entries = fs4.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const mainMd = path4.join(entryPath, "main.md");
+        if (fs4.existsSync(mainMd)) {
+          results.push({
+            name: entry.name,
+            planPath: mainMd,
+            itemCount: countCheckboxes(mainMd),
+            mtimeMs: getMtimeMs(mainMd)
+          });
+          continue;
+        }
+        const specYaml = path4.join(entryPath, "spec", "main.yaml");
+        if (fs4.existsSync(specYaml)) {
+          results.push({
+            name: `${entry.name} (yaml)`,
+            planPath: specYaml,
+            itemCount: 0,
+            mtimeMs: getMtimeMs(specYaml)
+          });
+          continue;
+        }
+      } else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "README.md") {
+        const itemCount = countCheckboxes(entryPath);
+        if (itemCount > 0) {
+          results.push({
+            name: entry.name.replace(/\.md$/, ""),
+            planPath: entryPath,
+            itemCount,
+            mtimeMs: getMtimeMs(entryPath)
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  results.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return results;
+}
+function shortenPath(p) {
+  const home = os2.homedir();
+  if (p.startsWith(home)) return "~" + p.slice(home.length);
+  return p;
+}
+function findClonePath(repoName3, candidatePath) {
+  const home = os2.homedir();
+  if (isGitRepo(candidatePath)) return candidatePath;
+  const searchRoots = [
+    path4.join(home, "repos"),
+    path4.join(home, "projects"),
+    path4.join(home, "src"),
+    path4.join(home, "code"),
+    path4.join(home, "dev")
+  ];
+  for (const root of searchRoots) {
+    const direct = path4.join(root, repoName3);
+    if (isGitRepo(direct)) return direct;
+    try {
+      if (!fs4.existsSync(root)) continue;
+      const orgs = fs4.readdirSync(root, { withFileTypes: true });
+      for (const org of orgs) {
+        if (!org.isDirectory()) continue;
+        const nested = path4.join(root, org.name, repoName3);
+        if (isGitRepo(nested)) return nested;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function isGitRepo(dir) {
+  return fs4.existsSync(path4.join(dir, ".git"));
+}
+function buildPlanLocations(repoPath, repoName3) {
+  const home = os2.homedir();
+  const locations = [];
+  const clonePath = isGitRepo(repoPath) ? repoPath : findClonePath(repoName3, repoPath);
+  if (clonePath) {
+    const localDirs = [
+      { dir: path4.join(clonePath, ".glrs", "plans"), label: `${shortenPath(clonePath)}/.glrs/plans` },
+      { dir: path4.join(clonePath, ".opencode", "plans"), label: `${shortenPath(clonePath)}/.opencode/plans` },
+      { dir: path4.join(clonePath, "docs", "plans"), label: `${shortenPath(clonePath)}/docs/plans` },
+      { dir: path4.join(clonePath, "plans"), label: `${shortenPath(clonePath)}/plans` }
+    ];
+    for (const { dir, label } of localDirs) {
+      const fileCount = countPlanEntries(dir);
+      if (fileCount > 0 || dir.includes(".glrs")) {
+        locations.push({ dir, label, fileCount });
+      }
+    }
+  }
+  const globalDirs = [
+    { dir: path4.join(home, ".glrs", repoName3, "plans"), label: `~/.glrs/${repoName3}/plans` },
+    { dir: path4.join(home, ".glorious", "opencode", repoName3, "plans"), label: `~/.glorious/opencode/${repoName3}/plans`, deprecated: true }
+  ];
+  for (const { dir, label, deprecated } of globalDirs) {
+    const fileCount = countPlanEntries(dir);
+    if (fileCount > 0 || !deprecated) {
+      locations.push({ dir, label, fileCount, deprecated });
+    }
+  }
+  const exploreDir = clonePath ?? home;
+  locations.push({
+    dir: exploreDir,
+    label: `${shortenPath(exploreDir)} [EXPLORE]`,
+    fileCount: 0,
+    explore: true
+  });
+  return locations;
+}
+function FileExplorer({ startDir, onSelect, onCancel }) {
+  const [cwd, setCwd] = useState2(startDir);
+  const [selectedIndex, setSelectedIndex] = useState2(0);
+  const entries = useMemo(() => {
+    try {
+      const raw = fs4.readdirSync(cwd, { withFileTypes: true });
+      const dirs = [];
+      const files = [];
+      for (const entry of raw) {
+        if (entry.name.startsWith(".") && entry.name !== ".glrs" && entry.name !== ".opencode") continue;
+        if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") continue;
+        const fullPath = path4.join(cwd, entry.name);
+        if (entry.isDirectory()) {
+          dirs.push({ name: entry.name + "/", isDir: true, path: fullPath });
+        } else if (entry.name.endsWith(".md") || entry.name.endsWith(".yaml")) {
+          files.push({ name: entry.name, isDir: false, path: fullPath });
+        }
+      }
+      dirs.sort((a, b) => a.name.localeCompare(b.name));
+      files.sort((a, b) => a.name.localeCompare(b.name));
+      return [...dirs, ...files];
+    } catch {
+      return [];
+    }
+  }, [cwd]);
+  useInput2((_input, key) => {
+    if (key.escape) {
+      if (cwd === startDir) {
+        onCancel();
+      } else {
+        setCwd(path4.dirname(cwd));
+        setSelectedIndex(0);
+      }
+      return;
+    }
+    if (key.return && entries[selectedIndex]) {
+      const entry = entries[selectedIndex];
+      if (entry.isDir) {
+        const mainMd = path4.join(entry.path, "main.md");
+        const specYaml = path4.join(entry.path, "spec", "main.yaml");
+        if (fs4.existsSync(mainMd)) {
+          onSelect(mainMd);
+        } else if (fs4.existsSync(specYaml)) {
+          onSelect(specYaml);
+        } else {
+          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 VIEWPORT = 12;
+  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__ */ jsxs3(Box3, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs3(Box3, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Explore: " }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: shortenPath(cwd) })
+    ] }),
+    windowStart > 0 && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      "  \u2191 ",
+      windowStart,
+      " more"
+    ] }),
+    visible.map((entry, i) => {
+      const globalIndex = windowStart + i;
+      const isSelected = globalIndex === selectedIndex;
+      return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs3(Text3, { color: isSelected ? "blue" : void 0, children: [
+        isSelected ? "\u25B6 " : "  ",
+        /* @__PURE__ */ jsx3(Text3, { bold: isSelected, color: entry.isDir ? "cyan" : void 0, children: entry.name })
+      ] }) }, `${entry.path}-${globalIndex}`);
+    }),
+    windowEnd < entries.length && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      "  \u2193 ",
+      entries.length - windowEnd,
+      " more"
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2191\u2193 navigate \xB7 Enter open/select \xB7 Esc back" }) })
+  ] });
+}
+function PlanList({ location, onSelect, onBack }) {
+  const [selectedIndex, setSelectedIndex] = useState2(0);
+  const plans = useMemo(() => scanPlanDir(location.dir), [location.dir]);
+  useInput2((_input, key) => {
+    if (key.escape) {
+      onBack();
+      return;
+    }
+    if (key.return && plans[selectedIndex]) {
+      onSelect(plans[selectedIndex].planPath);
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((i) => Math.max(0, i - 1));
+    }
+    if (key.downArrow) {
+      setSelectedIndex((i) => Math.min(plans.length - 1, i + 1));
+    }
+  });
+  const VIEWPORT = 10;
+  const halfWindow = Math.floor(VIEWPORT / 2);
+  let windowStart = Math.max(0, selectedIndex - halfWindow);
+  const windowEnd = Math.min(plans.length, windowStart + VIEWPORT);
+  if (windowEnd - windowStart < VIEWPORT) {
+    windowStart = Math.max(0, windowEnd - VIEWPORT);
+  }
+  const visible = plans.slice(windowStart, windowEnd);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs3(Box3, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Plans in " }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: location.label })
+    ] }),
+    plans.length === 0 ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "No plans in this location." }) : /* @__PURE__ */ jsxs3(Fragment2, { children: [
+      windowStart > 0 && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        "  \u2191 ",
+        windowStart,
+        " more"
+      ] }),
+      visible.map((plan, i) => {
+        const globalIndex = windowStart + i;
+        const isSelected = globalIndex === selectedIndex;
+        return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs3(Text3, { color: isSelected ? "blue" : void 0, children: [
+          isSelected ? "\u25B6 " : "  ",
+          /* @__PURE__ */ jsx3(Text3, { bold: isSelected, children: plan.name }),
+          plan.itemCount > 0 && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+            " (",
+            plan.itemCount,
+            " items)"
+          ] })
+        ] }) }, `${plan.planPath}-${globalIndex}`);
+      }),
+      windowEnd < plans.length && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        "  \u2193 ",
+        plans.length - windowEnd,
+        " more"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2191\u2193 navigate \xB7 Enter select \xB7 Esc back" }) })
+  ] });
+}
+var VIEWPORT_SIZE2 = 10;
+function PlanSelector({ repoPath, repoName: repoName3, onSelect, onCancel }) {
+  const [view, setView] = useState2({ kind: "locations" });
+  const [selectedIndex, setSelectedIndex] = useState2(0);
+  const locations = useMemo(() => buildPlanLocations(repoPath, repoName3), [repoPath, repoName3]);
+  useInput2((_input, key) => {
+    if (view.kind !== "locations") return;
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return && locations[selectedIndex]) {
+      const loc = locations[selectedIndex];
+      if (loc.explore) {
+        setView({ kind: "explore", startDir: loc.dir });
+      } else if (loc.fileCount > 0) {
+        setView({ kind: "plans", location: loc });
+      }
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((i) => Math.max(0, i - 1));
+    }
+    if (key.downArrow) {
+      setSelectedIndex((i) => Math.min(locations.length - 1, i + 1));
+    }
+  });
+  if (view.kind === "plans") {
+    return /* @__PURE__ */ jsx3(
+      PlanList,
+      {
+        location: view.location,
+        onSelect,
+        onBack: () => setView({ kind: "locations" })
+      }
+    );
+  }
+  if (view.kind === "explore") {
+    return /* @__PURE__ */ jsx3(
+      FileExplorer,
+      {
+        startDir: view.startDir,
+        onSelect,
+        onCancel: () => setView({ kind: "locations" })
+      }
+    );
+  }
+  const halfWindow = Math.floor(VIEWPORT_SIZE2 / 2);
+  let windowStart = Math.max(0, selectedIndex - halfWindow);
+  const windowEnd = Math.min(locations.length, windowStart + VIEWPORT_SIZE2);
+  if (windowEnd - windowStart < VIEWPORT_SIZE2) {
+    windowStart = Math.max(0, windowEnd - VIEWPORT_SIZE2);
+  }
+  const visible = locations.slice(windowStart, windowEnd);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs3(Box3, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Select Plan Location" }),
+      /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        " \u2014 ",
+        repoName3
+      ] })
+    ] }),
+    locations.length === 0 ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "No plan locations found for this repo." }) : /* @__PURE__ */ jsxs3(Fragment2, { children: [
+      windowStart > 0 && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        "  \u2191 ",
+        windowStart,
+        " more"
+      ] }),
+      visible.map((loc, i) => {
+        const globalIndex = windowStart + i;
+        const isSelected = globalIndex === selectedIndex;
+        const canEnter = loc.fileCount > 0 || loc.explore;
+        return /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs3(Text3, { color: isSelected ? "blue" : void 0, dimColor: !canEnter && !isSelected, children: [
+          isSelected ? "\u25B6 " : "  ",
+          /* @__PURE__ */ jsx3(Text3, { bold: isSelected, children: loc.label }),
+          loc.deprecated && /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: " [DEPRECATED]" }),
+          !loc.explore && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+            " (",
+            loc.fileCount,
+            " files)"
+          ] })
+        ] }) }, `${loc.dir}-${globalIndex}`);
+      }),
+      windowEnd < locations.length && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        "  \u2193 ",
+        locations.length - windowEnd,
+        " more"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2191\u2193 navigate \xB7 Enter open \xB7 Esc back" }) })
+  ] });
+}
+
+// src/tui/components/NewSessionFlow.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function NewSessionFlow({ manager, onDone, onCancel }) {
+  const [step, setStep] = useState3({ kind: "repo" });
+  const repos = useMemo2(() => getUniqueRepos(), []);
+  useInput3((_input, key) => {
+    if (step.kind === "error" && (key.escape || key.return)) {
+      onDone();
+    }
+  });
+  if (step.kind === "repo") {
+    return /* @__PURE__ */ jsx4(
+      RepoSelector,
+      {
+        repos,
+        onSelect: (repo) => setStep({ kind: "plan", repo }),
+        onCancel
+      }
+    );
+  }
+  if (step.kind === "plan") {
+    return /* @__PURE__ */ jsx4(
+      PlanSelector,
+      {
+        repoPath: step.repo.primaryPath,
+        repoName: step.repo.name,
+        onSelect: (planPath) => setStep({ kind: "confirm", repo: step.repo, planPath }),
+        onCancel: () => setStep({ kind: "repo" })
+      }
+    );
+  }
+  if (step.kind === "launching") {
+    return /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Spinner2, {}),
+      /* @__PURE__ */ jsx4(Text4, { children: " Creating worktree and launching session..." })
+    ] }) });
+  }
+  if (step.kind === "error") {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx4(Box4, { marginBottom: 1, children: /* @__PURE__ */ jsx4(Text4, { color: "red", bold: true, children: "Launch failed" }) }),
+      /* @__PURE__ */ jsx4(Text4, { color: "red", children: step.message }),
+      /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Press Enter or Esc to return to dashboard" }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsx4(
+    ConfirmLaunch,
+    {
+      repo: step.repo,
+      planPath: step.planPath,
+      onConfirm: () => {
+        setStep({ kind: "launching" });
+        setTimeout(() => {
+          try {
+            manager.launchSessionWithWorktree({
+              repoName: step.repo.name,
+              planPath: step.planPath,
+              fast: true
+            });
+            onDone();
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            setStep({ kind: "error", message });
+          }
+        }, 50);
+      },
+      onCancel: () => setStep({ kind: "plan", repo: step.repo })
+    }
+  );
+}
+function ConfirmLaunch({
+  repo,
+  planPath,
+  onConfirm,
+  onCancel
+}) {
+  useInput3((_input, key) => {
+    if (key.return) {
+      onConfirm();
+      return;
+    }
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+  });
+  const planName = planPath.split("/").pop() ?? planPath;
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx4(Box4, { marginBottom: 1, children: /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Launch Session" }) }),
+    /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs4(Box4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Repo: " }),
+        /* @__PURE__ */ jsx4(Text4, { children: repo.name })
+      ] }),
+      /* @__PURE__ */ jsxs4(Box4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Plan: " }),
+        /* @__PURE__ */ jsx4(Text4, { children: planName })
+      ] }),
+      /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        "A fresh worktree will be created via `glrs wt new ",
+        repo.name,
+        "`."
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Enter to launch \xB7 Esc to cancel" }) })
+  ] });
+}
+
+// src/tui/components/SessionExpanded.tsx
+import { Box as Box7, Text as Text7, useInput as useInput4 } from "ink";
+import { Spinner as Spinner3 } from "@inkjs/ui";
+
+// src/tui/components/PhaseTree.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function PhaseTree({ handle }) {
+  const { currentPhase } = handle;
+  if (!currentPhase) {
+    return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Phase Progress" }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "  No phase information available" })
+    ] });
+  }
+  const { phase, current, total } = currentPhase;
+  const phases = [];
+  for (let i = 1; i <= total; i++) {
+    if (i < current) {
+      phases.push(`phase_${i - 1}.md`);
+    } else if (i === current) {
+      phases.push(phase);
+    } else {
+      phases.push(`phase_${i - 1}.md`);
+    }
+  }
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Phase Progress" }),
+    phases.map((p, i) => {
+      const phaseNum = i + 1;
+      let icon;
+      let color;
+      let extra = "";
+      if (phaseNum < current) {
+        icon = "\u2713";
+        color = "green";
+      } else if (phaseNum === current) {
+        icon = "\u25CF";
+        color = "blue";
+        if (handle.currentIteration) {
+          extra = ` (iter ${handle.currentIteration.iteration}/${handle.currentIteration.max})`;
+        }
+      } else {
+        icon = "\u25CB";
+        color = "gray";
+      }
+      return /* @__PURE__ */ jsxs5(Box5, { children: [
+        /* @__PURE__ */ jsxs5(Text5, { color, children: [
+          "  ",
+          icon,
+          " "
+        ] }),
+        /* @__PURE__ */ jsxs5(Text5, { dimColor: phaseNum !== current, children: [
+          p,
+          extra
+        ] })
+      ] }, i);
+    })
+  ] });
+}
+
+// src/tui/components/EventTail.tsx
+import { useState as useState4, useEffect, useRef } from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+import { EventStreamReader as EventStreamReader3 } from "@glrs-dev/autopilot";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function formatTime(timestamp) {
+  try {
+    const d = new Date(timestamp);
+    const hh = String(d.getHours()).padStart(2, "0");
+    const mm = String(d.getMinutes()).padStart(2, "0");
+    const ss = String(d.getSeconds()).padStart(2, "0");
+    return `${hh}:${mm}:${ss}`;
+  } catch {
+    return "??:??:??";
+  }
+}
+function formatEventDetails(e) {
+  switch (e.type) {
+    case "session:start":
+      return e.planPath ?? "";
+    case "session:done":
+      return e.exitReason ?? "";
+    case "phase:start":
+      return `${e.phase} (${e.current}/${e.total})`;
+    case "phase:done":
+      return `${e.phase}`;
+    case "iteration:start":
+      return `${e.iteration}/${e.maxIterations}`;
+    case "iteration:done":
+      return `${e.iteration} ${e.madeProgress ? "\u2713" : "\u2014"}`;
+    case "tool:call":
+      return `${e.toolName} ${e.firstArg ?? ""}`;
+    case "cost:update":
+      return `$${e.cumulativeCostUsd.toFixed(3)}`;
+    case "error":
+      return e.message.slice(0, 60);
+    case "enrich:start":
+      return e.planPath ?? "";
+    case "enrich:done":
+      return `${e.filesProcessed} files`;
+    case "verify:start":
+      return `${e.itemCount} items`;
+    case "verify:done":
+      return `${e.passed} passed, ${e.failed} failed`;
+    default:
+      return "";
+  }
+}
+function EventTail({ eventFilePath, maxEvents = 20 }) {
+  const [events, setEvents] = useState4([]);
+  const offsetRef = useRef(0);
+  useEffect(() => {
+    const reader = new EventStreamReader3(eventFilePath);
+    const interval = setInterval(() => {
+      const { events: newEvents, newOffset } = reader.readFrom(offsetRef.current);
+      offsetRef.current = newOffset;
+      if (newEvents.length > 0) {
+        setEvents((prev) => [...prev, ...newEvents].slice(-maxEvents));
+      }
+    }, 500);
+    return () => clearInterval(interval);
+  }, [eventFilePath, maxEvents]);
+  if (events.length === 0) {
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Live Events" }),
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "  Waiting for events\u2026" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Live Events" }),
+    events.map((e, i) => /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+      "  ",
+      formatTime(e.timestamp),
+      " ",
+      e.type,
+      " ",
+      formatEventDetails(e)
+    ] }, i))
+  ] });
+}
+
+// src/tui/components/SessionExpanded.tsx
+import * as path5 from "path";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var STATUS_COLORS2 = {
+  running: "blue",
+  enriching: "yellow",
+  verifying: "cyan",
+  complete: "green",
+  error: "red",
+  stale: "gray"
+};
+function formatElapsed2(startedAt) {
+  const ms = Date.now() - new Date(startedAt).getTime();
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+function formatCost2(cost) {
+  return `$${cost.toFixed(3)}`;
+}
+function repoName2(cwd) {
+  return cwd.split("/").pop() || cwd;
+}
+function SessionExpanded({ handle, manager, onBack }) {
+  const isActive = handle.status === "running" || handle.status === "enriching" || handle.status === "verifying";
+  const isTerminal = handle.status === "complete" || handle.status === "error" || handle.status === "stale";
+  const color = STATUS_COLORS2[handle.status];
+  const eventFilePath = path5.join(handle.cwd, ".agent", "autopilot-events.jsonl");
+  useInput4((input, key) => {
+    if (key.escape) {
+      onBack();
+      return;
+    }
+    if (input === "k") {
+      manager.killSession(handle.id);
+      return;
+    }
+    if (input === "r" && isTerminal) {
+      manager.retrySession(handle.id);
+      onBack();
+      return;
+    }
+    if (input === "c" && isTerminal) {
+      manager.cleanupSession(handle.id);
+      onBack();
+      return;
+    }
+  });
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", padding: 1, borderStyle: "single", children: [
+    /* @__PURE__ */ jsxs7(Box7, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs7(Text7, { bold: true, children: [
+        "Session: ",
+        repoName2(handle.cwd)
+      ] }),
+      /* @__PURE__ */ jsx7(Text7, { children: " " }),
+      isActive && /* @__PURE__ */ jsx7(Spinner3, {}),
+      /* @__PURE__ */ jsxs7(Text7, { color, children: [
+        " ",
+        handle.status
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, children: /* @__PURE__ */ jsx7(PhaseTree, { handle }) }),
+    /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, children: /* @__PURE__ */ jsx7(Text7, { bold: true, children: "Summary" }) }),
+    /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, children: /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      "Cost: ",
+      formatCost2(handle.cost),
+      " \xB7 Elapsed: ",
+      formatElapsed2(handle.startedAt),
+      handle.totalIterations > 0 && ` \xB7 ${handle.totalIterations} iterations`
+    ] }) }),
+    handle.error && /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: "red", children: [
+      "\u2717 Error: ",
+      handle.error
+    ] }) }),
+    /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, children: /* @__PURE__ */ jsx7(EventTail, { eventFilePath }) }),
+    /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      "esc back \xB7 k kill",
+      isTerminal ? " \xB7 r retry \xB7 c cleanup" : ""
+    ] }) })
+  ] });
+}
+
+// src/tui/components/Dashboard.tsx
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function Dashboard({ manager }) {
+  const { exit } = useApp();
+  const [sessions, setSessions] = useState5([]);
+  const [selectedIndex, setSelectedIndex] = useState5(0);
+  const [view, setView] = useState5({ kind: "dashboard" });
+  useEffect2(() => {
+    setSessions(manager.getSessions());
+    const interval = setInterval(() => {
+      setSessions(manager.getSessions());
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [manager]);
+  useInput5((input, key) => {
+    if (view.kind !== "dashboard") return;
+    if (input === "q") {
+      exit();
+      return;
+    }
+    if (input === "n") {
+      setView({ kind: "new-session" });
+      return;
+    }
+    if (key.return && sessions[selectedIndex]) {
+      setView({ kind: "expanded", sessionId: sessions[selectedIndex].id });
+      return;
+    }
+    if (input === "k" && sessions[selectedIndex]) {
+      manager.killSession(sessions[selectedIndex].id);
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((i) => Math.max(0, i - 1));
+    }
+    if (key.downArrow) {
+      setSelectedIndex((i) => Math.min(sessions.length - 1, i + 1));
+    }
+  });
+  if (view.kind === "new-session") {
+    return /* @__PURE__ */ jsx8(
+      NewSessionFlow,
+      {
+        manager,
+        onDone: () => setView({ kind: "dashboard" }),
+        onCancel: () => setView({ kind: "dashboard" })
+      }
+    );
+  }
+  if (view.kind === "expanded") {
+    const session = sessions.find((s) => s.id === view.sessionId);
+    if (session) {
+      return /* @__PURE__ */ jsx8(
+        SessionExpanded,
+        {
+          handle: session,
+          manager,
+          onBack: () => setView({ kind: "dashboard" })
+        }
+      );
+    }
+    setView({ kind: "dashboard" });
+  }
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs8(Box8, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx8(Text8, { bold: true, children: "Autopilot Dashboard" }),
+      /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+        " ",
+        "\u2014 ",
+        sessions.length,
+        " session",
+        sessions.length !== 1 ? "s" : ""
+      ] })
+    ] }),
+    sessions.length === 0 ? /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "No active sessions. Press n to launch one, q to quit." }) : sessions.map((session, i) => /* @__PURE__ */ jsx8(
+      SessionCard,
+      {
+        handle: session,
+        selected: i === selectedIndex
+      },
+      session.id
+    )),
+    /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2191\u2193 navigate \xB7 Enter expand \xB7 n new \xB7 k kill \xB7 q quit" }) })
+  ] });
+}
+
+// src/tui/index.ts
+async function startDashboard(manager) {
+  manager.start();
+  const app = render(
+    React6.createElement(Dashboard, { manager }),
+    { stdout: process.stderr, exitOnCtrlC: false }
+  );
+  await app.waitUntilExit();
+  manager.stop();
+}
+
+// src/commands/dashboard.ts
+async function runDashboard() {
+  const repos = getConfiguredRepos();
+  const dirs = repos.map((r) => r.path);
+  const cwd = process.cwd();
+  if (!dirs.includes(cwd)) {
+    dirs.unshift(cwd);
+  }
+  const manager = new SessionManager(dirs);
+  if (!process.stderr.isTTY) {
+    manager.start();
+    const sessions = manager.getSessions();
+    manager.stop();
+    if (sessions.length === 0) {
+      process.stderr.write("No active autopilot sessions.\n");
+      return;
+    }
+    for (const s of sessions) {
+      const repo = s.cwd.split("/").pop() || s.cwd;
+      process.stderr.write(
+        `${s.status.toUpperCase().padEnd(10)} ${repo} \u2014 $${s.cost.toFixed(2)} \u2014 ${s.totalIterations} iterations
+`
+      );
+    }
+    return;
+  }
+  await startDashboard(manager);
+}
+export {
+  runDashboard
+};