agenthud 0.9.1 → 0.9.3

package/dist/{main-NHQJ23YJ.js → main-S27FZ2BJ.js}

@@ -1,13 +1,24 @@
 // src/main.ts
 import { existsSync as existsSync6, rmSync } from "fs";
+import { homedir as homedir5 } from "os";
 import { join as join6 } from "path";
-import { createInterface } from "readline";
+import { createInterface as createInterface2 } from "readline";
+
+// src/utils/legacyConfig.ts
+import { join, resolve } from "path";
+function isLegacyProjectConfig(cwd, home) {
+  const legacy = resolve(join(cwd, ".agenthud", "config.yaml"));
+  const global = resolve(join(home, ".agenthud", "config.yaml"));
+  return legacy !== global;
+}
+
+// src/main.ts
 import { render } from "ink";
 import React from "react";
 
 // src/cli.ts
 import { readFileSync } from "fs";
-import { dirname, join } from "path";
+import { dirname, join as join2 } from "path";
 import { fileURLToPath } from "url";
 var ALL_TYPES = [
   "response",
@@ -35,7 +46,16 @@ var KNOWN_REPORT_FLAGS = /* @__PURE__ */ new Set([
   "--detail-limit",
   "--with-git"
 ]);
-var KNOWN_SUMMARY_FLAGS = /* @__PURE__ */ new Set(["--date", "--prompt", "--force"]);
+var KNOWN_SUMMARY_FLAGS = /* @__PURE__ */ new Set([
+  "--date",
+  "--last",
+  "--from",
+  "--to",
+  "--prompt",
+  "--force",
+  "-y",
+  "--yes"
+]);
 var KNOWN_SUBCOMMANDS = /* @__PURE__ */ new Set(["report", "summary"]);
 function getHelp() {
   return `Usage: agenthud [options]
@@ -51,32 +71,37 @@ Options:
 Commands:
   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
+    --date YYYY-MM-DD|today|yesterday|-Nd     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
+    --with-git                  Merge git commits from each session's project into the timeline
 
-  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)
+  summary [--date DATE | --last Nd | --from DATE --to DATE] [--prompt TEXT] [--force] [-y]
+                                Generate LLM summary via claude CLI.
+                                Single day produces a daily summary;
+                                a date range produces a meta-summary built from daily summaries.
+    --date YYYY-MM-DD|today|yesterday|-Nd     Date to summarize (default: today)
+    --last Nd                   Date range: last N days, ending today (e.g. --last 7d)
+    --from YYYY-MM-DD           Date range: start date (use with --to)
+    --to YYYY-MM-DD             Date range: end date (use with --from)
+    --prompt TEXT               Override prompt for this run (daily only)
+    --force                     Regenerate even if cached
+    -y, --yes                   Skip confirmation prompts for new daily summaries
 
 Environment:
   CLAUDE_PROJECTS_DIR           Path to Claude projects directory
                                 (default: ~/.claude/projects)
 
 Config: ~/.agenthud/config.yaml
-Logs:   ~/.agenthud/logs/
 `;
 }
 function getVersion() {
   const __dirname2 = dirname(fileURLToPath(import.meta.url));
   const packageJson = JSON.parse(
-    readFileSync(join(__dirname2, "..", "package.json"), "utf-8")
+    readFileSync(join2(__dirname2, "..", "package.json"), "utf-8")
   );
   return packageJson.version;
 }
@@ -88,6 +113,16 @@ function parseLocalMidnight(dateStr) {
     const now = /* @__PURE__ */ new Date();
     return new Date(now.getFullYear(), now.getMonth(), now.getDate());
   }
+  if (dateStr === "yesterday") {
+    const now = /* @__PURE__ */ new Date();
+    return new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1);
+  }
+  const relMatch = dateStr.match(/^-(\d+)d$/);
+  if (relMatch) {
+    const days = Number(relMatch[1]);
+    const now = /* @__PURE__ */ new Date();
+    return new Date(now.getFullYear(), now.getMonth(), now.getDate() - days);
+  }
   const match = dateStr.match(/^(\d{4})-(\d{2})-(\d{2})$/);
   if (!match) return null;
   const [, y, m, d] = match.map(Number);
@@ -128,7 +163,7 @@ function parseArgs(args) {
       } else {
         const parsed = parseLocalMidnight(dateStr);
         if (!parsed) {
-          reportError = `Invalid date: "${dateStr}". Use YYYY-MM-DD or "today".`;
+          reportError = `Invalid date: "${dateStr}". Use YYYY-MM-DD, "today", "yesterday", or "-Nd" (N days ago).`;
         } else {
           reportDate = parsed;
         }
@@ -179,10 +214,20 @@ function parseArgs(args) {
   }
   if (args[0] === "summary") {
     const rest = args.slice(1);
-    let summaryDate = todayLocalMidnight();
+    let summaryDate;
+    let summaryFrom;
+    let summaryTo;
     let summaryPrompt;
     let summaryForce = false;
+    let summaryAssumeYes = false;
     let summaryError;
+    const FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
+      "--date",
+      "--last",
+      "--from",
+      "--to",
+      "--prompt"
+    ]);
     for (let i = 0; i < rest.length; i++) {
       const arg = rest[i];
       if (!arg.startsWith("-")) continue;
@@ -190,7 +235,7 @@ function parseArgs(args) {
         summaryError = `Unknown option: "${arg}". Run agenthud --help for usage.`;
         break;
       }
-      if (arg === "--date" || arg === "--prompt") i++;
+      if (FLAGS_WITH_VALUE.has(arg)) i++;
     }
     const dateIdx = rest.indexOf("--date");
     if (dateIdx !== -1) {
@@ -200,12 +245,70 @@ function parseArgs(args) {
       } else {
         const parsed = parseLocalMidnight(dateStr);
         if (!parsed) {
-          summaryError = `Invalid date: "${dateStr}". Use YYYY-MM-DD or "today".`;
+          summaryError = `Invalid date: "${dateStr}". Use YYYY-MM-DD, "today", "yesterday", or "-Nd" (N days ago).`;
         } else {
           summaryDate = parsed;
         }
       }
     }
+    const lastIdx = rest.indexOf("--last");
+    if (lastIdx !== -1 && !summaryError) {
+      const val = rest[lastIdx + 1];
+      if (!val) {
+        summaryError = "Invalid --last: missing value (e.g. --last 7d).";
+      } else {
+        const m = val.match(/^(\d+)d$/);
+        if (!m) {
+          summaryError = `Invalid --last: "${val}". Use form like "7d".`;
+        } else {
+          const days = Number(m[1]);
+          if (days < 1) {
+            summaryError = `Invalid --last: "${val}". Must be at least 1 day.`;
+          } else {
+            const today = todayLocalMidnight();
+            const from = new Date(today);
+            from.setDate(today.getDate() - (days - 1));
+            summaryFrom = from;
+            summaryTo = today;
+          }
+        }
+      }
+    }
+    const fromIdx = rest.indexOf("--from");
+    const toIdx = rest.indexOf("--to");
+    if ((fromIdx !== -1 || toIdx !== -1) && !summaryError) {
+      if (fromIdx === -1 || toIdx === -1) {
+        summaryError = "--from and --to must be used together.";
+      } else {
+        const fromStr = rest[fromIdx + 1];
+        const toStr = rest[toIdx + 1];
+        const from = fromStr ? parseLocalMidnight(fromStr) : null;
+        const to = toStr ? parseLocalMidnight(toStr) : null;
+        if (!from) {
+          summaryError = `Invalid --from: "${fromStr}".`;
+        } else if (!to) {
+          summaryError = `Invalid --to: "${toStr}".`;
+        } else if (from.getTime() > to.getTime()) {
+          summaryError = `--from (${fromStr}) must be on or before --to (${toStr}).`;
+        } else {
+          summaryFrom = from;
+          summaryTo = to;
+        }
+      }
+    }
+    if (!summaryError) {
+      const modesUsed = [
+        summaryDate !== void 0,
+        lastIdx !== -1,
+        fromIdx !== -1 || toIdx !== -1
+      ].filter(Boolean).length;
+      if (modesUsed > 1) {
+        summaryError = "--date, --last, and --from/--to are mutually exclusive.";
+      }
+    }
+    if (!summaryError && summaryDate === void 0 && summaryFrom === void 0) {
+      summaryDate = todayLocalMidnight();
+    }
     const promptIdx = rest.indexOf("--prompt");
     if (promptIdx !== -1) {
       const val = rest[promptIdx + 1];
@@ -216,11 +319,15 @@ function parseArgs(args) {
       }
     }
     if (rest.includes("--force")) summaryForce = true;
+    if (rest.includes("-y") || rest.includes("--yes")) summaryAssumeYes = true;
     return {
       mode: "summary",
       summaryDate,
+      summaryFrom,
+      summaryTo,
       summaryPrompt,
       summaryForce,
+      summaryAssumeYes,
       summaryError
     };
   }
@@ -241,21 +348,65 @@ function parseArgs(args) {
   return { mode: "watch" };
 }
 
+// src/utils/altScreen.ts
+var ENTER = "\x1B[?1049h";
+var LEAVE = "\x1B[?1049l";
+var entered = false;
+var left = false;
+function enterAltScreen() {
+  if (entered) return;
+  entered = true;
+  process.stdout.write(ENTER);
+}
+function leaveAltScreen() {
+  if (left || !entered) return;
+  left = true;
+  process.stdout.write(LEAVE);
+}
+var hooksInstalled = false;
+function installAltScreenCleanup() {
+  if (hooksInstalled) return;
+  hooksInstalled = true;
+  process.on("exit", () => {
+    leaveAltScreen();
+  });
+  process.on("SIGINT", () => {
+    leaveAltScreen();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    leaveAltScreen();
+    process.exit(143);
+  });
+  process.on("uncaughtException", (err) => {
+    leaveAltScreen();
+    setImmediate(() => {
+      throw err;
+    });
+  });
+}
+
 // src/config/globalConfig.ts
 import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { homedir } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-var CONFIG_PATH = join2(homedir(), ".agenthud", "config.yaml");
