agenthud 0.7.0 → 0.7.2

package/dist/main-I7XDIQE3.js

@@ -0,0 +1,4104 @@
+// 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 existsSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { basename as basename2, join as join4 } from "path";
+
+// src/data/otherSessions.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync4, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename, join as join3, sep } from "path";
+
+// 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/otherSessions.ts
+var MAX_LINES_TO_SCAN = 100;
+function getProjectsDir() {
+  return join3(homedir2(), ".claude", "projects");
+}
+function decodeProjectPath(encoded) {
+  const naiveDecoded = encoded.replace(/-/g, sep);
+  if (existsSync3(naiveDecoded)) {
+    return naiveDecoded;
+  }
+  const segments = encoded.split("-").filter(Boolean);
+  if (segments.length === 0) {
+    return naiveDecoded;
+  }
+  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 ? join3(currentPath, segment) : sep + segment;
+      try {
+        if (existsSync3(testPath)) {
+          const stat = statSync(testPath);
+          if (stat.isDirectory()) {
+            currentPath = testPath;
+            i = j;
+            found = true;
+            break;
+          }
+        }
+      } catch {
+      }
+    }
+    if (!found) {
+      currentPath = currentPath ? join3(currentPath, segments[i]) : sep + segments[i];
+      i++;
+    }
+  }
+  return currentPath || naiveDecoded;
+}
+function getAllProjects() {
+  const projectsDir = getProjectsDir();
+  if (!existsSync3(projectsDir)) {
+    return [];
+  }
+  const entries = readdirSync(projectsDir);
+  const projects = [];
+  for (const entry of entries) {
+    const fullPath = join3(projectsDir, entry);
+    try {
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        projects.push({
+          encodedPath: entry,
+          decodedPath: decodeProjectPath(entry)
+        });
+      }
+    } catch {
+    }
+  }
+  return projects;
+}
+function parseLastAssistantMessage(sessionFile) {
+  if (!existsSync3(sessionFile)) {
+    return null;
+  }
+  let content;
+  try {
+    content = readFileSync4(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_SCAN).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 (!existsSync3(projectDir)) {
+    return null;
+  }
+  let files;
+  try {
+    files = readdirSync(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 = join3(projectDir, file);
+    try {
+      const stat = statSync(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 (!existsSync3(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 = join3(projectsDir, project.encodedPath);
+    const sessionInfo = findMostRecentSession(projectDir);
+    if (sessionInfo) {
+      otherSessions.push({
+        projectPath: project.decodedPath,
+        projectName: basename(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 = homedir3();
+  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 (existsSync4(join4(projectPath, indicator))) {
+      return true;
+    }
+  }
+  return false;
+}
+function getSessionPath(projectPath) {
+  const encoded = projectPath.replace(/[/\\]/g, "-");
+  return join4(homedir3(), ".claude", "projects", encoded);
+}
+function getProjectMostRecentMtime(encodedPath) {
+  const projectDir = join4(homedir3(), ".claude", "projects", encodedPath);
+  if (!existsSync4(projectDir)) {
+    return 0;
+  }
+  let files;
+  try {
+    files = readdirSync2(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 = join4(projectDir, file);
+    try {
+      const stat = statSync2(filePath);
+      if (stat.mtimeMs && stat.mtimeMs > latestMtime) {
+        latestMtime = stat.mtimeMs;
+      }
+    } catch {
+    }
+  }
+  return latestMtime;
+}
+function hasCurrentProjectSession(cwd) {
+  const sessionPath = getSessionPath(cwd);
+  return existsSync4(sessionPath);
+}
+function getProjectsWithSessions(currentPath) {
+  const allProjects = getAllProjects();
+  const currentEncoded = currentPath.replace(/[/\\]/g, "-");
+  const projectsWithMtime = allProjects.filter((p) => p.encodedPath !== currentEncoded).filter((p) => existsSync4(p.decodedPath)).filter((p) => isDevProject(p.decodedPath)).map((p) => ({
+    name: basename2(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 existsSync5, readFileSync as readFileSync5 } 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: 60 * 60 * 1e3
+        // 60 minutes default
+      },
+      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 (!existsSync5(CONFIG_PATH)) {
+    return { config: defaultConfig, warnings };
+  }
+  let rawConfig;
+  try {
+    const content = readFileSync5(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/claude.ts
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { basename as basename3, join as join5 } 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/data/claude.ts
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+var MAX_LINES_TO_SCAN2 = 200;
+var DEFAULT_MAX_ACTIVITIES = 10;
+function getClaudeSessionPath2(projectPath) {
+  const encoded = projectPath.replace(/[/\\]/g, "-");
+  return join5(homedir4(), ".claude", "projects", encoded);
+}
+function findActiveSession(sessionDir, sessionTimeout) {
+  if (!existsSync6(sessionDir)) {
+    return null;
+  }
+  const files = readdirSync3(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 = join5(sessionDir, file);
+    const stat = statSync3(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 join5(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 basename3(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 = join5(sessionFile.replace(/\.jsonl$/, ""), "subagents");
+  if (!existsSync6(subagentsDir)) {
+    return [];
+  }
+  try {
+    const files = readdirSync3(subagentsDir).filter(
+      (f) => f.endsWith(".jsonl")
+    );
+    const fileInfos = files.map((file) => {
+      const filePath = join5(subagentsDir, file);
+      const stat = statSync3(filePath);
+      return { filePath, mtimeMs: stat.mtimeMs };
+    });
+    fileInfos.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return fileInfos;
+  } catch {
+    return [];
+  }
+}
+function parseSubagentFile(filePath) {
+  try {
+    const content = readFileSync6(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
+  };
+  if (!existsSync6(sessionFile)) {
+    return defaultState;
+  }
+  let content;
+  try {
+    content = readFileSync6(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;
+  const recentLines = lines.slice(-MAX_LINES_TO_SCAN2);
+  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 (entry.type === "system") {
+        const systemEntry = entry;
+        if (systemEntry.subtype === "stop_hook_summary") {
+          lastType = "stop";
+          if (systemEntry.timestamp) {
+            lastTimestamp = new Date(systemEntry.timestamp);
+          }
+        }
+      }
+    } 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 = join5(sessionFile.replace(/\.jsonl$/, ""), "subagents");
+  if (existsSync6(subagentsDir)) {
+    try {
+      const subagentFiles2 = readdirSync3(subagentsDir).filter(
+        (f) => f.endsWith(".jsonl")
+      );
+      for (const file of subagentFiles2) {
+        const filePath = join5(subagentsDir, file);
+        try {
+          const subContent = readFileSync6(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
+  };
+}
+var DEFAULT_SESSION_TIMEOUT = 60 * 60 * 1e3;
+function getClaudeData(projectPath, maxActivities, sessionTimeout = DEFAULT_SESSION_TIMEOUT) {
+  const defaultState = {
+    status: "none",
+    activities: [],
+    tokenCount: 0,
+    sessionStartTime: null,
+    todos: null
+  };
+  try {
+    const sessionDir = getClaudeSessionPath2(projectPath);
+    const hasSession = existsSync6(sessionDir);
+    const sessionFile = findActiveSession(sessionDir, sessionTimeout);
+    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/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 { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
+import { basename as basename4 } 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() {
+  try {
+    return execSync3('basename "$PWD"', { encoding: "utf-8" }).trim();
+  } catch {
+    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 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 excludes = EXCLUDE_DIRS.map((d) => `-path "*/${d}/*"`).join(" -o ");
+    const namePatterns = config.patterns.map((p) => `-name "${p}"`).join(" -o ");
+    const cmd = `find ${sourceDir} \\( ${excludes} \\) -prune -o -type f \\( ${namePatterns} \\) -print | wc -l`;
+    const result = execSync3(cmd, { encoding: "utf-8" });
+    const count = parseInt(result.trim(), 10) || 0;
+    return { count, 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 excludes = EXCLUDE_DIRS.map((d) => `-path "*/${d}/*"`).join(" -o ");
+    const namePatterns = config.patterns.map((p) => `-name "${p}"`).join(" -o ");
+    const cmd = `find ${sourceDir} \\( ${excludes} \\) -prune -o -type f \\( ${namePatterns} \\) -print0 | xargs -0 wc -l 2>/dev/null | tail -1 | awk '{print $1}'`;
+    const result = execSync3(cmd, { encoding: "utf-8" });
+    return parseInt(result.trim(), 10) || 0;
+  } 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 execSync5 } from "child_process";
+import { readFileSync as readFileSync10 } from "fs";
+import { join as join6 } from "path";
+
+// src/runner/command.ts
+import { execSync as execSync4 } 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 execSync4("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 {
+    execSync4(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 execSync5("git rev-parse --short HEAD", { encoding: "utf-8" }).trim();
+}
+function getCommitCount(fromHash) {
+  const result = execSync5(`git rev-list ${fromHash}..HEAD --count`, {
+    encoding: "utf-8"
+  }).trim();
+  return parseInt(result, 10) || 0;
+}
+function getTestData(dir = process.cwd()) {
+  const testResultsPath = join6(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 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 titleParts = [];
+  if (tokenDisplay) titleParts.push(tokenDisplay);
+  if (sessionTime) titleParts.push(sessionTime);
+  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("Claude", 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("Claude", 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("Claude", 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
+};