agenthud 0.7.4 → 0.8.0

package/dist/main-WFRLKQ72.js

@@ -1,4189 +0,0 @@
-// src/main.ts
-import { existsSync as existsSync9 } from "fs";
-import { render } from "ink";
-import React2 from "react";
-
-// src/cli.ts
-import { readFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-function getHelp() {
-  return `Usage: agenthud [command] [options]
-
-Commands:
-  init              Initialize agenthud in current directory
-
-Options:
-  -w, --watch       Watch mode (default)
-  --once            Run once and exit
-  -V, --version     Show version number
-  -h, --help        Show this help message
-`;
-}
-function getVersion() {
-  const __dirname3 = dirname(fileURLToPath(import.meta.url));
-  const packageJson = JSON.parse(
-    readFileSync(join(__dirname3, "..", "package.json"), "utf-8")
-  );
-  return packageJson.version;
-}
-function clearScreen() {
-  console.clear();
-}
-function parseArgs(args) {
-  const hasOnce = args.includes("--once");
-  const hasVersion = args.includes("--version") || args.includes("-V");
-  const hasHelp = args.includes("--help") || args.includes("-h");
-  if (hasHelp) {
-    return { mode: "watch", command: "help" };
-  }
-  if (hasVersion) {
-    return { mode: "watch", command: "version" };
-  }
-  const command = args[0] === "init" ? "init" : void 0;
-  if (hasOnce) {
-    return { mode: "once", command };
-  }
-  return { mode: "watch", command };
-}
-
-// src/commands/init.ts
-import {
-  appendFileSync,
-  existsSync as existsSync2,
-  mkdirSync,
-  readFileSync as readFileSync3,
-  writeFileSync
-} from "fs";
-import { homedir } from "os";
-import { dirname as dirname2, join as join2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
-// src/data/detectTestFramework.ts
-import { existsSync, readFileSync as readFileSync2 } from "fs";
-var TEST_RESULTS_FILE = ".agenthud/test-results.xml";
-var FRAMEWORK_COMMANDS = {
-  vitest: `npx vitest run --reporter=junit --outputFile=${TEST_RESULTS_FILE}`,
-  jest: `JEST_JUNIT_OUTPUT_FILE=${TEST_RESULTS_FILE} npx jest --reporters=jest-junit`,
-  mocha: `npx mocha --reporter mocha-junit-reporter --reporter-options mochaFile=${TEST_RESULTS_FILE}`,
-  pytest: `uv run pytest --junitxml=${TEST_RESULTS_FILE}`
-};
-var JS_FRAMEWORKS = ["vitest", "jest", "mocha"];
-function detectTestFramework() {
-  const jsFramework = detectJsFramework();
-  if (jsFramework) {
-    return jsFramework;
-  }
-  const pythonFramework = detectPythonFramework();
-  if (pythonFramework) {
-    return pythonFramework;
-  }
-  return null;
-}
-function detectJsFramework() {
-  if (!existsSync("package.json")) {
-    return null;
-  }
-  let packageJson;
-  try {
-    const content = readFileSync2("package.json", "utf-8");
-    packageJson = JSON.parse(content);
-  } catch {
-    return null;
-  }
-  const allDeps = {
-    ...packageJson.dependencies,
-    ...packageJson.devDependencies
-  };
-  for (const framework of JS_FRAMEWORKS) {
-    if (allDeps[framework]) {
-      return {
-        framework,
-        command: FRAMEWORK_COMMANDS[framework]
-      };
-    }
-  }
-  return null;
-}
-function detectPythonFramework() {
-  const pytestIndicators = ["pytest.ini", "conftest.py"];
-  for (const file of pytestIndicators) {
-    if (existsSync(file)) {
-      return {
-        framework: "pytest",
-        command: FRAMEWORK_COMMANDS.pytest
-      };
-    }
-  }
-  if (existsSync("pyproject.toml")) {
-    try {
-      const content = readFileSync2("pyproject.toml", "utf-8");
-      if (content.includes("[tool.pytest") || content.includes("[tool.pytest.ini_options]")) {
-        return {
-          framework: "pytest",
-          command: FRAMEWORK_COMMANDS.pytest
-        };
-      }
-    } catch {
-    }
-  }
-  const requirementsFiles = ["requirements.txt", "requirements-dev.txt"];
-  for (const file of requirementsFiles) {
-    if (existsSync(file)) {
-      try {
-        const content = readFileSync2(file, "utf-8");
-        if (content.includes("pytest")) {
-          return {
-            framework: "pytest",
-            command: FRAMEWORK_COMMANDS.pytest
-          };
-        }
-      } catch {
-      }
-    }
-  }
-  return null;
-}
-
-// src/commands/init.ts
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname2(__filename2);
-function getDefaultConfig() {
-  let templatePath = join2(__dirname2, "templates", "config.yaml");
-  if (!existsSync2(templatePath)) {
-    templatePath = join2(__dirname2, "..", "templates", "config.yaml");
-  }
-  return readFileSync3(templatePath, "utf-8");
-}
-function getClaudeSessionPath(projectPath) {
-  const encoded = projectPath.replace(/[/\\]/g, "-");
-  return join2(homedir(), ".claude", "projects", encoded);
-}
-function runInit(cwd = process.cwd()) {
-  const result = {
-    created: [],
-    skipped: [],
-    warnings: []
-  };
-  if (!existsSync2(".agenthud")) {
-    mkdirSync(".agenthud", { recursive: true });
-    result.created.push(".agenthud/");
-  } else {
-    result.skipped.push(".agenthud/");
-  }
-  if (!existsSync2(".agenthud/tests")) {
-    mkdirSync(".agenthud/tests", { recursive: true });
-    result.created.push(".agenthud/tests/");
-  } else {
-    result.skipped.push(".agenthud/tests/");
-  }
-  const testFramework = detectTestFramework();
-  if (testFramework) {
-    result.detectedTestFramework = testFramework.framework;
-  }
-  if (!existsSync2(".agenthud/config.yaml")) {
-    let configContent = getDefaultConfig();
-    if (testFramework) {
-      configContent = configContent.replace(
-        /command: npx vitest run --reporter=json/,
-        `command: ${testFramework.command}`
-      );
-    } else {
-      configContent = configContent.replace(
-        /command: npx vitest run --reporter=json/,
-        "# command: (auto-detect failed - configure manually)"
-      );
-    }
-    writeFileSync(".agenthud/config.yaml", configContent);
-    result.created.push(".agenthud/config.yaml");
-  } else {
-    result.skipped.push(".agenthud/config.yaml");
-  }
-  if (existsSync2(".git")) {
-    if (!existsSync2(".gitignore")) {
-      writeFileSync(".gitignore", ".agenthud/\n");
-      result.created.push(".gitignore");
-    } else {
-      const content = readFileSync3(".gitignore", "utf-8");
-      if (!content.includes(".agenthud/")) {
-        appendFileSync(".gitignore", "\n.agenthud/\n");
-        result.created.push(".gitignore");
-      } else {
-        result.skipped.push(".gitignore");
-      }
-    }
-  }
-  if (!existsSync2(".git")) {
-    result.warnings.push(
-      "Not a git repository - Git panel will show limited info"
-    );
-  }
-  const claudeSessionPath = getClaudeSessionPath(cwd);
-  if (!existsSync2(claudeSessionPath)) {
-    result.warnings.push(
-      "No Claude session found - start Claude to see activity"
-    );
-  }
-  return result;
-}
-
-// src/data/sessionAvailability.ts
-import { existsSync as existsSync5, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { homedir as homedir4 } from "os";
-import { basename as basename3, join as join5 } from "path";
-
-// src/data/claude.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync4, statSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { basename, join as join3 } from "path";
-
-// src/types/index.ts
-var ICONS = {
-  // Activity types
-  User: ">",
-  Response: "<",
-  // Tools
-  Edit: "~",
-  Write: "~",
-  Read: "\u25CB",
-  Bash: "$",
-  Glob: "*",
-  Grep: "*",
-  WebFetch: "@",
-  WebSearch: "@",
-  Task: "\xBB",
-  TodoWrite: "~",
-  AskUserQuestion: "?",
-  // Fallback
-  Default: "$"
-};
-
-// src/ui/constants.ts
-import stringWidth from "string-width";
-var THIRTY_SECONDS_MS = 30 * 1e3;
-var FIVE_MINUTES_MS = 5 * 60 * 1e3;
-var DEFAULT_PANEL_WIDTH = 70;
-var MIN_TERMINAL_WIDTH = 50;
-var MAX_TERMINAL_WIDTH = 120;
-var DEFAULT_FALLBACK_WIDTH = 80;
-var CONTENT_WIDTH = DEFAULT_PANEL_WIDTH - 4;
-var INNER_WIDTH = DEFAULT_PANEL_WIDTH - 2;
-function getContentWidth(panelWidth) {
-  return panelWidth - 4;
-}
-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;
-}
-function createSeparatorLine(title, panelWidth = DEFAULT_PANEL_WIDTH) {
-  const leftPart = `${BOX.h} ${title} `;
-  const leftWidth = leftPart.length;
-  const dashCount = panelWidth - 1 - leftWidth - 1;
-  const dashes = BOX.h.repeat(Math.max(0, dashCount));
-  return BOX.ml + leftPart + dashes + BOX.mr;
-}
-function padLine(content, panelWidth = DEFAULT_PANEL_WIDTH) {
-  const innerWidth = getInnerWidth(panelWidth);
-  const padding = innerWidth - content.length;
-  return content + " ".repeat(Math.max(0, padding));
-}
-var SEPARATOR = "\u2500".repeat(CONTENT_WIDTH);
-function truncate(text, maxLength) {
-  if (text.length <= maxLength) return text;
-  return `${text.slice(0, maxLength - 3)}...`;
-}
-var getDisplayWidth = stringWidth;
-
-// src/data/claude.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}$/, "");
-}
-var MAX_LINES_TO_SCAN = 200;
-var DEFAULT_MAX_ACTIVITIES = 10;
-function encodeProjectPath(projectPath) {
-  return projectPath.replace(/[/\\:]/g, "-");
-}
-function getClaudeSessionPath2(projectPath) {
-  return join3(homedir2(), ".claude", "projects", encodeProjectPath(projectPath));
-}
-function findActiveSession(sessionDir, sessionTimeout) {
-  if (!existsSync3(sessionDir)) {
-    return null;
-  }
-  const files = readdirSync(sessionDir);
-  const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
-  if (jsonlFiles.length === 0) {
-    return null;
-  }
-  let latestFile = null;
-  let latestMtime = 0;
-  let latestSize = 0;
-  for (const file of jsonlFiles) {
-    const filePath = join3(sessionDir, file);
-    const stat = statSync(filePath);
-    if (stat.mtimeMs > latestMtime || stat.mtimeMs === latestMtime && stat.size > latestSize) {
-      latestMtime = stat.mtimeMs;
-      latestSize = stat.size;
-      latestFile = file;
-    }
-  }
-  const cutoff = Date.now() - sessionTimeout;
-  if (latestMtime > cutoff && latestFile) {
-    return join3(sessionDir, latestFile);
-  }
-  return null;
-}
-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 "";
-}
-var MAX_SUB_ACTIVITIES = 3;
-function getSubagentFiles(sessionFile) {
-  const subagentsDir = join3(sessionFile.replace(/\.jsonl$/, ""), "subagents");
-  if (!existsSync3(subagentsDir)) {
-    return [];
-  }
-  try {
-    const files = readdirSync(subagentsDir).filter(
-      (f) => f.endsWith(".jsonl")
-    );
-    const fileInfos = files.map((file) => {
-      const filePath = join3(subagentsDir, file);
-      const stat = statSync(filePath);
-      return { filePath, mtimeMs: stat.mtimeMs };
-    });
-    fileInfos.sort((a, b) => b.mtimeMs - a.mtimeMs);
-    return fileInfos;
-  } catch {
-    return [];
-  }
-}
-function parseSubagentFile(filePath) {
-  try {
-    const content = readFileSync4(filePath, "utf-8");
-    const lines = content.trim().split("\n").filter(Boolean);
-    const allActivities = [];
-    for (const line of lines) {
-      try {
-        const entry = JSON.parse(line);
-        if (entry.type === "assistant" && entry.message?.content) {
-          const messageContent = entry.message.content;
-          if (Array.isArray(messageContent)) {
-            for (const block of messageContent) {
-              if (block.type === "tool_use" && block.name) {
-                const toolName = block.name;
-                if (toolName === "TodoWrite") continue;
-                const icon = ICONS[toolName] || ICONS.Default;
-                const detail = getToolDetail(toolName, block.input);
-                const timestamp = entry.timestamp ? new Date(entry.timestamp) : /* @__PURE__ */ new Date();
-                allActivities.push({
-                  timestamp,
-                  type: "tool",
-                  icon,
-                  label: toolName,
-                  detail
-                });
-              }
-            }
-          }
-        }
-      } catch {
-      }
-    }
-    allActivities.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
-    return {
-      activities: allActivities.slice(0, MAX_SUB_ACTIVITIES),
-      totalCount: allActivities.length
-    };
-  } catch {
-    return { activities: [], totalCount: 0 };
-  }
-}
-function parseSessionState(sessionFile, maxActivities = DEFAULT_MAX_ACTIVITIES) {
-  const defaultState = {
-    status: "none",
-    activities: [],
-    tokenCount: 0,
-    sessionStartTime: null,
-    todos: null,
-    modelName: null,
-    lastTurnDuration: null
-  };
-  if (!existsSync3(sessionFile)) {
-    return defaultState;
-  }
-  let content;
-  try {
-    content = readFileSync4(sessionFile, "utf-8");
-  } catch {
-    return defaultState;
-  }
-  const lines = content.trim().split("\n").filter(Boolean);
-  if (lines.length === 0) {
-    return defaultState;
-  }
-  let sessionStartTime = null;
-  for (let i = 0; i < Math.min(50, lines.length); i++) {
-    try {
-      const entry = JSON.parse(lines[i]);
-      if (entry.timestamp && typeof entry.timestamp === "string") {
-        sessionStartTime = new Date(entry.timestamp);
-        break;
-      }
-    } catch {
-    }
-  }
-  const activities = [];
-  let tokenCount = 0;
-  let lastTimestamp = null;
-  let lastType = null;
-  let todos = null;
-  let modelName = null;
-  let lastTurnDuration = null;
-  const recentLines = lines.slice(-MAX_LINES_TO_SCAN);
-  for (const line of recentLines) {
-    try {
-      const entry = JSON.parse(line);
-      if (entry.type === "user") {
-        const userEntry = entry;
-        if (userEntry.timestamp) {
-          lastTimestamp = new Date(userEntry.timestamp);
-        }
-        const msgContent = userEntry.message?.content;
-        let userText = "";
-        if (typeof msgContent === "string") {
-          userText = msgContent;
-        } else if (Array.isArray(msgContent)) {
-          const textBlock = msgContent.find(
-            (c) => typeof c === "object" && c !== null && c.type === "text" && typeof c.text === "string"
-          );
-          if (textBlock) {
-            userText = textBlock.text;
-          }
-        }
-        if (userText) {
-          activities.push({
-            timestamp: lastTimestamp || /* @__PURE__ */ new Date(),
-            type: "user",
-            icon: ICONS.User,
-            label: "User",
-            detail: userText.replace(/\n/g, " ")
-          });
-        }
-        if (userEntry.toolUseResult?.newTodos) {
-          todos = userEntry.toolUseResult.newTodos.map((t) => ({
-            content: t.content,
-            status: t.status,
-            activeForm: t.activeForm
-          }));
-        }
-        lastType = "user";
-      }
-      if (entry.type === "assistant") {
-        const assistantEntry = entry;
-        if (assistantEntry.timestamp) {
-          lastTimestamp = new Date(assistantEntry.timestamp);
-        }
-        const messageContent = assistantEntry.message?.content;
-        if (Array.isArray(messageContent)) {
-          for (const block of messageContent) {
-            if (block.type === "tool_use") {
-              const toolName = block.name || "Tool";
-              if (toolName === "TodoWrite") {
-                lastType = "tool";
-                continue;
-              }
-              const icon = ICONS[toolName] || ICONS.Default;
-              const detail = getToolDetail(toolName, block.input);
-              const lastActivity = activities[activities.length - 1];
-              if (lastActivity && lastActivity.type === "tool" && lastActivity.label === toolName && lastActivity.detail === detail) {
-                lastActivity.count = (lastActivity.count || 1) + 1;
-                lastActivity.timestamp = lastTimestamp || /* @__PURE__ */ new Date();
-              } else {
-                const activity = {
-                  timestamp: lastTimestamp || /* @__PURE__ */ new Date(),
-                  type: "tool",
-                  icon,
-                  label: toolName,
-                  detail
-                };
-                activities.push(activity);
-              }
-              lastType = "tool";
-            } else if (block.type === "text" && block.text) {
-              if (block.text.length > 10) {
-                activities.push({
-                  timestamp: lastTimestamp || /* @__PURE__ */ new Date(),
-                  type: "response",
-                  icon: ICONS.Response,
-                  label: "Response",
-                  detail: block.text.replace(/\n/g, " ")
-                });
-                lastType = "response";
-              }
-            }
-          }
-        }
-        const usage = assistantEntry.message?.usage;
-        if (usage) {
-          tokenCount += (usage.input_tokens || 0) + (usage.cache_read_input_tokens || 0) + (usage.output_tokens || 0);
-        }
-        if (assistantEntry.message?.model) {
-          modelName = parseModelName(assistantEntry.message.model);
-        }
-      }
-      if (entry.type === "system") {
-        const systemEntry = entry;
-        if (systemEntry.subtype === "stop_hook_summary") {
-          lastType = "stop";
-          if (systemEntry.timestamp) {
-            lastTimestamp = new Date(systemEntry.timestamp);
-          }
-        }
-        if (systemEntry.subtype === "turn_duration" && systemEntry.durationMs) {
-          lastTurnDuration = systemEntry.durationMs;
-        }
-      }
-    } catch {
-    }
-  }
-  let status = "none";
-  if (lastTimestamp) {
-    const elapsed = Date.now() - lastTimestamp.getTime();
-    if (elapsed < THIRTY_SECONDS_MS) {
-      if (lastType === "stop" || lastType === "response") {
-        status = "completed";
-      } else {
-        status = "running";
-      }
-    } else {
-      status = "completed";
-    }
-  }
-  const subagentsDir = join3(sessionFile.replace(/\.jsonl$/, ""), "subagents");
-  if (existsSync3(subagentsDir)) {
-    try {
-      const subagentFiles2 = readdirSync(subagentsDir).filter(
-        (f) => f.endsWith(".jsonl")
-      );
-      for (const file of subagentFiles2) {
-        const filePath = join3(subagentsDir, file);
-        try {
-          const subContent = readFileSync4(filePath, "utf-8");
-          const subLines = subContent.trim().split("\n").filter(Boolean);
-          for (const line of subLines) {
-            try {
-              const entry = JSON.parse(line);
-              if (entry.type === "assistant" && entry.message?.usage) {
-                const usage = entry.message.usage;
-                tokenCount += (usage.input_tokens || 0) + (usage.cache_read_input_tokens || 0) + (usage.output_tokens || 0);
-              }
-            } catch {
-            }
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  const finalActivities = activities.slice(-maxActivities).reverse();
-  const subagentFiles = getSubagentFiles(sessionFile);
-  let taskIndex = 0;
-  for (const activity of finalActivities) {
-    if (activity.label === "Task" && taskIndex < subagentFiles.length) {
-      const subagentData = parseSubagentFile(subagentFiles[taskIndex].filePath);
-      if (subagentData.totalCount > 0) {
-        activity.subActivities = subagentData.activities;
-        activity.subActivityCount = subagentData.totalCount;
-      }
-      taskIndex++;
-    }
-  }
-  return {
-    status,
-    activities: finalActivities,
-    tokenCount,
-    sessionStartTime,
-    todos,
-    modelName,
-    lastTurnDuration
-  };
-}
-function getTimeSinceMidnight() {
-  const now = /* @__PURE__ */ new Date();
-  const midnight = new Date(now.getFullYear(), now.getMonth(), now.getDate());
-  return now.getTime() - midnight.getTime();
-}
-function getClaudeData(projectPath, maxActivities, sessionTimeout) {
-  const effectiveTimeout = sessionTimeout ?? getTimeSinceMidnight();
-  const defaultState = {
-    status: "none",
-    activities: [],
-    tokenCount: 0,
-    sessionStartTime: null,
-    todos: null,
-    modelName: null,
-    lastTurnDuration: null
-  };
-  try {
-    const sessionDir = getClaudeSessionPath2(projectPath);
-    const hasSession = existsSync3(sessionDir);
-    const sessionFile = findActiveSession(sessionDir, effectiveTimeout);
-    if (!sessionFile) {
-      return {
-        state: defaultState,
-        hasSession,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-    }
-    const state = parseSessionState(sessionFile, maxActivities);
-    return {
-      state,
-      hasSession: true,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      state: defaultState,
-      hasSession: false,
-      error: message,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-}
-
-// src/data/otherSessions.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { basename as basename2, join as join4, sep } from "path";
-var MAX_LINES_TO_SCAN2 = 100;
-function getProjectsDir() {
-  return join4(homedir3(), ".claude", "projects");
-}
-function decodeProjectPath(encoded) {
-  const windowsDriveMatch = encoded.match(/^([A-Za-z])--(.*)$/);
-  if (windowsDriveMatch) {
-    const driveLetter = windowsDriveMatch[1];
-    const rest = windowsDriveMatch[2];
-    const decodedRest = rest.replace(/-/g, sep);
-    const windowsPath = `${driveLetter}:${sep}${decodedRest}`;
-    if (existsSync4(windowsPath)) {
-      return windowsPath;
-    }
-    const smartDecodedRest = smartDecodePath(rest);
-    const smartWindowsPath = `${driveLetter}:${sep}${smartDecodedRest}`;
-    if (existsSync4(smartWindowsPath)) {
-      return smartWindowsPath;
-    }
-    return windowsPath;
-  }
-  const naiveDecoded = encoded.replace(/-/g, sep);
-  if (existsSync4(naiveDecoded)) {
-    return naiveDecoded;
-  }
-  return smartDecodePath(encoded) || naiveDecoded;
-}
-function smartDecodePath(encoded) {
-  const segments = encoded.split("-").filter(Boolean);
-  if (segments.length === 0) {
-    return "";
-  }
-  let currentPath = "";
-  let i = 0;
-  while (i < segments.length) {
-    let found = false;
-    for (let j = segments.length; j > i; j--) {
-      const segment = segments.slice(i, j).join("-");
-      const testPath = currentPath ? join4(currentPath, segment) : sep + segment;
-      try {
-        if (existsSync4(testPath)) {
-          const stat = statSync2(testPath);
-          if (stat.isDirectory()) {
-            currentPath = testPath;
-            i = j;
-            found = true;
-            break;
-          }
-        }
-      } catch {
-      }
-    }
-    if (!found) {
-      currentPath = currentPath ? join4(currentPath, segments[i]) : sep + segments[i];
-      i++;
-    }
-  }
-  return currentPath;
-}
-function getAllProjects() {
-  const projectsDir = getProjectsDir();
-  if (!existsSync4(projectsDir)) {
-    return [];
-  }
-  const entries = readdirSync2(projectsDir);
-  const projects = [];
-  for (const entry of entries) {
-    const fullPath = join4(projectsDir, entry);
-    try {
-      const stat = statSync2(fullPath);
-      if (stat.isDirectory()) {
-        projects.push({
-          encodedPath: entry,
-          decodedPath: decodeProjectPath(entry)
-        });
-      }
-    } catch {
-    }
-  }
-  return projects;
-}
-function parseLastAssistantMessage(sessionFile) {
-  if (!existsSync4(sessionFile)) {
-    return null;
-  }
-  let content;
-  try {
-    content = readFileSync5(sessionFile, "utf-8");
-  } catch {
-    return null;
-  }
-  const lines = content.trim().split("\n").filter(Boolean);
-  if (lines.length === 0) {
-    return null;
-  }
-  const recentLines = lines.slice(-MAX_LINES_TO_SCAN2).reverse();
-  for (const line of recentLines) {
-    try {
-      const entry = JSON.parse(line);
-      if (entry.type === "assistant") {
-        const assistantEntry = entry;
-        const content2 = assistantEntry.message?.content;
-        if (Array.isArray(content2)) {
-          const textBlock = content2.find((c) => c.type === "text" && c.text);
-          if (textBlock?.text) {
-            return textBlock.text.replace(/\n/g, " ");
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-function formatRelativeTime(date) {
-  const elapsed = Date.now() - date.getTime();
-  const seconds = Math.floor(elapsed / 1e3);
-  const minutes = Math.floor(seconds / 60);
-  const hours = Math.floor(minutes / 60);
-  const days = Math.floor(hours / 24);
-  if (seconds < 1) {
-    return "just now";
-  }
-  if (seconds < 60) {
-    return `${seconds}s ago`;
-  }
-  if (minutes < 60) {
-    return `${minutes}m ago`;
-  }
-  if (hours < 24) {
-    return `${hours}h ago`;
-  }
-  return `${days}d ago`;
-}
-function findMostRecentSession(projectDir) {
-  if (!existsSync4(projectDir)) {
-    return null;
-  }
-  let files;
-  try {
-    files = readdirSync2(projectDir);
-  } catch {
-    return null;
-  }
-  const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
-  if (jsonlFiles.length === 0) {
-    return null;
-  }
-  let latestFile = null;
-  let latestMtime = 0;
-  for (const file of jsonlFiles) {
-    const filePath = join4(projectDir, file);
-    try {
-      const stat = statSync2(filePath);
-      if (stat.mtimeMs && stat.mtimeMs > latestMtime) {
-        latestMtime = stat.mtimeMs;
-        latestFile = filePath;
-      }
-    } catch {
-    }
-  }
-  if (!latestFile) {
-    return null;
-  }
-  return { file: latestFile, mtimeMs: latestMtime };
-}
-function getOtherSessionsData(currentProjectPath, options = {}) {
-  const activeThresholdMs = options.activeThresholdMs ?? FIVE_MINUTES_MS;
-  const projectsDir = getProjectsDir();
-  const defaultResult = {
-    totalProjects: 0,
-    activeCount: 0,
-    projectNames: [],
-    recentSession: null,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  if (!existsSync4(projectsDir)) {
-    return defaultResult;
-  }
-  const allProjects = getAllProjects();
-  defaultResult.totalProjects = allProjects.length;
-  const normalizedCurrentPath = currentProjectPath.replace(/[/\\]$/, "").replace(/\\/g, "/");
-  const otherSessions = [];
-  for (const project of allProjects) {
-    const normalizedDecodedPath = project.decodedPath.replace(/\\/g, "/");
-    if (normalizedDecodedPath === normalizedCurrentPath) {
-      continue;
-    }
-    const projectDir = join4(projectsDir, project.encodedPath);
-    const sessionInfo = findMostRecentSession(projectDir);
-    if (sessionInfo) {
-      otherSessions.push({
-        projectPath: project.decodedPath,
-        projectName: basename2(project.decodedPath),
-        lastModified: new Date(sessionInfo.mtimeMs),
-        mtimeMs: sessionInfo.mtimeMs,
-        sessionFile: sessionInfo.file
-      });
-    }
-  }
-  const now = Date.now();
-  let activeCount = 0;
-  for (const session of otherSessions) {
-    if (now - session.mtimeMs < activeThresholdMs) {
-      activeCount++;
-    }
-  }
-  defaultResult.activeCount = activeCount;
-  if (otherSessions.length === 0) {
-    return defaultResult;
-  }
-  otherSessions.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  const seen = /* @__PURE__ */ new Set();
-  defaultResult.projectNames = otherSessions.map((s) => s.projectName).filter((name) => {
-    if (seen.has(name)) return false;
-    seen.add(name);
-    return true;
-  });
-  const mostRecent = otherSessions[0];
-  const lastMessage = parseLastAssistantMessage(mostRecent.sessionFile);
-  const isActive = now - mostRecent.mtimeMs < activeThresholdMs;
-  defaultResult.recentSession = {
-    projectPath: mostRecent.projectPath,
-    projectName: mostRecent.projectName,
-    lastModified: mostRecent.lastModified,
-    lastMessage,
-    isActive,
-    relativeTime: formatRelativeTime(mostRecent.lastModified)
-  };
-  return defaultResult;
-}
-
-// src/data/sessionAvailability.ts
-function shortenPath(path) {
-  const home = homedir4();
-  if (path === home) {
-    return "~";
-  }
-  if (path.startsWith(`${home}/`) || path.startsWith(`${home}\\`)) {
-    return `~${path.slice(home.length)}`;
-  }
-  return path;
-}
-var PROJECT_INDICATORS = [
-  ".git",
-  // Git repository
-  "package.json",
-  // Node.js
-  "Cargo.toml",
-  // Rust
-  "pyproject.toml",
-  // Python (modern)
-  "setup.py",
-  // Python (legacy)
-  "go.mod",
-  // Go
-  "Makefile",
-  // Make-based projects
-  "CMakeLists.txt",
-  // CMake projects
-  "pom.xml",
-  // Java Maven
-  "build.gradle",
-  // Java Gradle
-  "Gemfile",
-  // Ruby
-  "composer.json"
-  // PHP
-];
-function isDevProject(projectPath) {
-  for (const indicator of PROJECT_INDICATORS) {
-    if (existsSync5(join5(projectPath, indicator))) {
-      return true;
-    }
-  }
-  return false;
-}
-function getProjectMostRecentMtime(encodedPath) {
-  const projectDir = join5(homedir4(), ".claude", "projects", encodedPath);
-  if (!existsSync5(projectDir)) {
-    return 0;
-  }
-  let files;
-  try {
-    files = readdirSync3(projectDir);
-  } catch {
-    return 0;
-  }
-  const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
-  if (jsonlFiles.length === 0) {
-    return 0;
-  }
-  let latestMtime = 0;
-  for (const file of jsonlFiles) {
-    const filePath = join5(projectDir, file);
-    try {
-      const stat = statSync3(filePath);
-      if (stat.mtimeMs && stat.mtimeMs > latestMtime) {
-        latestMtime = stat.mtimeMs;
-      }
-    } catch {
-    }
-  }
-  return latestMtime;
-}
-function hasCurrentProjectSession(cwd) {
-  const sessionPath = getClaudeSessionPath2(cwd);
-  return existsSync5(sessionPath);
-}
-function getProjectsWithSessions(currentPath) {
-  const allProjects = getAllProjects();
-  const currentEncoded = encodeProjectPath(currentPath);
-  const projectsWithMtime = allProjects.filter((p) => p.encodedPath !== currentEncoded).filter((p) => existsSync5(p.decodedPath)).filter((p) => isDevProject(p.decodedPath)).map((p) => ({
-    name: basename3(p.decodedPath),
-    path: p.decodedPath,
-    mtime: getProjectMostRecentMtime(p.encodedPath)
-  }));
-  projectsWithMtime.sort((a, b) => b.mtime - a.mtime);
-  return projectsWithMtime.map(({ name, path }) => ({ name, path }));
-}
-function checkSessionAvailability(cwd) {
-  const hasCurrentSession = hasCurrentProjectSession(cwd);
-  if (hasCurrentSession) {
-    return {
-      hasCurrentSession: true,
-      otherProjects: []
-    };
-  }
-  const otherProjects = getProjectsWithSessions(cwd);
-  return {
-    hasCurrentSession: false,
-    otherProjects
-  };
-}
-
-// src/ui/App.tsx
-import { Box as Box8, Text as Text8, useApp, useInput, useStdout } from "ink";
-import React, {
-  useCallback as useCallback4,
-  useEffect as useEffect4,
-  useMemo as useMemo3,
-  useRef as useRef3,
-  useState as useState4
-} from "react";
-
-// src/config/parser.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
-import { parse as parseYaml } from "yaml";
-var DEFAULT_WIDTH = DEFAULT_PANEL_WIDTH;
-var MIN_WIDTH = MIN_TERMINAL_WIDTH;
-var MAX_WIDTH = MAX_TERMINAL_WIDTH;
-var CONFIG_PATH = ".agenthud/config.yaml";
-function parseInterval(interval) {
-  if (!interval || interval === "manual") {
-    return null;
-  }
-  const match = interval.match(/^(\d+)(s|m)$/);
-  if (!match) {
-    return null;
-  }
-  const value = parseInt(match[1], 10);
-  const unit = match[2];
-  if (unit === "s") {
-    return value * 1e3;
-  } else if (unit === "m") {
-    return value * 60 * 1e3;
-  }
-  return null;
-}
-function getDefaultConfig2() {
-  return {
-    panels: {
-      project: {
-        enabled: true,
-        interval: 3e5
-        // 5 minutes (doesn't change often)
-      },
-      git: {
-        enabled: true,
-        interval: 3e4
-        // 30s
-      },
-      tests: {
-        enabled: true,
-        interval: null
-        // manual
-      },
-      claude: {
-        enabled: true,
-        interval: 1e4
-        // 10 seconds default
-        // sessionTimeout defaults to undefined = since midnight (today's sessions)
-      },
-      other_sessions: {
-        enabled: true,
-        interval: 1e4,
-        // 10 seconds default
-        activeThreshold: 5 * 60 * 1e3,
-        // 5 minutes
-        messageMaxLength: 50
-      }
-    },
-    panelOrder: ["project", "git", "tests", "claude", "other_sessions"],
-    width: DEFAULT_WIDTH,
-    wideLayoutThreshold: null
-    // disabled by default
-  };
-}
-var BUILTIN_PANELS = ["project", "git", "tests", "claude", "other_sessions"];
-var VALID_RENDERERS = ["list", "progress", "status"];
-function parseBasePanelConfig(panelConfig, targetConfig, panelName, warnings) {
-  if (typeof panelConfig.enabled === "boolean") {
-    targetConfig.enabled = panelConfig.enabled;
-  }
-  if (typeof panelConfig.interval === "string") {
-    const interval = parseInterval(panelConfig.interval);
-    if (interval === null && panelConfig.interval !== "manual") {
-      warnings.push(
-        `Invalid interval '${panelConfig.interval}' for ${panelName} panel, using default`
-      );
-    } else {
-      targetConfig.interval = interval;
-    }
-  }
-}
-function parseConfig() {
-  const warnings = [];
-  const defaultConfig = getDefaultConfig2();
-  if (!existsSync6(CONFIG_PATH)) {
-    return { config: defaultConfig, warnings };
-  }
-  let rawConfig;
-  try {
-    const content = readFileSync6(CONFIG_PATH, "utf-8");
-    rawConfig = parseYaml(content);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    warnings.push(`Failed to parse config: ${message}`);
-    return { config: defaultConfig, warnings };
-  }
-  if (!rawConfig || typeof rawConfig !== "object") {
-    return { config: defaultConfig, warnings };
-  }
-  const parsed = rawConfig;
-  const config = getDefaultConfig2();
-  if (typeof parsed.width === "number") {
-    if (parsed.width < MIN_WIDTH) {
-      warnings.push(
-        `Width ${parsed.width} is too small, using minimum of ${MIN_WIDTH}`
-      );
-      config.width = MIN_WIDTH;
-    } else if (parsed.width > MAX_WIDTH) {
-      warnings.push(
-        `Width ${parsed.width} is too large, using maximum of ${MAX_WIDTH}`
-      );
-      config.width = MAX_WIDTH;
-    } else {
-      config.width = parsed.width;
-    }
-  }
-  const MIN_WIDE_THRESHOLD = 140;
-  const wideThresholdValue = parsed.wideLayoutThreshold ?? parsed.wide_layout_threshold;
-  if (typeof wideThresholdValue === "number") {
-    if (wideThresholdValue < MIN_WIDE_THRESHOLD) {
-      warnings.push(
-        `wideLayoutThreshold ${wideThresholdValue} is too small, using minimum of ${MIN_WIDE_THRESHOLD}`
-      );
-      config.wideLayoutThreshold = MIN_WIDE_THRESHOLD;
-    } else {
-      config.wideLayoutThreshold = wideThresholdValue;
-    }
-  }
-  const panels = parsed.panels;
-  if (!panels || typeof panels !== "object") {
-    return { config, warnings };
-  }
-  const customPanels = {};
-  const panelOrder = [];
-  for (const panelName of Object.keys(panels)) {
-    panelOrder.push(panelName);
-    const panelConfig = panels[panelName];
-    if (!panelConfig || typeof panelConfig !== "object") {
-      continue;
-    }
-    if (panelName === "project") {
-      parseBasePanelConfig(
-        panelConfig,
-        config.panels.project,
-        panelName,
-        warnings
-      );
-      continue;
-    }
-    if (panelName === "git") {
-      parseBasePanelConfig(panelConfig, config.panels.git, panelName, warnings);
-      continue;
-    }
-    if (panelName === "tests") {
-      parseBasePanelConfig(
-        panelConfig,
-        config.panels.tests,
-        panelName,
-        warnings
-      );
-      if (typeof panelConfig.command === "string") {
-        config.panels.tests.command = panelConfig.command;
-      }
-      continue;
-    }
-    if (panelName === "claude") {
-      parseBasePanelConfig(
-        panelConfig,
-        config.panels.claude,
-        panelName,
-        warnings
-      );
-      if (typeof panelConfig.max_activities === "number") {
-        config.panels.claude.maxActivities = panelConfig.max_activities;
-      }
-      if (typeof panelConfig.session_timeout === "string") {
-        const timeout = parseInterval(panelConfig.session_timeout);
-        if (timeout !== null) {
-          config.panels.claude.sessionTimeout = timeout;
-        }
-      }
-      continue;
-    }
-    if (panelName === "other_sessions") {
-      parseBasePanelConfig(
-        panelConfig,
-        config.panels.other_sessions,
-        panelName,
-        warnings
-      );
-      if (typeof panelConfig.active_threshold === "string") {
-        const threshold = parseInterval(panelConfig.active_threshold);
-        if (threshold !== null) {
-          config.panels.other_sessions.activeThreshold = threshold;
-        }
-      }
-      if (typeof panelConfig.message_max_length === "number") {
-        config.panels.other_sessions.messageMaxLength = panelConfig.message_max_length;
-      }
-      continue;
-    }
-    const customPanel = {
-      enabled: typeof panelConfig.enabled === "boolean" ? panelConfig.enabled : true,
-      interval: 3e4,
-      // default 30s
-      renderer: "list"
-      // default
-    };
-    if (typeof panelConfig.interval === "string") {
-      const interval = parseInterval(panelConfig.interval);
-      customPanel.interval = interval;
-    }
-    if (typeof panelConfig.command === "string") {
-      customPanel.command = panelConfig.command;
-    }
-    if (typeof panelConfig.source === "string") {
-      customPanel.source = panelConfig.source;
-    }
-    if (typeof panelConfig.renderer === "string") {
-      if (VALID_RENDERERS.includes(panelConfig.renderer)) {
-        customPanel.renderer = panelConfig.renderer;
-      } else {
-        warnings.push(
-          `Invalid renderer '${panelConfig.renderer}' for custom panel, using 'list'`
-        );
-      }
-    }
-    customPanels[panelName] = customPanel;
-  }
-  if (Object.keys(customPanels).length > 0) {
-    config.customPanels = customPanels;
-  }
-  for (const builtIn of BUILTIN_PANELS) {
-    if (!panelOrder.includes(builtIn)) {
-      panelOrder.push(builtIn);
-    }
-  }
-  config.panelOrder = panelOrder;
-  return { config, warnings };
-}
-
-// src/data/custom.ts
-import { exec, execSync } from "child_process";
-import { promises as fsPromises, readFileSync as readFileSync7 } from "fs";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-function capitalizeFirst(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-function getCustomPanelData(name, panelConfig) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const defaultData = {
-    title: capitalizeFirst(name)
-  };
-  if (panelConfig.command) {
-    try {
-      const output = execSync(panelConfig.command, { encoding: "utf-8" }).trim();
-      try {
-        const parsed = JSON.parse(output);
-        return {
-          data: {
-            title: parsed.title || capitalizeFirst(name),
-            summary: parsed.summary,
-            items: parsed.items,
-            progress: parsed.progress,
-            stats: parsed.stats
-          },
-          timestamp
-        };
-      } catch {
-        const lines = output.split("\n").filter((l) => l.trim());
-        return {
-          data: {
-            title: capitalizeFirst(name),
-            items: lines.map((text) => ({ text }))
-          },
-          timestamp
-        };
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        data: defaultData,
-        error: `Command failed: ${message.split("\n")[0]}`,
-        timestamp
-      };
-    }
-  }
-  if (panelConfig.source) {
-    try {
-      const content = readFileSync7(panelConfig.source, "utf-8");
-      const parsed = JSON.parse(content);
-      return {
-        data: {
-          title: parsed.title || capitalizeFirst(name),
-          summary: parsed.summary,
-          items: parsed.items,
-          progress: parsed.progress,
-          stats: parsed.stats
-        },
-        timestamp
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.includes("ENOENT")) {
-        return {
-          data: defaultData,
-          error: "File not found",
-          timestamp
-        };
-      }
-      return {
-        data: defaultData,
-        error: "Invalid JSON",
-        timestamp
-      };
-    }
-  }
-  return {
-    data: defaultData,
-    error: "No command or source configured",
-    timestamp
-  };
-}
-async function getCustomPanelDataAsync(name, panelConfig) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const defaultData = {
-    title: capitalizeFirst(name)
-  };
-  if (panelConfig.command) {
-    try {
-      const { stdout } = await execAsync(panelConfig.command);
-      const output = stdout.trim();
-      try {
-        const parsed = JSON.parse(output);
-        return {
-          data: {
-            title: parsed.title || capitalizeFirst(name),
-            summary: parsed.summary,
-            items: parsed.items,
-            progress: parsed.progress,
-            stats: parsed.stats
-          },
-          timestamp
-        };
-      } catch {
-        const lines = output.split("\n").filter((l) => l.trim());
-        return {
-          data: {
-            title: capitalizeFirst(name),
-            items: lines.map((text) => ({ text }))
-          },
-          timestamp
-        };
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        data: defaultData,
-        error: `Command failed: ${message.split("\n")[0]}`,
-        timestamp
-      };
-    }
-  }
-  if (panelConfig.source) {
-    try {
-      const content = await fsPromises.readFile(panelConfig.source, "utf-8");
-      const parsed = JSON.parse(content);
-      return {
-        data: {
-          title: parsed.title || capitalizeFirst(name),
-          summary: parsed.summary,
-          items: parsed.items,
-          progress: parsed.progress,
-          stats: parsed.stats
-        },
-        timestamp
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.includes("ENOENT")) {
-        return {
-          data: defaultData,
-          error: "File not found",
-          timestamp
-        };
-      }
-      return {
-        data: defaultData,
-        error: "Invalid JSON",
-        timestamp
-      };
-    }
-  }
-  return {
-    data: defaultData,
-    error: "No command or source configured",
-    timestamp
-  };
-}
-
-// src/data/git.ts
-import { exec as exec2, execSync as execSync2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execAsync2 = promisify2(exec2);
-function cleanOutput(str) {
-  let result = str.replace(/^\uFEFF/, "");
-  result = result.replace(/^"|"$/g, "");
-  return result.trim();
-}
-function getUncommittedCount() {
-  try {
-    const result = execSync2("git status --porcelain", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const lines = result.trim().split("\n").filter(Boolean);
-    return lines.length;
-  } catch {
-    return 0;
-  }
-}
-var DEFAULT_COMMANDS = {
-  branch: "git branch --show-current",
-  commits: 'git log --since=midnight --format="%h|%aI|%s"',
-  stats: 'git log --since=midnight --numstat --format=""'
-};
-function parseCommitsOutput(output) {
-  const lines = cleanOutput(output).split("\n").filter(Boolean);
-  return lines.map((line) => {
-    const cleanLine = cleanOutput(line);
-    const [hash, timestamp, ...messageParts] = cleanLine.split("|");
-    return {
-      hash: cleanOutput(hash),
-      message: messageParts.join("|"),
-      timestamp: new Date(timestamp)
-    };
-  });
-}
-function parseStatsOutput(output) {
-  const lines = output.trim().split("\n").filter(Boolean);
-  let added = 0;
-  let deleted = 0;
-  const filesSet = /* @__PURE__ */ new Set();
-  for (const line of lines) {
-    const [addedStr, deletedStr, filename] = line.split("	");
-    if (addedStr === "-" || deletedStr === "-") {
-      if (filename) filesSet.add(filename);
-      continue;
-    }
-    added += parseInt(addedStr, 10) || 0;
-    deleted += parseInt(deletedStr, 10) || 0;
-    if (filename) filesSet.add(filename);
-  }
-  return { added, deleted, files: filesSet.size };
-}
-function getGitData(config) {
-  const commands = {
-    branch: config.command?.branch || DEFAULT_COMMANDS.branch,
-    commits: config.command?.commits || DEFAULT_COMMANDS.commits,
-    stats: config.command?.stats || DEFAULT_COMMANDS.stats
-  };
-  let branch = null;
-  try {
-    const result = execSync2(commands.branch, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    branch = result.trim();
-  } catch {
-    branch = null;
-  }
-  let commits = [];
-  try {
-    const result = execSync2(commands.commits, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    commits = parseCommitsOutput(result);
-  } catch {
-    commits = [];
-  }
-  let stats = { added: 0, deleted: 0, files: 0 };
-  try {
-    const result = execSync2(commands.stats, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    stats = parseStatsOutput(result);
-  } catch {
-    stats = { added: 0, deleted: 0, files: 0 };
-  }
-  const uncommitted = getUncommittedCount();
-  return { branch, commits, stats, uncommitted };
-}
-async function getGitDataAsync(config) {
-  const commands = {
-    branch: config.command?.branch || DEFAULT_COMMANDS.branch,
-    commits: config.command?.commits || DEFAULT_COMMANDS.commits,
-    stats: config.command?.stats || DEFAULT_COMMANDS.stats
-  };
-  let branch = null;
-  try {
-    const { stdout } = await execAsync2(commands.branch);
-    branch = stdout.trim();
-  } catch {
-    branch = null;
-  }
-  let commits = [];
-  try {
-    const { stdout } = await execAsync2(commands.commits);
-    commits = parseCommitsOutput(stdout);
-  } catch {
-    commits = [];
-  }
-  let stats = { added: 0, deleted: 0, files: 0 };
-  try {
-    const { stdout } = await execAsync2(commands.stats);
-    stats = parseStatsOutput(stdout);
-  } catch {
-    stats = { added: 0, deleted: 0, files: 0 };
-  }
-  const uncommitted = getUncommittedCount();
-  return { branch, commits, stats, uncommitted };
-}
-
-// src/data/project.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync8 } from "fs";
-import { basename as basename4, join as join6 } from "path";
-var LANGUAGE_INDICATORS = [
-  { file: "tsconfig.json", language: "TypeScript" },
-  { file: "package.json", language: "JavaScript" },
-  { file: "pyproject.toml", language: "Python" },
-  { file: "requirements.txt", language: "Python" },
-  { file: "setup.py", language: "Python" },
-  { file: "go.mod", language: "Go" },
-  { file: "Cargo.toml", language: "Rust" },
-  { file: "Gemfile", language: "Ruby" },
-  { file: "pom.xml", language: "Java" },
-  { file: "build.gradle", language: "Java" }
-];
-var KNOWN_STACK = {
-  frameworks: [
-    // JS/TS frameworks
-    "react",
-    "vue",
-    "angular",
-    "svelte",
-    "next",
-    "nuxt",
-    "express",
-    "fastify",
-    "koa",
-    "hono",
-    "ink",
-    // Python frameworks
-    "django",
-    "flask",
-    "fastapi",
-    "tornado",
-    "pyramid"
-  ],
-  tools: [
-    // JS/TS tools
-    "vitest",
-    "jest",
-    "mocha",
-    "webpack",
-    "vite",
-    "rollup",
-    "esbuild",
-    "tsup",
-    "eslint",
-    "prettier",
-    // Python tools
-    "pytest",
-    "pandas",
-    "numpy",
-    "tensorflow",
-    "pytorch",
-    "scikit-learn",
-    "sqlalchemy",
-    "celery"
-  ]
-};
-var FILE_EXTENSIONS = {
-  TypeScript: { ext: "ts", patterns: ["*.ts", "*.tsx"] },
-  JavaScript: { ext: "js", patterns: ["*.js", "*.jsx"] },
-  Python: { ext: "py", patterns: ["*.py"] },
-  Go: { ext: "go", patterns: ["*.go"] },
-  Rust: { ext: "rs", patterns: ["*.rs"] },
-  Ruby: { ext: "rb", patterns: ["*.rb"] },
-  Java: { ext: "java", patterns: ["*.java"] }
-};
-var SOURCE_DIRS = ["src", "lib", "app"];
-var EXCLUDE_DIRS = [
-  "node_modules",
-  "dist",
-  "build",
-  ".git",
-  "__pycache__",
-  "venv",
-  ".venv",
-  "target"
-];
-function detectLanguage() {
-  for (const { file, language } of LANGUAGE_INDICATORS) {
-    if (existsSync7(file)) {
-      return language;
-    }
-  }
-  return null;
-}
-function parsePackageJson(content) {
-  const pkg = JSON.parse(content);
-  const deps = Object.keys(pkg.dependencies || {});
-  const devDeps = Object.keys(pkg.devDependencies || {});
-  return {
-    name: pkg.name || "unknown",
-    license: pkg.license || null,
-    prodDeps: deps.length,
-    devDeps: devDeps.length,
-    allDeps: [...deps, ...devDeps]
-  };
-}
-function parsePyprojectToml(content) {
-  const lines = content.split("\n");
-  let name = "unknown";
-  let license = null;
-  const deps = [];
-  const devDeps = [];
-  let inProject = false;
-  let inDeps = false;
-  let inDevDeps = false;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed === "[project]") {
-      inProject = true;
-      inDeps = false;
-      inDevDeps = false;
-      continue;
-    }
-    if (trimmed.startsWith("[") && trimmed !== "[project]") {
-      if (trimmed === "[project.optional-dependencies]") {
-        inDevDeps = true;
-        inDeps = false;
-      } else {
-        inProject = false;
-        inDeps = false;
-        inDevDeps = false;
-      }
-      continue;
-    }
-    if (inProject) {
-      const nameMatch = trimmed.match(/^name\s*=\s*"([^"]+)"/);
-      if (nameMatch) {
-        name = nameMatch[1];
-      }
-      const licenseMatch = trimmed.match(
-        /^license\s*=\s*\{text\s*=\s*"([^"]+)"/
-      );
-      if (licenseMatch) {
-        license = licenseMatch[1];
-      }
-      const simpleLicense = trimmed.match(/^license\s*=\s*"([^"]+)"/);
-      if (simpleLicense) {
-        license = simpleLicense[1];
-      }
-      if (trimmed.startsWith("dependencies")) {
-        inDeps = true;
-        const inlineMatch = trimmed.match(/dependencies\s*=\s*\[([^\]]*)\]/);
-        if (inlineMatch) {
-          const items = inlineMatch[1].match(/"([^"]+)"/g);
-          if (items) {
-            deps.push(
-              ...items.map((s) => s.replace(/"/g, "").split(/[<>=[]/)[0])
-            );
-          }
-          inDeps = false;
-        }
-        continue;
-      }
-    }
-    if (inDeps && trimmed.startsWith('"')) {
-      const depMatch = trimmed.match(/"([^"]+)"/);
-      if (depMatch) {
-        deps.push(depMatch[1].split(/[<>=[]/)[0]);
-      }
-      if (trimmed.endsWith("]")) {
-        inDeps = false;
-      }
-    }
-    if (inDevDeps && trimmed.startsWith('"')) {
-      const depMatch = trimmed.match(/"([^"]+)"/);
-      if (depMatch) {
-        devDeps.push(depMatch[1].split(/[<>=[]/)[0]);
-      }
-    }
-    if (inDevDeps && trimmed.match(/^dev\s*=\s*\[/)) {
-      const inlineMatch = trimmed.match(/dev\s*=\s*\[([^\]]*)\]/);
-      if (inlineMatch) {
-        const items = inlineMatch[1].match(/"([^"]+)"/g);
-        if (items) {
-          devDeps.push(
-            ...items.map((s) => s.replace(/"/g, "").split(/[<>=[]/)[0])
-          );
-        }
-      }
-    }
-  }
-  return {
-    name,
-    license,
-    prodDeps: deps.length,
-    devDeps: devDeps.length,
-    allDeps: [...deps, ...devDeps]
-  };
-}
-function parseSetupPy(content) {
-  let name = "unknown";
-  const deps = [];
-  const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
-  if (nameMatch) {
-    name = nameMatch[1];
-  }
-  const reqMatch = content.match(/install_requires\s*=\s*\[([^\]]+)\]/s);
-  if (reqMatch) {
-    const items = reqMatch[1].match(/["']([^"']+)["']/g);
-    if (items) {
-      deps.push(...items.map((s) => s.replace(/["']/g, "").split(/[<>=[]/)[0]));
-    }
-  }
-  return {
-    name,
-    license: null,
-    prodDeps: deps.length,
-    devDeps: 0,
-    allDeps: deps
-  };
-}
-function getFolderName() {
-  return basename4(process.cwd());
-}
-function getProjectInfo() {
-  if (existsSync7("package.json")) {
-    try {
-      const content = readFileSync8("package.json", "utf-8");
-      return parsePackageJson(content);
-    } catch {
-    }
-  }
-  if (existsSync7("pyproject.toml")) {
-    try {
-      const content = readFileSync8("pyproject.toml", "utf-8");
-      return parsePyprojectToml(content);
-    } catch {
-    }
-  }
-  if (existsSync7("setup.py")) {
-    try {
-      const content = readFileSync8("setup.py", "utf-8");
-      return parseSetupPy(content);
-    } catch {
-    }
-  }
-  return {
-    name: getFolderName(),
-    license: null,
-    prodDeps: 0,
-    devDeps: 0,
-    allDeps: []
-  };
-}
-function detectStack(deps) {
-  const normalizedDeps = deps.map((d) => d.toLowerCase());
-  const frameworks = [];
-  const tools = [];
-  for (const framework of KNOWN_STACK.frameworks) {
-    if (normalizedDeps.includes(framework)) {
-      frameworks.push(framework);
-    }
-  }
-  for (const tool of KNOWN_STACK.tools) {
-    if (normalizedDeps.includes(tool)) {
-      tools.push(tool);
-    }
-  }
-  return [...frameworks, ...tools].slice(0, 5);
-}
-function findSourceDir() {
-  for (const dir of SOURCE_DIRS) {
-    if (existsSync7(dir)) {
-      return dir;
-    }
-  }
-  return null;
-}
-function globToRegex(pattern) {
-  const ext = pattern.replace("*", "").replace(".", "\\.");
-  return new RegExp(`${ext}$`, "i");
-}
-function findFiles(dir, patterns, excludeDirs) {
-  const files = [];
-  try {
-    const entries = readdirSync4(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join6(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (!excludeDirs.includes(entry.name)) {
-          files.push(...findFiles(fullPath, patterns, excludeDirs));
-        }
-      } else if (entry.isFile()) {
-        if (patterns.some((regex) => regex.test(entry.name))) {
-          files.push(fullPath);
-        }
-      }
-    }
-  } catch {
-  }
-  return files;
-}
-function countFiles(language) {
-  const sourceDir = findSourceDir();
-  if (!sourceDir || !language) {
-    return { count: 0, extension: "" };
-  }
-  const config = FILE_EXTENSIONS[language];
-  if (!config) {
-    return { count: 0, extension: "" };
-  }
-  try {
-    const patterns = config.patterns.map(globToRegex);
-    const files = findFiles(sourceDir, patterns, EXCLUDE_DIRS);
-    return { count: files.length, extension: config.ext };
-  } catch {
-    return { count: 0, extension: config.ext };
-  }
-}
-function countLines(language) {
-  const sourceDir = findSourceDir();
-  if (!sourceDir || !language) {
-    return 0;
-  }
-  const config = FILE_EXTENSIONS[language];
-  if (!config) {
-    return 0;
-  }
-  try {
-    const patterns = config.patterns.map(globToRegex);
-    const files = findFiles(sourceDir, patterns, EXCLUDE_DIRS);
-    let totalLines = 0;
-    for (const file of files) {
-      try {
-        const content = readFileSync8(file, "utf-8");
-        const lines = content.split("\n").length;
-        totalLines += lines;
-      } catch {
-      }
-    }
-    return totalLines;
-  } catch {
-    return 0;
-  }
-}
-function getProjectData() {
-  try {
-    const language = detectLanguage();
-    const projectInfo = getProjectInfo();
-    const stack = detectStack(projectInfo.allDeps);
-    const fileCount = countFiles(language);
-    const lineCount = countLines(language);
-    return {
-      name: projectInfo.name,
-      language,
-      license: projectInfo.license,
-      stack,
-      fileCount: fileCount.count,
-      fileExtension: fileCount.extension,
-      lineCount,
-      prodDeps: projectInfo.prodDeps,
-      devDeps: projectInfo.devDeps
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      name: getFolderName(),
-      language: null,
-      license: null,
-      stack: [],
-      fileCount: 0,
-      fileExtension: "",
-      lineCount: 0,
-      prodDeps: 0,
-      devDeps: 0,
-      error: message
-    };
-  }
-}
-
-// src/data/tests.ts
-import { execSync as execSync4 } from "child_process";
-import { readFileSync as readFileSync10 } from "fs";
-import { join as join7 } from "path";
-
-// src/runner/command.ts
-import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync9, unlinkSync } from "fs";
-function parseJUnitXml(xml) {
-  try {
-    if (!xml.includes("<testsuite") && !xml.includes("<testsuites")) {
-      return null;
-    }
-    let totalTests = 0;
-    let totalErrors = 0;
-    let totalFailures = 0;
-    let totalSkipped = 0;
-    const failures = [];
-    const testsuiteMatches = xml.match(/<testsuite\b[^>]*(?:\/>|>[\s\S]*?<\/testsuite>)/g) || [];
-    const testsuites = testsuiteMatches.length > 0 ? testsuiteMatches : [xml];
-    for (const suite of testsuites) {
-      const suiteTag = suite.match(/<testsuite[^>]*>/)?.[0] || "";
-      const testsMatch = suiteTag.match(/tests="(\d+)"/);
-      const errorsMatch = suiteTag.match(/errors="(\d+)"/);
-      const failuresMatch = suiteTag.match(/failures="(\d+)"/);
-      const skippedMatch = suiteTag.match(/skipped="(\d+)"/);
-      totalTests += testsMatch ? parseInt(testsMatch[1], 10) : 0;
-      totalErrors += errorsMatch ? parseInt(errorsMatch[1], 10) : 0;
-      totalFailures += failuresMatch ? parseInt(failuresMatch[1], 10) : 0;
-      totalSkipped += skippedMatch ? parseInt(skippedMatch[1], 10) : 0;
-      const testcaseRegex = /<testcase[^>]*classname="([^"]*)"[^>]*name="([^"]*)"[^/>]*(?:\/>|>[\s\S]*?<\/testcase>)/g;
-      const testcaseMatches = suite.matchAll(testcaseRegex);
-      for (const testcaseMatch of testcaseMatches) {
-        const testcaseContent = testcaseMatch[0];
-        const classname = testcaseMatch[1];
-        const name = testcaseMatch[2];
-        if (testcaseContent.includes("<failure") || testcaseContent.includes("<error")) {
-          failures.push({
-            file: classname,
-            name
-          });
-        }
-      }
-    }
-    if (totalTests === 0 && testsuiteMatches.length === 0) {
-      return null;
-    }
-    const failed = totalFailures + totalErrors;
-    const passed = totalTests - failed - totalSkipped;
-    return {
-      passed,
-      failed,
-      skipped: totalSkipped,
-      failures
-    };
-  } catch {
-    return null;
-  }
-}
-function getHeadHash() {
-  try {
-    return execSync3("git rev-parse --short HEAD", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-  } catch {
-    return "unknown";
-  }
-}
-function runTestCommand(command, source = TEST_RESULTS_FILE) {
-  try {
-    if (existsSync8(source)) {
-      unlinkSync(source);
-    }
-  } catch {
-  }
-  try {
-    execSync3(command, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch {
-  }
-  if (!existsSync8(source)) {
-    return {
-      results: null,
-      isOutdated: false,
-      commitsBehind: 0,
-      error: "Test command failed to produce output file"
-    };
-  }
-  let content;
-  try {
-    content = readFileSync9(source, "utf-8");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      results: null,
-      isOutdated: false,
-      commitsBehind: 0,
-      error: `Failed to read result file: ${message}`
-    };
-  }
-  const parsed = parseJUnitXml(content);
-  if (!parsed) {
-    return {
-      results: null,
-      isOutdated: false,
-      commitsBehind: 0,
-      error: "Failed to parse test results XML"
-    };
-  }
-  const hash = getHeadHash();
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const results = {
-    hash,
-    timestamp,
-    passed: parsed.passed,
-    failed: parsed.failed,
-    skipped: parsed.skipped,
-    failures: parsed.failures
-  };
-  return {
-    results,
-    isOutdated: false,
-    commitsBehind: 0
-  };
-}
-
-// src/data/tests.ts
-var AGENT_DIR = ".agenthud";
-var TEST_RESULTS_FILE2 = "test-results.json";
-function getHeadHash2() {
-  return execSync4("git rev-parse --short HEAD", { encoding: "utf-8" }).trim();
-}
-function getCommitCount(fromHash) {
-  const result = execSync4(`git rev-list ${fromHash}..HEAD --count`, {
-    encoding: "utf-8"
-  }).trim();
-  return parseInt(result, 10) || 0;
-}
-function getTestData(dir = process.cwd()) {
-  const testResultsPath = join7(dir, AGENT_DIR, TEST_RESULTS_FILE2);
-  let results = null;
-  let isOutdated = false;
-  let commitsBehind = 0;
-  let error;
-  try {
-    const content = readFileSync10(testResultsPath, "utf-8");
-    results = JSON.parse(content);
-  } catch (e) {
-    if (e instanceof SyntaxError) {
-      error = "Invalid test-results.json";
-    } else {
-      error = "No test results";
-    }
-    return { results: null, isOutdated: false, commitsBehind: 0, error };
-  }
-  try {
-    const currentHash = getHeadHash2();
-    if (results.hash !== currentHash) {
-      isOutdated = true;
-      commitsBehind = getCommitCount(results.hash);
-    }
-  } catch {
-    isOutdated = false;
-    commitsBehind = 0;
-  }
-  return { results, isOutdated, commitsBehind, error };
-}
-
-// src/ui/ClaudePanel.tsx
-import { Box, Text } from "ink";
-import { useEffect, useState } from "react";
-import { Fragment, 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 === "tool") {
-    if (activity.label === "Bash") {
-      return { color: "gray", dimColor: false };
-    }
-    return { dimColor: true };
-  }
-  return { dimColor: true };
-}
-function formatCountdown(seconds) {
-  if (seconds == null) return "";
-  const padded = String(seconds).padStart(2, " ");
-  return `\u21BB ${padded}s`;
-}
-function formatTokenCount(tokens) {
-  if (tokens <= 0) return "";
-  if (tokens < 1e3) return `${tokens} tokens`;
-  if (tokens < 1e6) return `${Math.round(tokens / 1e3)}K tokens`;
-  return `${(tokens / 1e6).toFixed(1)}M tokens`;
-}
-function formatSessionTime(startTime) {
-  if (!startTime) return "";
-  const startHours = String(startTime.getHours()).padStart(2, "0");
-  const startMinutes = String(startTime.getMinutes()).padStart(2, "0");
-  const startStr = `${startHours}:${startMinutes}`;
-  const elapsed = Date.now() - startTime.getTime();
-  const elapsedMinutes = Math.floor(elapsed / 6e4);
-  const hours = Math.floor(elapsedMinutes / 60);
-  const remainingMinutes = elapsedMinutes % 60;
-  let elapsedStr;
-  if (hours >= 10) {
-    elapsedStr = `${hours}h`;
-  } else if (hours > 0) {
-    elapsedStr = `${hours}h ${remainingMinutes}m`;
-  } else if (elapsedMinutes > 0) {
-    elapsedStr = `${elapsedMinutes}m`;
-  } else {
-    elapsedStr = "<1m";
-  }
-  return `${startStr} (${elapsedStr})`;
-}
-function formatTurnDuration(durationMs) {
-  if (durationMs == null || durationMs <= 0) return "";
-  const seconds = Math.round(durationMs / 1e3);
-  if (seconds >= 60) {
-    const minutes = Math.floor(seconds / 60);
-    const remainingSecs = seconds % 60;
-    const duration = remainingSecs > 0 ? `${minutes}m${remainingSecs}s` : `${minutes}m`;
-    return `Last: ${duration}`;
-  }
-  return `Last: ${seconds}s`;
-}
-function getStatusIcon(status) {
-  switch (status) {
-    case "running":
-      return "\u{1F504}";
-    case "completed":
-      return "\u2705";
-    case "idle":
-      return "\u23F3";
-    default:
-      return "";
-  }
-}
-function formatActivityTime(date) {
-  const hours = String(date.getHours()).padStart(2, "0");
-  const minutes = String(date.getMinutes()).padStart(2, "0");
-  const seconds = String(date.getSeconds()).padStart(2, "0");
-  return `${hours}:${minutes}:${seconds}`;
-}
-function formatActivityParts(activity, maxWidth) {
-  const time = formatActivityTime(activity.timestamp);
-  const icon = activity.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 skipLabel = label === "User" || label === "Response";
-  const timestamp = `[${time}] `;
-  const timestampWidth = timestamp.length;
-  const iconWidth = getDisplayWidth(icon);
-  if (skipLabel && detail) {
-    const prefixWidth = timestampWidth + iconWidth + 1;
-    const availableWidth = maxWidth - prefixWidth - countSuffixWidth;
-    let truncatedDetail = detail;
-    let detailDisplayWidth = getDisplayWidth(detail);
-    if (detailDisplayWidth > availableWidth) {
-      truncatedDetail = "";
-      let currentWidth = 0;
-      for (const char of detail) {
-        const charWidth = getDisplayWidth(char);
-        if (currentWidth + charWidth > availableWidth - 3) {
-          truncatedDetail += "...";
-          currentWidth += 3;
-          break;
-        }
-        truncatedDetail += char;
-        currentWidth += charWidth;
-      }
-      detailDisplayWidth = currentWidth;
-    }
-    return {
-      timestamp,
-      icon,
-      labelContent: truncatedDetail + countSuffix,
-      displayWidth: prefixWidth + detailDisplayWidth + countSuffixWidth
-    };
-  }
-  const labelWidth = label.length;
-  const separatorWidth = detail ? 2 : 0;
-  const contentPrefixWidth = iconWidth + 1 + labelWidth + separatorWidth;
-  const totalPrefixWidth = timestampWidth + contentPrefixWidth;
-  if (detail) {
-    const availableWidth = maxWidth - totalPrefixWidth - countSuffixWidth;
-    let truncatedDetail = detail;
-    let detailDisplayWidth = getDisplayWidth(detail);
-    if (detailDisplayWidth > availableWidth) {
-      truncatedDetail = "";
-      let currentWidth = 0;
-      for (const char of detail) {
-        const charWidth = getDisplayWidth(char);
-        if (currentWidth + charWidth > availableWidth - 3) {
-          truncatedDetail += "...";
-          currentWidth += 3;
-          break;
-        }
-        truncatedDetail += char;
-        currentWidth += charWidth;
-      }
-      detailDisplayWidth = currentWidth;
-    }
-    const labelContent2 = `${label}: ${truncatedDetail}${countSuffix}`;
-    const displayWidth2 = totalPrefixWidth + detailDisplayWidth + countSuffixWidth;
-    return { timestamp, icon, labelContent: labelContent2, displayWidth: displayWidth2 };
-  }
-  const labelContent = label + countSuffix;
-  const displayWidth = totalPrefixWidth + countSuffixWidth;
-  return { timestamp, icon, labelContent, displayWidth };
-}
-var TODO_ICONS = {
-  completed: "\u2713",
-  in_progress_left: "\u25D0",
-  in_progress_right: "\u25D1",
-  pending: "\u25CB"
-};
-function TodoSection({ todos, width }) {
-  const [tick, setTick] = useState(false);
-  const innerWidth = getInnerWidth(width);
-  const contentWidth = innerWidth - 1;
-  useEffect(() => {
-    const timer = setInterval(() => setTick((t) => !t), 500);
-    return () => clearInterval(timer);
-  }, []);
-  const completedCount = todos.filter((t) => t.status === "completed").length;
-  const totalCount = todos.length;
-  const headerTitle = `Todo (${completedCount}/${totalCount})`;
-  const inProgressIcon = tick ? TODO_ICONS.in_progress_left : TODO_ICONS.in_progress_right;
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(Text, { children: createSeparatorLine(headerTitle, width) }),
-    todos.map((todo, i) => {
-      let icon;
-      let iconColor;
-      switch (todo.status) {
-        case "completed":
-          icon = TODO_ICONS.completed;
-          iconColor = "green";
-          break;
-        case "in_progress":
-          icon = inProgressIcon;
-          iconColor = "yellow";
-          break;
-        default:
-          icon = TODO_ICONS.pending;
-          iconColor = void 0;
-      }
-      const text = todo.status === "in_progress" ? todo.activeForm : todo.content;
-      const maxTextWidth = contentWidth - 3;
-      let displayText = text;
-      if (getDisplayWidth(text) > maxTextWidth) {
-        displayText = "";
-        let currentWidth = 0;
-        for (const char of text) {
-          const charWidth = getDisplayWidth(char);
-          if (currentWidth + charWidth > maxTextWidth - 3) {
-            displayText += "...";
-            currentWidth += 3;
-            break;
-          }
-          displayText += char;
-          currentWidth += charWidth;
-        }
-      }
-      const padding = Math.max(
-        0,
-        contentWidth - getDisplayWidth(icon) - 1 - getDisplayWidth(displayText)
-      );
-      return /* @__PURE__ */ jsxs(Text, { children: [
-        BOX.v,
-        " ",
-        /* @__PURE__ */ jsx(Text, { color: iconColor, children: icon }),
-        " ",
-        /* @__PURE__ */ jsx(Text, { dimColor: todo.status === "completed", children: displayText }),
-        " ".repeat(padding),
-        BOX.v
-      ] }, `todo-${i}`);
-    })
-  ] });
-}
-function ClaudePanel({
-  data,
-  countdown,
-  width = DEFAULT_PANEL_WIDTH,
-  isRunning = false,
-  justRefreshed = false,
-  maxActivities
-}) {
-  const countdownSuffix = isRunning ? "running..." : formatCountdown(countdown);
-  const innerWidth = getInnerWidth(width);
-  const contentWidth = innerWidth - 1;
-  const { state } = data;
-  const _statusIcon = getStatusIcon(state.status);
-  const sessionTime = formatSessionTime(state.sessionStartTime);
-  const tokenDisplay = formatTokenCount(state.tokenCount);
-  const turnDuration = formatTurnDuration(state.lastTurnDuration);
-  const panelTitle = state.modelName ? `Claude [${state.modelName}]` : "Claude";
-  const titleParts = [];
-  if (tokenDisplay) titleParts.push(tokenDisplay);
-  if (sessionTime) titleParts.push(sessionTime);
-  if (turnDuration) titleParts.push(turnDuration);
-  if (countdownSuffix) titleParts.push(countdownSuffix);
-  const titleSuffix = titleParts.join(" \xB7 ");
-  if (data.error) {
-    const errorPadding = Math.max(0, contentWidth - data.error.length);
-    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width, children: [
-      /* @__PURE__ */ jsx(Text, { children: createTitleLine(panelTitle, titleSuffix, width) }),
-      /* @__PURE__ */ jsxs(Text, { children: [
-        BOX.v,
-        " ",
-        /* @__PURE__ */ jsx(Text, { color: "red", children: data.error }),
-        " ".repeat(errorPadding),
-        BOX.v
-      ] }),
-      /* @__PURE__ */ jsx(Text, { children: createBottomLine(width) })
-    ] });
-  }
-  if (!data.hasSession) {
-    const noSessionText = "No Claude session";
-    const noSessionPadding = Math.max(0, contentWidth - noSessionText.length);
-    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width, children: [
-      /* @__PURE__ */ jsx(Text, { children: createTitleLine("Claude", countdownSuffix, width) }),
-      /* @__PURE__ */ jsxs(Text, { children: [
-        BOX.v,
-        " ",
-        /* @__PURE__ */ jsx(Text, { dimColor: true, children: noSessionText }),
-        " ".repeat(noSessionPadding),
-        BOX.v
-      ] }),
-      /* @__PURE__ */ jsx(Text, { children: createBottomLine(width) })
-    ] });
-  }
-  if (state.status === "none" || state.activities.length === 0) {
-    const noActiveText = "No active session";
-    const noActivePadding = Math.max(0, contentWidth - noActiveText.length);
-    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width, children: [
-      /* @__PURE__ */ jsx(Text, { children: createTitleLine(panelTitle, titleSuffix, width) }),
-      /* @__PURE__ */ jsxs(Text, { children: [
-        BOX.v,
-        " ",
-        /* @__PURE__ */ jsx(Text, { dimColor: true, children: noActiveText }),
-        " ".repeat(noActivePadding),
-        BOX.v
-      ] }),
-      /* @__PURE__ */ jsx(Text, { children: createBottomLine(width) })
-    ] });
-  }
-  const lines = [];
-  const displayActivities = maxActivities !== void 0 ? state.activities.slice(0, maxActivities) : state.activities;
-  for (let i = 0; i < displayActivities.length; i++) {
-    const activity = displayActivities[i];
-    let modifiedActivity = activity;
-    if (activity.label === "Task" && activity.subActivityCount && activity.subActivityCount > 0) {
-      modifiedActivity = {
-        ...activity,
-        detail: activity.detail ? `${activity.detail} (${activity.subActivityCount})` : `(${activity.subActivityCount})`
-      };
-    }
-    const { timestamp, icon, labelContent, displayWidth } = formatActivityParts(
-      modifiedActivity,
-      contentWidth
-    );
-    const padding = Math.max(0, contentWidth - displayWidth);
-    const style = getActivityStyle(activity);
-    lines.push(
-      /* @__PURE__ */ jsxs(Text, { children: [
-        BOX.v,
-        " ",
-        /* @__PURE__ */ jsx(Text, { dimColor: true, children: timestamp }),
-        /* @__PURE__ */ jsx(Text, { color: "cyan", children: icon }),
-        " ",
-        /* @__PURE__ */ jsx(Text, { color: style.color, dimColor: style.dimColor, children: labelContent }),
-        " ".repeat(padding),
-        BOX.v
-      ] }, `activity-${i}`)
-    );
-    if (activity.subActivities && activity.subActivities.length > 0) {
-      const subPrefix = "          \u2514 ";
-      const subPrefixWidth = getDisplayWidth(subPrefix);
-      for (let j = 0; j < activity.subActivities.length; j++) {
-        const sub = activity.subActivities[j];
-        const subStyle = getActivityStyle(sub);
-        const subIcon = sub.icon;
-        const subIconWidth = getDisplayWidth(subIcon);
-        const subLabel = sub.label;
-        const subDetail = sub.detail;
-        const subContentPrefixWidth = subPrefixWidth + subIconWidth + 1;
-        const availableWidth = contentWidth - subContentPrefixWidth;
-        let subLabelContent;
-        let subDisplayWidth;
-        if (subDetail) {
-          const labelPart = `${subLabel}: `;
-          const detailAvailable = availableWidth - labelPart.length;
-          let truncatedDetail = subDetail;
-          if (getDisplayWidth(subDetail) > detailAvailable) {
-            truncatedDetail = "";
-            let currentWidth = 0;
-            for (const char of subDetail) {
-              const charWidth = getDisplayWidth(char);
-              if (currentWidth + charWidth > detailAvailable - 3) {
-                truncatedDetail += "...";
-                currentWidth += 3;
-                break;
-              }
-              truncatedDetail += char;
-              currentWidth += charWidth;
-            }
-          }
-          subLabelContent = labelPart + truncatedDetail;
-          subDisplayWidth = subContentPrefixWidth + labelPart.length + getDisplayWidth(truncatedDetail);
-        } else {
-          subLabelContent = subLabel;
-          subDisplayWidth = subContentPrefixWidth + subLabel.length;
-        }
-        const subPadding = Math.max(0, contentWidth - subDisplayWidth);
-        lines.push(
-          /* @__PURE__ */ jsxs(Text, { children: [
-            BOX.v,
-            " ",
-            /* @__PURE__ */ jsx(Text, { dimColor: true, children: subPrefix }),
-            /* @__PURE__ */ jsx(Text, { color: "cyan", children: subIcon }),
-            " ",
-            /* @__PURE__ */ jsx(Text, { color: subStyle.color, dimColor: subStyle.dimColor, children: subLabelContent }),
-            " ".repeat(subPadding),
-            BOX.v
-          ] }, `activity-${i}-sub-${j}`)
-        );
-      }
-    }
-  }
-  const hasTodos = state.todos && state.todos.length > 0;
-  const allCompleted = hasTodos && state.todos?.every((t) => t.status === "completed");
-  if (hasTodos && allCompleted) {
-    const todos = state.todos;
-    const summaryText = `Todo (${todos.length}/${todos.length} done)`;
-    const summaryIcon = "\u2713";
-    const timestamp = formatActivityTime(/* @__PURE__ */ new Date());
-    const timestampStr = `[${timestamp}] `;
-    const timestampWidth = timestampStr.length;
-    const iconWidth = getDisplayWidth(summaryIcon);
-    const prefixWidth = timestampWidth + iconWidth + 1;
-    const maxTextWidth = contentWidth - prefixWidth;
-    let displaySummary = summaryText;
-    if (getDisplayWidth(summaryText) > maxTextWidth) {
-      displaySummary = "";
-      let currentWidth = 0;
-      for (const char of summaryText) {
-        const charWidth = getDisplayWidth(char);
-        if (currentWidth + charWidth > maxTextWidth - 3) {
-          displaySummary += "...";
-          break;
-        }
-        displaySummary += char;
-        currentWidth += charWidth;
-      }
-    }
-    const summaryPadding = Math.max(
-      0,
-      contentWidth - prefixWidth - getDisplayWidth(displaySummary)
-    );
-    lines.push(
-      /* @__PURE__ */ jsxs(Text, { children: [
-        BOX.v,
-        " ",
-        /* @__PURE__ */ jsx(Text, { dimColor: true, children: timestampStr }),
-        /* @__PURE__ */ jsx(Text, { color: "green", children: summaryIcon }),
-        " ",
-        /* @__PURE__ */ jsx(Text, { color: "green", children: displaySummary }),
-        " ".repeat(summaryPadding),
-        BOX.v
-      ] }, "todo-summary")
-    );
-  }
-  const showTodoSection = hasTodos && !allCompleted;
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width, children: [
-    /* @__PURE__ */ jsx(Text, { children: createTitleLine(panelTitle, titleSuffix, width) }),
-    lines,
-    showTodoSection && /* @__PURE__ */ jsx(TodoSection, { todos: state.todos, width }),
-    /* @__PURE__ */ jsx(Text, { children: createBottomLine(width) })
-  ] });
-}
-
-// src/ui/GenericPanel.tsx
-import { Box as Box2, Text as Text2 } from "ink";
-import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-var PROGRESS_BAR_WIDTH = 10;
-function createProgressBar(done, total) {
-  if (total === 0) return "\u2591".repeat(PROGRESS_BAR_WIDTH);
-  const filled = Math.round(done / total * PROGRESS_BAR_WIDTH);
-  const empty = PROGRESS_BAR_WIDTH - filled;
-  return "\u2588".repeat(filled) + "\u2591".repeat(empty);
-}
-function formatTitleSuffix(countdown, relativeTime) {
-  if (countdown != null) {
-    const padded = String(countdown).padStart(2, " ");
-    return `\u21BB ${padded}s`;
-  }
-  if (relativeTime) return relativeTime;
-  return "";
-}
-function createProgressTitleLine(title, done, total, panelWidth, countdown, relativeTime) {
-  const label = ` ${title} `;
-  const count = ` ${done}/${total} `;
-  const bar = createProgressBar(done, total);
-  const suffix = formatTitleSuffix(countdown, relativeTime);
-  const suffixPart = suffix ? ` \xB7 ${suffix} ${BOX.h}` : "";
-  const dashCount = panelWidth - 3 - label.length - count.length - bar.length - suffixPart.length;
-  const dashes = BOX.h.repeat(Math.max(0, dashCount));
-  return BOX.tl + BOX.h + label + dashes + count + bar + suffixPart + BOX.tr;
-}
-function ListRenderer({
-  data,
-  width
-}) {
-  const items = data.items || [];
-  const contentWidth = getContentWidth(width);
-  if (items.length === 0 && !data.summary) {
-    return /* @__PURE__ */ jsxs2(Text2, { children: [
-      BOX.v,
-      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: padLine(" No data", width) }),
-      BOX.v
-    ] });
-  }
-  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
-    data.summary && /* @__PURE__ */ jsxs2(Text2, { children: [
-      BOX.v,
-      padLine(` ${truncate(data.summary, contentWidth)}`, width),
-      BOX.v
-    ] }),
-    items.map((item, index) => /* @__PURE__ */ jsxs2(Text2, { children: [
-      BOX.v,
-      padLine(` \u2022 ${truncate(item.text, contentWidth - 3)}`, width),
-      BOX.v
-    ] }, `list-item-${index}`)),
-    items.length === 0 && data.summary && null
-  ] });
-}
-function ProgressRenderer({
-  data,
-  width
-}) {
-  const items = data.items || [];
-  const contentWidth = getContentWidth(width);
-  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
-    data.summary && /* @__PURE__ */ jsxs2(Text2, { children: [
-      BOX.v,
-      padLine(` ${truncate(data.summary, contentWidth)}`, width),
-      BOX.v
-    ] }),
-    items.map((item, index) => {
-      const icon = item.status === "done" ? "\u2713" : item.status === "failed" ? "\u2717" : "\u25CB";
-      const line = ` ${icon} ${truncate(item.text, contentWidth - 3)}`;
-      return /* @__PURE__ */ jsxs2(Text2, { children: [
-        BOX.v,
-        padLine(line, width),
-        BOX.v
-      ] }, `progress-item-${index}`);
-    }),
-    items.length === 0 && !data.summary && /* @__PURE__ */ jsxs2(Text2, { children: [
-      BOX.v,
-      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: padLine(" No data", width) }),
-      BOX.v
-    ] })
-  ] });
-}
-function StatusRenderer({
-  data,
-  width
-}) {
-  const stats = data.stats || { passed: 0, failed: 0 };
-  const items = data.items?.filter((i) => i.status === "failed") || [];
-  const innerWidth = getInnerWidth(width);
-  const contentWidth = getContentWidth(width);
-  let summaryLength = 1 + 2 + String(stats.passed).length + " passed".length;
-  if (stats.failed > 0) {
-    summaryLength += 2 + 2 + String(stats.failed).length + " failed".length;
-  }
-  if (stats.skipped && stats.skipped > 0) {
-    summaryLength += 2 + 2 + String(stats.skipped).length + " skipped".length;
-  }
-  const summaryPadding = Math.max(0, innerWidth - summaryLength);
-  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
-    data.summary && /* @__PURE__ */ jsxs2(Text2, { children: [
-      BOX.v,
-      padLine(` ${truncate(data.summary, contentWidth)}`, width),
-      BOX.v
-    ] }),
-    /* @__PURE__ */ jsxs2(Text2, { children: [
-      BOX.v,
-      " ",
-      /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
-        "\u2713 ",
-        stats.passed,
-        " passed"
-      ] }),
-      stats.failed > 0 && /* @__PURE__ */ jsxs2(Fragment2, { children: [
-        "  ",
-        /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
-          "\u2717 ",
-          stats.failed,
-          " failed"
-        ] })
-      ] }),
-      stats.skipped && stats.skipped > 0 && /* @__PURE__ */ jsxs2(Fragment2, { children: [
-        "  ",
-        /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
-          "\u25CB ",
-          stats.skipped,
-          " skipped"
-        ] })
-      ] }),
-      " ".repeat(summaryPadding),
-      BOX.v
-    ] }),
-    items.length > 0 && items.map((item, index) => /* @__PURE__ */ jsxs2(Text2, { children: [
-      BOX.v,
-      padLine(` \u2022 ${truncate(item.text, contentWidth - 3)}`, width),
-      BOX.v
-    ] }, `status-item-${index}`))
-  ] });
-}
-function GenericPanel({
-  data,
-  renderer = "list",
-  countdown,
-  relativeTime,
-  error,
-  width = DEFAULT_PANEL_WIDTH,
-  isRunning = false,
-  justRefreshed = false
-}) {
-  const suffix = isRunning ? "running..." : formatTitleSuffix(countdown, relativeTime);
-  const _suffixColor = isRunning ? "yellow" : justRefreshed ? "green" : void 0;
-  const progress = data.progress || { done: 0, total: 0 };
-  if (error) {
-    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", width, children: [
-      /* @__PURE__ */ jsx2(Text2, { children: createTitleLine(data.title, suffix, width) }),
-      /* @__PURE__ */ jsxs2(Text2, { children: [
-        BOX.v,
-        /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: padLine(` ${error}`, width) }),
-        BOX.v
-      ] }),
-      /* @__PURE__ */ jsx2(Text2, { children: createBottomLine(width) })
-    ] });
-  }
-  if (renderer === "progress") {
-    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", width, children: [
-      /* @__PURE__ */ jsx2(Text2, { children: createProgressTitleLine(
-        data.title,
-        progress.done,
-        progress.total,
-        width,
-        countdown,
-        relativeTime
-      ) }),
-      /* @__PURE__ */ jsx2(ProgressRenderer, { data, width }),
-      /* @__PURE__ */ jsx2(Text2, { children: createBottomLine(width) })
-    ] });
-  }
-  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", width, children: [
-    /* @__PURE__ */ jsx2(Text2, { children: createTitleLine(data.title, suffix, width) }),
-    renderer === "status" ? /* @__PURE__ */ jsx2(StatusRenderer, { data, width }) : /* @__PURE__ */ jsx2(ListRenderer, { data, width }),
-    /* @__PURE__ */ jsx2(Text2, { children: createBottomLine(width) })
-  ] });
-}
-
-// src/ui/GitPanel.tsx
-import { Box as Box3, Text as Text3 } from "ink";
-import { Fragment as Fragment3, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
-var MAX_COMMITS = 5;
-function formatCountdown2(seconds) {
-  if (seconds == null) return "";
-  const padded = String(seconds).padStart(2, " ");
-  return `\u21BB ${padded}s`;
-}
-function GitPanel({
-  branch,
-  commits,
-  stats,
-  uncommitted = 0,
-  countdown,
-  width = DEFAULT_PANEL_WIDTH,
-  isRunning = false,
-  justRefreshed = false
-}) {
-  const countdownSuffix = isRunning ? "running..." : formatCountdown2(countdown);
-  const innerWidth = getInnerWidth(width);
-  const contentWidth = getContentWidth(width);
-  const maxMessageLength = contentWidth - 10;
-  if (branch === null) {
-    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width, children: [
-      /* @__PURE__ */ jsx3(Text3, { children: createTitleLine("Git", countdownSuffix, width) }),
-      /* @__PURE__ */ jsxs3(Text3, { children: [
-        BOX.v,
-        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: padLine(" Not a git repository", width) }),
-        BOX.v
-      ] }),
-      /* @__PURE__ */ jsx3(Text3, { children: createBottomLine(width) })
-    ] });
-  }
-  const displayCommits = commits.slice(0, MAX_COMMITS);
-  const hasCommits = commits.length > 0;
-  const commitWord = commits.length === 1 ? "commit" : "commits";
-  const fileWord = stats.files === 1 ? "file" : "files";
-  const hasUncommitted = uncommitted > 0;
-  let statsSuffix = "";
-  if (hasCommits) {
-    statsSuffix = ` \xB7 +${stats.added} -${stats.deleted} \xB7 ${commits.length} ${commitWord} \xB7 ${stats.files} ${fileWord}`;
-  }
-  if (hasUncommitted) {
-    statsSuffix += ` \xB7 ${uncommitted} dirty`;
-  }
-  const availableForBranch = innerWidth - 1 - statsSuffix.length;
-  const displayBranch = availableForBranch > 3 ? truncate(branch, availableForBranch) : truncate(branch, 10);
-  const branchLineLength = 1 + displayBranch.length + statsSuffix.length;
-  const branchPadding = Math.max(0, innerWidth - branchLineLength);
-  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width, children: [
-    /* @__PURE__ */ jsx3(Text3, { children: createTitleLine("Git", countdownSuffix, width) }),
-    /* @__PURE__ */ jsxs3(Text3, { children: [
-      BOX.v,
-      " ",
-      /* @__PURE__ */ jsx3(Text3, { color: "green", children: displayBranch }),
-      hasCommits && /* @__PURE__ */ jsxs3(Fragment3, { children: [
-        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " \xB7 " }),
-        /* @__PURE__ */ jsxs3(Text3, { color: "green", children: [
-          "+",
-          stats.added
-        ] }),
-        /* @__PURE__ */ jsx3(Text3, { children: " " }),
-        /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
-          "-",
-          stats.deleted
-        ] }),
-        /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
-          " ",
-          "\xB7 ",
-          commits.length,
-          " ",
-          commitWord,
-          " \xB7 ",
-          stats.files,
-          " ",
-          fileWord
-        ] })
-      ] }),
-      hasUncommitted && /* @__PURE__ */ jsxs3(Fragment3, { children: [
-        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " \xB7 " }),
-        /* @__PURE__ */ jsxs3(Text3, { color: "yellow", children: [
-          uncommitted,
-          " dirty"
-        ] })
-      ] }),
-      " ".repeat(branchPadding),
-      BOX.v
-    ] }),
-    hasCommits ? /* @__PURE__ */ jsx3(Fragment3, { children: displayCommits.map((commit) => {
-      const msg = truncate(commit.message, maxMessageLength);
-      const lineLength = 3 + 7 + 1 + msg.length;
-      const commitPadding = Math.max(0, innerWidth - lineLength);
-      return /* @__PURE__ */ jsxs3(Text3, { children: [
-        BOX.v,
-        " \u2022 ",
-        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: commit.hash.slice(0, 7) }),
-        " ",
-        msg,
-        " ".repeat(commitPadding),
-        BOX.v
-      ] }, commit.hash);
-    }) }) : /* @__PURE__ */ jsxs3(Text3, { children: [
-      BOX.v,
-      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: padLine(" No commits today", width) }),
-      BOX.v
-    ] }),
-    /* @__PURE__ */ jsx3(Text3, { children: createBottomLine(width) })
-  ] });
-}
-
-// src/ui/hooks/useCountdown.ts
-import { useCallback, useEffect as useEffect2, useMemo, useRef, useState as useState2 } from "react";
-function toSeconds(intervalMs) {
-  if (intervalMs === null) return null;
-  return Math.floor(intervalMs / 1e3);
-}
-function useCountdown({
-  panels,
-  customPanels,
-  enabled
-}) {
-  const initialCountdowns = useMemo(() => {
-    const result = {};
-    for (const [name, config] of Object.entries(panels)) {
-      result[name] = toSeconds(config.interval);
-    }
-    if (customPanels) {
-      for (const [name, config] of Object.entries(customPanels)) {
-        result[name] = toSeconds(config.interval);
-      }
-    }
-    return result;
-  }, [panels, customPanels]);
-  const intervalSeconds = useMemo(() => {
-    const result = {};
-    for (const [name, config] of Object.entries(panels)) {
-      result[name] = toSeconds(config.interval);
-    }
-    if (customPanels) {
-      for (const [name, config] of Object.entries(customPanels)) {
-        result[name] = toSeconds(config.interval);
-      }
-    }
-    return result;
-  }, [panels, customPanels]);
-  const [countdowns, setCountdowns] = useState2(initialCountdowns);
-  const intervalSecondsRef = useRef(intervalSeconds);
-  intervalSecondsRef.current = intervalSeconds;
-  useEffect2(() => {
-    if (!enabled) return;
-    const timer = setInterval(() => {
-      setCountdowns((prev) => {
-        const next = {};
-        for (const [name, value] of Object.entries(prev)) {
-          if (value === null) {
-            next[name] = null;
-          } else if (value > 1) {
-            next[name] = value - 1;
-          } else {
-            next[name] = 1;
-          }
-        }
-        return next;
-      });
-    }, 1e3);
-    return () => clearInterval(timer);
-  }, [enabled]);
-  const reset = useCallback((panelName) => {
-    const interval = intervalSecondsRef.current[panelName];
-    if (interval === null || interval === void 0) return;
-    setCountdowns((prev) => ({
-      ...prev,
-      [panelName]: interval
-    }));
-  }, []);
-  const resetAll = useCallback(() => {
-    setCountdowns((prev) => {
-      const next = {};
-      for (const name of Object.keys(prev)) {
-        const interval = intervalSecondsRef.current[name];
-        next[name] = interval ?? prev[name];
-      }
-      return next;
-    });
-  }, []);
-  return {
-    countdowns,
-    reset,
-    resetAll
-  };
-}
-
-// src/ui/hooks/useHotkeys.ts
-import { useCallback as useCallback2, useMemo as useMemo2 } from "react";
-var RESERVED_KEYS = /* @__PURE__ */ new Set(["r", "q"]);
-function useHotkeys({
-  manualPanels,
-  onRefreshAll,
-  onQuit
-}) {
-  const hotkeys = useMemo2(() => {
-    const result = [];
-    const usedKeys = new Set(RESERVED_KEYS);
-    for (const panel of manualPanels) {
-      let assignedKey = null;
-      for (const char of panel.name.toLowerCase()) {
-        if (!usedKeys.has(char)) {
-          assignedKey = char;
-          usedKeys.add(char);
-          break;
-        }
-      }
-      if (assignedKey) {
-        result.push({
-          key: assignedKey,
-          label: panel.label,
-          action: panel.action
-        });
-      }
-    }
-    result.push({
-      key: "r",
-      label: "refresh all",
-      action: onRefreshAll
-    });
-    result.push({
-      key: "q",
-      label: "quit",
-      action: onQuit
-    });
-    return result;
-  }, [manualPanels, onRefreshAll, onQuit]);
-  const handleInput = useCallback2(
-    (key) => {
-      const hotkey = hotkeys.find((h) => h.key === key);
-      if (hotkey) {
-        hotkey.action();
-      }
-    },
-    [hotkeys]
-  );
-  const statusBarItems = useMemo2(() => {
-    return hotkeys.map((h) => `${h.key}: ${h.label}`);
-  }, [hotkeys]);
-  return {
-    hotkeys,
-    handleInput,
-    statusBarItems
-  };
-}
-
-// src/ui/hooks/useVisualFeedback.ts
-import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef2, useState as useState3 } from "react";
-var DEFAULT_VISUAL_STATE = {
-  isRunning: false,
-  justRefreshed: false,
-  justCompleted: false
-};
-var FEEDBACK_DURATION = 1500;
-function useVisualFeedback({
-  panels
-}) {
-  const [states, setStates] = useState3(() => {
-    const initial = {};
-    for (const panel of panels) {
-      initial[panel] = { ...DEFAULT_VISUAL_STATE };
-    }
-    return initial;
-  });
-  const timeoutsRef = useRef2(/* @__PURE__ */ new Map());
-  useEffect3(() => {
-    return () => {
-      for (const timeout of timeoutsRef.current.values()) {
-        clearTimeout(timeout);
-      }
-      timeoutsRef.current.clear();
-    };
-  }, []);
-  const updateState = useCallback3(
-    (panel, update) => {
-      setStates((prev) => ({
-        ...prev,
-        [panel]: { ...prev[panel] || DEFAULT_VISUAL_STATE, ...update }
-      }));
-    },
-    []
-  );
-  const scheduleAutoClear = useCallback3(
-    (panel, key) => {
-      const timeoutKey = `${panel}:${key}`;
-      const existingTimeout = timeoutsRef.current.get(timeoutKey);
-      if (existingTimeout) {
-        clearTimeout(existingTimeout);
-      }
-      const timeout = setTimeout(() => {
-        updateState(panel, { [key]: false });
-        timeoutsRef.current.delete(timeoutKey);
-      }, FEEDBACK_DURATION);
-      timeoutsRef.current.set(timeoutKey, timeout);
-    },
-    [updateState]
-  );
-  const setRunning = useCallback3(
-    (panel, running) => {
-      updateState(panel, { isRunning: running });
-    },
-    [updateState]
-  );
-  const setRefreshed = useCallback3(
-    (panel) => {
-      updateState(panel, { justRefreshed: true });
-      scheduleAutoClear(panel, "justRefreshed");
-    },
-    [updateState, scheduleAutoClear]
-  );
-  const setCompleted = useCallback3(
-    (panel) => {
-      updateState(panel, { justCompleted: true });
-      scheduleAutoClear(panel, "justCompleted");
-    },
-    [updateState, scheduleAutoClear]
-  );
-  const startAsync = useCallback3(
-    (panel) => {
-      setRunning(panel, true);
-    },
-    [setRunning]
-  );
-  const endAsync = useCallback3(
-    (panel, opts) => {
-      setRunning(panel, false);
-      if (opts?.completed) {
-        setCompleted(panel);
-      } else {
-        setRefreshed(panel);
-      }
-    },
-    [setRunning, setRefreshed, setCompleted]
-  );
-  const getState = useCallback3(
-    (panel) => {
-      return states[panel] || { ...DEFAULT_VISUAL_STATE };
-    },
-    [states]
-  );
-  return {
-    states,
-    setRunning,
-    setRefreshed,
-    setCompleted,
-    startAsync,
-    endAsync,
-    getState
-  };
-}
-
-// src/ui/OtherSessionsPanel.tsx
-import { Box as Box4, Text as Text4 } from "ink";
-import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
-function formatCountdown3(seconds) {
-  if (seconds == null) return "";
-  const padded = String(seconds).padStart(2, " ");
-  return `\u21BB ${padded}s`;
-}
-function truncateMessage(message, maxLength) {
-  if (getDisplayWidth(message) <= maxLength) {
-    return message;
-  }
-  let truncated = "";
-  let currentWidth = 0;
-  for (const char of message) {
-    const charWidth = getDisplayWidth(char);
-    if (currentWidth + charWidth > maxLength - 3) {
-      truncated += "...";
-      break;
-    }
-    truncated += char;
-    currentWidth += charWidth;
-  }
-  return truncated;
-}
-function formatProjectNames(projectNames, maxWidth) {
-  if (projectNames.length === 0) {
-    return "No projects";
-  }
-  const MAX_NAMES_TO_SHOW = 3;
-  const remaining = projectNames.length - MAX_NAMES_TO_SHOW;
-  let namesToShow = projectNames.slice(0, MAX_NAMES_TO_SHOW);
-  let suffix = remaining > 0 ? ` +${remaining}` : "";
-  const availableWidth = maxWidth;
-  let text = namesToShow.join(", ") + suffix;
-  if (text.length <= availableWidth) {
-    return text;
-  }
-  for (let count = MAX_NAMES_TO_SHOW - 1; count >= 1; count--) {
-    namesToShow = projectNames.slice(0, count);
-    const newRemaining = projectNames.length - count;
-    suffix = newRemaining > 0 ? ` +${newRemaining}` : "";
-    text = namesToShow.join(", ") + suffix;
-    if (text.length <= availableWidth) {
-      return text;
-    }
-  }
-  const firstProject = projectNames[0];
-  const remainingCount = projectNames.length - 1;
-  suffix = remainingCount > 0 ? ` +${remainingCount}` : "";
-  const suffixLen = suffix.length;
-  const maxNameLen = availableWidth - suffixLen - 3;
-  if (maxNameLen > 0) {
-    return `${firstProject.slice(0, maxNameLen)}...${suffix}`;
-  }
-  return "...";
-}
-function OtherSessionsPanel({
-  data,
-  countdown,
-  width = DEFAULT_PANEL_WIDTH,
-  isRunning = false,
-  messageMaxLength = 50
-}) {
-  const countdownSuffix = isRunning ? "running..." : formatCountdown3(countdown);
-  const innerWidth = getInnerWidth(width);
-  const contentWidth = innerWidth - 1;
-  const { activeCount, projectNames, recentSession } = data;
-  const activeSuffix = ` | * ${activeCount} active`;
-  const projectsAvailableWidth = contentWidth - getDisplayWidth(activeSuffix);
-  const projectsText = formatProjectNames(projectNames, projectsAvailableWidth);
-  const headerText = `${projectsText}${activeSuffix}`;
-  const headerPadding = Math.max(0, contentWidth - getDisplayWidth(headerText));
-  const hasProjects = projectNames.length > 0;
-  const hasActive = activeCount > 0;
-  const lines = [];
-  lines.push(
-    /* @__PURE__ */ jsxs4(Text4, { children: [
-      BOX.v,
-      " ",
-      /* @__PURE__ */ jsx4(Text4, { dimColor: !hasProjects, color: hasProjects ? "cyan" : void 0, children: projectsText }),
-      /* @__PURE__ */ jsxs4(Text4, { dimColor: !hasActive, color: hasActive ? "yellow" : void 0, children: [
-        " ",
-        "| * ",
-        activeCount,
-        " active"
-      ] }),
-      " ".repeat(headerPadding),
-      BOX.v
-    ] }, "header")
-  );
-  lines.push(
-    /* @__PURE__ */ jsxs4(Text4, { children: [
-      BOX.v,
-      " ",
-      " ".repeat(contentWidth),
-      BOX.v
-    ] }, "empty")
-  );
-  if (recentSession) {
-    const statusIcon = recentSession.isActive ? "*" : "o";
-    const sessionLine = `${statusIcon} ${recentSession.projectName} (${recentSession.relativeTime})`;
-    const sessionLinePadding = Math.max(
-      0,
-      contentWidth - getDisplayWidth(sessionLine)
-    );
-    lines.push(
-      /* @__PURE__ */ jsxs4(Text4, { children: [
-        BOX.v,
-        " ",
-        /* @__PURE__ */ jsx4(Text4, { children: sessionLine }),
-        " ".repeat(sessionLinePadding),
-        BOX.v
-      ] }, "session")
-    );
-    if (recentSession.lastMessage) {
-      const indent = "   ";
-      const quotePrefix = '"';
-      const quoteSuffix = '"';
-      const availableWidth = contentWidth - indent.length - 2;
-      const truncatedMessage = truncateMessage(
-        recentSession.lastMessage,
-        Math.min(availableWidth, messageMaxLength)
-      );
-      const messageText = `${indent}${quotePrefix}${truncatedMessage}${quoteSuffix}`;
-      const messagePadding = Math.max(
-        0,
-        contentWidth - getDisplayWidth(messageText)
-      );
-      lines.push(
-        /* @__PURE__ */ jsxs4(Text4, { children: [
-          BOX.v,
-          " ",
-          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: messageText }),
-          " ".repeat(messagePadding),
-          BOX.v
-        ] }, "message")
-      );
-    }
-  } else {
-    const noSessionText = "No other active sessions";
-    const noSessionPadding = Math.max(0, contentWidth - noSessionText.length);
-    lines.push(
-      /* @__PURE__ */ jsxs4(Text4, { children: [
-        BOX.v,
-        " ",
-        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: noSessionText }),
-        " ".repeat(noSessionPadding),
-        BOX.v
-      ] }, "no-session")
-    );
-  }
-  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", width, children: [
-    /* @__PURE__ */ jsx4(Text4, { children: createTitleLine("Other Sessions", countdownSuffix, width) }),
-    lines,
-    /* @__PURE__ */ jsx4(Text4, { children: createBottomLine(width) })
-  ] });
-}
-
-// src/ui/ProjectPanel.tsx
-import { Box as Box5, Text as Text5 } from "ink";
-import { Fragment as Fragment4, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
-function formatCountdown4(seconds) {
-  if (seconds == null) return "";
-  const padded = String(seconds).padStart(2, " ");
-  return `\u21BB ${padded}s`;
-}
-function formatLineCount(count) {
-  if (count >= 1e3) {
-    return `${(count / 1e3).toFixed(1)}k`;
-  }
-  return String(count);
-}
-function ProjectPanel({
-  data,
-  countdown,
-  width = DEFAULT_PANEL_WIDTH,
-  isRunning = false,
-  justRefreshed = false
-}) {
-  const countdownSuffix = isRunning ? "running..." : formatCountdown4(countdown);
-  const innerWidth = getInnerWidth(width);
-  if (data.error) {
-    return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", width, children: [
-      /* @__PURE__ */ jsx5(Text5, { children: createTitleLine("Project", countdownSuffix, width) }),
-      /* @__PURE__ */ jsxs5(Text5, { children: [
-        BOX.v,
-        /* @__PURE__ */ jsx5(Text5, { color: "red", children: padLine(` ${data.error}`, width) }),
-        BOX.v
-      ] }),
-      /* @__PURE__ */ jsx5(Text5, { children: createBottomLine(width) })
-    ] });
-  }
-  const headerParts = [data.name];
-  if (data.language) {
-    headerParts.push(data.language);
-  }
-  if (data.license) {
-    headerParts.push(data.license);
-  }
-  const headerText = headerParts.join(" \xB7 ");
-  const headerPadding = Math.max(0, innerWidth - 1 - headerText.length);
-  const hasStack = data.stack.length > 0;
-  const stackText = hasStack ? `Stack: ${data.stack.join(", ")}` : "";
-  const stackPadding = Math.max(0, innerWidth - 1 - stackText.length);
-  const filesText = `Files: ${data.fileCount} ${data.fileExtension}`;
-  const linesText = `Lines: ${formatLineCount(data.lineCount)}`;
-  const filesLinesText = `${filesText} \xB7 ${linesText}`;
-  const filesLinesPadding = Math.max(0, innerWidth - 1 - filesLinesText.length);
-  let depsText = "Deps: ";
-  if (data.prodDeps > 0 && data.devDeps > 0) {
-    depsText += `${data.prodDeps} prod \xB7 ${data.devDeps} dev`;
-  } else if (data.prodDeps > 0) {
-    depsText += `${data.prodDeps}`;
-  } else if (data.devDeps > 0) {
-    depsText += `${data.devDeps} dev`;
-  } else {
-    depsText += "0";
-  }
-  const depsPadding = Math.max(0, innerWidth - 1 - depsText.length);
-  const _countdownColor = justRefreshed ? "green" : void 0;
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", width, children: [
-    /* @__PURE__ */ jsx5(Text5, { children: createTitleLine("Project", countdownSuffix, width) }),
-    /* @__PURE__ */ jsxs5(Text5, { children: [
-      BOX.v,
-      " ",
-      /* @__PURE__ */ jsx5(Text5, { bold: true, children: data.name }),
-      data.language && /* @__PURE__ */ jsxs5(Fragment4, { children: [
-        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " \xB7 " }),
-        /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: data.language })
-      ] }),
-      data.license && /* @__PURE__ */ jsxs5(Fragment4, { children: [
-        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " \xB7 " }),
-        /* @__PURE__ */ jsx5(Text5, { children: data.license })
-      ] }),
-      " ".repeat(headerPadding),
-      BOX.v
-    ] }),
-    hasStack && /* @__PURE__ */ jsxs5(Text5, { children: [
-      BOX.v,
-      " ",
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Stack:" }),
-      " ",
-      /* @__PURE__ */ jsx5(Text5, { children: data.stack.join(", ") }),
-      " ".repeat(stackPadding),
-      BOX.v
-    ] }),
-    /* @__PURE__ */ jsxs5(Text5, { children: [
-      BOX.v,
-      " ",
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Files:" }),
-      " ",
-      /* @__PURE__ */ jsxs5(Text5, { children: [
-        data.fileCount,
-        " ",
-        data.fileExtension
-      ] }),
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " \xB7 " }),
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Lines:" }),
-      " ",
-      /* @__PURE__ */ jsx5(Text5, { children: formatLineCount(data.lineCount) }),
-      " ".repeat(filesLinesPadding),
-      BOX.v
-    ] }),
-    /* @__PURE__ */ jsxs5(Text5, { children: [
-      BOX.v,
-      " ",
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Deps:" }),
-      " ",
-      data.prodDeps > 0 && data.devDeps > 0 ? /* @__PURE__ */ jsxs5(Fragment4, { children: [
-        /* @__PURE__ */ jsxs5(Text5, { children: [
-          data.prodDeps,
-          " prod"
-        ] }),
-        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " \xB7 " }),
-        /* @__PURE__ */ jsxs5(Text5, { children: [
-          data.devDeps,
-          " dev"
-        ] })
-      ] }) : data.prodDeps > 0 ? /* @__PURE__ */ jsx5(Text5, { children: data.prodDeps }) : data.devDeps > 0 ? /* @__PURE__ */ jsxs5(Text5, { children: [
-        data.devDeps,
-        " dev"
-      ] }) : /* @__PURE__ */ jsx5(Text5, { children: "0" }),
-      " ".repeat(depsPadding),
-      BOX.v
-    ] }),
-    /* @__PURE__ */ jsx5(Text5, { children: createBottomLine(width) })
-  ] });
-}
-
-// src/ui/TestPanel.tsx
-import { Box as Box6, Text as Text6 } from "ink";
-import { Fragment as Fragment5, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
-function formatRelativeTime2(timestamp) {
-  const now = Date.now();
-  const then = new Date(timestamp).getTime();
-  const diffMs = now - then;
-  const diffMins = Math.floor(diffMs / 6e4);
-  const diffHours = Math.floor(diffMs / 36e5);
-  const diffDays = Math.floor(diffMs / 864e5);
-  if (diffMins < 1) return "just now";
-  if (diffMins < 60) return `${diffMins}m ago`;
-  if (diffHours < 24) return `${diffHours}h ago`;
-  return `${diffDays}d ago`;
-}
-function createSeparator(panelWidth) {
-  return BOX.ml + BOX.h.repeat(getInnerWidth(panelWidth)) + BOX.mr;
-}
-function TestPanel({
-  results,
-  isOutdated,
-  commitsBehind,
-  error,
-  width = DEFAULT_PANEL_WIDTH,
-  isRunning = false,
-  justCompleted = false
-}) {
-  const innerWidth = getInnerWidth(width);
-  const contentWidth = getContentWidth(width);
-  const getTitleSuffix = () => {
-    if (isRunning) return "running...";
-    if (justCompleted) return "just now";
-    if (results) return formatRelativeTime2(results.timestamp);
-    return "";
-  };
-  const titleSuffix = getTitleSuffix();
-  if (error || !results) {
-    const message = error || (isRunning ? "Running..." : "Loading...");
-    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", width, children: [
-      /* @__PURE__ */ jsx6(Text6, { children: createTitleLine("Tests", titleSuffix, width) }),
-      /* @__PURE__ */ jsxs6(Text6, { children: [
-        BOX.v,
-        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: padLine(` ${message}`, width) }),
-        BOX.v
-      ] }),
-      /* @__PURE__ */ jsx6(Text6, { children: createBottomLine(width) })
-    ] });
-  }
-  const hasFailures = results.failures.length > 0;
-  const relativeTime = titleSuffix;
-  let summaryLength = 1 + 2 + String(results.passed).length + " passed".length;
-  if (results.failed > 0) {
-    summaryLength += 2 + 2 + String(results.failed).length + " failed".length;
-  }
-  if (results.skipped > 0) {
-    summaryLength += 2 + 2 + String(results.skipped).length + " skipped".length;
-  }
-  summaryLength += " \xB7 ".length + results.hash.length;
-  const summaryPadding = Math.max(0, innerWidth - summaryLength);
-  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", width, children: [
-    /* @__PURE__ */ jsx6(Text6, { children: createTitleLine("Tests", relativeTime, width) }),
-    isOutdated && /* @__PURE__ */ jsxs6(Text6, { children: [
-      BOX.v,
-      /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: padLine(
-        ` \u26A0 Outdated (${commitsBehind} ${commitsBehind === 1 ? "commit" : "commits"} behind)`,
-        width
-      ) }),
-      BOX.v
-    ] }),
-    /* @__PURE__ */ jsxs6(Text6, { children: [
-      BOX.v,
-      " ",
-      /* @__PURE__ */ jsxs6(Text6, { color: "green", children: [
-        "\u2713 ",
-        results.passed,
-        " passed"
-      ] }),
-      results.failed > 0 && /* @__PURE__ */ jsxs6(Fragment5, { children: [
-        "  ",
-        /* @__PURE__ */ jsxs6(Text6, { color: "red", children: [
-          "\u2717 ",
-          results.failed,
-          " failed"
-        ] })
-      ] }),
-      results.skipped > 0 && /* @__PURE__ */ jsxs6(Fragment5, { children: [
-        "  ",
-        /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
-          "\u25CB ",
-          results.skipped,
-          " skipped"
-        ] })
-      ] }),
-      /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
-        " \xB7 ",
-        results.hash
-      ] }),
-      " ".repeat(summaryPadding),
-      BOX.v
-    ] }),
-    hasFailures && /* @__PURE__ */ jsxs6(Fragment5, { children: [
-      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: createSeparator(width) }),
-      results.failures.map((failure, index) => {
-        const fileName = truncate(failure.file, contentWidth - 3);
-        const filePadding = Math.max(0, innerWidth - 3 - fileName.length);
-        const testName = truncate(failure.name, contentWidth - 5);
-        const testPadding = Math.max(0, innerWidth - 5 - testName.length);
-        return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsxs6(Text6, { children: [
-            BOX.v,
-            " ",
-            /* @__PURE__ */ jsxs6(Text6, { color: "red", children: [
-              "\u2717 ",
-              fileName
-            ] }),
-            " ".repeat(filePadding),
-            BOX.v
-          ] }),
-          /* @__PURE__ */ jsxs6(Text6, { children: [
-            BOX.v,
-            "   ",
-            "\u2022 ",
-            testName,
-            " ".repeat(testPadding),
-            BOX.v
-          ] })
-        ] }, `failure-${index}`);
-      })
-    ] }),
-    /* @__PURE__ */ jsx6(Text6, { children: createBottomLine(width) })
-  ] });
-}
-
-// src/ui/WelcomePanel.tsx
-import { Box as Box7, Text as Text7 } from "ink";
-import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
-function WelcomePanel() {
-  return /* @__PURE__ */ jsxs7(
-    Box7,
-    {
-      flexDirection: "column",
-      borderStyle: "single",
-      paddingX: 1,
-      width: DEFAULT_PANEL_WIDTH,
-      children: [
-        /* @__PURE__ */ jsx7(Box7, { marginTop: -1, children: /* @__PURE__ */ jsx7(Text7, { children: " Welcome to agenthud " }) }),
-        /* @__PURE__ */ jsx7(Text7, { children: " " }),
-        /* @__PURE__ */ jsx7(Text7, { children: " No .agenthud/ directory found." }),
-        /* @__PURE__ */ jsx7(Text7, { children: " " }),
-        /* @__PURE__ */ jsx7(Text7, { children: " Quick setup:" }),
-        /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: " npx agenthud init" }),
-        /* @__PURE__ */ jsx7(Text7, { children: " " }),
-        /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: " Or visit: github.com/neochoon/agenthud" }),
-        /* @__PURE__ */ jsx7(Text7, { children: " " }),
-        /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: " Press q to quit" })
-      ]
-    }
-  );
-}
-
-// src/ui/App.tsx
-import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
-function formatRelativeTime3(timestamp) {
-  const now = Date.now();
-  const then = new Date(timestamp).getTime();
-  const diffMs = now - then;
-  const diffMins = Math.floor(diffMs / 6e4);
-  const diffHours = Math.floor(diffMs / 36e5);
-  const diffDays = Math.floor(diffMs / 864e5);
-  if (diffMins < 1) return "just now";
-  if (diffMins < 60) return `${diffMins}m ago`;
-  if (diffHours < 24) return `${diffHours}h ago`;
-  return `${diffDays}d ago`;
-}
-function WelcomeApp() {
-  const { exit } = useApp();
-  useInput((input) => {
-    if (input === "q") {
-      exit();
-    }
-  });
-  return /* @__PURE__ */ jsx8(WelcomePanel, {});
-}
-function getClampedWidth(columns) {
-  if (!columns || columns <= 0) {
-    return DEFAULT_FALLBACK_WIDTH;
-  }
-  return Math.min(Math.max(columns, MIN_TERMINAL_WIDTH), MAX_TERMINAL_WIDTH);
-}
-function DashboardApp({
-  mode
-}) {
-  const { exit } = useApp();
-  const { stdout } = useStdout();
-  const isWatchMode = mode === "watch";
-  const { config, warnings } = useMemo3(() => parseConfig(), []);
-  const getEffectiveWidth = useCallback4(
-    (terminalColumns) => {
-      if (config.width) return config.width;
-      return getClampedWidth(terminalColumns);
-    },
-    [config.width]
-  );
-  const getEffectiveMaxActivities = useCallback4(
-    (terminalRows, todoCount = 0, isWideLayout = false) => {
-      const configMax = config.panels.claude.maxActivities ?? 10;
-      if (!terminalRows || !isWideLayout) {
-        return configMax;
-      }
-      const todoHeight = todoCount > 0 ? 1 + todoCount : 0;
-      const heightBasedMax = Math.max(5, terminalRows - 13 - todoHeight);
-      return Math.max(configMax, heightBasedMax);
-    },
-    [config.panels.claude.maxActivities]
-  );
-  const [width, setWidth] = useState4(() => getEffectiveWidth(stdout?.columns));
-  useEffect4(() => {
-    if (!config.width) {
-      const newWidth = getEffectiveWidth(stdout?.columns);
-      if (newWidth !== width) setWidth(newWidth);
-    }
-  }, [stdout?.columns, width, config.width, getEffectiveWidth]);
-  useEffect4(() => {
-    if (config.width) return;
-    const handleResize = () => setWidth(getEffectiveWidth(stdout?.columns));
-    stdout?.on("resize", handleResize);
-    return () => {
-      stdout?.off("resize", handleResize);
-    };
-  }, [stdout, config.width, getEffectiveWidth]);
-  const customPanelNames = useMemo3(
-    () => Object.keys(config.customPanels || {}),
-    [config.customPanels]
-  );
-  const allPanelNames = useMemo3(
-    () => [
-      "project",
-      "git",
-      "tests",
-      "claude",
-      "other_sessions",
-      ...customPanelNames
-    ],
-    [customPanelNames]
-  );
-  const panelIntervals = useMemo3(() => {
-    const panels = {
-      project: { interval: config.panels.project.interval },
-      git: { interval: config.panels.git.interval },
-      tests: { interval: config.panels.tests.interval },
-      claude: { interval: config.panels.claude.interval },
-      other_sessions: { interval: config.panels.other_sessions.interval }
-    };
-    const customPanels = {};
-    if (config.customPanels) {
-      for (const [name, cfg] of Object.entries(config.customPanels)) {
-        customPanels[name] = { interval: cfg.interval };
-      }
-    }
-    return { panels, customPanels };
-  }, [config]);
-  const { countdowns, reset: resetCountdown } = useCountdown({
-    panels: panelIntervals.panels,
-    customPanels: panelIntervals.customPanels,
-    enabled: isWatchMode
-  });
-  const visualFeedback = useVisualFeedback({ panels: allPanelNames });
-  const cwd = process.cwd();
-  const [projectData, setProjectData] = useState4(
-    () => getProjectData()
-  );
-  const [gitData, setGitData] = useState4(
-    () => getGitData(config.panels.git)
-  );
-  const fetchMaxActivities = Math.max(
-    config.panels.claude.maxActivities ?? 10,
-    stdout?.rows ?? 50
-  );
-  const [claudeData, setClaudeData] = useState4(
-    () => getClaudeData(cwd, fetchMaxActivities, config.panels.claude.sessionTimeout)
-  );
-  const [otherSessionsData, setOtherSessionsData] = useState4(
-    () => getOtherSessionsData(cwd, {
-      activeThresholdMs: config.panels.other_sessions.activeThreshold
-    })
-  );
-  const getTestDataFromConfig = useCallback4(() => {
-    if (config.panels.tests.command) {
-      return runTestCommand(config.panels.tests.command);
-    }
-    return getTestData();
-  }, [config.panels.tests.command]);
-  const [testData, setTestData] = useState4({
-    results: null,
-    isOutdated: false,
-    commitsBehind: 0
-  });
-  const testsInitializedRef = useRef3(false);
-  useEffect4(() => {
-    if (testsInitializedRef.current) return;
-    testsInitializedRef.current = true;
-    const timer = setTimeout(() => {
-      setTestData(getTestDataFromConfig());
-    }, 0);
-    return () => clearTimeout(timer);
-  }, [getTestDataFromConfig]);
-  const [customPanelData, setCustomPanelData] = useState4(() => {
-    const data = {};
-    if (config.customPanels) {
-      for (const [name, panelConfig] of Object.entries(config.customPanels)) {
-        if (panelConfig.enabled) {
-          data[name] = getCustomPanelData(name, panelConfig);
-        }
-      }
-    }
-    return data;
-  });
-  const refreshProject = useCallback4(() => {
-    setProjectData(getProjectData());
-    visualFeedback.setRefreshed("project");
-    resetCountdown("project");
-  }, [visualFeedback, resetCountdown]);
-  const refreshGitAsync = useCallback4(async () => {
-    visualFeedback.startAsync("git");
-    try {
-      const data = await getGitDataAsync(config.panels.git);
-      setGitData(data);
-    } finally {
-      visualFeedback.endAsync("git");
-      resetCountdown("git");
-    }
-  }, [config.panels.git, visualFeedback, resetCountdown]);
-  const refreshTestAsync = useCallback4(async () => {
-    visualFeedback.startAsync("tests");
-    try {
-      await new Promise((resolve) => {
-        setTimeout(() => {
-          setTestData(getTestDataFromConfig());
-          resolve();
-        }, 0);
-      });
-    } finally {
-      visualFeedback.endAsync("tests", { completed: true });
-    }
-  }, [getTestDataFromConfig, visualFeedback]);
-  const refreshClaude = useCallback4(() => {
-    const maxFetch = Math.max(
-      config.panels.claude.maxActivities ?? 10,
-      stdout?.rows ?? 50
-    );
-    setClaudeData(
-      getClaudeData(cwd, maxFetch, config.panels.claude.sessionTimeout)
-    );
-    visualFeedback.setRefreshed("claude");
-    resetCountdown("claude");
-  }, [
-    cwd,
-    stdout?.rows,
-    config.panels.claude.maxActivities,
-    config.panels.claude.sessionTimeout,
-    visualFeedback,
-    resetCountdown
-  ]);
-  const refreshOtherSessions = useCallback4(() => {
-    setOtherSessionsData(
-      getOtherSessionsData(cwd, {
-        activeThresholdMs: config.panels.other_sessions.activeThreshold
-      })
-    );
-    visualFeedback.setRefreshed("other_sessions");
-    resetCountdown("other_sessions");
-  }, [
-    cwd,
-    config.panels.other_sessions.activeThreshold,
-    visualFeedback,
-    resetCountdown
-  ]);
-  const refreshCustomPanelAsync = useCallback4(
-    async (name) => {
-      if (config.customPanels?.[name]) {
-        visualFeedback.startAsync(name);
-        try {
-          const result = await getCustomPanelDataAsync(
-            name,
-            config.customPanels[name]
-          );
-          setCustomPanelData((prev) => ({ ...prev, [name]: result }));
-        } finally {
-          visualFeedback.endAsync(name);
-          resetCountdown(name);
-        }
-      }
-    },
-    [config.customPanels, visualFeedback, resetCountdown]
-  );
-  const refreshAll = useCallback4(() => {
-    if (config.panels.project.enabled) refreshProject();
-    if (config.panels.git.enabled) void refreshGitAsync();
-    if (config.panels.tests.enabled) void refreshTestAsync();
-    if (config.panels.claude.enabled) refreshClaude();
-    if (config.panels.other_sessions.enabled) refreshOtherSessions();
-    for (const name of customPanelNames) {
-      if (config.customPanels?.[name].enabled) {
-        void refreshCustomPanelAsync(name);
-      }
-    }
-  }, [
-    config,
-    customPanelNames,
-    refreshProject,
-    refreshGitAsync,
-    refreshTestAsync,
-    refreshClaude,
-    refreshOtherSessions,
-    refreshCustomPanelAsync
-  ]);
-  const manualPanels = useMemo3(() => {
-    const panels = [];
-    if (config.panels.tests.enabled && config.panels.tests.interval === null) {
-      panels.push({
-        name: "tests",
-        label: "run tests",
-        action: () => void refreshTestAsync()
-      });
-    }
-    if (config.customPanels) {
-      for (const [name, panelConfig] of Object.entries(config.customPanels)) {
-        if (panelConfig.enabled && panelConfig.interval === null) {
-          panels.push({
-            name,
-            label: `run ${name}`,
-            action: () => void refreshCustomPanelAsync(name)
-          });
-        }
-      }
-    }
-    return panels;
-  }, [config, refreshTestAsync, refreshCustomPanelAsync]);
-  const { handleInput, statusBarItems } = useHotkeys({
-    manualPanels,
-    onRefreshAll: refreshAll,
-    onQuit: exit
-  });
-  useInput(
-    (input) => {
-      handleInput(input);
-    },
-    { isActive: isWatchMode }
-  );
-  const refreshProjectRef = useRef3(refreshProject);
-  const refreshGitAsyncRef = useRef3(refreshGitAsync);
-  const refreshTestAsyncRef = useRef3(refreshTestAsync);
-  const refreshClaudeRef = useRef3(refreshClaude);
-  const refreshOtherSessionsRef = useRef3(refreshOtherSessions);
-  const refreshCustomPanelAsyncRef = useRef3(refreshCustomPanelAsync);
-  refreshProjectRef.current = refreshProject;
-  refreshGitAsyncRef.current = refreshGitAsync;
-  refreshTestAsyncRef.current = refreshTestAsync;
-  refreshClaudeRef.current = refreshClaude;
-  refreshOtherSessionsRef.current = refreshOtherSessions;
-  refreshCustomPanelAsyncRef.current = refreshCustomPanelAsync;
-  useEffect4(() => {
-    if (!isWatchMode) return;
-    const timers = [];
-    if (config.panels.project.enabled && config.panels.project.interval !== null) {
-      timers.push(
-        setInterval(
-          () => refreshProjectRef.current(),
-          config.panels.project.interval
-        )
-      );
-    }
-    if (config.panels.git.enabled && config.panels.git.interval !== null) {
-      timers.push(
-        setInterval(
-          () => void refreshGitAsyncRef.current(),
-          config.panels.git.interval
-        )
-      );
-    }
-    if (config.panels.tests.enabled && config.panels.tests.interval !== null) {
-      timers.push(
-        setInterval(
-          () => void refreshTestAsyncRef.current(),
-          config.panels.tests.interval
-        )
-      );
-    }
-    if (config.panels.claude.enabled && config.panels.claude.interval !== null) {
-      timers.push(
-        setInterval(
-          () => refreshClaudeRef.current(),
-          config.panels.claude.interval
-        )
-      );
-    }
-    if (config.panels.other_sessions.enabled && config.panels.other_sessions.interval !== null) {
-      timers.push(
-        setInterval(
-          () => refreshOtherSessionsRef.current(),
-          config.panels.other_sessions.interval
-        )
-      );
-    }
-    if (config.customPanels) {
-      for (const [name, panelConfig] of Object.entries(config.customPanels)) {
-        if (panelConfig.enabled && panelConfig.interval !== null) {
-          timers.push(
-            setInterval(
-              () => void refreshCustomPanelAsyncRef.current(name),
-              panelConfig.interval
-            )
-          );
-        }
-      }
-    }
-    return () => timers.forEach((t) => clearInterval(t));
-  }, [isWatchMode, config]);
-  const terminalWidth = stdout?.columns ?? 0;
-  const terminalHeight = stdout?.rows ?? 0;
-  const columnGap = 2;
-  const effectiveThreshold = config.wideLayoutThreshold ?? MIN_TERMINAL_WIDTH * 2 + columnGap;
-  const useWideLayout = terminalWidth >= effectiveThreshold;
-  const singleColumnWidth = getClampedWidth(terminalWidth);
-  const leftColumnWidth = useWideLayout ? Math.floor((terminalWidth - columnGap) / 2) : singleColumnWidth;
-  const rightColumnWidth = useWideLayout ? terminalWidth - leftColumnWidth - columnGap : singleColumnWidth;
-  const claudeMaxActivities = useMemo3(() => {
-    if (!useWideLayout) return void 0;
-    const todos = claudeData.state.todos;
-    const hasTodos = todos && todos.length > 0;
-    const allCompleted = hasTodos && todos.every((t) => t.status === "completed");
-    const activeTodoCount = hasTodos && !allCompleted ? todos.length : 0;
-    return getEffectiveMaxActivities(terminalHeight, activeTodoCount, true);
-  }, [
-    useWideLayout,
-    claudeData.state.todos,
-    terminalHeight,
-    getEffectiveMaxActivities
-  ]);
-  const renderPanel = (panelName, panelWidth, marginTop) => {
-    if (panelName === "project" && config.panels.project.enabled) {
-      const vs = visualFeedback.getState("project");
-      return /* @__PURE__ */ jsx8(Box8, { marginTop, children: /* @__PURE__ */ jsx8(
-        ProjectPanel,
-        {
-          data: projectData,
-          countdown: isWatchMode ? countdowns.project : null,
-          width: panelWidth,
-          justRefreshed: vs.justRefreshed
-        }
-      ) }, `panel-${panelName}`);
-    }
-    if (panelName === "git" && config.panels.git.enabled) {
-      const vs = visualFeedback.getState("git");
-      return /* @__PURE__ */ jsx8(Box8, { marginTop, children: /* @__PURE__ */ jsx8(
-        GitPanel,
-        {
-          branch: gitData.branch,
-          commits: gitData.commits,
-          stats: gitData.stats,
-          uncommitted: gitData.uncommitted,
-          countdown: isWatchMode ? countdowns.git : null,
-          width: panelWidth,
-          isRunning: vs.isRunning,
-          justRefreshed: vs.justRefreshed
-        }
-      ) }, `panel-${panelName}`);
-    }
-    if (panelName === "tests" && config.panels.tests.enabled) {
-      const vs = visualFeedback.getState("tests");
-      return /* @__PURE__ */ jsx8(Box8, { marginTop, children: /* @__PURE__ */ jsx8(
-        TestPanel,
-        {
-          results: testData.results,
-          isOutdated: testData.isOutdated,
-          commitsBehind: testData.commitsBehind,
-          error: testData.error,
-          width: panelWidth,
-          isRunning: vs.isRunning,
-          justCompleted: vs.justCompleted
-        }
-      ) }, `panel-${panelName}`);
-    }
-    if (panelName === "claude" && config.panels.claude.enabled) {
-      const vs = visualFeedback.getState("claude");
-      return /* @__PURE__ */ jsx8(Box8, { marginTop, children: /* @__PURE__ */ jsx8(
-        ClaudePanel,
-        {
-          data: claudeData,
-          countdown: isWatchMode ? countdowns.claude : null,
-          width: panelWidth,
-          justRefreshed: vs.justRefreshed,
-          maxActivities: claudeMaxActivities
-        }
-      ) }, `panel-${panelName}`);
-    }
-    if (panelName === "other_sessions" && config.panels.other_sessions.enabled) {
-      const vs = visualFeedback.getState("other_sessions");
-      return /* @__PURE__ */ jsx8(Box8, { marginTop, children: /* @__PURE__ */ jsx8(
-        OtherSessionsPanel,
-        {
-          data: otherSessionsData,
-          countdown: isWatchMode ? countdowns.other_sessions : null,
-          width: panelWidth,
-          isRunning: vs.isRunning,
-          messageMaxLength: config.panels.other_sessions.messageMaxLength
-        }
-      ) }, `panel-${panelName}`);
-    }
-    const customConfig = config.customPanels?.[panelName];
-    if (customConfig?.enabled) {
-      const result = customPanelData[panelName];
-      if (!result) return null;
-      const vs = visualFeedback.getState(panelName);
-      const isManual = customConfig.interval === null;
-      const relativeTime = isManual ? formatRelativeTime3(result.timestamp) : void 0;
-      const countdown = !isManual && isWatchMode ? countdowns[panelName] : null;
-      return /* @__PURE__ */ jsx8(Box8, { marginTop, children: /* @__PURE__ */ jsx8(
-        GenericPanel,
-        {
-          data: result.data,
-          renderer: customConfig.renderer,
-          countdown,
-          relativeTime,
-          error: result.error,
-          width: panelWidth,
-          isRunning: vs.isRunning,
-          justRefreshed: vs.justRefreshed
-        }
-      ) }, `panel-${panelName}`);
-    }
-    return null;
-  };
-  if (useWideLayout) {
-    const leftPanels = ["claude", "other_sessions"];
-    const rightPanels = config.panelOrder.filter(
-      (name) => !leftPanels.includes(name)
-    );
-    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
-      warnings.length > 0 && /* @__PURE__ */ jsx8(Box8, { marginBottom: 1, children: /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
-        "\u26A0 ",
-        warnings.join(", ")
-      ] }) }),
-      /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", children: [
-        /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", width: leftColumnWidth, children: [
-          renderPanel("claude", leftColumnWidth, 0),
-          renderPanel("other_sessions", leftColumnWidth, 1)
-        ] }),
-        /* @__PURE__ */ jsx8(
-          Box8,
-          {
-            flexDirection: "column",
-            width: rightColumnWidth,
-            marginLeft: columnGap,
-            children: rightPanels.map(
-              (panelName, index) => renderPanel(panelName, rightColumnWidth, index === 0 ? 0 : 1)
-            )
-          }
-        )
-      ] }),
-      isWatchMode && /* @__PURE__ */ jsxs8(
-        Box8,
-        {
-          marginTop: 1,
-          width: terminalWidth,
-          justifyContent: "space-between",
-          children: [
-            /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: statusBarItems.map((item, index) => /* @__PURE__ */ jsxs8(React.Fragment, { children: [
-              index > 0 && " \xB7 ",
-              /* @__PURE__ */ jsxs8(Text8, { color: "cyan", children: [
-                item.split(":")[0],
-                ":"
-              ] }),
-              item.split(":").slice(1).join(":")
-            ] }, index)) }),
-            /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
-              "AgentHUD v",
-              getVersion()
-            ] })
-          ]
-        }
-      )
-    ] });
-  }
-  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
-    warnings.length > 0 && /* @__PURE__ */ jsx8(Box8, { marginBottom: 1, children: /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
-      "\u26A0 ",
-      warnings.join(", ")
-    ] }) }),
-    config.panelOrder.map(
-      (panelName, index) => renderPanel(panelName, width, index === 0 ? 0 : 1)
-    ),
-    isWatchMode && /* @__PURE__ */ jsxs8(Box8, { marginTop: 1, width, justifyContent: "space-between", children: [
-      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: statusBarItems.map((item, index) => /* @__PURE__ */ jsxs8(React.Fragment, { children: [
-        index > 0 && " \xB7 ",
-        /* @__PURE__ */ jsxs8(Text8, { color: "cyan", children: [
-          item.split(":")[0],
-          ":"
-        ] }),
-        item.split(":").slice(1).join(":")
-      ] }, index)) }),
-      /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
-        "AgentHUD v",
-        getVersion()
-      ] })
-    ] })
-  ] });
-}
-function App({
-  mode,
-  agentDirExists = true
-}) {
-  if (!agentDirExists) {
-    return /* @__PURE__ */ jsx8(WelcomeApp, {});
-  }
-  return /* @__PURE__ */ jsx8(DashboardApp, { mode });
-}
-
-// src/utils/performance.ts
-import { performance } from "perf_hooks";
-var DEFAULT_CLEANUP_INTERVAL = 6e4;
-var cleanupInterval = null;
-function clearPerformanceEntries() {
-  performance.clearMarks();
-  performance.clearMeasures();
-}
-function startPerformanceCleanup(intervalMs = DEFAULT_CLEANUP_INTERVAL) {
-  if (cleanupInterval !== null) {
-    clearInterval(cleanupInterval);
-  }
-  cleanupInterval = setInterval(() => {
-    clearPerformanceEntries();
-  }, intervalMs);
-}
-function stopPerformanceCleanup() {
-  if (cleanupInterval !== null) {
-    clearInterval(cleanupInterval);
-    cleanupInterval = null;
-  }
-}
-
-// src/main.ts
-function main() {
-  const 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);
-  }
-  if (options.command === "init") {
-    const result = runInit();
-    console.log("\n\u2713 agenthud initialized\n");
-    if (result.created.length > 0) {
-      console.log("Created:");
-      result.created.forEach((file) => console.log(`  ${file}`));
-    }
-    if (result.skipped.length > 0) {
-      console.log("\nSkipped (already exists):");
-      result.skipped.forEach((file) => console.log(`  ${file}`));
-    }
-    if (result.warnings.length > 0) {
-      console.log("\nWarnings:");
-      result.warnings.forEach((warning) => console.log(`  \u26A0 ${warning}`));
-    }
-    console.log("\nNext steps:");
-    console.log("  Run: npx agenthud\n");
-    process.exit(0);
-  }
-  const cwd = process.cwd();
-  const sessionAvailability = checkSessionAvailability(cwd);
-  if (!sessionAvailability.hasCurrentSession) {
-    if (sessionAvailability.otherProjects.length > 0) {
-      console.log("\nProjects with Claude Code sessions:");
-      sessionAvailability.otherProjects.forEach((project, index) => {
-        const shortPath = shortenPath(project.path);
-        console.log(`  ${index + 1}. ${project.name} (${shortPath})`);
-      });
-      const firstProject = sessionAvailability.otherProjects[0];
-      const firstShortPath = shortenPath(firstProject.path);
-      console.log(`
-Run: cd ${firstShortPath} && agenthud
-`);
-    } else {
-      console.log("\nCould not find any projects with Claude Code sessions.\n");
-      console.log("Start a Claude Code session in a project directory first:");
-      console.log("  $ claude\n");
-    }
-    process.exit(0);
-  }
-  const agentDirExists = existsSync9(".agenthud");
-  if (options.mode === "watch") {
-    clearScreen();
-  }
-  const { waitUntilExit } = render(
-    React2.createElement(App, { mode: options.mode, agentDirExists })
-  );
-  if (options.mode === "once") {
-    setTimeout(() => process.exit(0), 100);
-  } else {
-    startPerformanceCleanup();
-    waitUntilExit().then(() => {
-      stopPerformanceCleanup();
-      process.exit(0);
-    });
-  }
-}
-export {
-  main
-};