-var STATE_PATH = join2(homedir(), ".agenthud", "state.yaml");
+var CONFIG_PATH = join3(homedir(), ".agenthud", "config.yaml");
+var STATE_PATH = join3(homedir(), ".agenthud", "state.yaml");
 var DEFAULT_GLOBAL_CONFIG = {
   refreshIntervalMs: 2e3,
-  logDir: join2(homedir(), ".agenthud", "logs"),
   hiddenSessions: [],
   hiddenSubAgents: [],
-  filterPresets: [[], ["response"], ["commit"]],
+  // [] means "show all"; conversation preset bundles assistant + user;
+  // commits-only preset filters down to git activity.
+  filterPresets: [[], ["response", "user"], ["commit"]],
   hiddenProjects: []
 };
+var ALL_PRESET_KEYWORDS = /* @__PURE__ */ new Set(["all", "*", "any"]);
+function normalizePreset(tokens) {
+  if (tokens.some((t) => ALL_PRESET_KEYWORDS.has(t.toLowerCase()))) return [];
+  return tokens;
+}
 function parseInterval(value) {
   const match = value.match(/^(\d+)(s|m)$/);
   if (!match) return null;
@@ -263,7 +414,7 @@ function parseInterval(value) {
   return match[2] === "m" ? n * 60 * 1e3 : n * 1e3;
 }
 function ensureAgenthudDir() {
-  const dir = join2(homedir(), ".agenthud");
+  const dir = join3(homedir(), ".agenthud");
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 }
 function writeDefaultConfig() {
@@ -274,14 +425,12 @@ function writeDefaultConfig() {
 # How often to poll for activity updates
 refreshInterval: 2s
 
-# Where 's' key saves activity logs
-logDir: ~/.agenthud/logs
-
 # Activity filter presets (cycle with 'f' key in viewer)
-# Each list is one preset; [] means "all". First preset is the default.
+# Each list is one preset. Use "all" (or "*") to show everything.
+# Types: response, user, bash, edit, thinking, read, glob, commit
 filterPresets:
-  - []
-  - ["response"]
+  - ["all"]
+  - ["response", "user"]
   - ["commit"]
 `;
   try {
@@ -326,13 +475,13 @@ function loadGlobalConfig() {
     const ms = parseInterval(configRaw.refreshInterval);
     if (ms !== null) config.refreshIntervalMs = ms;
   }
-  if (typeof configRaw.logDir === "string") {
-    config.logDir = configRaw.logDir.replace(/^~/, homedir());
-  }
   if (Array.isArray(configRaw.filterPresets)) {
-    const presets = configRaw.filterPresets.filter(Array.isArray).map(
-      (p) => p.filter((t) => typeof t === "string")
-    );
+    const presets = configRaw.filterPresets.filter(Array.isArray).map((p) => {
+      const tokens = p.filter(
+        (t) => typeof t === "string"
+      );
+      return normalizePreset(tokens);
+    });
     if (presets.length > 0) config.filterPresets = presets;
   }
   const legacyHidden = {};
@@ -432,13 +581,10 @@ function hideProject(name) {
   if (config.hiddenProjects.includes(name)) return;
   updateState({ hiddenProjects: [...config.hiddenProjects, name] });
 }
-function ensureLogDir(logDir) {
-  if (!existsSync(logDir)) {
-    mkdirSync(logDir, { recursive: true });
-  }
-}
 function hasProjectLevelConfig() {
-  return existsSync(join2(process.cwd(), ".agenthud", "config.yaml"));
+  const candidate = join3(process.cwd(), ".agenthud", "config.yaml");
+  if (candidate === join3(homedir(), ".agenthud", "config.yaml")) return false;
+  return existsSync(candidate);
 }
 
 // src/data/reportGenerator.ts
@@ -475,7 +621,7 @@ function getCommitDetail(projectPath, hash) {
   if (!projectPath) return null;
   try {
     return execSync(
-      `git --git-dir="${projectPath}/.git" show --stat --no-color ${hash}`,
+      `git --git-dir="${projectPath}/.git" show --stat --patch --no-color ${hash}`,
       { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
     ).trim();
   } catch {
@@ -786,16 +932,18 @@ import {
   createWriteStream,
   existsSync as existsSync4,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync5
+  readFileSync as readFileSync5,
+  unlinkSync
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname2, join as join4 } from "path";
+import { dirname as dirname2, join as join5 } from "path";
+import { createInterface } from "readline";
 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";
-import { basename as basename2, join as join3 } from "path";
+import { basename as basename2, join as join4 } from "path";
 
 // src/ui/constants.ts
 import stringWidth from "string-width";
@@ -832,6 +980,21 @@ function createBottomLine(panelWidth = DEFAULT_PANEL_WIDTH) {
   return BOX.bl + BOX.h.repeat(getInnerWidth(panelWidth)) + BOX.br;
 }
 var SEPARATOR = "\u2500".repeat(CONTENT_WIDTH);
+function truncateByWidth(text, maxWidth) {
+  if (maxWidth <= 0) return "";
+  if (getDisplayWidth(text) <= maxWidth) return text;
+  if (maxWidth === 1) return "\u2026";
+  const ellipsisWidth = 1;
+  let acc = "";
+  let used = 0;
+  for (const ch of text) {
+    const w = getDisplayWidth(ch);
+    if (used + w + ellipsisWidth > maxWidth) break;
+    acc += ch;
+    used += w;
+  }
+  return `${acc}\u2026`;
+}
 var widthCache = /* @__PURE__ */ new Map();
 function getDisplayWidth(s) {
   const cached = widthCache.get(s);
@@ -843,7 +1006,7 @@ function getDisplayWidth(s) {
 
 // src/data/sessions.ts
 function getProjectsDir() {
-  return process.env.CLAUDE_PROJECTS_DIR ?? join3(homedir2(), ".claude", "projects");
+  return process.env.CLAUDE_PROJECTS_DIR ?? join4(homedir2(), ".claude", "projects");
 }
 function decodeProjectPath(encoded) {
   const windowsDriveMatch = encoded.match(/^([A-Za-z])--(.*)$/);
@@ -866,13 +1029,19 @@ function getSessionStatus(mtimeMs) {
   }
   return "cold";
 }
+var MAX_TITLE_LEN = 300;
+function capWithEllipsis(s, max = MAX_TITLE_LEN) {
+  const trimmed = s.trim();
+  if (trimmed.length <= max) return trimmed;
+  return `${trimmed.slice(0, max - 1)}\u2026`;
+}
 function extractTaskDescription(content) {
   const headerMatch = content.match(/##\s*(Task\s+\d+[:\s].+)/m);
-  if (headerMatch) return headerMatch[1].trim().slice(0, 60);
+  if (headerMatch) return capWithEllipsis(headerMatch[1]);
   const thisTaskMatch = content.match(/\*\*This Task[^:]+:\*\*\s*(.+)/);
-  if (thisTaskMatch) return thisTaskMatch[1].trim().slice(0, 60);
+  if (thisTaskMatch) return capWithEllipsis(thisTaskMatch[1]);
   const firstLine = content.split("\n").find((l) => l.trim());
-  return (firstLine ?? "").trim().slice(0, 60);
+  return capWithEllipsis(firstLine ?? "");
 }
 function readSubAgentInfo(filePath) {
   if (!existsSync3(filePath)) return { agentId: null, taskDescription: null };
@@ -955,8 +1124,7 @@ function readFirstUserPrompt(filePath) {
     if (!text || isSystemNoise(text)) continue;
     const firstLine = text.split("\n").find((l) => l.trim()) ?? "";
     if (!firstLine || isSystemNoise(firstLine)) continue;
-    const trimmed = firstLine.trim();
-    return trimmed.length > 80 ? trimmed.slice(0, 80) : trimmed;
+    return capWithEllipsis(firstLine);
   }
   return null;
 }
@@ -972,7 +1140,7 @@ function readEntrypoint(filePath) {
   }
 }
 function buildSubAgents(parentId, projectDir, config, projectName) {
-  const subagentsDir = join3(projectDir, parentId, "subagents");
+  const subagentsDir = join4(projectDir, parentId, "subagents");
   if (!existsSync3(subagentsDir)) return [];
   let files;
   try {
@@ -985,7 +1153,7 @@ function buildSubAgents(parentId, projectDir, config, projectName) {
   return files.map((file) => {
     const id = file.replace(/\.jsonl$/, "");
     const hideKey = `${projectName}/${id}`;
-    const filePath = join3(subagentsDir, file);
+    const filePath = join4(subagentsDir, file);
     try {
       const stat = statSync2(filePath);
       const { agentId, taskDescription } = readSubAgentInfo(filePath);
@@ -1025,7 +1193,7 @@ function discoverSessions(config) {
   try {
     projectDirs = readdirSync(projectsDir).filter((entry) => {
       try {
-        return statSync2(join3(projectsDir, entry)).isDirectory();
+        return statSync2(join4(projectsDir, entry)).isDirectory();
       } catch {
         return false;
       }
@@ -1040,7 +1208,7 @@ function discoverSessions(config) {
   }
   const allSessions = [];
   for (const encodedDir of projectDirs) {
-    const projectDir = join3(projectsDir, encodedDir);
+    const projectDir = join4(projectsDir, encodedDir);
     const decodedPath = decodeProjectPath(encodedDir);
     const projectName = basename2(decodedPath);
     let files;
@@ -1054,7 +1222,7 @@ function discoverSessions(config) {
     for (const file of files) {
       const id = file.replace(/\.jsonl$/, "");
       const hideKey = `${projectName}/${id}`;
-      const filePath = join3(projectDir, file);
+      const filePath = join4(projectDir, file);
       try {
         const stat = statSync2(filePath);
         const subAgents = buildSubAgents(id, projectDir, config, projectName);
@@ -1126,44 +1294,50 @@ function discoverSessions(config) {
 
 // src/data/summaryRunner.ts
 function agenthudHomeDir() {
-  const dir = join4(homedir3(), ".agenthud");
+  const dir = join5(homedir3(), ".agenthud");
   if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
   return dir;
 }
 function summariesDir() {
-  const dir = join4(agenthudHomeDir(), "summaries");
+  const dir = join5(agenthudHomeDir(), "summaries");
   if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
   return dir;
 }
-function userPromptPath() {
-  return join4(homedir3(), ".agenthud", "summary-prompt.md");
+function promptFilename(kind) {
+  return kind === "daily" ? "summary-prompt.md" : "summary-range-prompt.md";
+}
+function userPromptPath(kind) {
+  return join5(homedir3(), ".agenthud", promptFilename(kind));
 }
-function templatePath() {
+function templatePath(kind) {
   const here = dirname2(fileURLToPath2(import.meta.url));
-  return join4(here, "templates", "summary-prompt.md");
+  return join5(here, "templates", promptFilename(kind));
 }
 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 dailyCachePath(date) {
+  return join5(summariesDir(), `${dateKey(date)}.md`);
+}
+function rangeCachePath(from, to) {
+  return join5(summariesDir(), `range-${dateKey(from)}_${dateKey(to)}.md`);
 }
 function isSameLocalDay2(a, b) {
   return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
 }
-function ensureUserPromptFile() {
-  const p = userPromptPath();
+function ensureUserPromptFile(kind) {
+  const p = userPromptPath(kind);
   if (existsSync4(p)) return;
   const dir = dirname2(p);
   if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
   try {
-    copyFileSync(templatePath(), p);
+    copyFileSync(templatePath(kind), p);
   } catch {
   }
 }
-function resolvePrompt(override) {
+function resolvePrompt(kind, override) {
   if (override) return override;
-  const p = userPromptPath();
+  const p = userPromptPath(kind);
   if (existsSync4(p)) {
     try {
       return readFileSync5(p, "utf-8");
@@ -1171,90 +1345,411 @@ function resolvePrompt(override) {
     }
   }
   try {
-    return readFileSync5(templatePath(), "utf-8");
+    return readFileSync5(templatePath(kind), "utf-8");
   } catch {
-    return "Summarize the activity log below.";
+    return "Summarize the input 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 {
-    }
+function shouldUseRangeCache(force, dates, today, cacheExists) {
+  if (force) return false;
+  if (!cacheExists) return false;
+  if (dates.some((d) => isSameLocalDay2(d, today))) return false;
+  return true;
+}
+function enumerateDates(from, to) {
+  const dates = [];
+  const cursor = new Date(from);
+  while (cursor.getTime() <= to.getTime()) {
+    dates.push(new Date(cursor));
+    cursor.setDate(cursor.getDate() + 1);
   }
-  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"],
-      cwd: agenthudHomeDir()
+  return dates;
+}
+async function ask(question, defaultYes = false) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      if (trimmed.length === 0) return resolve2(defaultYes);
+      if (/^y(es)?$/i.test(trimmed)) return resolve2(true);
+      if (/^n(o)?$/i.test(trimmed)) return resolve2(false);
+      resolve2(defaultYes);
     });
+  });
+}
+function formatUsage(u) {
+  const fmt = (n) => n.toLocaleString("en-US");
+  const parts = [`${fmt(u.inputTokens)} in / ${fmt(u.outputTokens)} out`];
+  const cacheParts = [];
+  if (u.cacheReadTokens > 0) cacheParts.push(`${fmt(u.cacheReadTokens)} read`);
+  if (u.cacheCreationTokens > 0)
+    cacheParts.push(`${fmt(u.cacheCreationTokens)} written`);
+  if (cacheParts.length > 0) parts.push(`cache: ${cacheParts.join(", ")}`);
+  if (u.costUsd != null) parts.push(`$${u.costUsd.toFixed(4)}`);
+  return parts.join("  \xB7  ");
+}
+function spawnClaude(opts) {
+  return new Promise((resolve2) => {
+    const proc = spawn(
+      "claude",
+      [
+        "-p",
+        "--no-session-persistence",
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        opts.prompt
+      ],
+      {
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: agenthudHomeDir()
+      }
+    );
     let cacheStream = null;
-    cacheStream = createWriteStream(cached, { encoding: "utf-8" });
-    cacheStream.on("error", (err) => {
-      process.stderr.write(
-        `agenthud: warning: cannot write cache (${err.message})
+    if (opts.cachePath) {
+      cacheStream = createWriteStream(opts.cachePath, { encoding: "utf-8" });
+      cacheStream.on("error", (err) => {
+        process.stderr.write(
+          `agenthud: warning: cannot write cache (${err.message})
 `
-      );
-      cacheStream = null;
-    });
+        );
+        cacheStream = null;
+      });
+    }
     let stderrBuf = "";
