abmux 0.0.4 → 0.0.6

package/dist/cli/index.js

@@ -144,10 +144,97 @@ var createEditor = () => ({
   }
 });
 
+// src/infra/claude-cli.ts
+import { execFile as execFile2, execFileSync as execFileSync2 } from "node:child_process";
+
+// src/models/claude-session.ts
+var SESSION_SUMMARY_SCHEMA = {
+  type: "object",
+  properties: {
+    overallSummary: { type: "string" },
+    sessions: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          sessionName: { type: "string" },
+          panes: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                paneTitle: { type: "string" },
+                description: { type: "string" }
+              },
+              required: ["paneTitle", "description"]
+            }
+          }
+        },
+        required: ["sessionName", "panes"]
+      }
+    }
+  },
+  required: ["overallSummary", "sessions"]
+};
+
+// src/infra/claude-cli.ts
+var resolveClaudePath = () => {
+  try {
+    return execFileSync2("which", ["claude"], { encoding: "utf-8" }).trim();
+  } catch {
+    return "claude";
+  }
+};
+var claudePath = resolveClaudePath();
+var EMPTY_RESULT = { overallSummary: "", sessions: [] };
+var execClaude = (args) => new Promise((resolve, reject) => {
+  execFile2(claudePath, args, { timeout: 12e4 }, (error, stdout, stderr) => {
+    if (error) {
+      reject(new Error(`claude failed: ${stderr || error.message}`));
+      return;
+    }
+    resolve(stdout.trim());
+  });
+});
+var parseResult = (raw) => {
+  const output = JSON.parse(raw);
+  if (output.is_error) return EMPTY_RESULT;
+  const parsed = output.structured_output;
+  if (typeof parsed !== "object" || parsed === null || !("sessions" in parsed) || !Array.isArray(parsed.sessions)) {
+    return EMPTY_RESULT;
+  }
+  const result = parsed;
+  return {
+    overallSummary: result.overallSummary ?? "",
+    sessions: result.sessions
+  };
+};
+var createClaudeCli = () => ({
+  querySessionSummary: async (prompt) => {
+    try {
+      const raw = await execClaude([
+        "-p",
+        "--output-format",
+        "json",
+        "--json-schema",
+        JSON.stringify(SESSION_SUMMARY_SCHEMA),
+        "--no-session-persistence",
+        "--model",
+        "haiku",
+        prompt
+      ]);
+      return parseResult(raw);
+    } catch {
+      return EMPTY_RESULT;
+    }
+  }
+});
+
 // src/infra/index.ts
 var createInfra = () => ({
   tmuxCli: createTmuxCli(),
-  editor: createEditor()
+  editor: createEditor(),
+  claudeCli: createClaudeCli()
 });
 
 // src/models/session.ts
@@ -178,15 +265,6 @@ var PANE_KIND = {
   busy: "busy"
 };
 
