agenthud 0.7.4 → 0.8.1

package/dist/main-FKALFJFL.js

@@ -0,0 +1,1703 @@
+// src/main.ts
+import { createInterface } from "readline";
+import { existsSync as existsSync5, rmSync } from "fs";
+import { join as join5 } from "path";
+import { render } from "ink";
+import React from "react";
+
+// src/cli.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function getHelp() {
+  return `Usage: agenthud [options]
+
+Monitors all running Claude Code sessions in real-time.
+
+Options:
+  -w, --watch       Watch mode (default) \u2014 live updates
+  --once            Print once and exit
+  -V, --version     Show version number
+  -h, --help        Show this help message
+
+Config: ~/.agenthud/config.yaml
+Logs:   ~/.agenthud/logs/
+`;
+}
+function getVersion() {
+  const __dirname2 = dirname(fileURLToPath(import.meta.url));
+  const packageJson = JSON.parse(
+    readFileSync(join(__dirname2, "..", "package.json"), "utf-8")
+  );
+  return packageJson.version;
+}
+function clearScreen() {
+  console.clear();
+}
+function parseArgs(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    return { mode: "watch", command: "help" };
+  }
+  if (args.includes("--version") || args.includes("-V")) {
+    return { mode: "watch", command: "version" };
+  }
+  if (args.includes("--once")) {
+    return { mode: "once" };
+  }
+  return { mode: "watch" };
+}
+
+// src/ui/App.tsx
+import { existsSync as existsSync4, watch, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+import { Box as Box4, Text as Text4, useApp, useInput, useStdout } from "ink";
+import { useCallback, useEffect as useEffect2, useMemo, useRef, useState as useState2 } from "react";
+
+// src/config/globalConfig.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var CONFIG_PATH = join2(homedir(), ".agenthud", "config.yaml");
+var DEFAULT_GLOBAL_CONFIG = {
+  refreshIntervalMs: 2e3,
+  logDir: join2(homedir(), ".agenthud", "logs"),
+  hiddenSessions: [],
+  hiddenSubAgents: []
+};
+function parseInterval(value) {
+  const match = value.match(/^(\d+)(s|m)$/);
+  if (!match) return null;
+  const n = parseInt(match[1], 10);
+  return match[2] === "m" ? n * 60 * 1e3 : n * 1e3;
+}
+function loadGlobalConfig() {
+  const config = { ...DEFAULT_GLOBAL_CONFIG };
+  if (!existsSync(CONFIG_PATH)) {
+    return config;
+  }
+  let raw;
+  try {
+    raw = readFileSync2(CONFIG_PATH, "utf-8");
+  } catch {
+    return config;
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(raw) ?? {};
+  } catch {
+    return config;
+  }
+  if (typeof parsed.refreshInterval === "string") {
+    const ms = parseInterval(parsed.refreshInterval);
+    if (ms !== null) config.refreshIntervalMs = ms;
+  }
+  if (typeof parsed.logDir === "string") {
+    config.logDir = parsed.logDir.replace(/^~/, homedir());
+  }
+  if (Array.isArray(parsed.hiddenSessions)) {
+    config.hiddenSessions = parsed.hiddenSessions.filter(
+      (s) => typeof s === "string"
+    );
+  }
+  if (Array.isArray(parsed.hiddenSubAgents)) {
+    config.hiddenSubAgents = parsed.hiddenSubAgents.filter(
+      (s) => typeof s === "string"
+    );
+  }
+  return config;
+}
+function writeConfig(updates) {
+  const configDir = join2(homedir(), ".agenthud");
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  let raw = {};
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      raw = parseYaml(readFileSync2(CONFIG_PATH, "utf-8")) ?? {};
+    } catch {
+      raw = {};
+    }
+  }
+  if (updates.hiddenSessions !== void 0)
+    raw.hiddenSessions = updates.hiddenSessions;
+  if (updates.hiddenSubAgents !== void 0)
+    raw.hiddenSubAgents = updates.hiddenSubAgents;
+  writeFileSync(CONFIG_PATH, stringifyYaml(raw), "utf-8");
+}
+function hideSession(id) {
+  const config = loadGlobalConfig();
+  if (config.hiddenSessions.includes(id)) return;
+  writeConfig({ hiddenSessions: [...config.hiddenSessions, id] });
+}
+function hideSubAgent(id) {
+  const config = loadGlobalConfig();
+  if (config.hiddenSubAgents.includes(id)) return;
+  writeConfig({ hiddenSubAgents: [...config.hiddenSubAgents, id] });
+}
+function ensureLogDir(logDir) {
+  if (!existsSync(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+}
+function hasProjectLevelConfig() {
+  return existsSync(join2(process.cwd(), ".agenthud", "config.yaml"));
+}
+
+// src/data/sessionHistory.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+
+// src/data/activityParser.ts
+import { basename } from "path";
+
+// src/types/index.ts
+var ICONS = {
+  User: ">",
+  Response: "<",
+  Thinking: "\u2026",
+  Edit: "~",
+  Write: "~",
+  Read: "\u25CB",
+  Bash: "$",
+  Glob: "*",
+  Grep: "*",
+  WebFetch: "@",
+  WebSearch: "@",
+  Task: "\xBB",
+  TodoWrite: "~",
+  AskUserQuestion: "?",
+  Default: "$"
+};
+
+// src/data/activityParser.ts
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function parseModelName(modelId) {
+  const opusMatch = modelId.match(/claude-opus-(\d+)-(\d+)/);
+  if (opusMatch) return `opus-${opusMatch[1]}.${opusMatch[2]}`;
+  const sonnetMatch = modelId.match(/claude-sonnet-(\d+)/);
+  if (sonnetMatch) return `sonnet-${sonnetMatch[1]}`;
+  const haikuMatch = modelId.match(/claude-(\d+)-(\d+)-haiku/);
+  if (haikuMatch) return `haiku-${haikuMatch[1]}.${haikuMatch[2]}`;
+  return modelId.replace(/-\d{8}$/, "");
+}
+function getToolDetail(_toolName, input) {
+  if (!input) return "";
+  if (input.command) return stripAnsi(input.command.replace(/\n/g, " "));
+  if (input.file_path) return basename(input.file_path);
+  if (input.pattern) return stripAnsi(input.pattern);
+  if (input.query) return stripAnsi(input.query);
+  if (input.description) return stripAnsi(input.description);
+  return "";
+}
+function parseActivitiesFromLines(lines) {
+  const activities = [];
+  let tokenCount = 0;
+  let modelName = null;
+  let sessionStartTime = null;
+  for (const line of lines) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const timestamp = entry.timestamp ? new Date(entry.timestamp) : /* @__PURE__ */ new Date();
+    if (!sessionStartTime && entry.timestamp) {
+      sessionStartTime = timestamp;
+    }
+    if (entry.type === "user") {
+      const userEntry = entry;
+      const msgContent = userEntry.message?.content;
+      let userText = "";
+      if (typeof msgContent === "string") {
+        userText = msgContent;
+      } else if (Array.isArray(msgContent)) {
+        const textBlock = msgContent.find((c) => c.type === "text" && c.text);
+        if (textBlock?.text) userText = textBlock.text;
+      }
+      if (userText) {
+        activities.push({
+          timestamp,
+          type: "user",
+          icon: ICONS.User,
+          label: "User",
+          detail: userText.replace(/\n/g, " ")
+        });
+      }
+    }
+    if (entry.type === "assistant") {
+      const assistantEntry = entry;
+      if (assistantEntry.message?.model && !modelName) {
+        modelName = parseModelName(assistantEntry.message.model);
+      }
+      const usage = assistantEntry.message?.usage;
+      if (usage) {
+        tokenCount += (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.output_tokens ?? 0);
+      }
+      const content = assistantEntry.message?.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === "thinking" && block.thinking) {
+            activities.push({
+              timestamp,
+              type: "thinking",
+              icon: ICONS.Thinking,
+              label: "Thinking",
+              detail: block.thinking.replace(/\n/g, " ")
+            });
+          } else if (block.type === "tool_use" && block.name) {
+            if (block.name === "TodoWrite") continue;
+            const icon = ICONS[block.name] ?? ICONS.Default;
+            const detail = getToolDetail(block.name, block.input);
+            const last = activities[activities.length - 1];
+            if (last && last.type === "tool" && last.label === block.name && last.detail === detail) {
+              last.count = (last.count ?? 1) + 1;
+              last.timestamp = timestamp;
+            } else {
+              activities.push({
+                timestamp,
+                type: "tool",
+                icon,
+                label: block.name,
+                detail
+              });
+            }
+          } else if (block.type === "text" && block.text && block.text.length > 10) {
+            activities.push({
+              timestamp,
+              type: "response",
+              icon: ICONS.Response,
+              label: "Response",
+              detail: block.text.replace(/\n/g, " ")
+            });
+          }
+        }
+      }
+    }
+  }
+  return { activities, tokenCount, modelName, sessionStartTime };
+}
+
+// src/data/sessionHistory.ts
+function parseSessionHistory(filePath) {
+  if (!existsSync2(filePath)) return [];
+  let content;
+  try {
+    content = readFileSync3(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const lines = content.trim().split("\n").filter(Boolean);
+  const { activities } = parseActivitiesFromLines(lines);
+  return activities;
+}
+
+// src/data/sessions.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync4, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename as basename2, join as join3 } from "path";
+
+// src/ui/constants.ts
+import stringWidth from "string-width";
+var THIRTY_SECONDS_MS = 30 * 1e3;
+var THIRTY_MINUTES_MS = 30 * 60 * 1e3;
+var ONE_HOUR_MS = 60 * 60 * 1e3;
+var FIVE_MINUTES_MS = 5 * 60 * 1e3;
+var DEFAULT_PANEL_WIDTH = 70;
+var CONTENT_WIDTH = DEFAULT_PANEL_WIDTH - 4;
+var INNER_WIDTH = DEFAULT_PANEL_WIDTH - 2;
+function getInnerWidth(panelWidth) {
+  return panelWidth - 2;
+}
+var BOX = {
+  tl: "\u250C",
+  tr: "\u2510",
+  bl: "\u2514",
+  br: "\u2518",
+  h: "\u2500",
+  v: "\u2502",
+  ml: "\u251C",
+  mr: "\u2524"
+};
+function createTitleLine(label, suffix = "", panelWidth = DEFAULT_PANEL_WIDTH) {
+  const leftPart = `${BOX.h} ${label} `;
+  const rightPart = suffix ? ` ${suffix} ${BOX.h}` : "";
+  const leftWidth = getDisplayWidth(leftPart);
+  const rightWidth = suffix ? getDisplayWidth(rightPart) : 0;
+  const dashCount = panelWidth - 1 - leftWidth - rightWidth - 1;
+  const dashes = BOX.h.repeat(Math.max(0, dashCount));
+  return BOX.tl + leftPart + dashes + rightPart + BOX.tr;
+}
+function createBottomLine(panelWidth = DEFAULT_PANEL_WIDTH) {
+  return BOX.bl + BOX.h.repeat(getInnerWidth(panelWidth)) + BOX.br;
+}
+var SEPARATOR = "\u2500".repeat(CONTENT_WIDTH);
+var getDisplayWidth = stringWidth;
+
+// src/data/sessions.ts
+function getProjectsDir() {
+  return join3(homedir2(), ".claude", "projects");
+}
+function decodeProjectPath(encoded) {
+  const windowsDriveMatch = encoded.match(/^([A-Za-z])--(.*)$/);
+  if (windowsDriveMatch) {
+    const drive = windowsDriveMatch[1];
+    const rest = windowsDriveMatch[2].replace(/-/g, "\\");
+    return `${drive}:\\${rest}`;
+  }
+  return encoded.replace(/-/g, "/");
+}
+function getSessionStatus(mtimeMs) {
+  const now = Date.now();
+  const age = now - mtimeMs;
+  if (age < THIRTY_MINUTES_MS) return "hot";
+  if (age < ONE_HOUR_MS) return "warm";
+  const mtime = new Date(mtimeMs);
+  const nowDate = new Date(now);
+  if (mtime.getUTCFullYear() === nowDate.getUTCFullYear() && mtime.getUTCMonth() === nowDate.getUTCMonth() && mtime.getUTCDate() === nowDate.getUTCDate()) {
+    return "cool";
+  }
+  return "cold";
+}
+function extractTaskDescription(content) {
+  const headerMatch = content.match(/##\s*(Task\s+\d+[:\s].+)/m);
+  if (headerMatch) return headerMatch[1].trim().slice(0, 60);
+  const thisTaskMatch = content.match(/\*\*This Task[^:]+:\*\*\s*(.+)/);
+  if (thisTaskMatch) return thisTaskMatch[1].trim().slice(0, 60);
+  const firstLine = content.split("\n").find((l) => l.trim());
+  return (firstLine ?? "").trim().slice(0, 60);
+}
+function readSubAgentInfo(filePath) {
+  if (!existsSync3(filePath)) return { agentId: null, taskDescription: null };
+  try {
+    const firstLine = readFileSync4(filePath, "utf-8").split("\n")[0];
+    if (!firstLine) return { agentId: null, taskDescription: null };
+    const entry = JSON.parse(firstLine);
+    const agentId = typeof entry.agentId === "string" ? entry.agentId : null;
+    const content = typeof entry.message?.content === "string" ? entry.message.content : null;
+    const taskDescription = content ? extractTaskDescription(content) : null;
+    return { agentId, taskDescription };
+  } catch {
+    return { agentId: null, taskDescription: null };
+  }
+}
+function readModelName(filePath) {
+  if (!existsSync3(filePath)) return null;
+  try {
+    const content = readFileSync4(filePath, "utf-8");
+    const lines = content.trim().split("\n").filter(Boolean);
+    for (const line of lines.slice(-50).reverse()) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "assistant" && entry.message?.model) {
+          return parseModelName(entry.message.model);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function buildSubAgents(parentId, projectDir, config, projectName) {
+  const subagentsDir = join3(projectDir, parentId, "subagents");
+  if (!existsSync3(subagentsDir)) return [];
+  let files;
+  try {
+    files = readdirSync(subagentsDir).filter(
+      (f) => f.endsWith(".jsonl")
+    );
+  } catch {
+    return [];
+  }
+  return files.map((file) => {
+    const id = file.replace(/\.jsonl$/, "");
+    const hideKey = `${projectName}/${id}`;
+    const filePath = join3(subagentsDir, file);
+    try {
+      const stat = statSync(filePath);
+      const { agentId, taskDescription } = readSubAgentInfo(filePath);
+      return {
+        id,
+        hideKey,
+        filePath,
+        projectPath: "",
+        projectName: "",
+        lastModifiedMs: stat.mtimeMs,
+        status: getSessionStatus(stat.mtimeMs),
+        modelName: readModelName(filePath),
+        subAgents: [],
+        agentId: agentId ?? void 0,
+        taskDescription: taskDescription ?? void 0
+      };
+    } catch {
+      return null;
+    }
+  }).filter(
+    (n) => n !== null && !config.hiddenSubAgents.includes(n.hideKey)
+  ).sort((a, b) => b.lastModifiedMs - a.lastModifiedMs);
+}
+function discoverSessions(config) {
+  const projectsDir = getProjectsDir();
+  if (!existsSync3(projectsDir)) {
+    return { sessions: [], totalCount: 0, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  let projectDirs;
+  try {
+    projectDirs = readdirSync(projectsDir).filter((entry) => {
+      try {
+        return statSync(join3(projectsDir, entry)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return { sessions: [], totalCount: 0, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  const allSessions = [];
+  for (const encodedDir of projectDirs) {
+    const projectDir = join3(projectsDir, encodedDir);
+    const decodedPath = decodeProjectPath(encodedDir);
+    const projectName = basename2(decodedPath);
+    let files;
+    try {
+      files = readdirSync(projectDir).filter(
+        (f) => f.endsWith(".jsonl")
+      );
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      const id = file.replace(/\.jsonl$/, "");
+      const hideKey = `${projectName}/${id}`;
+      const filePath = join3(projectDir, file);
+      try {
+        const stat = statSync(filePath);
+        const subAgents = buildSubAgents(id, projectDir, config, projectName);
+        allSessions.push({
+          id,
+          hideKey,
+          filePath,
+          projectPath: decodedPath,
+          projectName,
+          lastModifiedMs: stat.mtimeMs,
+          status: getSessionStatus(stat.mtimeMs),
+          modelName: readModelName(filePath),
+          subAgents
+        });
+      } catch {
+      }
+    }
+  }
+  allSessions.sort((a, b) => {
+    const statusOrder = {
+      hot: 0,
+      warm: 1,
+      cool: 2,
+      cold: 3
+    };
+    const statusDiff = statusOrder[a.status] - statusOrder[b.status];
+    if (statusDiff !== 0) return statusDiff;
+    return b.lastModifiedMs - a.lastModifiedMs;
+  });
+  const visible = allSessions.filter(
+    (s) => !config.hiddenSessions.includes(s.hideKey)
+  );
+  const totalCount = visible.length + visible.reduce((sum, s) => sum + s.subAgents.length, 0);
+  return {
+    sessions: visible,
+    totalCount,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/ui/ActivityViewerPanel.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function getActivityStyle(activity) {
+  if (activity.type === "user") {
+    return { color: "white", dimColor: false };
+  }
+  if (activity.type === "response") {
+    return { color: "green", dimColor: false };
+  }
+  if (activity.type === "thinking") {
+    return { color: "magenta", dimColor: true };
+  }
+  if (activity.type === "tool") {
+    if (activity.label === "Bash") {
+      return { color: "gray", dimColor: false };
+    }
+    return { dimColor: true };
+  }
+  return { dimColor: true };
+}
+function formatActivityTime(date, now) {
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  const time = `${hours}:${minutes}:${seconds}`;
+  const sameDay = date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate();
+  if (sameDay) return time;
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${month}/${day} ${time}`;
+}
+function truncateDetail(detail, maxWidth) {
+  if (getDisplayWidth(detail) <= maxWidth) return detail;
+  let truncated = "";
+  let currentWidth = 0;
+  for (const char of detail) {
+    const charWidth = getDisplayWidth(char);
+    if (currentWidth + charWidth > maxWidth - 3) {
+      truncated += "...";
+      break;
+    }
+    truncated += char;
+    currentWidth += charWidth;
+  }
+  return truncated;
+}
+function ActivityViewerPanel({
+  activities,
+  sessionName,
+  scrollOffset,
+  isLive,
+  newCount,
+  visibleRows,
+  width,
+  cursorLine,
+  hasFocus,
+  spinner = ""
+}) {
+  const innerWidth = getInnerWidth(width);
+  const contentWidth = innerWidth - 1;
+  let titleSuffix;
+  if (isLive) {
+    titleSuffix = `[LIVE ${spinner || "\u25BC"}]`;
+  } else {
+    const badge = newCount > 0 ? ` +${newCount}\u2191` : "";
+    titleSuffix = `[PAUSED \u2193${scrollOffset}${badge}]`;
+  }
+  let visibleActivities;
+  if (activities.length === 0) {
+    visibleActivities = [];
+  } else if (isLive) {
+    visibleActivities = activities.slice(-visibleRows).reverse();
+  } else {
+    const end = Math.max(0, activities.length - scrollOffset);
+    const start = Math.max(0, end - visibleRows);
+    visibleActivities = activities.slice(start, end).reverse();
+  }
+  const now = /* @__PURE__ */ new Date();
+  const lines = [];
+  if (visibleActivities.length === 0) {
+    const emptyText = "No activity yet";
+    const emptyPadding = Math.max(0, contentWidth - emptyText.length - 1);
+    lines.push(
+      /* @__PURE__ */ jsxs(Text, { children: [
+        BOX.v,
+        " ",
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: emptyText }),
+        " ".repeat(emptyPadding),
+        BOX.v
+      ] }, "empty")
+    );
+  } else {
+    const effectiveCursor = Math.min(cursorLine, visibleActivities.length - 1);
+    for (let i = 0; i < visibleActivities.length; i++) {
+      const activity = visibleActivities[i];
+      const style = getActivityStyle(activity);
+      const isCursor = hasFocus && i === effectiveCursor;
+      const time = formatActivityTime(activity.timestamp, now);
+      const timestamp = `[${time}] `;
+      const timestampWidth = timestamp.length;
+      const icon = activity.icon;
+      const iconWidth = getDisplayWidth(icon);
+      const label = activity.label;
+      const detail = activity.detail;
+      const count = activity.count;
+      const countSuffix = count && count > 1 ? ` (\xD7${count})` : "";
+      const countSuffixWidth = countSuffix.length;
+      const prefixWidth = 2 + timestampWidth + iconWidth + 1;
+      const labelPart = detail ? `${label}: ` : label;
+      const labelWidth = labelPart.length;
+      const _availableForDetail = contentWidth - prefixWidth - labelWidth - countSuffixWidth + 1;
+      const detailMaxWidth = width - 2 - timestampWidth - iconWidth - 1 - labelWidth - countSuffixWidth - 1;
+      let labelContent;
+      let _displayWidth;
+      if (detail) {
+        const truncated = truncateDetail(detail, Math.max(0, detailMaxWidth));
+        labelContent = `${labelPart}${truncated}${countSuffix}`;
+        _displayWidth = prefixWidth - 1 + labelWidth + getDisplayWidth(truncated) + countSuffixWidth;
+      } else {
+        labelContent = label + countSuffix;
+        _displayWidth = prefixWidth - 1 + label.length + countSuffixWidth;
+      }
+      const usedWidth = 1 + 1 + timestampWidth + iconWidth + 1 + getDisplayWidth(labelContent) + 1;
+      const padding = Math.max(0, width - usedWidth);
+      lines.push(
+        /* @__PURE__ */ jsxs(Text, { children: [
+          BOX.v,
+          " ",
+          /* @__PURE__ */ jsxs(Text, { backgroundColor: isCursor ? "blue" : void 0, children: [
+            /* @__PURE__ */ jsx(Text, { dimColor: !isCursor, children: timestamp }),
+            /* @__PURE__ */ jsx(Text, { color: "cyan", children: icon }),
+            " ",
+            /* @__PURE__ */ jsx(
+              Text,
+              {
+                color: isCursor ? void 0 : style.color,
+                dimColor: !isCursor && style.dimColor,
+                children: labelContent
+              }
+            ),
+            " ".repeat(padding)
+          ] }),
+          BOX.v
+        ] }, `activity-${i}`)
+      );
+    }
+  }
+  const emptyRow = `${BOX.v}${" ".repeat(contentWidth + 1)}${BOX.v}`;
+  while (lines.length < visibleRows) {
+    lines.push(/* @__PURE__ */ jsx(Text, { children: emptyRow }, `pad-${lines.length}`));
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsx(Text, { color: isLive ? void 0 : "yellow", children: createTitleLine(sessionName, titleSuffix, width) }),
+    lines,
+    /* @__PURE__ */ jsx(Text, { children: createBottomLine(width) })
+  ] });
+}
+
+// src/ui/DetailViewPanel.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function wrapText(text, maxWidth) {
+  if (!text) return ["(empty)"];
+  const words = text.split(" ");
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    if (!current) {
+      current = word;
+    } else if (getDisplayWidth(`${current} ${word}`) <= maxWidth) {
+      current += ` ${word}`;
+    } else {
+      lines.push(current);
+      current = word;
+    }
+  }
+  if (current) lines.push(current);
+  return lines.length > 0 ? lines : ["(empty)"];
+}
+function DetailViewPanel({
+  activity,
+  width,
+  visibleRows,
+  scrollOffset
+}) {
+  const innerWidth = getInnerWidth(width);
+  const contentWidth = innerWidth - 1;
+  const allLines = wrapText(activity.detail, contentWidth);
+  const totalLines = allLines.length;
+  const clampedOffset = Math.min(
+    scrollOffset,
+    Math.max(0, totalLines - visibleRows)
+  );
+  const visibleSlice = allLines.slice(
+    clampedOffset,
+    clampedOffset + visibleRows
+  );
+  const style = getActivityStyle(activity);
+  const scrollSuffix = totalLines > visibleRows ? `[${clampedOffset + 1}-${Math.min(clampedOffset + visibleRows, totalLines)}/${totalLines}]` : "";
+  const iconWidth = getDisplayWidth(activity.icon);
+  const labelWidth = activity.label.length;
+  const scrollPart = scrollSuffix ? ` ${scrollSuffix} ${BOX.h}` : "";
+  const scrollPartWidth = scrollSuffix ? getDisplayWidth(scrollPart) : 0;
+  const dashCount = Math.max(
+    0,
+    width - 3 - iconWidth - 1 - labelWidth - 1 - scrollPartWidth - 1
+  );
+  const dashes = BOX.h.repeat(dashCount);
+  const titleRight = `${dashes}${scrollPart}${BOX.tr}`;
+  const contentRows = [];
+  for (let i = 0; i < visibleRows; i++) {
+    const line = visibleSlice[i] ?? "";
+    const padding = Math.max(0, contentWidth - getDisplayWidth(line));
+    contentRows.push(
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        BOX.v,
+        " ",
+        line,
+        " ".repeat(padding),
+        BOX.v
+      ] }, i)
+    );
+  }
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      BOX.tl,
+      BOX.h,
+      " ",
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: activity.icon }),
+      " ",
+      /* @__PURE__ */ jsx2(Text2, { color: style.color, dimColor: style.dimColor, children: activity.label }),
+      " ",
+      titleRight
+    ] }),
+    contentRows,
+    /* @__PURE__ */ jsx2(Text2, { children: createBottomLine(width) })
+  ] });
+}
+
+// src/ui/hooks/useHotkeys.ts
+function useHotkeys({
+  focus,
+  detailMode,
+  onSwitchFocus,
+  onScrollUp,
+  onScrollDown,
+  onScrollPageUp,
+  onScrollPageDown,
+  onScrollHalfPageUp,
+  onScrollHalfPageDown,
+  onScrollTop,
+  onScrollBottom,
+  onSaveLog,
+  onRefresh,
+  onQuit,
+  onEnter,
+  onHide,
+  onDetailClose,
+  onDetailScrollUp,
+  onDetailScrollDown
+}) {
+  const handleInput = (input, key) => {
+    if (detailMode) {
+      if (key.upArrow || input === "k") {
+        onDetailScrollUp();
+        return;
+      }
+      if (key.downArrow || input === "j") {
+        onDetailScrollDown();
+        return;
+      }
+      if (key.return || key.escape || input === "q") {
+        onDetailClose();
+        return;
+      }
+      return;
+    }
+    if (input === "q") {
+      onQuit();
+      return;
+    }
+    if (key.tab) {
+      onSwitchFocus();
+      return;
+    }
+    if (key.return) {
+      onEnter();
+      return;
+    }
+    if (input === "r") {
+      onRefresh();
+      return;
+    }
+    if (key.pageUp) {
+      onScrollPageUp();
+      return;
+    }
+    if (key.pageDown) {
+      onScrollPageDown();
+      return;
+    }
+    if (key.ctrl) {
+      if (input === "b") {
+        onScrollPageUp();
+        return;
+      }
+      if (input === "f") {
+        onScrollPageDown();
+        return;
+      }
+      if (input === "u") {
+        onScrollHalfPageUp();
+        return;
+      }
+      if (input === "d") {
+        onScrollHalfPageDown();
+        return;
+      }
+    }
+    if (focus === "tree") {
+      if (input === "h") {
+        onHide();
+        return;
+      }
+      if (key.upArrow || input === "k") {
+        onScrollUp();
+        return;
+      }
+      if (key.downArrow || input === "j") {
+        onScrollDown();
+        return;
+      }
+    }
+    if (focus === "viewer") {
+      if (key.upArrow || input === "k") {
+        onScrollUp();
+        return;
+      }
+      if (key.downArrow || input === "j") {
+        onScrollDown();
+        return;
+      }
+      if (input === "g") {
+        onScrollTop();
+        return;
+      }
+      if (input === "G") {
+        onScrollBottom();
+        return;
+      }
+      if (input === "s") {
+        onSaveLog();
+        return;
+      }
+    }
+  };
+  const statusBarItems = detailMode ? ["\u2191\u2193/jk: scroll", "\u21B5/Esc: close"] : focus === "tree" ? [
+    "Tab: viewer",
+    "\u2191\u2193/jk: select",
+    "PgUp/Dn: page",
+    "\u21B5: expand",
+    "h: hide",
+    "r: refresh",
+    "q: quit"
+  ] : [
+    "Tab: sessions",
+    "\u2191\u2193/jk: scroll",
+    "PgUp/Dn: page",
+    "g: top",
+    "G: live",
+    "\u21B5: detail",
+    "q: quit"
+  ];
+  return { handleInput, statusBarItems };
+}
+
+// src/ui/hooks/useSpinner.ts
+import { useEffect, useState } from "react";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function useSpinner(active, intervalMs = 100) {
+  const [index, setIndex] = useState(0);
+  useEffect(() => {
+    if (!active) return;
+    const timer = setInterval(() => {
+      setIndex((i) => (i + 1) % FRAMES.length);
+    }, intervalMs);
+    return () => clearInterval(timer);
+  }, [active, intervalMs]);
+  return active ? FRAMES[index] : "";
+}
+
+// src/ui/SessionTreePanel.tsx
+import { homedir as homedir3 } from "os";
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function formatElapsed(lastModifiedMs) {
+  const elapsed = Date.now() - lastModifiedMs;
+  const seconds = Math.floor(elapsed / 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`;
+  if (seconds > 0) return `${seconds}s`;
+  return "<1s";
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "hot":
+      return "green";
+    case "warm":
+      return "yellow";
+    case "cool":
+      return "cyan";
+    case "cold":
+      return "gray";
+  }
+}
+function formatProjectPath(projectPath) {
+  const home = homedir3();
+  const raw = projectPath.startsWith(home) ? `~${projectPath.slice(home.length)}` : projectPath;
+  return raw;
+}
+function truncatePath(path, maxWidth) {
+  if (getDisplayWidth(path) <= maxWidth) return path;
+  if (maxWidth < 4) return "";
+  return `...${path.slice(-(maxWidth - 3))}`;
+}
+function SessionRow({
+  session,
+  isSelected,
+  hasFocus,
+  prefix,
+  contentWidth
+}) {
+  const isParent = prefix === "";
+  const statusColor = getStatusColor(session.status);
+  const badge = `[${session.status}]`;
+  const elapsed = formatElapsed(session.lastModifiedMs);
+  const model = session.modelName ?? "";
+  const name = isParent ? session.projectName || session.id.slice(0, 8) : session.agentId ?? session.id.slice(0, 8);
+  const shortId = isParent && session.projectName ? ` #${session.id.slice(0, 4)}` : "";
+  const rightParts = [elapsed];
+  if (model) rightParts.push(model);
+  const rightSide = rightParts.join(" ");
+  const leftCore = `${prefix}${name}${shortId} ${badge}`;
+  const leftCoreWidth = getDisplayWidth(leftCore);
+  const rightWidth = getDisplayWidth(rightSide);
+  const middleAvailable = contentWidth - leftCoreWidth - 1 - rightWidth - 1;
+  let middleText = "";
+  if (middleAvailable > 3) {
+    const raw = isParent ? session.projectPath ? formatProjectPath(session.projectPath) : "" : session.taskDescription ?? "";
+    if (raw) {
+      const truncated = truncatePath(raw, middleAvailable);
+      if (truncated) middleText = truncated;
+    }
+  }
+  const middleSection = middleText ? ` ${middleText}` : "";
+  const gapWidth = Math.max(
+    1,
+    contentWidth - leftCoreWidth - getDisplayWidth(middleSection) - rightWidth
+  );
+  const gap = " ".repeat(gapWidth);
+  const fullLine = leftCore + middleSection + gap + rightSide;
+  const linePadding = Math.max(0, contentWidth - getDisplayWidth(fullLine));
+  const highlight = isSelected && hasFocus;
+  return /* @__PURE__ */ jsxs3(Text3, { children: [
+    BOX.v,
+    " ",
+    /* @__PURE__ */ jsxs3(Text3, { backgroundColor: highlight ? "blue" : void 0, bold: highlight, children: [
+      /* @__PURE__ */ jsx3(Text3, { children: prefix }),
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: name }),
+      shortId ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: shortId }) : null,
+      /* @__PURE__ */ jsx3(Text3, { children: " " }),
+      /* @__PURE__ */ jsx3(Text3, { color: statusColor, children: badge }),
+      middleText ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: middleSection }) : null,
+      /* @__PURE__ */ jsx3(Text3, { children: gap }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: elapsed }),
+      model ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: ` ${model}` }) : null
+    ] }),
+    " ".repeat(linePadding),
+    BOX.v
+  ] });
+}
+function appendSessionRows(result, session, expandedIds) {
+  const isExpanded = expandedIds.has(session.id);
+  const hotWarm = session.subAgents.filter(
+    (s) => s.status === "hot" || s.status === "warm"
+  );
+  const cool = session.subAgents.filter((s) => s.status === "cool");
+  const cold = session.subAgents.filter((s) => s.status === "cold");
+  if (isExpanded) {
+    const all = [...hotWarm, ...cool, ...cold];
+    for (let i = 0; i < all.length; i++) {
+      const isLast = i === all.length - 1;
+      result.push({
+        kind: "session",
+        session: all[i],
+        prefix: `${isLast ? "\u2514\u2500 " : "\u251C\u2500 "}\xBB `
+      });
+    }
+  } else {
+    const hasSummary = cool.length > 0 || cold.length > 0;
+    for (let i = 0; i < hotWarm.length; i++) {
+      const isLast = i === hotWarm.length - 1 && !hasSummary;
+      result.push({
+        kind: "session",
+        session: hotWarm[i],
+        prefix: `${isLast ? "\u2514\u2500 " : "\u251C\u2500 "}\xBB `
+      });
+    }
+    if (hasSummary) {
+      result.push({
+        kind: "subagent-summary",
+        parentId: session.id,
+        coolCount: cool.length,
+        coldCount: cold.length
+      });
+    }
+  }
+}
+function flattenSessions(sessions, expandedIds) {
+  const result = [];
+  const visibleSessions = sessions.filter((s) => s.status !== "cold");
+  const coldSessions = sessions.filter((s) => s.status === "cold");
+  for (const session of visibleSessions) {
+    result.push({ kind: "session", session, prefix: "" });
+    appendSessionRows(result, session, expandedIds);
+  }
+  if (coldSessions.length > 0) {
+    result.push({ kind: "cold-sessions-summary", count: coldSessions.length });
+    if (expandedIds.has("__cold__")) {
+      for (const session of coldSessions) {
+        result.push({ kind: "session", session, prefix: "" });
+        appendSessionRows(result, session, expandedIds);
+      }
+    }
+  }
+  return result;
+}
+function SubagentSummaryRow({
+  coolCount,
+  coldCount,
+  contentWidth,
+  isSelected,
+  hasFocus
+}) {
+  const parts = [];
+  if (coolCount > 0) parts.push(`${coolCount} cool`);
+  if (coldCount > 0) parts.push(`${coldCount} cold`);
+  const hint = " +";
+  const text = `\u2514\u2500 ... ${parts.join("  ")}`;
+  const padding = Math.max(
+    0,
+    contentWidth - getDisplayWidth(text) - getDisplayWidth(hint)
+  );
+  const active = isSelected && hasFocus;
+  return /* @__PURE__ */ jsxs3(Text3, { children: [
+    BOX.v,
+    " ",
+    /* @__PURE__ */ jsxs3(Text3, { dimColor: !active, inverse: active, children: [
+      text,
+      " ".repeat(padding),
+      hint
+    ] }),
+    BOX.v
+  ] });
+}
+function ColdSessionsSummaryRow({
+  count,
+  isSelected,
+  hasFocus,
+  width
+}) {
+  const innerWidth = getInnerWidth(width);
+  const label = ` ${count} cold `;
+  const hint = isSelected && hasFocus ? " + " : "";
+  const hintWidth = getDisplayWidth(hint);
+  const labelWidth = getDisplayWidth(label);
+  const dashCount = Math.max(0, innerWidth - 1 - labelWidth - hintWidth);
+  const dashes = BOX.h.repeat(dashCount);
+  const line = `${BOX.ml}${BOX.h}${label}${dashes}${hint}${BOX.mr}`;
+  const highlight = isSelected && hasFocus;
+  return /* @__PURE__ */ jsx3(
+    Text3,
+    {
+      backgroundColor: highlight ? "blue" : void 0,
+      bold: highlight,
+      dimColor: !highlight,
+      children: line
+    }
+  );
+}
+function SessionTreePanel({
+  sessions,
+  selectedId,
+  hasFocus,
+  width = DEFAULT_PANEL_WIDTH,
+  maxRows,
+  expandedIds = /* @__PURE__ */ new Set()
+}) {
+  const innerWidth = getInnerWidth(width);
+  const contentWidth = innerWidth - 1;
+  const titleLine = createTitleLine("Sessions", "", width);
+  const bottomLine = createBottomLine(width);
+  if (sessions.length === 0) {
+    const emptyText = "No Claude sessions";
+    const emptyPadding = Math.max(0, contentWidth - emptyText.length);
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width, children: [
+      /* @__PURE__ */ jsx3(Text3, { children: titleLine }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        BOX.v,
+        " ",
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: emptyText }),
+        " ".repeat(emptyPadding),
+        BOX.v
+      ] }),
+      /* @__PURE__ */ jsx3(Text3, { children: bottomLine })
+    ] });
+  }
+  const flatRows = flattenSessions(sessions, expandedIds);
+  const totalRows = flatRows.length;
+  const selectedFlatIndex = flatRows.findIndex((row) => {
+    if (row.kind === "session") return row.session.id === selectedId;
+    if (row.kind === "subagent-summary")
+      return selectedId === `__sub-${row.parentId}__`;
+    if (row.kind === "cold-sessions-summary") return selectedId === "__cold__";
+    return false;
+  });
+  const needsOverflow = maxRows !== void 0 && totalRows > maxRows;
+  const visibleCount = needsOverflow ? maxRows - 1 : totalRows;
+  let scrollTop = 0;
+  if (needsOverflow && selectedFlatIndex >= 0) {
+    scrollTop = Math.max(0, selectedFlatIndex - visibleCount + 1);
+    scrollTop = Math.min(scrollTop, Math.max(0, totalRows - visibleCount));
+  }
+  const displayRows = flatRows.slice(scrollTop, scrollTop + visibleCount);
+  const hiddenBelow = totalRows - (scrollTop + displayRows.length);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsx3(Text3, { children: titleLine }),
+    displayRows.map(
+      (row, idx) => row.kind === "session" ? /* @__PURE__ */ jsx3(
+        SessionRow,
+        {
+          session: row.session,
+          isSelected: row.session.id === selectedId,
+          hasFocus,
+          prefix: row.prefix,
+          contentWidth
+        },
+        `${row.session.id}-${idx}`
+      ) : row.kind === "subagent-summary" ? /* @__PURE__ */ jsx3(
+        SubagentSummaryRow,
+        {
+          coolCount: row.coolCount,
+          coldCount: row.coldCount,
+          contentWidth,
+          isSelected: selectedId === `__sub-${row.parentId}__`,
+          hasFocus
+        },
+        `subagent-summary-${idx}`
+      ) : /* @__PURE__ */ jsx3(
+        ColdSessionsSummaryRow,
+        {
+          count: row.count,
+          isSelected: selectedId === "__cold__",
+          hasFocus,
+          width
+        },
+        "cold-summary"
+      )
+    ),
+    hiddenBelow > 0 && /* @__PURE__ */ jsxs3(Text3, { children: [
+      BOX.v,
+      " ",
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: `... ${hiddenBelow} more` }),
+      " ".repeat(
+        Math.max(0, contentWidth - `... ${hiddenBelow} more`.length - 1)
+      ),
+      BOX.v
+    ] }),
+    /* @__PURE__ */ jsx3(Text3, { children: bottomLine })
+  ] });
+}
+
+// src/ui/App.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var VIEWER_HEIGHT_FRACTION = 0.55;
+function subSummarySentinel(parentId) {
+  return {
+    id: `__sub-${parentId}__`,
+    filePath: "",
+    projectPath: "",
+    projectName: "",
+    lastModifiedMs: 0,
+    status: "cold",
+    modelName: null,
+    subAgents: []
+  };
+}
+function appendSubAgentRows(result, session, expandedIds) {
+  if (expandedIds.has(session.id)) {
+    result.push(...session.subAgents);
+  } else {
+    result.push(
+      ...session.subAgents.filter(
+        (sub) => sub.status === "hot" || sub.status === "warm"
+      )
+    );
+    if (session.subAgents.some(
+      (sub) => sub.status === "cool" || sub.status === "cold"
+    )) {
+      result.push(subSummarySentinel(session.id));
+    }
+  }
+}
+function flattenSessions2(tree, expandedIds) {
+  const result = [];
+  const visible = tree.sessions.filter((s) => s.status !== "cold");
+  const cold = tree.sessions.filter((s) => s.status === "cold");
+  for (const s of visible) {
+    result.push(s);
+    appendSubAgentRows(result, s, expandedIds);
+  }
+  if (cold.length > 0) {
+    result.push({
+      id: "__cold__",
+      filePath: "",
+      projectPath: "",
+      projectName: `${cold.length} cold`,
+      lastModifiedMs: 0,
+      status: "cold",
+      modelName: null,
+      subAgents: []
+    });
+    if (expandedIds.has("__cold__")) {
+      for (const s of cold) {
+        result.push(s);
+        appendSubAgentRows(result, s, expandedIds);
+      }
+    }
+  }
+  return result;
+}
+function getSelectedActivity(acts, live, scrollOff, rows, cursorLine) {
+  if (acts.length === 0) return null;
+  let visible;
+  if (live) {
+    visible = acts.slice(-rows).reverse();
+  } else {
+    const end = Math.max(0, acts.length - scrollOff);
+    const start = Math.max(0, end - rows);
+    visible = acts.slice(start, end).reverse();
+  }
+  const effectiveCursor = Math.min(cursorLine, visible.length - 1);
+  return visible[effectiveCursor] ?? null;
+}
+function App({ mode }) {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const isWatchMode = mode === "watch";
+  const config = useMemo(() => loadGlobalConfig(), []);
+  const migrationWarning = useMemo(() => hasProjectLevelConfig(), []);
+  const [sessionTree, setSessionTree] = useState2(
+    () => discoverSessions(config)
+  );
+  const [selectedId, setSelectedId] = useState2(() => {
+    const first = sessionTree.sessions[0];
+    return first?.id ?? null;
+  });
+  const [focus, setFocus] = useState2("tree");
+  const [scrollOffset, setScrollOffset] = useState2(0);
+  const [isLive, setIsLive] = useState2(true);
+  const [activities, setActivities] = useState2([]);
+  const [newCount, setNewCount] = useState2(0);
+  const [expandedIds, setExpandedIds] = useState2(/* @__PURE__ */ new Set());
+  const [viewerCursorLine, setViewerCursorLine] = useState2(0);
+  const [detailMode, setDetailMode] = useState2(false);
+  const [detailActivity, setDetailActivity] = useState2(
+    null
+  );
+  const [detailScrollOffset, setDetailScrollOffset] = useState2(0);
+  const allFlat = useMemo(
+    () => flattenSessions2(sessionTree, expandedIds),
+    [sessionTree, expandedIds]
+  );
+  const allFlatRef = useRef(allFlat);
+  useEffect2(() => {
+    allFlatRef.current = allFlat;
+  }, [allFlat]);
+  const activitiesLengthRef = useRef(0);
+  useEffect2(() => {
+    activitiesLengthRef.current = activities.length;
+  }, [activities.length]);
+  useEffect2(() => {
+    const node = allFlatRef.current.find((s) => s.id === selectedId);
+    if (node?.filePath) {
+      setActivities(parseSessionHistory(node.filePath));
+      setScrollOffset(0);
+      setIsLive(true);
+      setNewCount(0);
+      setViewerCursorLine(0);
+    } else {
+      setActivities([]);
+    }
+  }, [selectedId]);
+  const refresh = useCallback(() => {
+    const freshConfig = loadGlobalConfig();
+    const tree = discoverSessions(freshConfig);
+    setSessionTree(tree);
+    const updatedFlat = flattenSessions2(tree, expandedIds);
+    const node = updatedFlat.find((s) => s.id === selectedId);
+    if (!node || !node.filePath) return;
+    const newActivities = parseSessionHistory(node.filePath);
+    const delta = newActivities.length - activitiesLengthRef.current;
+    setActivities(newActivities);
+    if (!isLive && delta > 0) {
+      setScrollOffset((o) => o + delta);
+      setNewCount((n) => n + delta);
+    }
+  }, [selectedId, isLive, expandedIds]);
+  const refreshRef = useRef(refresh);
+  useEffect2(() => {
+    refreshRef.current = refresh;
+  }, [refresh]);
+  useEffect2(() => {
+    if (!isWatchMode) return;
+    const projectsDir = getProjectsDir();
+    const usePolling = process.platform === "linux" || !existsSync4(projectsDir);
+    if (usePolling) {
+      const timer = setInterval(
+        () => refreshRef.current(),
+        config.refreshIntervalMs
+      );
+      return () => clearInterval(timer);
+    }
+    let debounce = null;
+    let watcher = null;
+    try {
+      watcher = watch(projectsDir, { recursive: true }, () => {
+        if (debounce) clearTimeout(debounce);
+        debounce = setTimeout(() => refreshRef.current(), 150);
+      });
+    } catch {
+      const timer = setInterval(
+        () => refreshRef.current(),
+        config.refreshIntervalMs
+      );
+      return () => clearInterval(timer);
+    }
+    return () => {
+      watcher?.close();
+      if (debounce) clearTimeout(debounce);
+    };
+  }, [isWatchMode, config.refreshIntervalMs]);
+  const selectedIndex = allFlat.findIndex((s) => s.id === selectedId);
+  const height = (stdout?.rows ?? 41) - 1;
+  const width = stdout?.columns ?? 80;
+  const viewerRows = Math.max(
+    5,
+    Math.floor(height * VIEWER_HEIGHT_FRACTION) - 4
+  );
+  const treeRows = Math.max(3, height - viewerRows - 7);
+  const saveLog = useCallback(() => {
+    if (!activities.length || !selectedId) return;
+    ensureLogDir(config.logDir);
+    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const filePath = join4(
+      config.logDir,
+      `${date}-${selectedId.slice(0, 8)}.txt`
+    );
+    const lines = activities.map(
+      (a) => `[${a.timestamp.toISOString()}] ${a.icon} ${a.label} ${a.detail}`
+    );
+    try {
+      writeFileSync2(filePath, `${lines.join("\n")}
+`, "utf-8");
+    } catch {
+    }
+  }, [activities, selectedId, config.logDir]);
+  const spinner = useSpinner(isWatchMode);
+  const { handleInput, statusBarItems } = useHotkeys({
+    focus,
+    detailMode,
+    onSwitchFocus: () => setFocus((f) => f === "tree" ? "viewer" : "tree"),
+    onScrollUp: () => {
+      if (focus === "tree") {
+        const prev = Math.max(0, selectedIndex - 1);
+        setSelectedId(allFlat[prev]?.id ?? selectedId);
+      } else {
+        if (viewerCursorLine > 0) {
+          setViewerCursorLine((c) => c - 1);
+        } else {
+          setScrollOffset((o) => {
+            const newOffset = Math.max(0, o - 1);
+            if (newOffset === 0) {
+              setIsLive(true);
+              setNewCount(0);
+            }
+            return newOffset;
+          });
+        }
+      }
+    },
+    onScrollDown: () => {
+      if (focus === "tree") {
+        const next = Math.min(allFlat.length - 1, selectedIndex + 1);
+        setSelectedId(allFlat[next]?.id ?? selectedId);
+      } else {
+        if (viewerCursorLine < viewerRows - 1) {
+          setViewerCursorLine((c) => c + 1);
+        } else {
+          setIsLive(false);
+          setScrollOffset(
+            (o) => Math.min(o + 1, Math.max(0, activities.length - viewerRows))
+          );
+        }
+      }
+    },
+    onScrollPageUp: () => {
+      if (focus === "tree") {
+        const prev = Math.max(0, selectedIndex - 5);
+        setSelectedId(allFlat[prev]?.id ?? selectedId);
+      } else {
+        setViewerCursorLine(0);
+        setScrollOffset((o) => {
+          const newOffset = Math.max(0, o - viewerRows);
+          if (newOffset === 0) {
+            setIsLive(true);
+            setNewCount(0);
+          }
+          return newOffset;
+        });
+      }
+    },
+    onScrollPageDown: () => {
+      if (focus === "tree") {
+        const next = Math.min(allFlat.length - 1, selectedIndex + 5);
+        setSelectedId(allFlat[next]?.id ?? selectedId);
+      } else {
+        setViewerCursorLine(0);
+        setIsLive(false);
+        setScrollOffset(
+          (o) => Math.min(o + viewerRows, Math.max(0, activities.length - viewerRows))
+        );
+      }
+    },
+    onScrollHalfPageUp: () => {
+      if (focus === "tree") {
+        const prev = Math.max(0, selectedIndex - Math.ceil(5 / 2));
+        setSelectedId(allFlat[prev]?.id ?? selectedId);
+      } else {
+        setViewerCursorLine(0);
+        setScrollOffset((o) => {
+          const newOffset = Math.max(0, o - Math.floor(viewerRows / 2));
+          if (newOffset === 0) {
+            setIsLive(true);
+            setNewCount(0);
+          }
+          return newOffset;
+        });
+      }
+    },
+    onScrollHalfPageDown: () => {
+      if (focus === "tree") {
+        const next = Math.min(
+          allFlat.length - 1,
+          selectedIndex + Math.ceil(5 / 2)
+        );
+        setSelectedId(allFlat[next]?.id ?? selectedId);
+      } else {
+        setViewerCursorLine(0);
+        setIsLive(false);
+        setScrollOffset(
+          (o) => Math.min(
+            o + Math.floor(viewerRows / 2),
+            Math.max(0, activities.length - viewerRows)
+          )
+        );
+      }
+    },
+    onScrollTop: () => {
+      setViewerCursorLine(0);
+      setIsLive(false);
+      setScrollOffset(Math.max(0, activities.length - viewerRows));
+    },
+    onScrollBottom: () => {
+      setViewerCursorLine(0);
+      setIsLive(true);
+      setScrollOffset(0);
+      setNewCount(0);
+    },
+    onDetailClose: () => {
+      setDetailMode(false);
+    },
+    onDetailScrollUp: () => {
+      setDetailScrollOffset((o) => Math.max(0, o - 1));
+    },
+    onDetailScrollDown: () => {
+      setDetailScrollOffset((o) => o + 1);
+    },
+    onEnter: () => {
+      if (focus === "viewer") {
+        const act = getSelectedActivity(
+          activities,
+          isLive,
+          scrollOffset,
+          viewerRows,
+          viewerCursorLine
+        );
+        if (act) {
+          setDetailActivity(act);
+          setDetailMode(true);
+          setDetailScrollOffset(0);
+        }
+        return;
+      }
+      if (focus !== "tree" || !selectedId) return;
+      if (selectedId === "__cold__") {
+        setExpandedIds((prev) => {
+          const next = new Set(prev);
+          if (next.has("__cold__")) {
+            next.delete("__cold__");
+          } else {
+            next.add("__cold__");
+          }
+          return next;
+        });
+        return;
+      }
+      if (selectedId.startsWith("__sub-") && selectedId.endsWith("__")) {
+        const parentId = selectedId.slice(6, -2);
+        setExpandedIds((prev) => {
+          const next = new Set(prev);
+          if (next.has(parentId)) {
+            next.delete(parentId);
+          } else {
+            next.add(parentId);
+          }
+          return next;
+        });
+        return;
+      }
+      const parentSession = sessionTree.sessions.find(
+        (s) => s.id === selectedId
+      );
+      if (!parentSession || !parentSession.subAgents.some(
+        (s) => s.status === "cool" || s.status === "cold"
+      ))
+        return;
+      setExpandedIds((prev) => {
+        const next = new Set(prev);
+        if (next.has(selectedId)) {
+          next.delete(selectedId);
+        } else {
+          next.add(selectedId);
+        }
+        return next;
+      });
+    },
+    onHide: () => {
+      if (focus !== "tree" || !selectedId) return;
+      if (selectedId === "__cold__") {
+        const coldSessions = sessionTree.sessions.filter(
+          (s) => s.status === "cold"
+        );
+        for (const s of coldSessions) hideSession(s.hideKey);
+        const nextId = allFlat[selectedIndex - 1]?.id ?? null;
+        refresh();
+        setSelectedId(nextId);
+        return;
+      }
+      const selectedSession2 = sessionTree.sessions.find(
+        (s) => s.id === selectedId
+      );
+      if (selectedSession2) {
+        hideSession(selectedSession2.hideKey);
+        const nextId = allFlat[selectedIndex + 1]?.id ?? allFlat[selectedIndex - 1]?.id ?? null;
+        refresh();
+        setSelectedId(nextId);
+        return;
+      }
+      for (const s of sessionTree.sessions) {
+        const selectedSubAgent = s.subAgents.find((sa) => sa.id === selectedId);
+        if (selectedSubAgent) {
+          hideSubAgent(selectedSubAgent.hideKey);
+          const nextId = allFlat[selectedIndex + 1]?.id ?? allFlat[selectedIndex - 1]?.id ?? null;
+          refresh();
+          setSelectedId(nextId);
+          return;
+        }
+      }
+    },
+    onSaveLog: saveLog,
+    onRefresh: refresh,
+    onQuit: exit
+  });
+  useInput((input, key) => handleInput(input, key), { isActive: isWatchMode });
+  const selectedSession = allFlat.find((s) => s.id === selectedId);
+  const isPlaceholderSelected = !selectedSession || selectedId === "__cold__" || !!selectedId && selectedId.startsWith("__sub-") && selectedId.endsWith("__");
+  const sessionDisplayName = isPlaceholderSelected ? "No session selected" : selectedSession.projectPath ? selectedSession.projectName || selectedSession.id.slice(0, 8) : selectedSession.agentId ?? selectedSession.id.slice(0, 8);
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    migrationWarning && /* @__PURE__ */ jsx4(Box4, { marginBottom: 1, children: /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: "Config moved to ~/.agenthud/config.yaml" }) }),
+    isWatchMode && /* @__PURE__ */ jsxs4(Box4, { marginBottom: 1, justifyContent: "space-between", width, children: [
+      /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        spinner,
+        " AgentHUD v",
+        getVersion()
+      ] }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: statusBarItems.join(" \xB7 ") })
+    ] }),
+    /* @__PURE__ */ jsx4(
+      SessionTreePanel,
+      {
+        sessions: sessionTree.sessions,
+        selectedId,
+        hasFocus: focus === "tree",
+        width,
+        maxRows: treeRows,
+        expandedIds
+      }
+    ),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: detailMode && detailActivity ? /* @__PURE__ */ jsx4(
+      DetailViewPanel,
+      {
+        activity: detailActivity,
+        sessionName: sessionDisplayName,
+        scrollOffset: detailScrollOffset,
+        visibleRows: viewerRows,
+        width
+      }
+    ) : /* @__PURE__ */ jsx4(
+      ActivityViewerPanel,
+      {
+        activities,
+        sessionName: sessionDisplayName,
+        scrollOffset,
+        isLive,
+        newCount,
+        visibleRows: viewerRows,
+        width,
+        cursorLine: viewerCursorLine,
+        hasFocus: focus === "viewer",
+        spinner
+      }
+    ) })
+  ] });
+}
+
+// src/main.ts
+var options = parseArgs(process.argv.slice(2));
+if (options.command === "help") {
+  console.log(getHelp());
+  process.exit(0);
+}
+if (options.command === "version") {
+  console.log(getVersion());
+  process.exit(0);
+}
+var legacyConfig = join5(process.cwd(), ".agenthud", "config.yaml");
+if (existsSync5(legacyConfig)) {
+  console.log(
+    "The project-level config file (.agenthud/config.yaml) is no longer supported."
+  );
+  console.log("Settings have moved to ~/.agenthud/config.yaml.");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  await new Promise((resolve) => {
+    rl.question(
+      "Delete the old config file and continue? [y/N] ",
+      (answer) => {
+        rl.close();
+        if (answer.trim().toLowerCase() === "y") {
+          rmSync(legacyConfig);
+          console.log("Deleted .agenthud/config.yaml.");
+        } else {
+          console.log("Aborted.");
+          process.exit(0);
+        }
+        resolve();
+      }
+    );
+  });
+}
+if (options.mode === "watch") {
+  clearScreen();
+}
+render(React.createElement(App, { mode: options.mode }));