+    let stdoutErrBuf = "";
+    let lineBuf = "";
+    let assembledText = "";
+    let usage = null;
     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);
+        resolve2({ code: 1, text: "", usage: null });
       } else {
         process.stderr.write(`Error: ${err.message}
 `);
-        resolve(1);
+        resolve2({ code: 1, text: "", usage: null });
       }
     });
+    const writeText = (text) => {
+      assembledText += text;
+      if (opts.streamToStdout) process.stdout.write(text);
+      cacheStream?.write(text);
+    };
+    const handleEvent = (event) => {
+      const type = event.type;
+      if (type === "assistant") {
+        const msg = event.message;
+        for (const block of msg?.content ?? []) {
+          if (block.type === "text" && typeof block.text === "string") {
+            writeText(block.text);
+          }
+        }
+      } else if (type === "result") {
+        const u = event.usage;
+        const cost = event.total_cost_usd;
+        if (u) {
+          usage = {
+            inputTokens: u.input_tokens ?? 0,
+            outputTokens: u.output_tokens ?? 0,
+            cacheReadTokens: u.cache_read_input_tokens ?? 0,
+            cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+            costUsd: cost ?? null
+          };
+        }
+      }
+    };
     proc.stdout.on("data", (chunk) => {
-      process.stdout.write(chunk);
-      cacheStream?.write(chunk);
+      lineBuf += chunk.toString();
+      let nl = lineBuf.indexOf("\n");
+      while (nl !== -1) {
+        const line = lineBuf.slice(0, nl).trim();
+        lineBuf = lineBuf.slice(nl + 1);
+        if (line.length > 0) {
+          try {
+            handleEvent(JSON.parse(line));
+          } catch {
+            if (stdoutErrBuf.length < 1024) stdoutErrBuf += `${line}
+`;
+          }
+        }
+        nl = lineBuf.indexOf("\n");
+      }
     });
     proc.stderr.on("data", (chunk) => {
       stderrBuf += chunk.toString();
       process.stderr.write(chunk);
     });
     proc.on("close", (code) => {
+      if (lineBuf.trim().length > 0) {
+        try {
+          handleEvent(JSON.parse(lineBuf.trim()));
+        } catch {
+          if (stdoutErrBuf.length < 1024) stdoutErrBuf += lineBuf;
+        }
+        lineBuf = "";
+      }
+      if (opts.streamToStdout) process.stdout.write("\n");
       cacheStream?.end();
       if (code !== 0) {
-        const lower = stderrBuf.toLowerCase();
-        if (lower.includes("not authenticated") || lower.includes("login") || lower.includes(" auth")) {
+        if (opts.cachePath) {
+          try {
+            unlinkSync(opts.cachePath);
+          } catch {
+          }
+        }
+        const combined = (stderrBuf + stdoutErrBuf).toLowerCase();
+        if (combined.includes("not logged in") || combined.includes("not authenticated") || combined.includes("please run /login") || combined.includes(" auth")) {
           process.stderr.write(
-            "\nHint: claude appears to be unauthenticated. Run: claude\n"
+            "\nHint: claude appears to be unauthenticated. Run: claude /login\n"
           );
         }
       }
-      resolve(code ?? 1);
+      resolve2({ code: code ?? 1, text: assembledText, usage });
+    });
+    proc.stdin.end(opts.stdin);
+  });
+}
+async function generateDailySummary(opts) {
+  ensureUserPromptFile("daily");
+  const isToday = isSameLocalDay2(opts.date, opts.today);
+  const cached = dailyCachePath(opts.date);
+  const dateLabel = dateKey(opts.date);
+  if (!isToday && !opts.force && existsSync4(cached)) {
+    try {
+      const content = readFileSync5(cached, "utf-8");
+      if (opts.announce) {
+        process.stderr.write(`agenthud: cached summary from ${cached}
+`);
+      }
+      if (opts.streamToStdout) {
+        process.stdout.write(content);
+        if (!content.endsWith("\n")) process.stdout.write("\n");
+      }
+      return {
+        code: 0,
+        markdown: content,
+        fromCache: true,
+        skipped: false,
+        usage: null
+      };
+    } catch {
+    }
+  }
+  if (opts.announce) {
+    process.stderr.write(`agenthud: scanning sessions for ${dateLabel}...
+`);
+  }
+  const config = loadGlobalConfig();
+  const tree = discoverSessions(config);
+  const flatSessions = [
+    ...tree.projects.flatMap((p) => p.sessions),
+    ...tree.coldProjects.flatMap((p) => p.sessions)
+  ];
+  const reportMarkdown = generateReport(flatSessions, {
+    date: opts.date,
+    include: ["response", "bash", "edit", "thinking"],
+    format: "markdown",
+    detailLimit: 0,
+    withGit: true
+  });
+  if (opts.announce) {
+    const reportLines = reportMarkdown.split("\n");
+    const sessionCount = reportLines.filter((l) => l.startsWith("## ")).length;
+    const activityCount = reportLines.filter(
+      (l) => /^\[\d{2}:\d{2}\]/.test(l)
+    ).length;
+    const commitCount = reportLines.filter(
+      (l) => /^\[\d{2}:\d{2}\] ◆/.test(l)
+    ).length;
+    const sizeKb = (Buffer.byteLength(reportMarkdown, "utf-8") / 1024).toFixed(
+      1
+    );
+    process.stderr.write(
+      `agenthud: input: ${sessionCount} sessions, ${activityCount} activities, ${commitCount} commits (${reportLines.length} lines, ${sizeKb}KB)
+`
+    );
+  }
+  if (opts.confirmBeforeSpawn) {
+    const proceed = await opts.confirmBeforeSpawn();
+    if (!proceed) {
+      return {
+        code: 0,
+        markdown: "",
+        fromCache: false,
+        skipped: true,
+        usage: null
+      };
+    }
+  }
+  if (opts.announce) {
+    process.stderr.write(
+      `agenthud: sending to claude (this may take a minute)...
+
+`
+    );
+  }
+  const prompt = resolvePrompt("daily", opts.promptOverride);
+  const result = await spawnClaude({
+    prompt,
+    stdin: reportMarkdown,
+    cachePath: cached,
+    streamToStdout: opts.streamToStdout
+  });
+  if (opts.announce && result.code === 0) {
+    process.stderr.write("\n");
+    process.stderr.write(`agenthud: saved to ${cached}
+`);
+    if (result.usage) {
+      process.stderr.write(`agenthud: ${formatUsage(result.usage)}
+`);
+    }
+  }
+  return {
+    code: result.code,
+    markdown: result.text,
+    fromCache: false,
+    skipped: false,
+    usage: result.usage
+  };
+}
+async function runSummary(options2) {
+  const res = await generateDailySummary({
+    date: options2.date,
+    today: options2.today,
+    force: options2.force,
+    promptOverride: options2.prompt,
+    streamToStdout: true,
+    announce: true
+  });
+  return res.code;
+}
+async function runRangeSummary(options2) {
+  ensureUserPromptFile("daily");
+  ensureUserPromptFile("range");
+  const dates = enumerateDates(options2.from, options2.to);
+  const fromLabel = dateKey(options2.from);
+  const toLabel = dateKey(options2.to);
+  const rangeCache = rangeCachePath(options2.from, options2.to);
+  if (shouldUseRangeCache(
+    options2.force,
+    dates,
+    options2.today,
+    existsSync4(rangeCache)
+  )) {
+    try {
+      const content = readFileSync5(rangeCache, "utf-8");
+      process.stderr.write(
+        `agenthud: cached range summary from ${rangeCache}
+`
+      );
+      process.stdout.write(content);
+      if (!content.endsWith("\n")) process.stdout.write("\n");
+      return 0;
+    } catch {
+    }
+  }
+  let cachedCount = 0;
+  let missingCount = 0;
+  for (const d of dates) {
+    const isToday = isSameLocalDay2(d, options2.today);
+    if (!isToday && existsSync4(dailyCachePath(d))) cachedCount++;
+    else missingCount++;
+  }
+  process.stderr.write(
+    `agenthud: range ${fromLabel} \u2192 ${toLabel} (${dates.length} days)
+`
+  );
+  process.stderr.write(
+    `agenthud: ${cachedCount} cached, ${missingCount} to generate
+`
+  );
+  const dailyMarkdowns = [];
+  let skippedCount = 0;
+  for (const d of dates) {
+    const label = dateKey(d);
+    const isToday = isSameLocalDay2(d, options2.today);
+    process.stderr.write(`
+agenthud: --- ${label} ---
+`);
+    const willPrompt = !options2.assumeYes && (isToday || !existsSync4(dailyCachePath(d)));
+    const confirmer = willPrompt ? async () => {
+      const hint = isToday ? " (today \u2014 regenerated every time)" : "";
+      return ask(`Generate this summary${hint}? [Y/n] `, true);
+    } : void 0;
+    const res = await generateDailySummary({
+      date: d,
+      today: options2.today,
+      force: false,
+      streamToStdout: false,
+      announce: true,
+      confirmBeforeSpawn: confirmer
     });
-    proc.stdin.end(reportMarkdown);
+    if (res.skipped) {
+      process.stderr.write(`agenthud: ${label} \u2014 skipped by user.
+`);
+      skippedCount++;
+      continue;
+    }
+    if (res.code !== 0) {
+      process.stderr.write(
+        `agenthud: aborted (failed to generate daily summary for ${label}).
+`
+      );
+      return res.code;
+    }
+    const text = res.markdown.trim();
+    if (text.length === 0 || /^no activity found/i.test(text)) {
+      process.stderr.write(`agenthud: ${label} has no activity \u2014 skipping.
+`);
+      continue;
+    }
+    dailyMarkdowns.push({ date: d, markdown: text });
+  }
+  if (dailyMarkdowns.length === 0) {
+    process.stderr.write("agenthud: no daily summaries to combine.\n");
+    return 1;
+  }
+  const metaInput = dailyMarkdowns.map(({ date, markdown }) => `# ${dateKey(date)}
+
+${markdown}`).join("\n\n---\n\n");
+  process.stderr.write(
+    `
+agenthud: combining ${dailyMarkdowns.length} daily summaries into range summary...
+`
+  );
+  process.stderr.write(
+    `agenthud: sending to claude (this may take a minute)...
+
+`
+  );
+  const metaPrompt = resolvePrompt("range");
+  const metaResult = await spawnClaude({
+    prompt: metaPrompt,
+    stdin: metaInput,
+    cachePath: rangeCache,
+    streamToStdout: true
   });
+  if (metaResult.code !== 0) {
+    return metaResult.code;
+  }
+  process.stderr.write("\n");
+  process.stderr.write(`agenthud: saved to ${rangeCache}
+`);
+  if (metaResult.usage) {
+    process.stderr.write(`agenthud: ${formatUsage(metaResult.usage)}
+`);
+  }
+  return 0;
 }
 
 // src/ui/App.tsx
