agenthud 0.8.3 → 0.8.5

package/README.md

@@ -130,6 +130,23 @@ Output is written to stdout in Markdown format:
 **`--include` types:** `response`, `bash`, `edit`, `thinking`, `read`, `glob`, `user`  
 Default: `response,bash,edit,thinking`
 
+## Summary
+
+Generate an LLM-based summary of a day's activity using the `claude` CLI:
+
+```bash
+agenthud summary                          # today
+agenthud summary --date 2026-05-14        # past date (cached on second run)
+agenthud summary --date 2026-05-14 --force # ignore cache
+agenthud summary --prompt "커밋만 요약해"  # override prompt
+```
+
+Results are saved to `~/.agenthud/summaries/YYYY-MM-DD.md`. Past dates are cached and returned instantly on re-run. Today's date is always regenerated since activity is still growing.
+
+**Prompt customization:** The summary uses `~/.agenthud/summary-prompt.md`, which is auto-created from a built-in template on first run. Edit it freely or override per-call with `--prompt`.
+
+**Requires:** [`@anthropic-ai/claude-code`](https://www.npmjs.com/package/@anthropic-ai/claude-code) installed and authenticated (`npm i -g @anthropic-ai/claude-code`).
+
 ## Configuration
 
 Optional. Create `~/.agenthud/config.yaml`:

package/dist/index.js

@@ -14,4 +14,5 @@ Error: Node.js ${MIN_NODE_VERSION}+ is required (current: ${process.version})
   console.error("  https://nodejs.org/\n");
   process.exit(1);
 }
-import("./main-VPGVYRCR.js");
+if (!process.env.NODE_ENV) process.env.NODE_ENV = "production";
+import("./main-LOBTW45O.js");

package/dist/{main-VPGVYRCR.js → main-LOBTW45O.js}

@@ -1,6 +1,6 @@
 // src/main.ts
-import { existsSync as existsSync5, rmSync } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, rmSync } from "fs";
+import { join as join6 } from "path";
 import { createInterface } from "readline";
 import { render } from "ink";
 import React from "react";
@@ -28,8 +28,15 @@ var KNOWN_WATCH_FLAGS = /* @__PURE__ */ new Set([
   "-h",
   "--help"
 ]);