-// src/utils/PathUtils.ts
-var formatCwd = (cwd) => {
-  const home = process.env["HOME"] ?? "";
-  if (home && cwd.startsWith(home)) {
-    return `~${cwd.slice(home.length)}`;
-  }
-  return cwd;
-};
-
 // src/services/session-detection-service.ts
 var BUSY_TITLES = /* @__PURE__ */ new Set([
   "nvim",
@@ -252,66 +330,44 @@ var toUnifiedPane = (pane) => {
 var createSessionDetectionService = () => ({
   groupBySession: ({ panes }) => {
     const windowKey = (pane) => `${pane.sessionName}:${String(pane.windowIndex)}`;
-    const windowMap = /* @__PURE__ */ new Map();
-    for (const pane of panes) {
-      const key = windowKey(pane);
-      const unified = toUnifiedPane(pane);
-      const existing = windowMap.get(key);
-      if (existing) {
-        existing.panes = [...existing.panes, unified];
-        if (pane.isActive) {
-          existing.activePaneTitle = pane.title;
-        }
-      } else {
-        windowMap.set(key, {
-          sessionName: pane.sessionName,
-          windowIndex: pane.windowIndex,
-          cwd: formatCwd(pane.cwd),
-          windowName: pane.windowName,
-          activePaneTitle: pane.isActive ? pane.title : "",
-          panes: [unified]
-        });
+    const panesByWindow = Map.groupBy(panes, windowKey);
+    const sortPanes = (items) => items.toSorted((a, b) => {
+      const kindOrder = { claude: 0, available: 1, busy: 2 };
+      const kindDiff = kindOrder[a.kind] - kindOrder[b.kind];
+      if (kindDiff !== 0) return kindDiff;
+      if (a.kind === "claude" && b.kind === "claude") {
+        const statusOrder = {
+          "waiting-confirm": 0,
+          "waiting-input": 1,
+          thinking: 2,
+          "tool-running": 3,
+          idle: 4
+        };
+        const sa = statusOrder[a.claudeStatus ?? "idle"] ?? 4;
+        const sb = statusOrder[b.claudeStatus ?? "idle"] ?? 4;
+        if (sa !== sb) return sa - sb;
       }
-    }
-    const windowGroups = [...windowMap.entries()].toSorted(([a], [b]) => a.localeCompare(b)).map(([, group]) => ({
-      windowIndex: group.windowIndex,
-      windowName: group.windowName || group.activePaneTitle || `Window ${String(group.windowIndex)}`,
-      sessionName: group.sessionName,
-      panes: group.panes.toSorted((a, b) => {
-        const kindOrder = { claude: 0, available: 1, busy: 2 };
-        const kindDiff = kindOrder[a.kind] - kindOrder[b.kind];
-        if (kindDiff !== 0) return kindDiff;
-        if (a.kind === "claude" && b.kind === "claude") {
-          const statusOrder = {
-            "waiting-confirm": 0,
-            "waiting-input": 1,
-            thinking: 2,
-            "tool-running": 3,
-            idle: 4
-          };
-          const sa = statusOrder[a.claudeStatus ?? "idle"] ?? 4;
-          const sb = statusOrder[b.claudeStatus ?? "idle"] ?? 4;
-          if (sa !== sb) return sa - sb;
-        }
-        return a.pane.paneIndex - b.pane.paneIndex;
-      })
+      return a.pane.paneIndex - b.pane.paneIndex;
+    });
+    const windowGroups = [...panesByWindow.entries()].toSorted(([a], [b]) => a.localeCompare(b)).map(([, group]) => {
+      const first = group[0];
+      const activePaneTitle = group.find((p) => p.isActive)?.title ?? "";
+      return {
+        windowIndex: first.windowIndex,
+        windowName: first.windowName || activePaneTitle || `Window ${String(first.windowIndex)}`,
+        sessionName: first.sessionName,
+        panes: sortPanes(group.map(toUnifiedPane))
+      };
+    });
+    const sessionGroups = Map.groupBy(windowGroups, (win) => win.sessionName);
+    return [...sessionGroups.entries()].map(([sessionName, wins]) => ({
+      sessionName,
+      tabs: wins.map(({ windowIndex, windowName, panes: p }) => ({
+        windowIndex,
+        windowName,
+        panes: p
+      }))
     }));
-    const sessionMap = /* @__PURE__ */ new Map();
-    for (const win of windowGroups) {
-      const existing = sessionMap.get(win.sessionName);
-      if (existing) {
-        existing.push({
-          windowIndex: win.windowIndex,
-          windowName: win.windowName,
-          panes: win.panes
-        });
-      } else {
-        sessionMap.set(win.sessionName, [
-          { windowIndex: win.windowIndex, windowName: win.windowName, panes: win.panes }
-        ]);
-      }
-    }
-    return [...sessionMap.entries()].map(([sessionName, tabs]) => ({ sessionName, tabs }));
   },
   detectStatusFromText
 });
@@ -396,24 +452,15 @@ var findProjects = async (dir, depth) => {
     const dirs = entries.filter(
       (e) => e.isDirectory() && !e.name.startsWith(".") && !SKIP_DIRS.has(e.name)
     );
-    const results = [];
-    const childScans = [];
-    for (const entry of dirs) {
+    const childScans = dirs.map((entry) => {
       const fullPath = join2(dir, entry.name);
-      childScans.push(
-        exists(join2(fullPath, ".git")).then(async (isProject) => {
-          if (isProject) return [fullPath];
-          return await findProjects(fullPath, depth + 1);
-        })
-      );
-    }
+      return exists(join2(fullPath, ".git")).then(async (isProject) => {
+        if (isProject) return [fullPath];
+        return await findProjects(fullPath, depth + 1);
+      });
+    });
     const nested = await Promise.all(childScans);
-    for (const paths of nested) {
-      for (const p of paths) {
-        results.push(p);
-      }
-    }
-    return results;
+    return nested.flat();
   } catch {
     return [];
   }
@@ -427,11 +474,51 @@ var createDirectoryScanService = () => ({
   }
 });
 
+// src/services/session-summary-service.ts
+var EMPTY_RESULT2 = { overallSummary: "", sessions: [] };
+var formatGroupsForPrompt = (groups) => {
+  const lines = [];
+  for (const group of groups) {
+    const panes = group.tabs.flatMap((t) => t.panes);
+    const paneDescriptions = panes.map((p) => {
+      if (p.kind === "claude") {
+        const status = p.claudeStatus ? SESSION_STATUS_LABEL[p.claudeStatus] : "idle";
+        const title = p.claudeTitle ?? "";
+        return `  - [claude] status=${status} title="${title}"`;
+      }
+      return `  - [${p.kind}] title="${p.pane.title}"`;
+    });
+    lines.push(`session: ${group.sessionName}`);
+    lines.push(`  panes (${String(panes.length)}):`);
+    lines.push(...paneDescriptions);
+  }
+  return lines.join("\n");
+};
+var buildPrompt = (groups) => {
+  const data = formatGroupsForPrompt(groups);
+  return [
+    "\u4EE5\u4E0B\u306F tmux \u30BB\u30C3\u30B7\u30E7\u30F3\u3068\u30DA\u30A4\u30F3\u306E\u4E00\u89A7\u3067\u3059\u3002",
+    "overallSummary: \u5168\u4F53\u3068\u3057\u3066\u4ECA\u3069\u3046\u3044\u3046\u4F5C\u696D\u304C\u884C\u308F\u308C\u3066\u3044\u3066\u3001\u3069\u3046\u3044\u3046\u72B6\u614B\u304B\u3092\u65E5\u672C\u8A9E\u3067\u7C21\u6F54\u306B1\u301C2\u6587\u3067\u8AAC\u660E\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+    "sessions.panes: \u5404\u30DA\u30A4\u30F3\u304C\u4F55\u3092\u3057\u3066\u3044\u308B\u304B\u3001\u65E5\u672C\u8A9E\u3067\u7C21\u6F54\u306B1\u6587\u305A\u3064\u8AAC\u660E\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+    "sessionName \u306F\u305D\u306E\u307E\u307E\u3001paneTitle \u306F\u30DA\u30A4\u30F3\u306E title \u3092\u305D\u306E\u307E\u307E\u5165\u308C\u3066\u304F\u3060\u3055\u3044\u3002",
+    "",
+    data
+  ].join("\n");
+};
+var createSessionSummaryService = (context) => ({
+  fetchSummary: async (groups) => {
+    if (groups.length === 0) return EMPTY_RESULT2;
+    const prompt = buildPrompt(groups);
+    return await context.infra.claudeCli.querySessionSummary(prompt);
+  }
+});
+
 // src/services/index.ts
 var createServices = (context) => ({
   tmux: createTmuxService(context),
   sessionDetection: createSessionDetectionService(),
-  directoryScan: createDirectoryScanService()
+  directoryScan: createDirectoryScanService(),
+  sessionSummary: createSessionSummaryService(context)
 });
 
 // src/utils/ShellUtils.ts
@@ -464,6 +551,9 @@ var createManagerUsecase = (context) => {
       const sessionGroups = sessionDetection.groupBySession({ panes });
       return { sessionGroups };
     },
+    fetchOverview: async (groups) => {
+      return await context.services.sessionSummary.fetchSummary(groups);
+    },
     enrichStatus: async (up) => {
       if (up.kind !== "claude") return up;
       try {
@@ -507,7 +597,7 @@ var createUsecases = (context) => ({
 // package.json
 var package_default = {
   name: "abmux",
-  version: "0.0.4",
+  version: "0.0.6",
   repository: {
     type: "git",
     url: "https://github.com/cut0/abmux.git"
@@ -577,8 +667,8 @@ import { createElement } from "react";
 
 // src/components/ManagerView.tsx
 import { basename as basename2 } from "node:path";
-import { Box as Box10, Text as Text10 } from "ink";
-import { useCallback as useCallback3, useEffect as useEffect2, useMemo as useMemo5, useState as useState5 } from "react";
+import { Box as Box11 } from "ink";
+import { useCallback as useCallback4, useMemo as useMemo7, useRef as useRef3, useState as useState6 } from "react";
 
 // src/components/shared/Header.tsx
 import { Box, Text } from "ink";
@@ -589,24 +679,57 @@ var Header = ({ title }) => {
 
 // src/components/shared/StatusBar.tsx
 import { Box as Box2, Text as Text2 } from "ink";
-import { jsx as jsx2 } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var STATUS_ICON = {
+  [SESSION_STATUS.waitingInput]: "\u276F",
+  [SESSION_STATUS.waitingConfirm]: "\u2753",
+  [SESSION_STATUS.thinking]: "\u25CF",
+  [SESSION_STATUS.toolRunning]: "\u2733",
+  [SESSION_STATUS.idle]: "\u25CB"
+};
 var COLOR_MAP = {
   success: "green",
   error: "red",
   info: "gray"
 };
-var StatusBar = ({ message, type = "info" }) => {
-  return /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { color: COLOR_MAP[type], children: message }) });
+var STATUS_ORDER = [
+  SESSION_STATUS.thinking,
+  SESSION_STATUS.toolRunning,
+  SESSION_STATUS.waitingConfirm,
+  SESSION_STATUS.waitingInput,
+  SESSION_STATUS.idle
+];
+var StatusBar = ({ message, type = "info", statusCounts }) => {
+  const summaryEntries = useMemo(() => {
+    if (!statusCounts) return [];
+    return STATUS_ORDER.filter((s) => (statusCounts[s] ?? 0) > 0).map((s) => ({
+      status: s,
+      icon: STATUS_ICON[s],
+      label: SESSION_STATUS_LABEL[s],
+      color: SESSION_STATUS_COLOR[s],
+      count: statusCounts[s] ?? 0
+    }));
+  }, [statusCounts]);
+  return /* @__PURE__ */ jsxs(Box2, { children: [
+    /* @__PURE__ */ jsx2(Box2, { flexGrow: 1, children: /* @__PURE__ */ jsx2(Text2, { color: COLOR_MAP[type], children: message }) }),
+    summaryEntries.length > 0 && /* @__PURE__ */ jsx2(Box2, { gap: 1, children: summaryEntries.map((entry) => /* @__PURE__ */ jsxs(Text2, { color: entry.color, children: [
+      entry.icon,
+      String(entry.count),
+      " ",
+      entry.label
+    ] }, entry.status)) })
+  ] });
 };
 
 // src/components/shared/DirectorySelect.tsx
 import { Box as Box3, Text as Text3, useApp, useInput } from "ink";
-import { useCallback, useMemo as useMemo2, useState } from "react";
+import { useCallback, useMemo as useMemo3, useState } from "react";
 
 // src/hooks/use-scroll.ts
-import { useMemo } from "react";
+import { useMemo as useMemo2 } from "react";
 var useScroll = (cursor, totalItems, availableRows) => {
-  return useMemo(() => {
+  return useMemo2(() => {
     const visibleCount = Math.max(1, availableRows);
     if (totalItems <= visibleCount) {
       return { scrollOffset: 0, visibleCount };
@@ -618,17 +741,29 @@ var useScroll = (cursor, totalItems, availableRows) => {
   }, [cursor, totalItems, availableRows]);
 };
 
+// src/utils/PathUtils.ts
+var formatCwd = (cwd) => {
+  const home = process.env["HOME"] ?? "";
+  if (home && cwd.startsWith(home)) {
+    return `~${cwd.slice(home.length)}`;
+  }
+  return cwd;
+};
+var findMatchingDirectory = (path, directories) => directories.filter((dir) => path === dir || path.startsWith(dir + "/")).reduce(
+  (best, dir) => !best || dir.length > best.length ? dir : best,
+  void 0
+);
+
 // src/components/shared/DirectorySelect.tsx
-import { jsx as jsx3, jsxs } from "react/jsx-runtime";
-var sortSessionGroups = (groups, currentSession) => {
-  const current = groups.filter((g) => g.sessionName === currentSession);
-  const rest = groups.filter((g) => g.sessionName !== currentSession);
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var sortSessions = (sessions, currentSession) => {
+  const current = sessions.filter((s) => s.name === currentSession);
+  const rest = sessions.filter((s) => s.name !== currentSession);
   return [...current, ...rest];
 };
 var SessionListPanel = ({
-  sessionGroups,
+  sessions,
   currentSession,
-  sessionPathMap,
   isFocused,
   availableRows,
   onSelect,
@@ -638,30 +773,30 @@ var SessionListPanel = ({
 }) => {
   const { exit } = useApp();
   const [cursor, setCursor] = useState(0);
-  const sortedGroups = useMemo2(
-    () => sortSessionGroups(sessionGroups, currentSession),
-    [sessionGroups, currentSession]
+  const sortedSessions = useMemo3(
+    () => sortSessions(sessions, currentSession),
+    [sessions, currentSession]
   );
-  const sessions = useMemo2(() => sortedGroups.map((g) => g.sessionName), [sortedGroups]);
-  const clampedCursor = cursor >= sessions.length ? Math.max(0, sessions.length - 1) : cursor;
+  const names = useMemo3(() => sortedSessions.map((s) => s.name), [sortedSessions]);
+  const clampedCursor = cursor >= names.length ? Math.max(0, names.length - 1) : cursor;
   if (clampedCursor !== cursor) {
     setCursor(clampedCursor);
   }
   const reservedLines = 1;
   const { scrollOffset, visibleCount } = useScroll(
     clampedCursor,
-    sessions.length,
+    names.length,
     availableRows - reservedLines
   );
-  const visibleSessions = sessions.slice(scrollOffset, scrollOffset + visibleCount);
+  const visibleSessions = sortedSessions.slice(scrollOffset, scrollOffset + visibleCount);
   const moveCursor = useCallback(
     (next) => {
-      const clamped = Math.max(0, Math.min(sessions.length - 1, next));
+      const clamped = Math.max(0, Math.min(names.length - 1, next));
       setCursor(clamped);
-      const name = sessions[clamped];
+      const name = names[clamped];
       if (name) onCursorChange(name);
     },
-    [sessions, onCursorChange]
+    [names, onCursorChange]
   );
   useInput(
     (input, key) => {
@@ -678,12 +813,12 @@ var SessionListPanel = ({
         return;
       }
       if (key.return || key.rightArrow) {
-        const name = sessions[clampedCursor];
+        const name = names[clampedCursor];
         if (name) onSelect(name);
         return;
       }
       if (input === "d" && onDeleteSession) {
-        const name = sessions[clampedCursor];
+        const name = names[clampedCursor];
         if (name) onDeleteSession(name);
         return;
       }
@@ -693,28 +828,27 @@ var SessionListPanel = ({
     },
     { isActive: isFocused }
   );
-  return /* @__PURE__ */ jsxs(Box3, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs(Box3, { paddingLeft: 1, children: [
+  return /* @__PURE__ */ jsxs2(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Box3, { paddingLeft: 1, children: [
       /* @__PURE__ */ jsx3(Text3, { bold: true, color: isFocused ? "green" : "gray", children: "Sessions" }),
-      /* @__PURE__ */ jsxs(Text3, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs2(Text3, { dimColor: true, children: [
         " ",
         "(",
         clampedCursor + 1,
         "/",
-        sessions.length,
+        names.length,
         ")"
       ] })
     ] }),
-    /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: visibleSessions.map((name, i) => {
+    /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: visibleSessions.map((session, i) => {
       const globalIndex = scrollOffset + i;
       const isHighlighted = globalIndex === clampedCursor;
-      const isCurrent = name === currentSession;
-      const path = sessionPathMap.get(name);
-      return /* @__PURE__ */ jsxs(Box3, { paddingLeft: 1, gap: 1, children: [
+      const isCurrent = session.name === currentSession;
+      return /* @__PURE__ */ jsxs2(Box3, { paddingLeft: 1, gap: 1, children: [
         /* @__PURE__ */ jsx3(Text3, { color: isHighlighted ? "green" : void 0, children: isHighlighted ? "\u25B6" : " " }),
-        /* @__PURE__ */ jsx3(Text3, { color: isHighlighted ? "green" : "cyan", bold: isHighlighted, wrap: "truncate", children: path ? formatCwd(path) : name }),
+        /* @__PURE__ */ jsx3(Text3, { color: isHighlighted ? "green" : "cyan", bold: isHighlighted, wrap: "truncate", children: session.path ? formatCwd(session.path) : session.name }),
         isCurrent && /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "(cwd)" })
-      ] }, name);
+      ] }, session.name);
     }) })
   ] });
 };
@@ -724,21 +858,21 @@ import { Box as Box6, Text as Text6 } from "ink";
 
 // src/components/PaneListView.tsx
 import { Box as Box5, Text as Text5, useApp as useApp2, useInput as useInput2 } from "ink";
-import { useCallback as useCallback2, useMemo as useMemo3, useRef, useState as useState2 } from "react";
+import { useCallback as useCallback2, useMemo as useMemo4, useRef, useState as useState2 } from "react";
 
 // src/components/sessions/PaneItem.tsx
 import { Box as Box4, Text as Text4 } from "ink";
-import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
 var PaneItem = ({ unifiedPane, isHighlighted }) => {
   const { pane, kind, claudeStatus, claudeTitle } = unifiedPane;
   if (kind === "claude") {
     const icon = pane.title.charAt(0);
     const statusLabel = claudeStatus ? SESSION_STATUS_LABEL[claudeStatus] : "";
     const statusColor = claudeStatus ? SESSION_STATUS_COLOR[claudeStatus] : "gray";
-    return /* @__PURE__ */ jsxs2(Box4, { paddingLeft: 3, gap: 1, children: [
+    return /* @__PURE__ */ jsxs3(Box4, { paddingLeft: 3, gap: 1, children: [
       /* @__PURE__ */ jsx4(Text4, { color: isHighlighted ? "green" : void 0, children: isHighlighted ? "\u25B6" : " " }),
       /* @__PURE__ */ jsx4(Text4, { color: "#FF8C00", children: icon }),
-      /* @__PURE__ */ jsxs2(Text4, { color: statusColor, children: [
+      /* @__PURE__ */ jsxs3(Text4, { color: statusColor, children: [
         "[",
         statusLabel,
         "]"
@@ -747,7 +881,7 @@ var PaneItem = ({ unifiedPane, isHighlighted }) => {
       /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: pane.paneId })
     ] });
   }
-  return /* @__PURE__ */ jsxs2(Box4, { paddingLeft: 3, gap: 1, children: [
+  return /* @__PURE__ */ jsxs3(Box4, { paddingLeft: 3, gap: 1, children: [
     /* @__PURE__ */ jsx4(Text4, { color: isHighlighted ? "green" : void 0, children: isHighlighted ? "\u25B6" : " " }),
     kind === "available" && /* @__PURE__ */ jsx4(Text4, { color: "#4AA8D8", children: "\u25CB" }),
     kind === "busy" && /* @__PURE__ */ jsx4(Text4, { color: "#E05252", children: "\u25CF" }),
@@ -757,7 +891,7 @@ var PaneItem = ({ unifiedPane, isHighlighted }) => {
 };
 
 // src/components/PaneListView.tsx
-import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 var PaneListView = ({
   selectedSession,
   group,
@@ -773,7 +907,7 @@ var PaneListView = ({
   const { exit } = useApp2();
   const [cursor, setCursor] = useState2(0);
   const highlightedRef = useRef(void 0);
-  const panes = useMemo3(() => group.tabs.flatMap((t) => t.panes), [group]);
+  const panes = useMemo4(() => group.tabs.flatMap((t) => t.panes), [group]);
   const clampedCursor = cursor >= panes.length ? Math.max(0, panes.length - 1) : cursor;
   if (clampedCursor !== cursor) {
     setCursor(clampedCursor);
@@ -784,7 +918,7 @@ var PaneListView = ({
     panes.length,
     availableRows - reservedLines
   );
-  const visiblePanes = useMemo3(
+  const visiblePanes = useMemo4(
     () => panes.slice(scrollOffset, scrollOffset + visibleCount),
     [panes, scrollOffset, visibleCount]
   );
@@ -853,10 +987,10 @@ var PaneListView = ({
     },
     { isActive: isFocused }
   );
-  return /* @__PURE__ */ jsxs3(Box5, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs3(Box5, { paddingLeft: 1, children: [
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs4(Box5, { paddingLeft: 1, children: [
       /* @__PURE__ */ jsx5(Text5, { bold: true, color: isFocused ? "green" : "gray", children: "Panes" }),
-      /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
         " ",
         selectedSession,
         " (",
@@ -912,15 +1046,140 @@ var PaneListPanel = ({
   );
 };
 
+// src/components/SessionOverviewPanel.tsx
+import { Spinner } from "@inkjs/ui";
+import { Box as Box7, Text as Text7, useApp as useApp3, useInput as useInput3 } from "ink";
+import { useCallback as useCallback3, useMemo as useMemo5, useState as useState3 } from "react";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+var SessionOverviewPanel = ({
+  overallSummary,
+  items,
+  groups,
+  isLoading,
+  isFocused,
+  availableRows,
+  onBack
+}) => {
+  const { exit } = useApp3();
+  const [cursor, setCursor] = useState3(0);
+  const lines = useMemo5(() => {
+    const summaryLines = overallSummary ? [
+      { key: "summary", type: "summary", text: overallSummary },
+      { key: "spacer:summary", type: "spacer" }
+    ] : [];
+    const sessionLines = items.flatMap((item, idx) => {
+      const group = groups.find((g) => g.sessionName === item.sessionName);
+      const allPanes = group?.tabs.flatMap((t) => t.panes) ?? [];
+      const paneLines = item.panes.map((paneSummary) => {
+        const matched = allPanes.find(
+          (p) => (p.claudeTitle ?? p.pane.title) === paneSummary.paneTitle
+        );
+        const statusLabel = matched?.claudeStatus ? SESSION_STATUS_LABEL[matched.claudeStatus] : void 0;
+        const statusColor = matched?.claudeStatus ? SESSION_STATUS_COLOR[matched.claudeStatus] : void 0;
+        return {
+          key: `p:${item.sessionName}:${paneSummary.paneTitle}`,
+          type: "pane",
+          statusLabel,
+          statusColor,
+          description: paneSummary.description
+        };
+      });
+      const spacer = idx > 0 ? [{ key: `spacer:${item.sessionName}`, type: "spacer" }] : [];
+      return [
+        ...spacer,
+        { key: `s:${item.sessionName}`, type: "session", sessionName: item.sessionName },
+        ...paneLines
+      ];
+    });
+    return [...summaryLines, ...sessionLines];
+  }, [overallSummary, items, groups]);
+  const clampedCursor = cursor >= lines.length ? Math.max(0, lines.length - 1) : cursor;
+  if (clampedCursor !== cursor) {
+    setCursor(clampedCursor);
+  }
+  const reservedLines = 3;
+  const { scrollOffset, visibleCount } = useScroll(
+    clampedCursor,
+    lines.length,
+    availableRows - reservedLines
+  );
+  const visibleLines = useMemo5(
+    () => lines.slice(scrollOffset, scrollOffset + visibleCount),
+    [lines, scrollOffset, visibleCount]
+  );
+  const moveCursor = useCallback3(
+    (next) => {
+      setCursor(Math.max(0, Math.min(lines.length - 1, next)));
+    },
+    [lines.length]
+  );
+  useInput3(
+    (input, key) => {
+      if (input === "q") {
+        exit();
+        return;
+      }
+      if (key.escape || key.leftArrow) {
+        onBack();
+        return;
+      }
+      if (key.upArrow) {
+        moveCursor(clampedCursor - 1);
+        return;
+      }
+      if (key.downArrow) {
+        moveCursor(clampedCursor + 1);
+      }
+    },
+    { isActive: isFocused }
+  );
+  return /* @__PURE__ */ jsxs5(
+    Box7,
+    {
+      flexDirection: "column",
+      height: availableRows,
+      borderStyle: "round",
+      borderColor: isFocused ? "green" : "gray",
+      children: [
+        /* @__PURE__ */ jsxs5(Box7, { paddingLeft: 1, gap: 1, children: [
+          /* @__PURE__ */ jsx7(Text7, { bold: true, color: isFocused ? "green" : "gray", children: "Overview" }),
+          isLoading && /* @__PURE__ */ jsx7(Spinner, { label: "" })
+        ] }),
+        /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: lines.length === 0 && !isLoading ? /* @__PURE__ */ jsx7(Box7, { paddingLeft: 1, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "No sessions." }) }) : visibleLines.map((line, i) => {
+          const globalIndex = scrollOffset + i;
+          const isHighlighted = isFocused && globalIndex === clampedCursor;
+          if (line.type === "spacer") {
+            return /* @__PURE__ */ jsx7(Box7, { height: 1 }, line.key);
+          }
+          if (line.type === "summary") {
+            return /* @__PURE__ */ jsx7(Box7, { paddingLeft: 1, children: /* @__PURE__ */ jsx7(Text7, { color: isHighlighted ? "green" : void 0, wrap: "wrap", children: line.text }) }, line.key);
+          }
+          if (line.type === "session") {
+            return /* @__PURE__ */ jsx7(Box7, { paddingLeft: 1, children: /* @__PURE__ */ jsx7(Text7, { color: isHighlighted ? "green" : "cyan", children: line.sessionName }) }, line.key);
+          }
+          return /* @__PURE__ */ jsxs5(Box7, { paddingLeft: 3, gap: 1, children: [
+            line.statusLabel ? /* @__PURE__ */ jsxs5(Text7, { color: isHighlighted ? "green" : line.statusColor, children: [
+              "[",
+              line.statusLabel,
+              "]"
+            ] }) : /* @__PURE__ */ jsx7(Text7, { color: isHighlighted ? "green" : "gray", children: "[--]" }),
+            /* @__PURE__ */ jsx7(Text7, { color: isHighlighted ? "green" : void 0, wrap: "wrap", children: line.description })
+          ] }, line.key);
+        }) })
+      ]
+    }
+  );
+};
+
 // src/components/ConfirmView.tsx
-import { Box as Box7, Text as Text7, useInput as useInput3 } from "ink";
+import { Box as Box8, Text as Text8, useInput as useInput4 } from "ink";
 
 // src/hooks/use-terminal-size.ts
 import { useStdout } from "ink";
-import { useEffect, useState as useState3 } from "react";
+import { useEffect, useState as useState4 } from "react";
 var useTerminalSize = () => {
   const { stdout } = useStdout();
-  const [size, setSize] = useState3({
+  const [size, setSize] = useState4({
     rows: stdout.rows ?? 24,
     columns: stdout.columns ?? 80
   });
@@ -940,12 +1199,12 @@ var useTerminalSize = () => {
 };
 
 // src/components/ConfirmView.tsx
-import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
 var ConfirmView = ({ selectedDir, prompt, onConfirm, onCancel }) => {
   const { rows } = useTerminalSize();
   const previewLines = prompt.split("\n");
   const maxPreview = Math.min(previewLines.length, rows - 6);
-  useInput3((_input, key) => {
+  useInput4((_input, key) => {
     if (key.return) {
       onConfirm();
       return;
@@ -954,30 +1213,30 @@ var ConfirmView = ({ selectedDir, prompt, onConfirm, onCancel }) => {
       onCancel();
     }
   });
-  return /* @__PURE__ */ jsxs4(Box7, { flexDirection: "column", height: rows, children: [
-    /* @__PURE__ */ jsx7(Header, { title: `${APP_TITLE} \u2014 ${selectedDir}` }),
-    /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, children: /* @__PURE__ */ jsx7(Text7, { bold: true, children: "New Claude session:" }) }),
-    /* @__PURE__ */ jsxs4(Box7, { flexDirection: "column", flexGrow: 1, overflow: "hidden", paddingLeft: 2, children: [
-      previewLines.slice(0, maxPreview).map((line, i) => /* @__PURE__ */ jsx7(Text7, { color: "white", children: line }, i)),
-      previewLines.length > maxPreview && /* @__PURE__ */ jsxs4(Text7, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx8(Header, { title: `${APP_TITLE} \u2014 ${selectedDir}` }),
+    /* @__PURE__ */ jsx8(Box8, { marginBottom: 1, children: /* @__PURE__ */ jsx8(Text8, { bold: true, children: "New Claude session:" }) }),
+    /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", flexGrow: 1, overflow: "hidden", paddingLeft: 2, children: [
+      previewLines.slice(0, maxPreview).map((line, i) => /* @__PURE__ */ jsx8(Text8, { color: "white", children: line }, i)),
+      previewLines.length > maxPreview && /* @__PURE__ */ jsxs6(Text8, { dimColor: true, children: [
         "... (",
         previewLines.length - maxPreview,
         " more lines)"
       ] })
     ] }),
-    /* @__PURE__ */ jsxs4(Box7, { gap: 2, children: [
-      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Enter confirm" }),
-      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Esc cancel" })
+    /* @__PURE__ */ jsxs6(Box8, { gap: 2, children: [
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Enter confirm" }),
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Esc cancel" })
     ] })
   ] });
 };
 
 // src/components/DeleteSessionView.tsx
-import { Box as Box8, Text as Text8, useInput as useInput4 } from "ink";
-import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+import { Box as Box9, Text as Text9, useInput as useInput5 } from "ink";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
 var DeleteSessionView = ({ sessionName, paneCount, onConfirm, onCancel }) => {
   const { rows } = useTerminalSize();
-  useInput4((_input, key) => {
+  useInput5((_input, key) => {
     if (key.return) {
       onConfirm();
       return;
@@ -986,33 +1245,33 @@ var DeleteSessionView = ({ sessionName, paneCount, onConfirm, onCancel }) => {
       onCancel();
     }
   });
-  return /* @__PURE__ */ jsxs5(Box8, { flexDirection: "column", height: rows, children: [
-    /* @__PURE__ */ jsx8(Header, { title: APP_TITLE }),
-    /* @__PURE__ */ jsxs5(Box8, { flexDirection: "column", gap: 1, paddingLeft: 2, children: [
-      /* @__PURE__ */ jsx8(Text8, { bold: true, color: "red", children: "Delete session?" }),
-      /* @__PURE__ */ jsxs5(Text8, { children: [
+  return /* @__PURE__ */ jsxs7(Box9, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx9(Header, { title: APP_TITLE }),
+    /* @__PURE__ */ jsxs7(Box9, { flexDirection: "column", gap: 1, paddingLeft: 2, children: [
+      /* @__PURE__ */ jsx9(Text9, { bold: true, color: "red", children: "Delete session?" }),
+      /* @__PURE__ */ jsxs7(Text9, { children: [
         "Session: ",
-        /* @__PURE__ */ jsx8(Text8, { bold: true, children: sessionName })
+        /* @__PURE__ */ jsx9(Text9, { bold: true, children: sessionName })
       ] }),
-      /* @__PURE__ */ jsxs5(Text8, { children: [
+      /* @__PURE__ */ jsxs7(Text9, { children: [
         "Panes: ",
-        /* @__PURE__ */ jsx8(Text8, { bold: true, children: paneCount })
+        /* @__PURE__ */ jsx9(Text9, { bold: true, children: paneCount })
       ] }),
-      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "All processes in this session will be terminated." })
+      /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "All processes in this session will be terminated." })
     ] }),
-    /* @__PURE__ */ jsx8(Box8, { flexGrow: 1 }),
-    /* @__PURE__ */ jsxs5(Box8, { gap: 2, children: [
-      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Enter confirm" }),
-      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Esc cancel" })
+    /* @__PURE__ */ jsx9(Box9, { flexGrow: 1 }),
+    /* @__PURE__ */ jsxs7(Box9, { gap: 2, children: [
+      /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "Enter confirm" }),
+      /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "Esc cancel" })
     ] })
   ] });
 };
 
 // src/components/DirectorySearchView.tsx
-import { Box as Box9, Text as Text9, useInput as useInput5 } from "ink";
-import { useMemo as useMemo4, useState as useState4 } from "react";
+import { Box as Box10, Text as Text10, useInput as useInput6 } from "ink";
+import { useMemo as useMemo6, useState as useState5 } from "react";
 import { basename } from "node:path";
-import { jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
 var formatPath = (path) => {
   const home = process.env["HOME"] ?? "";
   if (home && path.startsWith(home)) {
@@ -1022,9 +1281,9 @@ var formatPath = (path) => {
 };
 var DirectorySearchView = ({ directories, onSelect, onCancel }) => {
   const { rows } = useTerminalSize();
-  const [query, setQuery] = useState4("");
-  const [cursor, setCursor] = useState4(0);
-  const filtered = useMemo4(() => {
+  const [query, setQuery] = useState5("");
+  const [cursor, setCursor] = useState5(0);
+  const filtered = useMemo6(() => {
     if (!query) return directories;
     const lower = query.toLowerCase();
     return directories.filter((d) => {
@@ -1039,11 +1298,11 @@ var DirectorySearchView = ({ directories, onSelect, onCancel }) => {
   }
   const listHeight = rows - 6;
   const { scrollOffset, visibleCount } = useScroll(clampedCursor, filtered.length, listHeight);
-  const visibleItems = useMemo4(
+  const visibleItems = useMemo6(
     () => filtered.slice(scrollOffset, scrollOffset + visibleCount),
     [filtered, scrollOffset, visibleCount]
   );
-  useInput5((input, key) => {
+  useInput6((input, key) => {
     if (key.escape) {
       onCancel();
       return;
@@ -1071,33 +1330,50 @@ var DirectorySearchView = ({ directories, onSelect, onCancel }) => {
       setCursor(0);
     }
   });
-  return /* @__PURE__ */ jsxs6(Box9, { flexDirection: "column", height: rows, children: [
-    /* @__PURE__ */ jsx9(Header, { title: `${APP_TITLE} \u2014 Add Session` }),
-    /* @__PURE__ */ jsxs6(Box9, { paddingLeft: 1, gap: 1, children: [
-      /* @__PURE__ */ jsx9(Text9, { bold: true, children: ">" }),
-      /* @__PURE__ */ jsx9(Text9, { children: query }),
-      /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: query ? "" : "type to filter..." })
+  return /* @__PURE__ */ jsxs8(Box10, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx10(Header, { title: `${APP_TITLE} \u2014 Add Session` }),
+    /* @__PURE__ */ jsxs8(Box10, { paddingLeft: 1, gap: 1, children: [
+      /* @__PURE__ */ jsx10(Text10, { bold: true, children: ">" }),
+      /* @__PURE__ */ jsx10(Text10, { children: query }),
+      /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: query ? "" : "type to filter..." })
     ] }),
-    /* @__PURE__ */ jsx9(Box9, { paddingLeft: 1, children: /* @__PURE__ */ jsxs6(Text9, { dimColor: true, children: [
+    /* @__PURE__ */ jsx10(Box10, { paddingLeft: 1, children: /* @__PURE__ */ jsxs8(Text10, { dimColor: true, children: [
       filtered.length,
       "/",
       directories.length
     ] }) }),
-    /* @__PURE__ */ jsx9(Box9, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: visibleItems.map((dir, i) => {
+    /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: visibleItems.map((dir, i) => {
       const globalIndex = scrollOffset + i;
       const isHighlighted = globalIndex === clampedCursor;
-      return /* @__PURE__ */ jsxs6(Box9, { paddingLeft: 1, gap: 1, children: [
-        /* @__PURE__ */ jsx9(Text9, { color: isHighlighted ? "green" : void 0, children: isHighlighted ? "\u25B6" : " " }),
-        /* @__PURE__ */ jsx9(Text9, { color: isHighlighted ? "green" : void 0, bold: isHighlighted, children: formatPath(dir) })
+      return /* @__PURE__ */ jsxs8(Box10, { paddingLeft: 1, gap: 1, children: [
+        /* @__PURE__ */ jsx10(Text10, { color: isHighlighted ? "green" : void 0, children: isHighlighted ? "\u25B6" : " " }),
+        /* @__PURE__ */ jsx10(Text10, { color: isHighlighted ? "green" : void 0, bold: isHighlighted, children: formatPath(dir) })
       ] }, dir);
     }) }),
-    /* @__PURE__ */ jsxs6(Box9, { gap: 2, children: [
-      /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "Enter select" }),
-      /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "Esc cancel" })
+    /* @__PURE__ */ jsxs8(Box10, { gap: 2, children: [
+      /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "Enter select" }),
+      /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "Esc cancel" })
     ] })
   ] });
 };
 
+// src/hooks/use-interval.ts
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+var useInterval = (fn, intervalMs, enabled = true) => {
+  const fnRef = useRef2(fn);
+  fnRef.current = fn;
+  useEffect2(() => {
+    if (!enabled) return;
+    fnRef.current();
+    const timer = setInterval(() => {
+      fnRef.current();
+    }, intervalMs);
+    return () => {
+      clearInterval(timer);
+    };
+  }, [intervalMs, enabled]);
+};
+
 // src/utils/PromiseUtils.ts
 var swallow = async (fn) => {
   try {
@@ -1107,7 +1383,7 @@ var swallow = async (fn) => {
 };
 
 // src/components/ManagerView.tsx
-import { jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
 var MODE = {
   split: "split",
   confirm: "confirm",
@@ -1116,165 +1392,199 @@ var MODE = {
 };
 var FOCUS = {
   left: "left",
-  right: "right"
+  right: "right",
+  bottom: "bottom"
 };
 var POLL_INTERVAL = 3e3;
+var OVERVIEW_POLL_INTERVAL = 6e4;
 var ManagerView = ({
   actions,
   currentSession,
-  currentCwd,
   directories,
-  sessionCwdMap,
   restoredPrompt,
-  restoredSession
+  restoredSession,
+  restoredCwd
 }) => {
   const { rows, columns } = useTerminalSize();
-  const [fetchState, setFetchState] = useState5({ data: [], isLoading: true });
-  const [mode, setMode] = useState5(restoredPrompt ? MODE.confirm : MODE.split);
-  const [focus, setFocus] = useState5(FOCUS.left);
-  const [selectedSession, setSelectedSession] = useState5(restoredSession);
-  const [pendingPrompt, setPendingPrompt] = useState5(restoredPrompt ?? "");
-  const [pendingDeleteSession, setPendingDeleteSession] = useState5(void 0);
-  const refresh = useCallback3(async () => {
+  const [sessionsState, setSessionsState] = useState6({
+    sessions: [],
+    isLoading: true
+  });
+  const [mode, setMode] = useState6(restoredPrompt ? MODE.confirm : MODE.split);
+  const [focus, setFocus] = useState6(FOCUS.left);
+  const [selectedSession, setSelectedSession] = useState6(restoredSession);
+  const [pendingPrompt, setPendingPrompt] = useState6(restoredPrompt ?? "");
+  const [pendingDeleteSession, setPendingDeleteSession] = useState6(void 0);
+  const [overviewResult, setOverviewResult] = useState6({
+    overallSummary: "",
+    sessions: []
+  });
+  const [overviewLoading, setOverviewLoading] = useState6(true);
+  const overviewInFlightRef = useRef3(false);
+  const refresh = useCallback4(async () => {
     try {
-      const groups = await actions.fetchSessions();
-      const knownNames = new Set(groups.map((g) => g.sessionName));
-      const missing = [];
-      for (const name of sessionCwdMap.keys()) {
-        if (!knownNames.has(name)) {
-          missing.push({ sessionName: name, tabs: [] });
-        }
-      }
-      setFetchState({ data: [...missing, ...groups], isLoading: false });
+      const fetched = await actions.fetchSessions();
+      setSessionsState((prev) => {
+        const fetchedNames = new Set(fetched.map((s) => s.name));
+        const userOnly = prev.sessions.filter(
+          (s) => !fetchedNames.has(s.name) && s.groups.length === 0
+        );
+        return { sessions: [...userOnly, ...fetched], isLoading: false };
+      });
     } catch {
-      setFetchState((prev) => ({ ...prev, isLoading: false }));
+      setSessionsState((prev) => ({ ...prev, isLoading: false }));
     }
   }, [actions]);
-  useEffect2(() => {
-    void refresh();
-    const timer = setInterval(() => {
-      void refresh();
-    }, POLL_INTERVAL);
-    return () => {
-      clearInterval(timer);
+  useInterval(() => void refresh(), POLL_INTERVAL);
+  useInterval(
+    () => {
+      if (overviewInFlightRef.current) return;
+      overviewInFlightRef.current = true;
+      setOverviewLoading(true);
+      void actions.fetchOverview(sessionsState.sessions).then((result) => {
+        setOverviewResult(result);
+      }).catch(() => {
+      }).finally(() => {
+        setOverviewLoading(false);
+        overviewInFlightRef.current = false;
+      });
+    },
+    OVERVIEW_POLL_INTERVAL,
+    !sessionsState.isLoading
+  );
+  const resolvedSession = selectedSession ?? sessionsState.sessions[0]?.name;
+  const selectedManagedSession = useMemo7(
+    () => sessionsState.sessions.find((s) => s.name === resolvedSession),
+    [sessionsState.sessions, resolvedSession]
+  );
+  const selectedGroup = useMemo7(() => {
+    if (!selectedManagedSession) return void 0;
+    return {
+      sessionName: selectedManagedSession.name,
+      tabs: selectedManagedSession.groups.flatMap((g) => g.tabs)
     };
-  }, [refresh]);
-  const resolvedSession = selectedSession ?? fetchState.data[0]?.sessionName;
-  const selectedGroup = useMemo5(
-    () => fetchState.data.find((g) => g.sessionName === resolvedSession),
-    [fetchState.data, resolvedSession]
+  }, [selectedManagedSession]);
+  const allGroups = useMemo7(
+    () => sessionsState.sessions.flatMap((s) => s.groups),
+    [sessionsState.sessions]
   );
-  const sessionPathMap = useMemo5(() => {
-    const map = /* @__PURE__ */ new Map();
-    for (const group of fetchState.data) {
-      const fromMap = sessionCwdMap.get(group.sessionName);
-      const fromPane = group.tabs[0]?.panes[0]?.pane.cwd;
-      const path = fromMap ?? fromPane;
-      if (path) map.set(group.sessionName, path);
-    }
-    return map;
-  }, [fetchState.data]);
-  const handleOpenAddSession = useCallback3(() => {
+  const statusCounts = useMemo7(
+    () => allGroups.flatMap((g) => g.tabs).flatMap((t) => t.panes).filter((p) => p.kind === "claude" && p.claudeStatus).reduce((acc, p) => {
+      const s = p.claudeStatus;
+      if (!s) return acc;
+      return { ...acc, [s]: (acc[s] ?? 0) + 1 };
+    }, {}),
+    [allGroups]
+  );
+  const handleOpenAddSession = useCallback4(() => {
     setMode(MODE.addSession);
   }, []);
-  const handleAddSessionSelect = useCallback3(
-    (path) => {
-      const name = basename2(path);
-      sessionCwdMap.set(name, path);
-      const exists2 = fetchState.data.some((g) => g.sessionName === name);
-      if (!exists2) {
-        setFetchState((prev) => ({
-          ...prev,
-          data: [{ sessionName: name, tabs: [] }, ...prev.data]
-        }));
-      }
-      setSelectedSession(name);
-      setMode(MODE.split);
-    },
-    [fetchState.data]
-  );
-  const handleCancelAddSession = useCallback3(() => {
+  const handleAddSessionSelect = useCallback4((path) => {
+    const name = basename2(path);
+    setSessionsState((prev) => {
+      const exists2 = prev.sessions.some((s) => s.name === name);
+      if (exists2) return prev;
+      return {
+        ...prev,
+        sessions: [{ name, path, groups: [] }, ...prev.sessions]
+      };
+    });
+    setSelectedSession(name);
     setMode(MODE.split);
   }, []);
-  const handleDeleteSession = useCallback3((name) => {
+  const handleCancelAddSession = useCallback4(() => {
+    setMode(MODE.split);
+  }, []);
+  const handleDeleteSession = useCallback4((name) => {
     setPendingDeleteSession(name);
     setMode(MODE.deleteSession);
   }, []);
-  const handleConfirmDelete = useCallback3(() => {
+  const handleConfirmDelete = useCallback4(() => {
     if (!pendingDeleteSession) return;
-    sessionCwdMap.delete(pendingDeleteSession);
+    const session = sessionsState.sessions.find((s) => s.name === pendingDeleteSession);
+    setSessionsState((prev) => ({
+      ...prev,
+      sessions: prev.sessions.filter((s) => s.name !== pendingDeleteSession)
+    }));
     if (resolvedSession === pendingDeleteSession) {
       setSelectedSession(void 0);
     }
-    void swallow(() => actions.killSession(pendingDeleteSession)).then(() => void refresh());
+    if (session) {
+      const killAll = Promise.all(
+        session.groups.map((g) => swallow(() => actions.killSession(g.sessionName)))
+      );
+      void killAll.then(() => void refresh());
+    }
     setPendingDeleteSession(void 0);
     setMode(MODE.split);
-  }, [pendingDeleteSession, resolvedSession, actions, refresh]);
-  const handleCancelDelete = useCallback3(() => {
+  }, [pendingDeleteSession, resolvedSession, sessionsState.sessions, actions, refresh]);
+  const handleCancelDelete = useCallback4(() => {
     setPendingDeleteSession(void 0);
     setMode(MODE.split);
   }, []);
-  const handleNewSession = useCallback3(
+  const handleNewSession = useCallback4(
     (sessionName) => {
-      actions.openEditor(sessionName);
+      const cwd = selectedManagedSession?.path;
+      if (!cwd) return;
+      actions.openEditor(sessionName, cwd);
     },
-    [actions]
+    [actions, selectedManagedSession]
   );
-  const handleConfirmNew = useCallback3(() => {
+  const handleConfirmNew = useCallback4(() => {
     if (!resolvedSession) return;
-    const existingCwd = selectedGroup?.tabs[0]?.panes[0]?.pane.cwd;
-    const cwd = sessionCwdMap.get(resolvedSession) ?? existingCwd ?? currentCwd;
+    const cwd = restoredCwd ?? selectedManagedSession?.path;
+    if (!cwd) return;
     void actions.createSession(resolvedSession, cwd, pendingPrompt).then(() => void refresh());
     setPendingPrompt("");
     setMode(MODE.split);
-  }, [resolvedSession, selectedGroup, currentCwd, pendingPrompt, actions, refresh]);
-  const handleCancelConfirm = useCallback3(() => {
+  }, [resolvedSession, restoredCwd, selectedManagedSession, pendingPrompt, actions, refresh]);
+  const handleCancelConfirm = useCallback4(() => {
     setPendingPrompt("");
     setMode(MODE.split);
   }, []);
-  const handleSessionSelect = useCallback3((name) => {
+  const handleSessionSelect = useCallback4((name) => {
     setSelectedSession(name);
     setFocus(FOCUS.right);
   }, []);
-  const handleSessionCursorChange = useCallback3((name) => {
+  const handleSessionCursorChange = useCallback4((name) => {
     setSelectedSession(name);
   }, []);
-  const handleNavigate = useCallback3(
+  const handleNavigate = useCallback4(
     (up) => {
       void actions.navigateToPane(up);
     },
     [actions]
   );
-  const handleBack = useCallback3(() => {
+  const handleBack = useCallback4(() => {
     setFocus(FOCUS.left);
   }, []);
-  const handleKillPane = useCallback3(
+  const handleKillPane = useCallback4(
     async (paneId) => {
       await swallow(() => actions.killPane(paneId));
       void refresh();
     },
     [actions, refresh]
   );
-  const handleHighlight = useCallback3(
+  const handleHighlight = useCallback4(
     async (up) => {
       await swallow(() => actions.highlightWindow(up));
     },
     [actions]
   );
-  const handleUnhighlight = useCallback3(
+  const handleUnhighlight = useCallback4(
     async (up) => {
       await swallow(() => actions.unhighlightWindow(up));
     },
     [actions]
   );
-  if (fetchState.isLoading) {
-    return /* @__PURE__ */ jsxs7(Box10, { flexDirection: "column", height: rows, children: [
-      /* @__PURE__ */ jsx10(Header, { title: `${APP_TITLE} v${APP_VERSION}` }),
-      /* @__PURE__ */ jsx10(StatusBar, { message: "Loading...", type: "info" })
+  if (sessionsState.isLoading) {
+    return /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", height: rows, children: [
+      /* @__PURE__ */ jsx11(Header, { title: `${APP_TITLE} v${APP_VERSION}` }),
+      /* @__PURE__ */ jsx11(StatusBar, { message: "Loading...", type: "info" })
     ] });
   }
   if (mode === MODE.addSession) {
-    return /* @__PURE__ */ jsx10(
+    return /* @__PURE__ */ jsx11(
       DirectorySearchView,
       {
         directories,
@@ -1284,9 +1594,12 @@ var ManagerView = ({
     );
   }
   if (mode === MODE.deleteSession && pendingDeleteSession) {
-    const deleteGroup = fetchState.data.find((g) => g.sessionName === pendingDeleteSession);
-    const paneCount = deleteGroup?.tabs.reduce((sum, t) => sum + t.panes.length, 0) ?? 0;
-    return /* @__PURE__ */ jsx10(
+    const deleteSession = sessionsState.sessions.find((s) => s.name === pendingDeleteSession);
+    const paneCount = deleteSession?.groups.reduce(
+      (sum, g) => sum + g.tabs.reduce((s, t) => s + t.panes.length, 0),
+      0
+    ) ?? 0;
+    return /* @__PURE__ */ jsx11(
       DeleteSessionView,
       {
         sessionName: pendingDeleteSession,
@@ -1297,7 +1610,7 @@ var ManagerView = ({
     );
   }
   if (mode === MODE.confirm && pendingPrompt) {
-    return /* @__PURE__ */ jsx10(
+    return /* @__PURE__ */ jsx11(
       ConfirmView,
       {
         selectedDir: resolvedSession ?? "",
@@ -1307,27 +1620,29 @@ var ManagerView = ({
       }
     );
   }
-  const panelHeight = rows - 5;
+  const fixedRows = 3;
+  const contentHeight = rows - fixedRows;
+  const topHeight = Math.floor(contentHeight / 2);
+  const bottomHeight = contentHeight - topHeight;
   const leftWidth = Math.floor(columns / 3);
   const rightWidth = columns - leftWidth;
-  return /* @__PURE__ */ jsxs7(Box10, { flexDirection: "column", height: rows, children: [
-    /* @__PURE__ */ jsx10(Header, { title: `${APP_TITLE} - v${APP_VERSION}` }),
-    /* @__PURE__ */ jsxs7(Box10, { flexDirection: "row", flexGrow: 1, children: [
-      /* @__PURE__ */ jsx10(
-        Box10,
+  return /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx11(Header, { title: `${APP_TITLE} - v${APP_VERSION}` }),
+    /* @__PURE__ */ jsxs9(Box11, { flexDirection: "row", height: topHeight, children: [
+      /* @__PURE__ */ jsx11(
+        Box11,
         {
           flexDirection: "column",
           width: leftWidth,
           borderStyle: "round",
           borderColor: focus === FOCUS.left ? "green" : "gray",
-          children: /* @__PURE__ */ jsx10(
+          children: /* @__PURE__ */ jsx11(
             SessionListPanel,
             {
-              sessionGroups: fetchState.data,
+              sessions: sessionsState.sessions,
               currentSession,
-              sessionPathMap,
               isFocused: focus === FOCUS.left,
-              availableRows: panelHeight,
+              availableRows: topHeight - 2,
               onSelect: handleSessionSelect,
               onCursorChange: handleSessionCursorChange,
               onDeleteSession: handleDeleteSession,
@@ -1336,20 +1651,20 @@ var ManagerView = ({
           )
         }
       ),
-      /* @__PURE__ */ jsx10(
-        Box10,
+      /* @__PURE__ */ jsx11(
+        Box11,
         {
           flexDirection: "column",
           width: rightWidth,
           borderStyle: "round",
           borderColor: focus === FOCUS.right ? "green" : "gray",
-          children: /* @__PURE__ */ jsx10(
+          children: /* @__PURE__ */ jsx11(
             PaneListPanel,
             {
               selectedSession: resolvedSession,
               group: selectedGroup,
               isFocused: focus === FOCUS.right,
-              availableRows: panelHeight,
+              availableRows: topHeight - 2,
               onNavigate: handleNavigate,
               onHighlight: handleHighlight,
               onUnhighlight: handleUnhighlight,
@@ -1361,32 +1676,67 @@ var ManagerView = ({
         }
       )
     ] }),
-    /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: focus === FOCUS.left ? "\u2191/\u2193 move  Enter/\u2192 select  n add  d delete  q quit" : "\u2191/\u2193 move  Enter focus  n new  d kill  Esc/\u2190 back  q quit" })
+    /* @__PURE__ */ jsx11(
+      SessionOverviewPanel,
+      {
+        overallSummary: overviewResult.overallSummary,
+        items: overviewResult.sessions,
+        groups: allGroups,
+        isLoading: overviewLoading,
+        isFocused: focus === FOCUS.bottom,
+        availableRows: bottomHeight,
+        onBack: handleBack
+      }
+    ),
+    /* @__PURE__ */ jsx11(
+      StatusBar,
+      {
+        message: focus === FOCUS.left ? "\u2191/\u2193 move  Enter/\u2192 select  n add  d delete  q quit" : focus === FOCUS.right ? "\u2191/\u2193 move  Enter focus  n new  d kill  Esc/\u2190 back  q quit" : "\u2191/\u2193 scroll  Esc/\u2190 back  q quit",
+        statusCounts
+      }
+    )
   ] });
 };
 
 // src/cli/tui-command.ts
 var createTuiCommand = ({ usecases, services, infra }) => async () => {
   const directories = await services.directoryScan.scan();
-  const sessionCwdMap = /* @__PURE__ */ new Map();
   let instance;
   let pendingPrompt;
   let pendingSession;
+  let pendingCwd;
   const actions = {
     fetchSessions: async () => {
       const result = await usecases.manager.list();
-      return await Promise.all(
-        result.sessionGroups.map(async (group) => ({
-          sessionName: group.sessionName,
-          tabs: await Promise.all(
-            group.tabs.map(async (tab) => ({
-              windowIndex: tab.windowIndex,
-              windowName: tab.windowName,
-              panes: await Promise.all(tab.panes.map((up) => usecases.manager.enrichStatus(up)))
-            }))
-          )
-        }))
+      const resolved = await Promise.all(
+        result.sessionGroups.map(async (group) => {
+          const enrichedGroup = {
+            sessionName: group.sessionName,
+            tabs: await Promise.all(
+              group.tabs.map(async (tab) => ({
+                windowIndex: tab.windowIndex,
+                windowName: tab.windowName,
+                panes: await Promise.all(
+                  tab.panes.map((up) => usecases.manager.enrichStatus(up))
+                )
+              }))
+            )
+          };
+          const paneCwd = group.tabs[0]?.panes[0]?.pane.cwd ?? "";
+          const path = findMatchingDirectory(paneCwd, directories) ?? paneCwd;
+          return { path, group: enrichedGroup };
+        })
       );
+      const grouped = Map.groupBy(resolved, (item) => item.path || item.group.sessionName);
+      return [...grouped.entries()].map(([key, items]) => ({
+        name: basename3(key) || items[0].group.sessionName,
+        path: items[0].path,
+        groups: items.map((item) => item.group)
+      }));
+    },
+    fetchOverview: async (sessions) => {
+      const groups = sessions.flatMap((s) => s.groups);
+      return await usecases.manager.fetchOverview(groups);
     },
     createSession: async (sessionName, cwd, prompt) => {
       await usecases.manager.createSession({ sessionName, cwd, prompt });
@@ -1403,11 +1753,12 @@ var createTuiCommand = ({ usecases, services, infra }) => async () => {
     unhighlightWindow: async (up) => {
       await usecases.manager.unhighlightWindow(up);
     },
-    openEditor: (sessionName) => {
+    openEditor: (sessionName, cwd) => {
       instance.unmount();
       const prompt = infra.editor.open();
       pendingPrompt = prompt;
       pendingSession = sessionName;
+      pendingCwd = cwd;
       instance = renderApp();
       return prompt;
     },
@@ -1423,17 +1774,20 @@ var createTuiCommand = ({ usecases, services, infra }) => async () => {
   const renderApp = () => {
     const prompt = pendingPrompt;
     const session = pendingSession;
+    const cwd = pendingCwd;
     pendingPrompt = void 0;
     pendingSession = void 0;
+    pendingCwd = void 0;
+    const rawCwd = process.cwd();
+    const currentSession = basename3(findMatchingDirectory(rawCwd, directories) ?? rawCwd);
     return render(
       createElement(ManagerView, {
         actions,
-        currentSession: basename3(process.cwd()),
-        currentCwd: process.cwd(),
+        currentSession,
         directories,
-        sessionCwdMap,
         restoredPrompt: prompt,
-        restoredSession: session
+        restoredSession: session,
+        restoredCwd: cwd
       }),
       { concurrent: true }
     );
@@ -1491,10 +1845,11 @@ var createListCommand = ({ usecases }) => async () => {
     console.log("No sessions found.");
     return;
   }
-  for (const group of result.sessionGroups) {
+  const lines = result.sessionGroups.map((group) => {
     const paneCount = group.tabs.reduce((sum, t) => sum + t.panes.length, 0);
-    console.log(`${group.sessionName} (${String(paneCount)} panes)`);
-  }
+    return `${group.sessionName} (${String(paneCount)} panes)`;
+  });
+  console.log(lines.join("\n"));
 };
 
 // src/cli/index.ts