-import { existsSync as existsSync5, watch, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync5, watch } from "fs";
 import { Box as Box5, Text as Text5, useApp, useInput, useStdout } from "ink";
-import { useCallback, useEffect as useEffect2, useMemo, useRef, useState as useState2 } from "react";
+import { useCallback, useEffect as useEffect3, useMemo, useRef, useState as useState3 } from "react";
 
 // src/ui/ActivityViewerPanel.tsx
 import { Box, Text } from "ink";
@@ -1314,6 +1809,8 @@ function ActivityViewerPanel({
   isLive,
   newCount,
   visibleRows,
+  trailingBlankRows = 0,
+  liveIndicatorPosition = null,
   width,
   cursorLine,
   hasFocus,
@@ -1327,18 +1824,18 @@ function ActivityViewerPanel({
   if (isLive) {
     titleSuffix = `[LIVE ${spinner || "\u25BC"}${filterSuffix}]`;
   } else {
-    const badge = newCount > 0 ? ` +${newCount}\u2191` : "";
-    titleSuffix = `[PAUSED \u2193${scrollOffset}${badge}${filterSuffix}]`;
+    const badge = newCount > 0 ? ` +${newCount}\u2193` : "";
+    titleSuffix = `[PAUSED \u2191${scrollOffset}${badge}${filterSuffix}]`;
   }
   let visibleActivities;
   if (activities.length === 0) {
     visibleActivities = [];
   } else if (isLive) {
-    visibleActivities = activities.slice(-visibleRows).reverse();
+    visibleActivities = activities.slice(-visibleRows);
   } else {
     const end = Math.max(0, activities.length - scrollOffset);
     const start = Math.max(0, end - visibleRows);
-    visibleActivities = activities.slice(start, end).reverse();
+    visibleActivities = activities.slice(start, end);
   }
   const now = /* @__PURE__ */ new Date();
   const lines = [];
@@ -1356,10 +1853,11 @@ function ActivityViewerPanel({
     );
   } else {
     const effectiveCursor = Math.min(cursorLine, visibleActivities.length - 1);
+    const cursorIndexInSlice = visibleActivities.length - 1 - effectiveCursor;
     for (let i = 0; i < visibleActivities.length; i++) {
       const activity = visibleActivities[i];
       const style = getActivityStyle(activity);
-      const isCursor = hasFocus && i === effectiveCursor;
+      const isCursor = hasFocus && i === cursorIndexInSlice;
       const time = formatActivityTime(activity.timestamp, now);
       const timestamp = `[${time}] `;
       const timestampWidth = timestamp.length;
@@ -1411,28 +1909,110 @@ function ActivityViewerPanel({
     }
   }
   const emptyRow = `${BOX.v}${" ".repeat(contentWidth + 1)}${BOX.v}`;
-  while (lines.length < visibleRows) {
-    lines.push(/* @__PURE__ */ jsx(Text, { children: emptyRow }, `pad-${lines.length}`));
+  const padCount = Math.max(0, visibleRows - lines.length);
+  const padded = [];
+  for (let i = 0; i < padCount; i++) {
+    padded.push(/* @__PURE__ */ jsx(Text, { children: emptyRow }, `pad-${i}`));
+  }
+  const hasContent = visibleActivities.length > 0;
+  const trailing = [];
+  for (let i = 0; i < trailingBlankRows; i++) {
+    if (i === 0 && isLive && liveIndicatorPosition != null && hasContent) {
+      const pos = Math.max(0, liveIndicatorPosition);
+      const arrow = "\u203A";
+      const safePos = Math.min(pos, Math.max(0, contentWidth - 1));
+      const padAfter = Math.max(0, contentWidth - safePos - 1);
+      trailing.push(
+        /* @__PURE__ */ jsxs(Text, { children: [
+          BOX.v,
+          " ",
+          " ".repeat(safePos),
+          /* @__PURE__ */ jsx(Text, { color: "cyan", dimColor: true, children: arrow }),
+          " ".repeat(padAfter),
+          BOX.v
+        ] }, `trail-${i}`)
+      );
+    } else {
+      trailing.push(/* @__PURE__ */ jsx(Text, { children: emptyRow }, `trail-${i}`));
+    }
   }
+  const finalLines = [...padded, ...lines, ...trailing];
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width, children: [
     /* @__PURE__ */ jsx(Text, { color: isLive ? void 0 : "yellow", children: createTitleLine(sessionName, titleSuffix, width) }),
-    lines,
+    finalLines,
     /* @__PURE__ */ jsx(Text, { children: createBottomLine(width) })
   ] });
 }
 
 // src/ui/DetailViewPanel.tsx
 import { Box as Box2, Text as Text2 } from "ink";
+
+// src/ui/lineColoring.ts
+var DIFF_META_PREFIXES = [
+  "diff --git",
+  "index ",
+  "commit ",
+  "Author:",
+  "Date:",
+  "Merge:"
+];
+function classifyDiffLines(lines) {
+  return lines.map((line) => {
+    if (line.startsWith("+++") || line.startsWith("---")) return "diff-meta";
+    if (DIFF_META_PREFIXES.some((p) => line.startsWith(p))) return "diff-meta";
+    if (line.startsWith("@@")) return "diff-hunk";
+    if (line.startsWith("+")) return "diff-add";
+    if (line.startsWith("-")) return "diff-remove";
+    return "prose";
+  });
+}
+function classifyCodeFences(lines) {
+  const out = [];
+  let inCode = false;
+  for (const line of lines) {
+    if (/^\s*```/.test(line)) {
+      out.push("code-fence");
+      inCode = !inCode;
+    } else {
+      out.push(inCode ? "code" : "prose");
+    }
+  }
+  return out;
+}
+function getLineStyle(category) {
+  switch (category) {
+    case "diff-add":
+      return { color: "green" };
+    case "diff-remove":
+      return { color: "red" };
+    case "diff-hunk":
+      return { color: "cyan" };
+    case "diff-meta":
+      return { dimColor: true };
+    case "code-fence":
+      return { color: "cyan", dimColor: true };
+    case "code":
+      return { color: "cyan" };
+    case "prose":
+      return {};
+  }
+}
+
+// src/ui/DetailViewPanel.tsx
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-function wrapText(text, maxWidth) {
-  if (!text) return ["(empty)"];
-  const result = [];
-  for (const rawLine of text.split("\n")) {
-    if (!rawLine) {
-      result.push("");
+function wrapClassified(text, maxWidth, classifier) {
+  if (!text) return [{ text: "(empty)", category: "prose" }];
+  const sourceLines = text.split("\n");
+  const categories = classifier(sourceLines);
+  const out = [];
+  for (let i = 0; i < sourceLines.length; i++) {
+    const line = sourceLines[i];
+    const cat = categories[i] ?? "prose";
+    if (!line) {
+      out.push({ text: "", category: cat });
       continue;
     }
-    const words = rawLine.split(" ");
+    const words = line.split(" ");
     let current = "";
     for (const word of words) {
       if (!current) {
@@ -1440,13 +2020,13 @@ function wrapText(text, maxWidth) {
       } else if (getDisplayWidth(`${current} ${word}`) <= maxWidth) {
         current += ` ${word}`;
       } else {
-        result.push(current);
+        out.push({ text: current, category: cat });
         current = word;
       }
     }
-    if (current) result.push(current);
+    if (current) out.push({ text: current, category: cat });
   }
-  return result.length > 0 ? result : ["(empty)"];
+  return out.length > 0 ? out : [{ text: "(empty)", category: "prose" }];
 }
 function DetailViewPanel({
   activity,
@@ -1456,7 +2036,8 @@ function DetailViewPanel({
 }) {
   const innerWidth = getInnerWidth(width);
   const contentWidth = innerWidth - 1;
-  const allLines = wrapText(activity.detail, contentWidth);
+  const classifier = activity.type === "commit" ? classifyDiffLines : classifyCodeFences;
+  const allLines = wrapClassified(activity.detail, contentWidth, classifier);
   const totalLines = allLines.length;
   const clampedOffset = Math.min(
     scrollOffset,
@@ -1480,13 +2061,14 @@ function DetailViewPanel({
   const titleRight = `${dashes}${scrollPart}${BOX.tr}`;
   const contentRows = [];
   for (let i = 0; i < visibleRows; i++) {
-    const line = visibleSlice[i] ?? "";
-    const padding = Math.max(0, contentWidth - getDisplayWidth(line));
+    const entry = visibleSlice[i] ?? { text: "", category: "prose" };
+    const padding = Math.max(0, contentWidth - getDisplayWidth(entry.text));
+    const lineStyle = getLineStyle(entry.category);
     contentRows.push(
       /* @__PURE__ */ jsxs2(Text2, { children: [
         BOX.v,
         " ",
-        line,
+        /* @__PURE__ */ jsx2(Text2, { color: lineStyle.color, dimColor: lineStyle.dimColor, children: entry.text }),
         " ".repeat(padding),
         BOX.v
       ] }, i)
@@ -1513,7 +2095,7 @@ import { Box as Box3, Text as Text3 } from "ink";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 var SECTIONS = [
   {
-    title: "Session tree",
+    title: "Project tree",
     rows: [
       ["\u2191 \u2193 / k j", "Move selection"],
       ["PgUp / Ctrl+B", "Page up"],
@@ -1530,12 +2112,11 @@ var SECTIONS = [
       ["\u2191 \u2193 / k j", "Scroll one line"],
       ["PgUp/Dn, Ctrl+B/F", "Scroll one page"],
       ["Ctrl+U / Ctrl+D", "Scroll half page"],
-      ["g", "Jump to live (newest)"],
-      ["G", "Jump to oldest"],
+      ["g", "Jump to top (oldest)"],
+      ["G", "Jump to live (newest, bottom)"],
       ["\u21B5", "Open detail view for selected activity"],
       ["f", "Cycle filter preset (set in config.yaml)"],
-      ["s", "Save activity log to ~/.agenthud/logs/"],
-      ["Tab", "Switch focus to session tree"]
+      ["Tab", "Switch focus to project tree"]
     ]
   },
   {
@@ -1545,6 +2126,15 @@ var SECTIONS = [
       ["\u21B5 / Esc / q", "Close"]
     ]
   },
+  {
+    title: "Session status (by recent activity)",
+    rows: [
+      ["[hot]", "Updated in the last 30 minutes", "green"],
+      ["[warm]", "Updated in the last hour", "yellow"],
+      ["[cool]", "Updated earlier today", "cyan"],
+      ["[cold]", "Last updated yesterday or earlier (collapsed)", "gray"]
+    ]
+  },
   {
     title: "Always available",
     rows: [
@@ -1565,14 +2155,17 @@ var SECTIONS = [
     rows: [
       ["~/.agenthud/config.yaml", "User settings (edit freely)"],
       ["~/.agenthud/state.yaml", "Hidden items (app-managed)"],
-      ["~/.agenthud/summary-prompt.md", "LLM prompt template"],
-      ["~/.agenthud/summaries/", "Cached daily summaries"]
+      ["~/.agenthud/summary-prompt.md", "Daily summary prompt template"],
+      ["~/.agenthud/summary-range-prompt.md", "Range summary prompt template"],
+      ["~/.agenthud/summaries/", "Cached daily and range summaries"]
     ]
   }
 ];
 function HelpPanel({
   width,
-  height
+  height,
+  scrollOffset = 0,
+  onTotalLinesChange
 }) {
   const allKeys = SECTIONS.flatMap((s) => s.rows.map((r) => r[0]));
   const keyColumn = Math.min(
@@ -1594,21 +2187,35 @@ function HelpPanel({
       /* @__PURE__ */ jsx3(Text3, { bold: true, color: "cyan", children: SECTIONS[s].title }, `title-${s}`)
     );
     for (let r = 0; r < SECTIONS[s].rows.length; r++) {
-      const [key, desc] = SECTIONS[s].rows[r];
+      const row = SECTIONS[s].rows[r];
+      const [key, desc] = row;
+      const explicitColor = row.length === 3 ? row[2] : void 0;
       const isCli = key.trim().startsWith("agenthud");
       const isFile = key.includes("~/.agenthud");
+      const color = explicitColor ?? (isCli ? "cyan" : isFile ? "green" : void 0);
       lines.push(
         /* @__PURE__ */ jsxs3(Text3, { children: [
           /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " " }),
-          /* @__PURE__ */ jsx3(Text3, { color: isCli ? "cyan" : isFile ? "green" : void 0, children: padTo(key, keyColumn) }),
+          /* @__PURE__ */ jsx3(Text3, { color, children: padTo(key, keyColumn) }),
           /* @__PURE__ */ jsx3(Text3, { children: " " }),
           /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: desc })
         ] }, `row-${s}-${r}`)
       );
     }
   }
-  const visible = lines.slice(0, height);
-  return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", width, children: visible });
+  const indicatorReserved = lines.length > height ? 1 : 0;
+  const viewport = Math.max(1, height - indicatorReserved);
+  const maxOffset = Math.max(0, lines.length - viewport);
+  const offset = Math.max(0, Math.min(scrollOffset, maxOffset));
+  if (onTotalLinesChange) onTotalLinesChange(lines.length);
+  const visible = lines.slice(offset, offset + viewport);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width, children: [
+    visible,
+    indicatorReserved > 0 && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      `-- ${offset + viewport} / ${lines.length} `,
+      offset < maxOffset ? "(\u2193 / j / PgDn / Space for more) --" : "(top: g \xB7 \u2191 / k to scroll back) --"
+    ] })
+  ] });
 }
 
 // src/ui/hooks/useHotkeys.ts
@@ -1625,7 +2232,6 @@ function useHotkeys({
   onScrollHalfPageDown,
   onScrollTop,
   onScrollBottom,
-  onSaveLog,
   onRefresh,
   onQuit,
   onEnter,
@@ -1635,6 +2241,8 @@ function useHotkeys({
   onDetailScrollDown,
   onFilter,
   onHelp,
+  onHelpScroll,
+  onHelpScrollToTop,
   filterLabel
 }) {
   const handleInput = (input, key) => {
@@ -1643,6 +2251,32 @@ function useHotkeys({
         onHelp();
         return;
       }
+      if (onHelpScroll) {
+        if (key.downArrow || input === "j" || input === " ") {
+          onHelpScroll(1);
+          return;
+        }
+        if (key.upArrow || input === "k") {
+          onHelpScroll(-1);
+          return;
+        }
+        if (key.pageDown || key.ctrl && input === "f") {
+          onHelpScroll(10);
+          return;
+        }
+        if (key.pageUp || key.ctrl && input === "b") {
+          onHelpScroll(-10);
+          return;
+        }
+        if (input === "G") {
+          onHelpScroll(Number.MAX_SAFE_INTEGER);
+          return;
+        }
+      }
+      if (input === "g" && onHelpScrollToTop) {
+        onHelpScrollToTop();
+        return;
+      }
       return;
     }
     if (input === "?") {
@@ -1741,13 +2375,9 @@ function useHotkeys({
         onScrollBottom();
         return;
       }
-      if (input === "s") {
-        onSaveLog();
-        return;
-      }
     }
   };
-  const statusBarItems = helpMode ? ["\u21B5/Esc/q/?: close"] : detailMode ? ["\u2191\u2193/jk: scroll", "\u21B5/Esc: close", "?: help"] : focus === "tree" ? [
+  const statusBarItems = helpMode ? ["\u2191\u2193/jk: scroll", "PgDn/Space: page", "\u21B5/Esc/q/?: close"] : detailMode ? ["\u2191\u2193/jk: scroll", "\u21B5/Esc: close", "?: help"] : focus === "tree" ? [
     "Tab: viewer",
     "\u2191\u2193/jk: select",
     "PgUp/Dn: page",
@@ -1757,11 +2387,11 @@ function useHotkeys({
     "?: help",
     "q: quit"
   ] : [
-    "Tab: sessions",
+    "Tab: projects",
     "\u2191\u2193/jk: scroll",
     "PgUp/Dn: page",
-    "g: live",
-    "G: oldest",
+    "g: oldest",
+    "G: live",
     "\u21B5: detail",
     `f: ${filterLabel}`,
     "?: help",
@@ -1770,12 +2400,29 @@ function useHotkeys({
   return { handleInput, statusBarItems };
 }
 
-// src/ui/hooks/useSpinner.ts
+// src/ui/hooks/useSlide.ts
 import { useEffect, useState } from "react";
-var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-function useSpinner(active, intervalMs = 100) {
+function useSlide(active, positions, intervalMs = 180, resetKey) {
   const [index, setIndex] = useState(0);
   useEffect(() => {
+    setIndex(0);
+  }, [resetKey]);
+  useEffect(() => {
+    if (!active) return;
+    const timer = setInterval(() => {
+      setIndex((i) => (i + 1) % positions);
+    }, intervalMs);
+    return () => clearInterval(timer);
+  }, [active, positions, intervalMs]);
+  return index;
+}
+
+// src/ui/hooks/useSpinner.ts
+import { useEffect as useEffect2, useState as useState2 } from "react";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function useSpinner(active, intervalMs = 100) {
+  const [index, setIndex] = useState2(0);
+  useEffect2(() => {
     if (!active) return;
     const timer = setInterval(() => {
       setIndex((i) => (i + 1) % FRAMES.length);
@@ -1789,12 +2436,20 @@ function useSpinner(active, intervalMs = 100) {
 import { homedir as homedir4 } from "os";
 import { Box as Box4, Text as Text4 } from "ink";
 import { Fragment, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
-function formatElapsed(lastModifiedMs) {
-  const elapsed = Date.now() - lastModifiedMs;
+function formatElapsed(lastModifiedMs, now = Date.now()) {
+  const elapsed = Math.max(0, now - lastModifiedMs);
   const seconds = Math.floor(elapsed / 1e3);
   const minutes = Math.floor(seconds / 60);
   const hours = Math.floor(minutes / 60);
-  if (hours > 0) return `${hours}h${minutes % 60}m`;
+  const days = Math.floor(hours / 24);
+  const weeks = Math.floor(days / 7);
+  const months = Math.floor(days / 30);
+  const years = Math.floor(days / 365);
+  if (years >= 1) return `${years}y`;
+  if (months >= 1) return `${months}mo`;
+  if (weeks >= 1) return `${weeks}w`;
+  if (days >= 1) return `${days}d`;
+  if (hours > 0) return `${hours}h`;
   if (minutes > 0) return `${minutes}m`;
   if (seconds > 0) return `${seconds}s`;
   return "<1s";
@@ -1816,11 +2471,6 @@ function formatProjectPath(projectPath) {
   const raw = projectPath.startsWith(home) ? `~${projectPath.slice(home.length)}` : projectPath;
   return raw;
 }
-function truncatePath(path, maxWidth) {
-  if (getDisplayWidth(path) <= maxWidth) return path;
-  if (maxWidth < 4) return "";
-  return `...${path.slice(-(maxWidth - 3))}`;
-}
 function SessionRow({
   session,
   isSelected,
@@ -1842,36 +2492,40 @@ function SessionRow({
   const leftCoreBase = `${prefix}${rawName}${shortIdDisplay} ${badge}`;
   const leftCoreWidth = getDisplayWidth(leftCoreBase);
   const rightWidth = getDisplayWidth(rightSide);
-  const middleAvailable = contentWidth - leftCoreWidth - 1 - rightWidth - 1;
+  const RIGHT_GAP = 3;
+  const middleAvailable = contentWidth - leftCoreWidth - 1 - rightWidth - RIGHT_GAP;
   let middleText = "";
-  if (middleAvailable > 3) {
+  if (middleAvailable > 1) {
     const raw = isParent ? session.firstUserPrompt ?? "" : session.taskDescription ?? "";
     if (raw) {
-      const truncated = truncatePath(raw, middleAvailable);
+      const flat = raw.replace(/[\r\n\t]+/g, " ").trim();
+      const truncated = truncateByWidth(flat, middleAvailable);
       if (truncated) middleText = truncated;
     }
   }
   const middleSection = middleText ? ` ${middleText}` : "";
   const gapWidth = Math.max(
-    1,
+    RIGHT_GAP,
     contentWidth - leftCoreWidth - getDisplayWidth(middleSection) - rightWidth
   );
   const gap = " ".repeat(gapWidth);
   const fullLine = leftCoreBase + middleSection + gap + rightSide;
   const linePadding = Math.max(0, contentWidth - getDisplayWidth(fullLine));
-  const highlight = isSelected && hasFocus;
-  const shouldDim = isNonInteractive;
+  const focused = isSelected && hasFocus;
+  const muted = isSelected && !hasFocus;
+  const showBg = focused || muted;
+  const shouldDim = isNonInteractive || muted;
   return /* @__PURE__ */ jsxs4(Text4, { children: [
     BOX.v,
     " ",
     /* @__PURE__ */ jsxs4(
       Text4,
       {
-        backgroundColor: highlight ? "blue" : void 0,
-        bold: highlight,
-        dimColor: shouldDim && !highlight,
+        backgroundColor: showBg ? "blue" : void 0,
+        bold: focused,
+        dimColor: shouldDim && !focused,
         children: [
-          /* @__PURE__ */ jsx4(Text4, { dimColor: shouldDim && !highlight, children: prefix }),
+          /* @__PURE__ */ jsx4(Text4, { dimColor: shouldDim && !focused, children: prefix }),
           /* @__PURE__ */ jsx4(Text4, { bold: !shouldDim, children: rawName }),
           shortIdDisplay ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: shortIdDisplay }) : null,
           /* @__PURE__ */ jsx4(Text4, { children: " " }),
@@ -1968,23 +2622,47 @@ function ProjectRow({
 }) {
   const nameText = `> ${project.name}`;
   const pathText = project.projectPath ? formatProjectPath(project.projectPath) : "";
+  const latestMtime = project.sessions.reduce(
+    (acc, s) => Math.max(acc, s.lastModifiedMs),
+    0
+  );
+  const elapsed = latestMtime > 0 ? formatElapsed(latestMtime) : "";
   const nameWidth = getDisplayWidth(nameText);
   const pathWidth = pathText ? getDisplayWidth(pathText) : 0;
-  const gapWidth = pathText ? 2 : 0;
-  const totalWidth = nameWidth + gapWidth + pathWidth;
+  const elapsedWidth = elapsed ? getDisplayWidth(elapsed) : 0;
+  const middleGap = pathText ? 2 : 0;
+  const leftWidth = nameWidth + middleGap + pathWidth;
+  const PROJECT_RIGHT_GAP = 3;
+  const rightGap = Math.max(
+    PROJECT_RIGHT_GAP,
+    contentWidth - leftWidth - elapsedWidth
+  );
+  const totalWidth = leftWidth + rightGap + elapsedWidth;
   const padding = Math.max(0, contentWidth - totalWidth);
-  const highlight = isSelected && hasFocus;
+  const focused = isSelected && hasFocus;
+  const muted = isSelected && !hasFocus;
+  const showBg = focused || muted;
   return /* @__PURE__ */ jsxs4(Text4, { children: [
     BOX.v,
     " ",
-    /* @__PURE__ */ jsxs4(Text4, { backgroundColor: highlight ? "blue" : void 0, bold: !highlight, children: [
-      nameText,
-      pathText ? /* @__PURE__ */ jsxs4(Fragment, { children: [
-        "  ",
-        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: pathText })
-      ] }) : null,
-      " ".repeat(padding)
-    ] }),
+    /* @__PURE__ */ jsxs4(
+      Text4,
+      {
+        backgroundColor: showBg ? "blue" : void 0,
+        bold: !showBg,
+        dimColor: muted,
+        children: [
+          nameText,
+          pathText ? /* @__PURE__ */ jsxs4(Fragment, { children: [
+            "  ",
+            /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: pathText })
+          ] }) : null,
+          " ".repeat(rightGap),
+          elapsed ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: elapsed }) : null,
+          " ".repeat(padding)
+        ]
+      }
+    ),
     BOX.v
   ] });
 }
@@ -2004,11 +2682,12 @@ function SubagentSummaryRow({
     0,
     contentWidth - getDisplayWidth(text) - getDisplayWidth(hint)
   );
-  const active = isSelected && hasFocus;
+  const focused = isSelected && hasFocus;
+  const muted = isSelected && !hasFocus;
   return /* @__PURE__ */ jsxs4(Text4, { children: [
     BOX.v,
     " ",
-    /* @__PURE__ */ jsxs4(Text4, { dimColor: !active, inverse: active, children: [
+    /* @__PURE__ */ jsxs4(Text4, { dimColor: !focused, inverse: focused || muted, children: [
       text,
       " ".repeat(padding),
       hint
@@ -2030,13 +2709,14 @@ function ColdProjectsSummaryRow({
   const dashCount = Math.max(0, innerWidth - 1 - labelWidth - hintWidth);
   const dashes = BOX.h.repeat(dashCount);
   const line = `${BOX.ml}${BOX.h}${label}${dashes}${hint}${BOX.mr}`;
-  const highlight = isSelected && hasFocus;
+  const focused = isSelected && hasFocus;
+  const muted = isSelected && !hasFocus;
   return /* @__PURE__ */ jsx4(
     Text4,
     {
-      backgroundColor: highlight ? "blue" : void 0,
-      bold: highlight,
-      dimColor: !highlight,
+      backgroundColor: focused || muted ? "blue" : void 0,
+      bold: focused,
+      dimColor: !focused,
       children: line
     }
   );
@@ -2052,7 +2732,7 @@ function SessionTreePanel({
 }) {
   const innerWidth = getInnerWidth(width);
   const contentWidth = innerWidth - 1;
-  const titleLine = createTitleLine("Sessions", "", width);
+  const titleLine = createTitleLine("Projects", "", width);
   const bottomLine = createBottomLine(width);
   const totalProjectCount = projects.length + coldProjects.length;
   if (totalProjectCount === 0) {
@@ -2159,7 +2839,8 @@ function subSummarySentinel(parentId) {
     status: "cold",
     modelName: null,
     subAgents: [],
-    nonInteractive: false
+    nonInteractive: false,
+    firstUserPrompt: null
   };
 }
 function appendSubAgentRows(result, session, expandedIds) {
@@ -2197,7 +2878,8 @@ function flattenSessions2(tree, expandedIds) {
       status: project.hotness,
       modelName: null,
       subAgents: [],
-      nonInteractive: false
+      nonInteractive: false,
+      firstUserPrompt: null
     });
     const shouldShowSessions = isCold ? expandedIds.has(`__expanded-${sentinelId}`) : !expandedIds.has(`__collapsed-${sentinelId}`);
     if (shouldShowSessions) {
@@ -2221,7 +2903,8 @@ function flattenSessions2(tree, expandedIds) {
       status: "cold",
       modelName: null,
       subAgents: [],
-      nonInteractive: false
+      nonInteractive: false,
+      firstUserPrompt: null
     });
     if (expandedIds.has("__cold__")) {
       for (const project of tree.coldProjects) {
@@ -2235,14 +2918,14 @@ function getSelectedActivity(acts, live, scrollOff, rows, cursorLine) {
   if (acts.length === 0) return null;
   let visible;
   if (live) {
-    visible = acts.slice(-rows).reverse();
+    visible = acts.slice(-rows);
   } else {
     const end = Math.max(0, acts.length - scrollOff);
     const start = Math.max(0, end - rows);
-    visible = acts.slice(start, end).reverse();
+    visible = acts.slice(start, end);
   }
   const effectiveCursor = Math.min(cursorLine, visible.length - 1);
-  return visible[effectiveCursor] ?? null;
+  return visible[visible.length - 1 - effectiveCursor] ?? null;
 }
 function App({ mode }) {
   const { exit } = useApp();
@@ -2250,45 +2933,47 @@ function App({ mode }) {
   const isWatchMode = mode === "watch";
   const config = useMemo(() => loadGlobalConfig(), []);
   const migrationWarning = useMemo(() => hasProjectLevelConfig(), []);
-  const [sessionTree, setSessionTree] = useState2(
+  const [sessionTree, setSessionTree] = useState3(
     () => discoverSessions(config)
   );
-  const [selectedId, setSelectedId] = useState2(() => {
+  const [selectedId, setSelectedId] = useState3(() => {
     const firstProject = sessionTree.projects[0];
     if (firstProject) return `__proj-${firstProject.name}__`;
     return null;
   });
-  const [focus, setFocus] = useState2("tree");
-  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);
-  const [detailMode, setDetailMode] = useState2(false);
-  const [detailActivity, setDetailActivity] = useState2(
+  const [focus, setFocus] = useState3("tree");
+  const [scrollOffset, setScrollOffset] = useState3(0);
+  const [isLive, setIsLive] = useState3(true);
+  const [activities, setActivities] = useState3([]);
+  const [gitActivities, setGitActivities] = useState3([]);
+  const [newCount, setNewCount] = useState3(0);
+  const [expandedIds, setExpandedIds] = useState3(/* @__PURE__ */ new Set());
+  const [viewerCursorLine, setViewerCursorLine] = useState3(0);
+  const [detailMode, setDetailMode] = useState3(false);
+  const [detailActivity, setDetailActivity] = useState3(
     null
   );
-  const [detailScrollOffset, setDetailScrollOffset] = useState2(0);
-  const [filterIndex, setFilterIndex] = useState2(0);
-  const [helpMode, setHelpMode] = useState2(false);
+  const [detailScrollOffset, setDetailScrollOffset] = useState3(0);
+  const [filterIndex, setFilterIndex] = useState3(0);
+  const [helpMode, setHelpMode] = useState3(false);
+  const [helpScroll, setHelpScroll] = useState3(0);
+  const helpTotalLinesRef = useRef(0);
   const allFlat = useMemo(
     () => flattenSessions2(sessionTree, expandedIds),
     [sessionTree, expandedIds]
   );
   const allFlatRef = useRef(allFlat);
-  useEffect2(() => {
+  useEffect3(() => {
     allFlatRef.current = allFlat;
   }, [allFlat]);
   const activitiesLengthRef = useRef(0);
   const activitiesRef = useRef(activities);
-  useEffect2(() => {
+  useEffect3(() => {
     activitiesLengthRef.current = activities.length;
     activitiesRef.current = activities;
   }, [activities]);
   const lastLoadedFileRef = useRef(null);
-  useEffect2(() => {
+  useEffect3(() => {
     let node = allFlatRef.current.find((s) => s.id === selectedId);
     if (node && selectedId?.startsWith("__proj-") && selectedId.endsWith("__")) {
       const projectName = selectedId.slice(7, -2);
@@ -2316,12 +3001,12 @@ function App({ mode }) {
       if (fileChanged) setGitActivities([]);
     }
   }, [selectedId, sessionTree]);
-  useEffect2(() => {
+  useEffect3(() => {
     setScrollOffset(0);
     setIsLive(true);
     setViewerCursorLine(0);
   }, [filterIndex]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (!isWatchMode) return;
     const node = allFlatRef.current.find((s) => s.id === selectedId);
     if (!node?.projectPath) return;
@@ -2376,10 +3061,10 @@ function App({ mode }) {
     }
   }, [selectedId, isLive, expandedIds]);
   const refreshRef = useRef(refresh);
-  useEffect2(() => {
+  useEffect3(() => {
     refreshRef.current = refresh;
   }, [refresh]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (!isWatchMode) return;
     const projectsDir = getProjectsDir();
     const usePolling = process.platform === "linux" || !existsSync5(projectsDir);
@@ -2433,36 +3118,61 @@ function App({ mode }) {
   const maxTreeRows = Math.floor(height * (1 - VIEWER_HEIGHT_FRACTION));
   const naturalTreeRows = allFlat.length;
   const treeRows = Math.max(1, Math.min(naturalTreeRows, maxTreeRows));
-  const viewerRows = Math.max(5, height - 7 - treeRows);
-  const saveLog = useCallback(() => {
-    if (!activities.length || !selectedId) return;
-    ensureLogDir(config.logDir);
-    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const filePath = join5(
-      config.logDir,
-      `${date}-${selectedId.slice(0, 8)}.txt`
-    );
-    const lines = activities.map(
-      (a) => `[${a.timestamp.toISOString()}] ${a.icon} ${a.label} ${a.detail}`
-    );
-    try {
-      writeFileSync2(filePath, `${lines.join("\n")}
-`, "utf-8");
-    } catch {
-    }
-  }, [activities, selectedId, config.logDir]);
+  const VIEWER_BREATHING_ROWS = 1;
+  const viewerRows = Math.max(
+    5,
+    height - 7 - treeRows - VIEWER_BREATHING_ROWS
+  );
   const spinner = useSpinner(isWatchMode);
+  const viewerIndicatorWidth = Math.max(1, width - 3);
+  const liveIndicatorPosition = useSlide(
+    isWatchMode,
+    viewerIndicatorWidth,
+    180,
+    // Reset to 0 whenever the viewer's subject changes so each new
+    // session/sub-agent restarts the arrow from the left.
+    selectedId
+  );
+  const helpViewportRows = Math.max(1, height - 3);
+  const helpScrollStep = (delta) => {
+    const max = Math.max(0, helpTotalLinesRef.current - helpViewportRows);
+    setHelpScroll((s) => Math.max(0, Math.min(max, s + delta)));
+  };
   const { handleInput, statusBarItems } = useHotkeys({
     focus,
     detailMode,
     helpMode,
-    onHelp: () => setHelpMode((m) => !m),
+    onHelp: () => {
+      setHelpScroll(0);
+      setHelpMode((m) => !m);
+    },
+    onHelpScroll: helpScrollStep,
+    onHelpScrollToTop: () => setHelpScroll(0),
     onSwitchFocus: () => setFocus((f) => f === "tree" ? "viewer" : "tree"),
+    // cursorLine = "entries back from the newest" (0 = newest = bottom row).
+    // Up arrow moves visually upward = older direction = cursorLine++.
+    // Down arrow moves visually downward = newer direction = cursorLine--.
     onScrollUp: () => {
       if (focus === "tree") {
         if (selectedIndex === -1) return;
         const prev = Math.max(0, selectedIndex - 1);
         setSelectedId(allFlat[prev]?.id ?? selectedId);
+      } else {
+        if (viewerCursorLine < viewerRows - 1) {
+          setViewerCursorLine((c) => c + 1);
+        } else {
+          setIsLive(false);
+          setScrollOffset(
+            (o) => Math.min(o + 1, Math.max(0, activities.length - viewerRows))
+          );
+        }
+      }
+    },
+    onScrollDown: () => {
+      if (focus === "tree") {
+        if (selectedIndex === -1) return;
+        const next = Math.min(allFlat.length - 1, selectedIndex + 1);
+        setSelectedId(allFlat[next]?.id ?? selectedId);
       } else {
         if (viewerCursorLine > 0) {
           setViewerCursorLine((c) => c - 1);
@@ -2478,26 +3188,25 @@ function App({ mode }) {
         }
       }
     },
-    onScrollDown: () => {
+    // PgUp/PgDn semantics flip to match the bottom-feed layout:
+    // PgUp = visually up = older direction = scrollOffset++
+    // PgDn = visually down = newer direction = scrollOffset--
+    onScrollPageUp: () => {
       if (focus === "tree") {
-        if (selectedIndex === -1) return;
-        const next = Math.min(allFlat.length - 1, selectedIndex + 1);
-        setSelectedId(allFlat[next]?.id ?? selectedId);
+        const prev = Math.max(0, selectedIndex - 5);
+        setSelectedId(allFlat[prev]?.id ?? selectedId);
       } else {
-        if (viewerCursorLine < viewerRows - 1) {
-          setViewerCursorLine((c) => c + 1);
-        } else {
-          setIsLive(false);
-          setScrollOffset(
-            (o) => Math.min(o + 1, Math.max(0, activities.length - viewerRows))
-          );
-        }
+        setViewerCursorLine(0);
+        setIsLive(false);
+        setScrollOffset(
+          (o) => Math.min(o + viewerRows, Math.max(0, activities.length - viewerRows))
+        );
       }
     },
-    onScrollPageUp: () => {
+    onScrollPageDown: () => {
       if (focus === "tree") {
-        const prev = Math.max(0, selectedIndex - 5);
-        setSelectedId(allFlat[prev]?.id ?? selectedId);
+        const next = Math.min(allFlat.length - 1, selectedIndex + 5);
+        setSelectedId(allFlat[next]?.id ?? selectedId);
       } else {
         setViewerCursorLine(0);
         setScrollOffset((o) => {
@@ -2510,22 +3219,28 @@ function App({ mode }) {
         });
       }
     },
-    onScrollPageDown: () => {
+    onScrollHalfPageUp: () => {
       if (focus === "tree") {
-        const next = Math.min(allFlat.length - 1, selectedIndex + 5);
-        setSelectedId(allFlat[next]?.id ?? selectedId);
+        const prev = Math.max(0, selectedIndex - Math.ceil(5 / 2));
+        setSelectedId(allFlat[prev]?.id ?? selectedId);
       } else {
         setViewerCursorLine(0);
         setIsLive(false);
         setScrollOffset(
-          (o) => Math.min(o + viewerRows, Math.max(0, activities.length - viewerRows))
+          (o) => Math.min(
+            o + Math.floor(viewerRows / 2),
+            Math.max(0, activities.length - viewerRows)
+          )
         );
       }
     },
-    onScrollHalfPageUp: () => {
+    onScrollHalfPageDown: () => {
       if (focus === "tree") {
-        const prev = Math.max(0, selectedIndex - Math.ceil(5 / 2));
-        setSelectedId(allFlat[prev]?.id ?? selectedId);
+        const next = Math.min(
+          allFlat.length - 1,
+          selectedIndex + Math.ceil(5 / 2)
+        );
+        setSelectedId(allFlat[next]?.id ?? selectedId);
       } else {
         setViewerCursorLine(0);
         setScrollOffset((o) => {
@@ -2538,35 +3253,17 @@ function App({ mode }) {
         });
       }
     },
-    onScrollHalfPageDown: () => {
-      if (focus === "tree") {
-        const next = Math.min(
-          allFlat.length - 1,
-          selectedIndex + Math.ceil(5 / 2)
-        );
-        setSelectedId(allFlat[next]?.id ?? selectedId);
-      } else {
-        setViewerCursorLine(0);
-        setIsLive(false);
-        setScrollOffset(
-          (o) => Math.min(
-            o + Math.floor(viewerRows / 2),
-            Math.max(0, activities.length - viewerRows)
-          )
-        );
-      }
-    },
     onScrollTop: () => {
+      setViewerCursorLine(Math.max(0, viewerRows - 1));
+      setIsLive(false);
+      setScrollOffset(Math.max(0, mergedActivities.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);
     },
@@ -2658,15 +3355,23 @@ function App({ mode }) {
         const toggleKey = isCold ? `__expanded-session-${selectedId}` : `__collapsed-session-${selectedId}`;
         setExpandedIds((prev) => {
           const next = new Set(prev);
-          if (next.has(toggleKey)) {
-            next.delete(toggleKey);
-            if (!isCold) setSelectedId(selectedId);
-          } else {
-            next.add(toggleKey);
-            if (isCold) {
+          if (isCold) {
+            if (next.has(toggleKey)) {
+              next.delete(toggleKey);
+              next.delete(selectedId);
+            } else {
+              next.add(toggleKey);
               const firstSub = selectedSessionObj.subAgents[0];
               if (firstSub) setSelectedId(firstSub.id);
             }
+          } else {
+            if (next.has(toggleKey)) {
+              next.delete(toggleKey);
+            } else {
+              next.add(toggleKey);
+              next.delete(selectedId);
+              setSelectedId(selectedId);
+            }
           }
           return next;
         });
@@ -2711,7 +3416,6 @@ function App({ mode }) {
         }
       }
     },
-    onSaveLog: saveLog,
     onRefresh: refresh,
     onQuit: exit,
     onFilter: () => setFilterIndex((i) => (i + 1) % filterPresets.length),
@@ -2729,17 +3433,48 @@ function App({ mode }) {
     }
   }
   const isPlaceholderSelected = !selectedSession || selectedId === "__cold__" || !!selectedId && selectedId.startsWith("__sub-") && selectedId.endsWith("__");
-  const sessionDisplayName = isPlaceholderSelected ? "No session selected" : selectedSession.projectPath ? selectedSession.projectName || selectedSession.id.slice(0, 8) : selectedSession.agentId ?? selectedSession.id.slice(0, 8);
+  const sessionDisplayName = isPlaceholderSelected || !selectedSession ? "No session selected" : selectedSession.projectPath ? selectedSession.projectName || selectedSession.id.slice(0, 8) : selectedSession.agentId ?? selectedSession.id.slice(0, 8);
+  const MIN_WIDTH = 80;
+  const MIN_HEIGHT = 20;
+  if (isWatchMode && (width < MIN_WIDTH || height + 1 < MIN_HEIGHT)) {
+    return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", width, children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "AgentHUD needs a larger terminal." }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: `Minimum: ${MIN_WIDTH} cols \xD7 ${MIN_HEIGHT} rows` }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: `Current: ${width} cols \xD7 ${height + 1} rows` }),
+      /* @__PURE__ */ jsx5(Text5, { children: " " }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Resize the window and AgentHUD will redraw automatically." }),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Press q to quit." })
+    ] });
+  }
   return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
-    isWatchMode && /* @__PURE__ */ jsxs5(Box5, { marginBottom: 1, justifyContent: "space-between", width, children: [
-      /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
-        spinner,
-        " AgentHUD v",
-        getVersion()
-      ] }),
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: statusBarItems.join(" \xB7 ") })
-    ] }),
-    helpMode ? /* @__PURE__ */ jsx5(HelpPanel, { width, height: height - 2 }) : /* @__PURE__ */ jsxs5(Fragment2, { children: [
+    isWatchMode && (() => {
+      const branding = `${spinner} AgentHUD v${getVersion()}`;
+      const sep = " \xB7 ";
+      let items = statusBarItems;
+      let shortcuts = items.join(sep);
+      let showBranding = true;
+      const fits = () => (showBranding ? getDisplayWidth(branding) + 1 : 0) + getDisplayWidth(shortcuts) <= width;
+      if (!fits()) showBranding = false;
+      while (!fits() && items.length > 1) {
+        items = items.slice(1);
+        shortcuts = items.join(sep);
+      }
+      return /* @__PURE__ */ jsxs5(Box5, { marginBottom: 1, justifyContent: "space-between", width, children: [
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: showBranding ? branding : "" }),
+        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: shortcuts })
+      ] });
+    })(),
+    helpMode ? /* @__PURE__ */ jsx5(
+      HelpPanel,
+      {
+        width,
+        height: height - 2,
+        scrollOffset: helpScroll,
+        onTotalLinesChange: (n) => {
+          helpTotalLinesRef.current = n;
+        }
+      }
+    ) : /* @__PURE__ */ jsxs5(Fragment2, { children: [
       migrationWarning && /* @__PURE__ */ jsx5(Box5, { marginBottom: 1, children: /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: "Config moved to ~/.agenthud/config.yaml" }) }),
       /* @__PURE__ */ jsx5(
         SessionTreePanel,
@@ -2771,6 +3506,8 @@ function App({ mode }) {
           isLive,
           newCount,
           visibleRows: viewerRows,
+          trailingBlankRows: VIEWER_BREATHING_ROWS,
+          liveIndicatorPosition,
           width,
           cursorLine: viewerCursorLine,
           hasFocus: focus === "viewer",
@@ -2798,13 +3535,13 @@ if (options.command === "version") {
   process.exit(0);
 }
 var legacyConfig = join6(process.cwd(), ".agenthud", "config.yaml");
-if (existsSync6(legacyConfig)) {
+if (isLegacyProjectConfig(process.cwd(), homedir5()) && existsSync6(legacyConfig)) {
   console.log(
     "The project-level config file (.agenthud/config.yaml) is no longer supported."
   );
   console.log("Settings have moved to ~/.agenthud/config.yaml.");
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  await new Promise((resolve) => {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  await new Promise((resolve2) => {
     rl.question("Delete the old config file and continue? [y/N] ", (answer) => {
       rl.close();
       if (answer.trim().toLowerCase() === "y") {
@@ -2814,7 +3551,7 @@ if (existsSync6(legacyConfig)) {
         console.log("Aborted.");
         process.exit(0);
       }
-      resolve();
+      resolve2();
     });
   });
 }
@@ -2826,7 +3563,11 @@ if (options.mode === "report") {
   }
   const config = loadGlobalConfig();
   const tree = discoverSessions(config);
-  const markdown = generateReport(tree.sessions, {
+  const flatSessions = [
+    ...tree.projects.flatMap((p) => p.sessions),
+    ...tree.coldProjects.flatMap((p) => p.sessions)
+  ];
+  const markdown = generateReport(flatSessions, {
     date: options.reportDate,
     include: options.reportInclude,
     format: options.reportFormat,
@@ -2843,15 +3584,29 @@ if (options.mode === "summary") {
 `);
     process.exit(1);
   }
+  const today = /* @__PURE__ */ new Date();
+  if (options.summaryFrom && options.summaryTo) {
+    const exitCode2 = await runRangeSummary({
+      from: options.summaryFrom,
+      to: options.summaryTo,
+      today,
+      force: options.summaryForce ?? false,
+      assumeYes: options.summaryAssumeYes ?? false
+    });
+    process.exit(exitCode2);
+  }
   const exitCode = await runSummary({
     date: options.summaryDate,
     prompt: options.summaryPrompt,
     force: options.summaryForce ?? false,
-    today: /* @__PURE__ */ new Date()
+    today
   });
   process.exit(exitCode);
 }
 if (options.mode === "watch") {
-  clearScreen();
+  installAltScreenCleanup();
+  enterAltScreen();
+} else {
+  if (options.mode === "once") clearScreen();
 }
 render(React.createElement(App, { mode: options.mode }));