-var KNOWN_REPORT_FLAGS = /* @__PURE__ */ new Set(["--date", "--include", "--format"]);
-var KNOWN_SUBCOMMANDS = /* @__PURE__ */ new Set(["report"]);
+var KNOWN_REPORT_FLAGS = /* @__PURE__ */ new Set([
+  "--date",
+  "--include",
+  "--format",
+  "--detail-limit",
+  "--with-git"
+]);
+var KNOWN_SUMMARY_FLAGS = /* @__PURE__ */ new Set(["--date", "--prompt", "--force"]);
+var KNOWN_SUBCOMMANDS = /* @__PURE__ */ new Set(["report", "summary"]);
 function getHelp() {
   return `Usage: agenthud [options]
 
@@ -42,13 +49,21 @@ Options:
   -h, --help                    Show this help message
 
 Commands:
-  report [--date DATE] [--include TYPES]
+  report [--date DATE] [--include TYPES] [--format FORMAT] [--detail-limit N] [--with-git]
                                 Print activity report for a date (default: today)
     --date YYYY-MM-DD|today     Date to report on
     --include TYPES             Comma-separated types or "all"
                                 Types: response,bash,edit,thinking,read,glob,user
                                 Default: response,bash,edit,thinking
     --format FORMAT             Output format: markdown (default) or json
+    --detail-limit N            Max chars per activity detail (default: 120, 0 = unlimited)
+    --with-git                  Append today's git commits from cwd to report
+
+  summary [--date DATE] [--prompt TEXT] [--force]
+                                Generate LLM summary of daily activity via claude CLI
+    --date YYYY-MM-DD|today     Date to summarize (default: today)
+    --prompt TEXT               Override prompt for this run
+    --force                     Regenerate even if cached (past dates)
 
 Environment:
   CLAUDE_PROJECTS_DIR           Path to Claude projects directory
@@ -140,14 +155,75 @@ function parseArgs(args) {
         reportError = "Invalid format: missing value for --format.";
       }
     }
+    let reportDetailLimit;
+    const detailLimitIdx = rest.indexOf("--detail-limit");
+    if (detailLimitIdx !== -1) {
+      const val = rest[detailLimitIdx + 1];
+      const n = Number(val);
+      if (!val || Number.isNaN(n) || n < 0 || !Number.isInteger(n)) {
+        reportError = `Invalid --detail-limit: "${val}". Must be a non-negative integer.`;
+      } else {
+        reportDetailLimit = n;
+      }
+    }
+    const reportWithGit = rest.includes("--with-git");
     return {
       mode: "report",
       reportDate,
       reportInclude,
       reportFormat,
+      reportDetailLimit,
+      reportWithGit,
       reportError
     };
   }
+  if (args[0] === "summary") {
+    const rest = args.slice(1);
+    let summaryDate = todayLocalMidnight();
+    let summaryPrompt;
+    let summaryForce = false;
+    let summaryError;
+    for (let i = 0; i < rest.length; i++) {
+      const arg = rest[i];
+      if (!arg.startsWith("-")) continue;
+      if (!KNOWN_SUMMARY_FLAGS.has(arg)) {
+        summaryError = `Unknown option: "${arg}". Run agenthud --help for usage.`;
+        break;
+      }
+      if (arg === "--date" || arg === "--prompt") i++;
+    }
+    const dateIdx = rest.indexOf("--date");
+    if (dateIdx !== -1) {
+      const dateStr = rest[dateIdx + 1];
+      if (!dateStr) {
+        summaryError = "Invalid date: missing value for --date";
+      } else {
+        const parsed = parseLocalMidnight(dateStr);
+        if (!parsed) {
+          summaryError = `Invalid date: "${dateStr}". Use YYYY-MM-DD or "today".`;
+        } else {
+          summaryDate = parsed;
+        }
+      }
+    }
+    const promptIdx = rest.indexOf("--prompt");
+    if (promptIdx !== -1) {
+      const val = rest[promptIdx + 1];
+      if (!val) {
+        summaryError = "Invalid --prompt: missing value";
+      } else {
+        summaryPrompt = val;
+      }
+    }
+    if (rest.includes("--force")) summaryForce = true;
+    return {
+      mode: "summary",
+      summaryDate,
+      summaryPrompt,
+      summaryForce,
+      summaryError
+    };
+  }
   if (args[0] && !args[0].startsWith("-") && !KNOWN_SUBCOMMANDS.has(args[0])) {
     return {
       mode: "watch",
@@ -175,7 +251,8 @@ var DEFAULT_GLOBAL_CONFIG = {
   refreshIntervalMs: 2e3,
   logDir: join2(homedir(), ".agenthud", "logs"),
   hiddenSessions: [],
-  hiddenSubAgents: []
+  hiddenSubAgents: [],
+  filterPresets: [[], ["response"], ["commit"]]
 };
 function parseInterval(value) {
   const match = value.match(/^(\d+)(s|m)$/);
@@ -217,6 +294,12 @@ function loadGlobalConfig() {
       (s) => typeof s === "string"
     );
   }
+  if (Array.isArray(parsed.filterPresets)) {
+    const presets = parsed.filterPresets.filter(Array.isArray).map(
+      (p) => p.filter((t) => typeof t === "string")
+    );
+    if (presets.length > 0) config.filterPresets = presets;
+  }
   return config;
 }
 function writeConfig(updates) {
@@ -260,11 +343,8 @@ function hasProjectLevelConfig() {
 // src/data/reportGenerator.ts
 import { statSync } from "fs";
 
-// src/data/sessionHistory.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
-
-// src/data/activityParser.ts
-import { basename } from "path";
+// src/data/gitCommits.ts
+import { execSync } from "child_process";
 
 // src/types/index.ts
 var ICONS = {
@@ -282,10 +362,62 @@ var ICONS = {
   Task: "\xBB",
   TodoWrite: "~",
   AskUserQuestion: "?",
+  Commit: "\u25C6",
   Default: "$"
 };
 
+// src/data/gitCommits.ts
+function formatDateString(date) {
+  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+function getCommitDetail(projectPath, hash) {
+  if (!projectPath) return null;
+  try {
+    return execSync(
+      `git --git-dir="${projectPath}/.git" show --stat --no-color ${hash}`,
+      { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+  } catch {
+    return null;
+  }
+}
+function parseGitCommits(projectPath, startDate, endDate) {
+  if (!projectPath) return [];
+  const start = formatDateString(startDate);
+  const end = formatDateString(endDate ?? startDate);
+  let raw;
+  try {
+    raw = execSync(
+      `git --git-dir="${projectPath}/.git" log --format="%ct|%h|%s" --after="${start} 00:00:00" --before="${end} 23:59:59"`,
+      { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+  } catch {
+    return [];
+  }
+  if (!raw) return [];
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    const parts = line.trim().split("|");
+    if (parts.length < 3) continue;
+    const [tsStr, hash, ...rest] = parts;
+    const ts = Number(tsStr);
+    if (Number.isNaN(ts)) continue;
+    entries.push({
+      timestamp: new Date(ts * 1e3),
+      type: "commit",
+      icon: ICONS.Commit,
+      label: hash,
+      detail: rest.join("|")
+    });
+  }
+  return entries.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+}
+
+// src/data/sessionHistory.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+
 // src/data/activityParser.ts
+import { basename } from "path";
 function stripAnsi(text) {
   return text.replace(/\x1b\[[0-9;]*m/g, "");
 }
@@ -432,13 +564,13 @@ function isSameLocalDay(a, b) {
 function formatTime(date) {
   return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
 }
-function formatActivity(activity) {
+function formatActivity(activity, limit) {
   const time = formatTime(activity.timestamp);
-  const detail = activity.detail.length > 120 ? activity.detail.slice(0, 120) : activity.detail;
+  const detail = truncateDetail(activity.detail, limit);
   const suffix = detail ? `: ${detail}` : "";
   return `[${time}] ${activity.icon} ${activity.label}${suffix}`;
 }
-function formatDateString(date) {
+function formatDateString2(date) {
   return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
 }
 function sessionIsOnDate(session, date, activities) {
@@ -449,14 +581,28 @@ function sessionIsOnDate(session, date, activities) {
   }
   return activities.some((a) => isSameLocalDay(a.timestamp, date));
 }
+function truncateDetail(detail, limit) {
+  if (limit === 0 || detail.length <= limit) return detail;
+  return detail.slice(0, limit);
+}
 function generateReport(sessions, options2) {
-  const { date, include, format = "markdown" } = options2;
-  const dateStr = formatDateString(date);
+  const {
+    date,
+    include,
+    format = "markdown",
+    detailLimit = 120,
+    withGit = false
+  } = options2;
+  const dateStr = formatDateString2(date);
   const blocks = [];
   for (const session of sessions) {
     const allActivities = parseSessionHistory(session.filePath);
     if (!sessionIsOnDate(session, date, allActivities)) continue;
-    const dayActivities = allActivities.filter((a) => isSameLocalDay(a.timestamp, date)).filter((a) => activityMatchesInclude(a, include));
+    const commits = withGit ? parseGitCommits(session.projectPath, date) : [];
+    const dayActivities = [
+      ...allActivities.filter((a) => isSameLocalDay(a.timestamp, date)).filter((a) => activityMatchesInclude(a, include)),
+      ...commits
+    ].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
     if (dayActivities.length === 0) continue;
     blocks.push({
       session,
@@ -472,20 +618,39 @@ function generateReport(sessions, options2) {
   }
   blocks.sort((a, b) => a.firstTime - b.firstTime);
   if (format === "json") {
-    return JSON.stringify(
-      {
-        date: dateStr,
-        sessions: blocks.map(({ session, activities }) => ({
-          project: session.projectName,
-          start: formatTime(activities[0].timestamp),
-          end: formatTime(activities[activities.length - 1].timestamp),
-          activities: activities.map((a) => ({
+    const buildJsonSession = (session, acts) => {
+      const subAgentBlocks = session.subAgents.map((sa) => {
+        const saActivities = parseSessionHistory(sa.filePath).filter((a) => isSameLocalDay(a.timestamp, date)).filter((a) => activityMatchesInclude(a, include));
+        return {
+          agentId: sa.agentId,
+          taskDescription: sa.taskDescription,
+          activities: saActivities.map((a) => ({
             time: formatTime(a.timestamp),
             icon: a.icon,
             label: a.label,
-            detail: a.detail.length > 120 ? a.detail.slice(0, 120) : a.detail
+            detail: truncateDetail(a.detail, detailLimit)
           }))
-        }))
+        };
+      });
+      return {
+        project: session.projectName,
+        start: formatTime(acts[0].timestamp),
+        end: formatTime(acts[acts.length - 1].timestamp),
+        activities: acts.map((a) => ({
+          time: formatTime(a.timestamp),
+          icon: a.icon,
+          label: a.label,
+          detail: truncateDetail(a.detail, detailLimit)
+        })),
+        subAgents: subAgentBlocks
+      };
+    };
+    return JSON.stringify(
+      {
+        date: dateStr,
+        sessions: blocks.map(
+          ({ session, activities }) => buildJsonSession(session, activities)
+        )
       },
       null,
       2
@@ -498,13 +663,26 @@ function generateReport(sessions, options2) {
     lines.push(`## ${session.projectName} (${first} \u2013 ${last})`);
     lines.push("");
     for (const activity of activities) {
-      lines.push(formatActivity(activity));
+      lines.push(formatActivity(activity, detailLimit));
     }
     lines.push("");
   }
   return lines.join("\n").trimEnd();
 }
 
+// src/data/summaryRunner.ts
+import { spawn } from "child_process";
+import {
+  copyFileSync,
+  createWriteStream,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync5
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
 // src/data/sessions.ts
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
 import { homedir as homedir2 } from "os";
@@ -724,9 +902,129 @@ function discoverSessions(config) {
   };
 }
 
+// src/data/summaryRunner.ts
+function summariesDir() {
+  const dir = join4(homedir3(), ".agenthud", "summaries");
+  if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
+  return dir;
+}
+function userPromptPath() {
+  return join4(homedir3(), ".agenthud", "summary-prompt.md");
+}
+function templatePath() {
+  const here = dirname2(fileURLToPath2(import.meta.url));
+  return join4(here, "templates", "summary-prompt.md");
+}
+function dateKey(d) {
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function cachePath(date) {
+  return join4(summariesDir(), `${dateKey(date)}.md`);
+}
+function isSameLocalDay2(a, b) {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+function ensureUserPromptFile() {
+  const p = userPromptPath();
+  if (existsSync4(p)) return;
+  const dir = dirname2(p);
+  if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
+  try {
+    copyFileSync(templatePath(), p);
+  } catch {
+  }
+}
+function resolvePrompt(override) {
+  if (override) return override;
+  const p = userPromptPath();
+  if (existsSync4(p)) {
+    try {
+      return readFileSync5(p, "utf-8");
+    } catch {
+    }
+  }
+  try {
+    return readFileSync5(templatePath(), "utf-8");
+  } catch {
+    return "Summarize the activity log below.";
+  }
+}
+async function runSummary(options2) {
+  ensureUserPromptFile();
+  const isToday = isSameLocalDay2(options2.date, options2.today);
+  const cached = cachePath(options2.date);
+  if (!isToday && !options2.force && existsSync4(cached)) {
+    try {
+      const content = readFileSync5(cached, "utf-8");
+      process.stdout.write(content);
+      if (!content.endsWith("\n")) process.stdout.write("\n");
+      return 0;
+    } catch {
+    }
+  }
+  const config = loadGlobalConfig();
+  const sessions = discoverSessions(config);
+  const reportMarkdown = generateReport(sessions.sessions, {
+    date: options2.date,
+    include: ["response", "bash", "edit", "thinking"],
+    format: "markdown",
+    detailLimit: 0,
+    withGit: true
+  });
+  const prompt = resolvePrompt(options2.prompt);
+  return new Promise((resolve) => {
+    const proc = spawn("claude", ["-p", prompt], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let cacheStream = null;
+    cacheStream = createWriteStream(cached, { encoding: "utf-8" });
+    cacheStream.on("error", (err) => {
+      process.stderr.write(
+        `agenthud: warning: cannot write cache (${err.message})
+`
+      );
+      cacheStream = null;
+    });
+    let stderrBuf = "";
+    proc.on("error", (err) => {
+      if (err.code === "ENOENT") {
+        process.stderr.write(
+          "Error: claude CLI not found. Install: npm i -g @anthropic-ai/claude-code\n"
+        );
+        resolve(1);
+      } else {
+        process.stderr.write(`Error: ${err.message}
+`);
+        resolve(1);
+      }
+    });
+    proc.stdout.on("data", (chunk) => {
+      process.stdout.write(chunk);
+      cacheStream?.write(chunk);
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderrBuf += chunk.toString();
+      process.stderr.write(chunk);
+    });
+    proc.on("close", (code) => {
+      cacheStream?.end();
+      if (code !== 0) {
+        const lower = stderrBuf.toLowerCase();
+        if (lower.includes("not authenticated") || lower.includes("login") || lower.includes(" auth")) {
+          process.stderr.write(
+            "\nHint: claude appears to be unauthenticated. Run: claude\n"
+          );
+        }
+      }
+      resolve(code ?? 1);
+    });
+    proc.stdin.end(reportMarkdown);
+  });
+}
+
 // src/ui/App.tsx
-import { existsSync as existsSync4, watch, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, watch, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
 import { Box as Box4, Text as Text4, useApp, useInput, useStdout } from "ink";
 import { useCallback, useEffect as useEffect2, useMemo, useRef, useState as useState2 } from "react";
 
@@ -743,6 +1041,9 @@ function getActivityStyle(activity) {
   if (activity.type === "thinking") {
     return { color: "magenta", dimColor: true };
   }
+  if (activity.type === "commit") {
+    return { color: "yellow", dimColor: false };
+  }
   if (activity.type === "tool") {
     if (activity.label === "Bash") {
       return { color: "gray", dimColor: false };
@@ -762,7 +1063,7 @@ function formatActivityTime(date, now) {
   const day = String(date.getDate()).padStart(2, "0");
   return `${month}/${day} ${time}`;
 }
-function truncateDetail(detail, maxWidth) {
+function truncateDetail2(detail, maxWidth) {
   if (getDisplayWidth(detail) <= maxWidth) return detail;
   let truncated = "";
   let currentWidth = 0;
@@ -787,16 +1088,18 @@ function ActivityViewerPanel({
   width,
   cursorLine,
   hasFocus,
-  spinner = ""
+  spinner = "",
+  filterLabel
 }) {
   const innerWidth = getInnerWidth(width);
   const contentWidth = innerWidth - 1;
+  const filterSuffix = filterLabel && filterLabel !== "all" ? ` \xB7 ${filterLabel}` : "";
   let titleSuffix;
   if (isLive) {
-    titleSuffix = `[LIVE ${spinner || "\u25BC"}]`;
+    titleSuffix = `[LIVE ${spinner || "\u25BC"}${filterSuffix}]`;
   } else {
     const badge = newCount > 0 ? ` +${newCount}\u2191` : "";
-    titleSuffix = `[PAUSED \u2193${scrollOffset}${badge}]`;
+    titleSuffix = `[PAUSED \u2193${scrollOffset}${badge}${filterSuffix}]`;
   }
   let visibleActivities;
   if (activities.length === 0) {
@@ -846,7 +1149,7 @@ function ActivityViewerPanel({
       let labelContent;
       let _displayWidth;
       if (detail) {
-        const truncated = truncateDetail(detail, Math.max(0, detailMaxWidth));
+        const truncated = truncateDetail2(detail, Math.max(0, detailMaxWidth));
         labelContent = `${labelPart}${truncated}${countSuffix}`;
         _displayWidth = prefixWidth - 1 + labelWidth + getDisplayWidth(truncated) + countSuffixWidth;
       } else {
@@ -894,21 +1197,27 @@ import { Box as Box2, Text as Text2 } from "ink";
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 function wrapText(text, maxWidth) {
   if (!text) return ["(empty)"];
-  const words = text.split(" ");
-  const lines = [];
-  let current = "";
-  for (const word of words) {
-    if (!current) {
-      current = word;
-    } else if (getDisplayWidth(`${current} ${word}`) <= maxWidth) {
-      current += ` ${word}`;
-    } else {
-      lines.push(current);
-      current = word;
+  const result = [];
+  for (const rawLine of text.split("\n")) {
+    if (!rawLine) {
+      result.push("");
+      continue;
     }
+    const words = rawLine.split(" ");
+    let current = "";
+    for (const word of words) {
+      if (!current) {
+        current = word;
+      } else if (getDisplayWidth(`${current} ${word}`) <= maxWidth) {
+        current += ` ${word}`;
+      } else {
+        result.push(current);
+        current = word;
+      }
+    }
+    if (current) result.push(current);
   }
-  if (current) lines.push(current);
-  return lines.length > 0 ? lines : ["(empty)"];
+  return result.length > 0 ? result : ["(empty)"];
 }
 function DetailViewPanel({
   activity,
@@ -990,7 +1299,9 @@ function useHotkeys({
   onHide,
   onDetailClose,
   onDetailScrollUp,
-  onDetailScrollDown
+  onDetailScrollDown,
+  onFilter,
+  filterLabel
 }) {
   const handleInput = (input, key) => {
     if (detailMode) {
@@ -1024,6 +1335,10 @@ function useHotkeys({
       onRefresh();
       return;
     }
+    if (input === "f" && !key.ctrl && focus === "viewer") {
+      onFilter();
+      return;
+    }
     if (key.pageUp) {
       onScrollPageUp();
       return;
@@ -1099,9 +1414,10 @@ function useHotkeys({
     "Tab: sessions",
     "\u2191\u2193/jk: scroll",
     "PgUp/Dn: page",
-    "g: top",
-    "G: live",
+    "g: live",
+    "G: oldest",
     "\u21B5: detail",
+    `f: ${filterLabel}`,
     "q: quit"
   ];
   return { handleInput, statusBarItems };
@@ -1123,7 +1439,7 @@ function useSpinner(active, intervalMs = 100) {
 }
 
 // src/ui/SessionTreePanel.tsx
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import { Box as Box3, Text as Text3 } from "ink";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 function formatElapsed(lastModifiedMs) {
@@ -1149,7 +1465,7 @@ function getStatusColor(status) {
   }
 }
 function formatProjectPath(projectPath) {
-  const home = homedir3();
+  const home = homedir4();
   const raw = projectPath.startsWith(home) ? `~${projectPath.slice(home.length)}` : projectPath;
   return raw;
 }
@@ -1504,6 +1820,7 @@ function App({ mode }) {
   const [scrollOffset, setScrollOffset] = useState2(0);
   const [isLive, setIsLive] = useState2(true);
   const [activities, setActivities] = useState2([]);
+  const [gitActivities, setGitActivities] = useState2([]);
   const [newCount, setNewCount] = useState2(0);
   const [expandedIds, setExpandedIds] = useState2(/* @__PURE__ */ new Set());
   const [viewerCursorLine, setViewerCursorLine] = useState2(0);
@@ -1512,6 +1829,7 @@ function App({ mode }) {
     null
   );
   const [detailScrollOffset, setDetailScrollOffset] = useState2(0);
+  const [filterIndex, setFilterIndex] = useState2(0);
   const allFlat = useMemo(
     () => flattenSessions2(sessionTree, expandedIds),
     [sessionTree, expandedIds]
@@ -1521,9 +1839,11 @@ function App({ mode }) {
     allFlatRef.current = allFlat;
   }, [allFlat]);
   const activitiesLengthRef = useRef(0);
+  const activitiesRef = useRef(activities);
   useEffect2(() => {
     activitiesLengthRef.current = activities.length;
-  }, [activities.length]);
+    activitiesRef.current = activities;
+  }, [activities]);
   useEffect2(() => {
     const node = allFlatRef.current.find((s) => s.id === selectedId);
     if (node?.filePath) {
@@ -1535,13 +1855,57 @@ function App({ mode }) {
     } else {
       setActivities([]);
     }
+    setGitActivities([]);
   }, [selectedId]);
+  useEffect2(() => {
+    setScrollOffset(0);
+    setIsLive(true);
+    setViewerCursorLine(0);
+  }, [filterIndex]);
+  useEffect2(() => {
+    if (!isWatchMode) return;
+    const node = allFlatRef.current.find((s) => s.id === selectedId);
+    if (!node?.projectPath) return;
+    const load = () => {
+      const acts = activitiesRef.current;
+      const today = /* @__PURE__ */ new Date();
+      const todayMidnight = new Date(
+        today.getFullYear(),
+        today.getMonth(),
+        today.getDate()
+      );
+      const startDate = acts.length > 0 ? new Date(
+        acts[0].timestamp.getFullYear(),
+        acts[0].timestamp.getMonth(),
+        acts[0].timestamp.getDate()
+      ) : todayMidnight;
+      const endDate = acts.length > 0 ? new Date(
+        acts[acts.length - 1].timestamp.getFullYear(),
+        acts[acts.length - 1].timestamp.getMonth(),
+        acts[acts.length - 1].timestamp.getDate()
+      ) : todayMidnight;
+      const commits = parseGitCommits(node.projectPath, startDate, endDate);
+      setGitActivities(commits);
+    };
+    const initial = setTimeout(load, 100);
+    const timer = setInterval(load, 3e4);
+    return () => {
+      clearTimeout(initial);
+      clearInterval(timer);
+    };
+  }, [selectedId, isWatchMode]);
   const refresh = useCallback(() => {
     const freshConfig = loadGlobalConfig();
     const tree = discoverSessions(freshConfig);
-    setSessionTree(tree);
     const updatedFlat = flattenSessions2(tree, expandedIds);
     const node = updatedFlat.find((s) => s.id === selectedId);
+    if (!node) {
+      const parentSession = tree.sessions.find(
+        (s) => s.subAgents.some((sa) => sa.id === selectedId)
+      );
+      if (parentSession) setSelectedId(parentSession.id);
+    }
+    setSessionTree(tree);
     if (!node || !node.filePath) return;
     const newActivities = parseSessionHistory(node.filePath);
     const delta = newActivities.length - activitiesLengthRef.current;
@@ -1558,7 +1922,7 @@ function App({ mode }) {
   useEffect2(() => {
     if (!isWatchMode) return;
     const projectsDir = getProjectsDir();
-    const usePolling = process.platform === "linux" || !existsSync4(projectsDir);
+    const usePolling = process.platform === "linux" || !existsSync5(projectsDir);
     if (usePolling) {
       const timer = setInterval(
         () => refreshRef.current(),
@@ -1585,6 +1949,24 @@ function App({ mode }) {
       if (debounce) clearTimeout(debounce);
     };
   }, [isWatchMode, config.refreshIntervalMs]);
+  const filterPresets = config.filterPresets;
+  const activePreset = useMemo(
+    () => filterPresets[filterIndex % filterPresets.length] ?? [],
+    [filterPresets, filterIndex]
+  );
+  const filterLabel = useMemo(
+    () => activePreset.length === 0 ? "all" : activePreset.join("+"),
+    [activePreset]
+  );
+  const mergedActivities = useMemo(() => {
+    const merged = [...activities, ...gitActivities].sort(
+      (a, b) => a.timestamp.getTime() - b.timestamp.getTime()
+    );
+    if (activePreset.length === 0) return merged;
+    return merged.filter(
+      (a) => activePreset.includes(a.type) || a.type === "tool" && activePreset.some((p) => a.label.toLowerCase() === p)
+    );
+  }, [activities, gitActivities, activePreset]);
   const selectedIndex = allFlat.findIndex((s) => s.id === selectedId);
   const height = (stdout?.rows ?? 41) - 1;
   const width = stdout?.columns ?? 80;
@@ -1596,7 +1978,7 @@ function App({ mode }) {
     if (!activities.length || !selectedId) return;
     ensureLogDir(config.logDir);
     const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const filePath = join4(
+    const filePath = join5(
       config.logDir,
       `${date}-${selectedId.slice(0, 8)}.txt`
     );
@@ -1616,6 +1998,7 @@ function App({ mode }) {
     onSwitchFocus: () => setFocus((f) => f === "tree" ? "viewer" : "tree"),
     onScrollUp: () => {
       if (focus === "tree") {
+        if (selectedIndex === -1) return;
         const prev = Math.max(0, selectedIndex - 1);
         setSelectedId(allFlat[prev]?.id ?? selectedId);
       } else {
@@ -1635,6 +2018,7 @@ function App({ mode }) {
     },
     onScrollDown: () => {
       if (focus === "tree") {
+        if (selectedIndex === -1) return;
         const next = Math.min(allFlat.length - 1, selectedIndex + 1);
         setSelectedId(allFlat[next]?.id ?? selectedId);
       } else {
@@ -1711,16 +2095,16 @@ function App({ mode }) {
       }
     },
     onScrollTop: () => {
-      setViewerCursorLine(0);
-      setIsLive(false);
-      setScrollOffset(Math.max(0, activities.length - viewerRows));
-    },
-    onScrollBottom: () => {
       setViewerCursorLine(0);
       setIsLive(true);
       setScrollOffset(0);
       setNewCount(0);
     },
+    onScrollBottom: () => {
+      setViewerCursorLine(0);
+      setIsLive(false);
+      setScrollOffset(Math.max(0, mergedActivities.length - viewerRows));
+    },
     onDetailClose: () => {
       setDetailMode(false);
     },
@@ -1733,14 +2117,20 @@ function App({ mode }) {
     onEnter: () => {
       if (focus === "viewer") {
         const act = getSelectedActivity(
-          activities,
+          mergedActivities,
           isLive,
           scrollOffset,
           viewerRows,
           viewerCursorLine
         );
         if (act) {
-          setDetailActivity(act);
+          if (act.type === "commit") {
+            const node = allFlatRef.current.find((s) => s.id === selectedId);
+            const detail = node?.projectPath ? getCommitDetail(node.projectPath, act.label) ?? act.detail : act.detail;
+            setDetailActivity({ ...act, detail });
+          } else {
+            setDetailActivity(act);
+          }
           setDetailMode(true);
           setDetailScrollOffset(0);
         }
@@ -1765,8 +2155,14 @@ function App({ mode }) {
           const next = new Set(prev);
           if (next.has(parentId)) {
             next.delete(parentId);
+            setSelectedId(parentId);
           } else {
             next.add(parentId);
+            const parent = sessionTree.sessions.find((s) => s.id === parentId);
+            const firstNew = parent?.subAgents.find(
+              (sa) => sa.status === "cool" || sa.status === "cold"
+            );
+            if (firstNew) setSelectedId(firstNew.id);
           }
           return next;
         });
@@ -1824,7 +2220,9 @@ function App({ mode }) {
     },
     onSaveLog: saveLog,
     onRefresh: refresh,
-    onQuit: exit
+    onQuit: exit,
+    onFilter: () => setFilterIndex((i) => (i + 1) % filterPresets.length),
+    filterLabel
   });
   useInput((input, key) => handleInput(input, key), { isActive: isWatchMode });
   const selectedSession = allFlat.find((s) => s.id === selectedId);
@@ -1863,7 +2261,7 @@ function App({ mode }) {
     ) : /* @__PURE__ */ jsx4(
       ActivityViewerPanel,
       {
-        activities,
+        activities: mergedActivities,
         sessionName: sessionDisplayName,
         scrollOffset,
         isLive,
@@ -1872,7 +2270,8 @@ function App({ mode }) {
         width,
         cursorLine: viewerCursorLine,
         hasFocus: focus === "viewer",
-        spinner
+        spinner,
+        filterLabel
       }
     ) })
   ] });
@@ -1893,8 +2292,8 @@ if (options.command === "version") {
   console.log(getVersion());
   process.exit(0);
 }
-var legacyConfig = join5(process.cwd(), ".agenthud", "config.yaml");
-if (existsSync5(legacyConfig)) {
+var legacyConfig = join6(process.cwd(), ".agenthud", "config.yaml");
+if (existsSync6(legacyConfig)) {
   console.log(
     "The project-level config file (.agenthud/config.yaml) is no longer supported."
   );
@@ -1925,12 +2324,28 @@ if (options.mode === "report") {
   const markdown = generateReport(tree.sessions, {
     date: options.reportDate,
     include: options.reportInclude,
-    format: options.reportFormat
+    format: options.reportFormat,
+    detailLimit: options.reportDetailLimit,
+    withGit: options.reportWithGit
   });
   process.stdout.write(`${markdown}
 `);
   process.exit(0);
 }
+if (options.mode === "summary") {
+  if (options.summaryError) {
+    process.stderr.write(`agenthud: ${options.summaryError}
+`);
+    process.exit(1);
+  }
+  const exitCode = await runSummary({
+    date: options.summaryDate,
+    prompt: options.summaryPrompt,
+    force: options.summaryForce ?? false,
+    today: /* @__PURE__ */ new Date()
+  });
+  process.exit(exitCode);
+}
 if (options.mode === "watch") {
   clearScreen();
 }

package/dist/templates/summary-prompt.md

@@ -0,0 +1,12 @@
+The following is an activity log of work done with Claude Code. Summarize it concisely in English using the format below.
+
+## Completed Work
+- (What was accomplished — focus on Response entries)
+
+## Notable Changes
+- (Which files were modified and how — from Edit/Write entries)
+
+## Commits
+- (Summary of the ◆ commit lines)
+
+Activity log:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenthud",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "CLI tool to monitor agent status in real-time. Works with Claude Code, multi-agent workflows, and any AI agent system.",
   "type": "module",
   "main": "dist/index.js",

package/scripts/daily-summary.sh

@@ -0,0 +1,10 @@
+#!/bin/zsh
+# Daily summary: pipe today's agenthud report to claude for summarization
+# Usage: daily-summary.sh [--date YYYY-MM-DD]
+
+DATE_ARG=""
+if [[ "$1" == "--date" && -n "$2" ]]; then
+  DATE_ARG="--date $2"
+fi
+
+agenthud report ${DATE_ARG} --detail-limit 0 --with-git | claude -p "다음은 오늘 Claude Code로 작업한 활동 로그입니다. 이를 바탕으로 오늘 작업 내용을 한국어로 간결하게 정리해주세요. 완료한 작업, 주요 변경사항, 커밋 내역 순으로 bullet point로 작성해주세요."

package/scripts/diff-heap.ts

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+// Compare two heap snapshots and show which object types grew the most.
+
+import { readFileSync } from "node:fs";
+
+const earlyPath = process.argv[2] ?? "/tmp/agenthud-early.heapsnapshot";
+const latePath = process.argv[3] ?? "/tmp/agenthud-late.heapsnapshot";
+
+interface Snapshot {
+  snapshot: {
+    node_count: number;
+    meta: {
+      node_fields: string[];
+      node_types: (string | string[])[];
+    };
+  };
+  nodes: number[];
+  strings: string[];
+}
+
+function countByType(path: string): Map<string, { count: number; size: number }> {
+  const raw = JSON.parse(readFileSync(path, "utf-8")) as Snapshot;
+  const fields = raw.snapshot.meta.node_fields;
+  const typeEnum = raw.snapshot.meta.node_types[fields.indexOf("type")] as string[];
+  const fieldCount = fields.length;
+  const nameIdx = fields.indexOf("name");
+  const typeIdx = fields.indexOf("type");
+  const sizeIdx = fields.indexOf("self_size");
+
+  const counts = new Map<string, { count: number; size: number }>();
+  for (let i = 0; i < raw.nodes.length; i += fieldCount) {
+    const type = typeEnum[raw.nodes[i + typeIdx]];
+    const name = raw.strings[raw.nodes[i + nameIdx]];
+    const size = raw.nodes[i + sizeIdx];
+    const key = `${type}|${name}`;
+    const entry = counts.get(key) ?? { count: 0, size: 0 };
+    entry.count++;
+    entry.size += size;
+    counts.set(key, entry);
+  }
+  return counts;
+}
+
+const early = countByType(earlyPath);
+const late = countByType(latePath);
+
+interface Diff {
+  key: string;
+  earlyCount: number;
+  lateCount: number;
+  countDelta: number;
+  sizeDelta: number;
+}
+const diffs: Diff[] = [];
+
+for (const [key, lateVal] of late) {
+  const earlyVal = early.get(key) ?? { count: 0, size: 0 };
+  diffs.push({
+    key,
+    earlyCount: earlyVal.count,
+    lateCount: lateVal.count,
+    countDelta: lateVal.count - earlyVal.count,
+    sizeDelta: lateVal.size - earlyVal.size,
+  });
+}
+
+diffs.sort((a, b) => b.sizeDelta - a.sizeDelta);
+console.log("Top growers by total size delta:");
+console.log("size_delta_kb\tcount_delta\tearly\tlate\ttype|name");
+for (const d of diffs.slice(0, 40)) {
+  console.log(
+    `${(d.sizeDelta / 1024).toFixed(0).padStart(8)}\t${d.countDelta.toString().padStart(8)}\t${d.earlyCount.toString().padStart(5)}\t${d.lateCount.toString().padStart(5)}\t${d.key}`,
+  );
+}

package/scripts/memcheck-minimal.tsx

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+// Minimal Ink test: only spinner-style re-renders, no other state.
+
+import { Text } from "ink";
+import { render } from "ink-testing-library";
+import React, { useEffect, useState } from "react";
+
+const seconds = Number(process.argv[2] ?? 60);
+const mb = (b: number) => (b / 1024 / 1024).toFixed(1);
+const printMem = (label: string) => {
+  const m = process.memoryUsage();
+  console.log(
+    `${label.padEnd(20)} rss=${mb(m.rss)}MB heap=${mb(m.heapUsed)}/${mb(m.heapTotal)}MB ext=${mb(m.external)}MB`,
+  );
+};
+
+function App() {
+  const [i, setI] = useState(0);
+  useEffect(() => {
+    const t = setInterval(() => setI((v) => v + 1), 100);
+    return () => clearInterval(t);
+  }, []);
+  return React.createElement(Text, null, `tick ${i}`);
+}
+
+printMem("start");
+const instance = render(React.createElement(App));
+printMem("after render");
+
+const iv = setInterval(() => {
+  if (global.gc) global.gc();
+  printMem(`t=${process.uptime().toFixed(0)}s`);
+}, 5_000);
+
+setTimeout(() => {
+  clearInterval(iv);
+  instance.unmount();
+  if (global.gc) global.gc();
+  printMem("end");
+  process.exit(0);
+}, seconds * 1000);

package/scripts/memcheck-ui.tsx

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// Render App with ink-testing-library and watch memory while time passes.
+// Spinner re-renders every 100ms, so this simulates the watch loop.
+
+import { writeHeapSnapshot } from "node:v8";
+import { render } from "ink-testing-library";
+import React from "react";
+import { App } from "../src/ui/App.js";
+
+const seconds = Number(process.argv[2] ?? 60);
+const mb = (b: number) => (b / 1024 / 1024).toFixed(1);
+
+const printMem = (label: string) => {
+  const m = process.memoryUsage();
+  console.log(
+    `${label.padEnd(20)} rss=${mb(m.rss)}MB heap=${mb(m.heapUsed)}/${mb(m.heapTotal)}MB ext=${mb(m.external)}MB`,
+  );
+};
+
+printMem("start");
+
+const instance = render(React.createElement(App, { mode: "watch" }));
+
+printMem("after render");
+
+const interval = setInterval(() => {
+  if (global.gc) global.gc();
+  printMem(`t=${process.uptime().toFixed(0)}s`);
+}, 5_000);
+
+// Snapshot at start (after warm-up) and end so we can diff
+setTimeout(() => {
+  if (global.gc) global.gc();
+  const p = writeHeapSnapshot("/tmp/agenthud-early.heapsnapshot");
+  console.log(`early snapshot: ${p}`);
+}, 5_000);
+
+setTimeout(() => {
+  clearInterval(interval);
+  if (global.gc) global.gc();
+  const p = writeHeapSnapshot("/tmp/agenthud-late.heapsnapshot");
+  console.log(`late snapshot: ${p}`);
+  instance.unmount();
+  if (global.gc) global.gc();
+  printMem("end");
+  process.exit(0);
+}, seconds * 1000);

package/scripts/memcheck.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+// Run data-layer loop and watch memory growth.
+// Usage: tsx scripts/memcheck.ts [iterations]
+
+import { loadGlobalConfig } from "../src/config/globalConfig.js";
+import { parseGitCommits } from "../src/data/gitCommits.js";
+import { parseSessionHistory } from "../src/data/sessionHistory.js";
+import { discoverSessions } from "../src/data/sessions.js";
+
+const iterations = Number(process.argv[2] ?? 1000);
+
+const mb = (b: number) => (b / 1024 / 1024).toFixed(1);
+const printMem = (label: string) => {
+  const m = process.memoryUsage();
+  console.log(
+    `${label.padEnd(20)} rss=${mb(m.rss)}MB heap=${mb(m.heapUsed)}/${mb(m.heapTotal)}MB ext=${mb(m.external)}MB`,
+  );
+};
+
+const config = loadGlobalConfig();
+printMem("start");
+
+const tree = discoverSessions(config);
+const session = tree.sessions[0];
+if (!session) {
+  console.error("No sessions found");
+  process.exit(1);
+}
+console.log(`Using session: ${session.projectName}/${session.id}`);
+console.log(`File: ${session.filePath}`);
+
+printMem("after discover");
+
+for (let i = 1; i <= iterations; i++) {
+  // Simulate what refresh() + git effect do every cycle
+  discoverSessions(config);
+  parseSessionHistory(session.filePath);
+  if (session.projectPath) {
+    const today = new Date();
+    const day = new Date(today.getFullYear(), today.getMonth(), today.getDate());
+    parseGitCommits(session.projectPath, day);
+  }
+
+  if (i % 100 === 0) {
+    if (global.gc) global.gc();
+    printMem(`iter ${i}`);
+  }
+}
+
+if (global.gc) global.gc();
+printMem("end");