agenthud 0.11.4 → 0.12.2

package/dist/{main-WAT4DY4T.js → main-YCUCY2QP.js}

@@ -1,15 +1,306 @@
 // src/main.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, realpathSync, rmSync } from "fs";
+import { existsSync as existsSync8, readdirSync as readdirSync3, realpathSync, rmSync } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 import { createInterface as createInterface2 } from "readline";
 import { render } from "ink";
 import React from "react";
 
 // src/cli.ts
-import { readFileSync } from "fs";
-import { dirname, join } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join2 } from "path";
 import { fileURLToPath } from "url";
+
+// src/config/globalConfig.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var CONFIG_PATH = join(homedir(), ".agenthud", "config.yaml");
+var STATE_PATH = join(homedir(), ".agenthud", "state.yaml");
+var DEFAULT_INCLUDE_TYPES = [
+  "user",
+  "response",
+  "bash",
+  "edit",
+  "thinking"
+];
+var ALLOWED_INCLUDE_TYPES = /* @__PURE__ */ new Set([
+  "user",
+  "response",
+  "bash",
+  "edit",
+  "thinking",
+  "read",
+  "glob",
+  "commit"
+]);
+var DEFAULT_GLOBAL_CONFIG = {
+  refreshIntervalMs: 2e3,
+  hiddenSessions: [],
+  hiddenSubAgents: [],
+  // [] means "show all"; conversation preset bundles assistant + user;
+  // commits-only preset filters down to git activity.
+  filterPresets: [[], ["response", "user"], ["commit"]],
+  hiddenProjects: [],
+  report: {
+    include: [...DEFAULT_INCLUDE_TYPES],
+    detailLimit: 120,
+    withGit: false,
+    format: "markdown"
+  },
+  summary: {}
+};
+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;
+  const n = parseInt(match[1], 10);
+  return match[2] === "m" ? n * 60 * 1e3 : n * 1e3;
+}
+function ensureAgenthudDir() {
+  const dir = join(homedir(), ".agenthud");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+function writeDefaultConfig() {
+  ensureAgenthudDir();
+  const defaultYaml = `# AgentHUD user settings.
+# App-managed state (hidden sessions/projects) lives in state.yaml.
+
+# How often to poll for activity updates
+refreshInterval: 2s
+
+# Activity filter presets (cycle with 'f' key in viewer)
+# Each list is one preset. Use "all" (or "*") to show everything.
+# Types: response, user, bash, edit, thinking, read, glob, commit
+filterPresets:
+  - ["all"]
+  - ["response", "user"]
+  - ["commit"]
+
+# Defaults for \`agenthud report\` (CLI flags still win per-invocation).
+# include: activity types to keep. Types: user, response, bash, edit,
+#          thinking, read, glob.
+# detailLimit: max chars per activity detail (0 = unlimited).
+# withGit: merge git commits from each session's project.
+# format: markdown | json.
+report:
+  include: [user, response, bash, edit, thinking]
+  detailLimit: 120
+  withGit: false
+  format: markdown
+
+# Defaults for \`agenthud summary\`. Any field omitted here is inherited
+# from \`report\` above. \`model\` is summary-specific and passed to
+# \`claude --model\` (e.g. sonnet, haiku, or a full model id).
+summary:
+  withGit: true
+  detailLimit: 0
+  # model: sonnet
+`;
+  try {
+    writeFileSync(CONFIG_PATH, defaultYaml, "utf-8");
+  } catch {
+  }
+}
+function writeState(state) {
+  ensureAgenthudDir();
+  try {
+    writeFileSync(STATE_PATH, stringifyYaml(state), "utf-8");
+  } catch {
+  }
+}
+function rewriteConfigWithoutHideFields(raw) {
+  const cleaned = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (k === "hiddenSessions" || k === "hiddenSubAgents" || k === "hiddenProjects")
+      continue;
+    cleaned[k] = v;
+  }
+  try {
+    writeFileSync(CONFIG_PATH, stringifyYaml(cleaned), "utf-8");
+  } catch {
+  }
+}
+function loadGlobalConfig() {
+  const config = {
+    ...DEFAULT_GLOBAL_CONFIG,
+    hiddenSessions: [...DEFAULT_GLOBAL_CONFIG.hiddenSessions],
+    hiddenSubAgents: [...DEFAULT_GLOBAL_CONFIG.hiddenSubAgents],
+    hiddenProjects: [...DEFAULT_GLOBAL_CONFIG.hiddenProjects],
+    filterPresets: DEFAULT_GLOBAL_CONFIG.filterPresets.map((p) => [...p]),
+    report: {
+      ...DEFAULT_GLOBAL_CONFIG.report,
+      include: [...DEFAULT_GLOBAL_CONFIG.report.include]
+    },
+    summary: { ...DEFAULT_GLOBAL_CONFIG.summary }
+  };
+  let configRaw = {};
+  let configHadHideFields = false;
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      const text = readFileSync(CONFIG_PATH, "utf-8");
+      configRaw = parseYaml(text) ?? {};
+    } catch {
+      configRaw = {};
+    }
+  } else {
+    writeDefaultConfig();
+  }
+  if (typeof configRaw.refreshInterval === "string") {
+    const ms = parseInterval(configRaw.refreshInterval);
+    if (ms !== null) config.refreshIntervalMs = ms;
+  }
+  if (Array.isArray(configRaw.filterPresets)) {
+    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;
+  }
+  if (configRaw.report && typeof configRaw.report === "object") {
+    const r = configRaw.report;
+    if (Array.isArray(r.include)) {
+      const tokens = r.include.filter(
+        (t) => typeof t === "string"
+      );
+      const cleaned = tokens.filter((t) => ALLOWED_INCLUDE_TYPES.has(t));
+      if (cleaned.length > 0) config.report.include = cleaned;
+    }
+    if (typeof r.detailLimit === "number" && Number.isInteger(r.detailLimit) && r.detailLimit >= 0) {
+      config.report.detailLimit = r.detailLimit;
+    }
+    if (typeof r.withGit === "boolean") config.report.withGit = r.withGit;
+    if (r.format === "markdown" || r.format === "json") config.report.format = r.format;
+  }
+  if (configRaw.summary && typeof configRaw.summary === "object") {
+    const s = configRaw.summary;
+    if (Array.isArray(s.include)) {
+      const tokens = s.include.filter(
+        (t) => typeof t === "string"
+      );
+      const cleaned = tokens.filter((t) => ALLOWED_INCLUDE_TYPES.has(t));
+      if (cleaned.length > 0) config.summary.include = cleaned;
+    }
+    if (typeof s.detailLimit === "number" && Number.isInteger(s.detailLimit) && s.detailLimit >= 0) {
+      config.summary.detailLimit = s.detailLimit;
+    }
+    if (typeof s.withGit === "boolean") config.summary.withGit = s.withGit;
+    if (s.format === "markdown" || s.format === "json") config.summary.format = s.format;
+    if (typeof s.model === "string" && s.model.trim().length > 0) {
+      config.summary.model = s.model.trim();
+    }
+  }
+  const legacyHidden = {};
+  for (const key of [
+    "hiddenSessions",
+    "hiddenSubAgents",
+    "hiddenProjects"
+  ]) {
+    if (Array.isArray(configRaw[key])) {
+      configHadHideFields = true;
+      legacyHidden[key] = configRaw[key].filter(
+        (s) => typeof s === "string"
+      );
+    }
+  }
+  let stateRaw = {};
+  if (existsSync(STATE_PATH)) {
+    try {
+      const text = readFileSync(STATE_PATH, "utf-8");
+      stateRaw = parseYaml(text) ?? {};
+    } catch {
+      stateRaw = {};
+    }
+  }
+  for (const key of [
+    "hiddenSessions",
+    "hiddenSubAgents",
+    "hiddenProjects"
+  ]) {
+    if (Array.isArray(stateRaw[key])) {
+      config[key] = stateRaw[key].filter(
+        (s) => typeof s === "string"
+      );
+    }
+  }
+  if (configHadHideFields) {
+    const merged = {
+      hiddenSessions: config.hiddenSessions.length > 0 ? config.hiddenSessions : legacyHidden.hiddenSessions ?? [],
+      hiddenSubAgents: config.hiddenSubAgents.length > 0 ? config.hiddenSubAgents : legacyHidden.hiddenSubAgents ?? [],
+      hiddenProjects: config.hiddenProjects.length > 0 ? config.hiddenProjects : legacyHidden.hiddenProjects ?? []
+    };
+    writeState(merged);
+    rewriteConfigWithoutHideFields(configRaw);
+    config.hiddenSessions = merged.hiddenSessions;
+    config.hiddenSubAgents = merged.hiddenSubAgents;
+    config.hiddenProjects = merged.hiddenProjects;
+  }
+  return config;
+}
+function updateState(updates) {
+  let state = {
+    hiddenSessions: [],
+    hiddenSubAgents: [],
+    hiddenProjects: []
+  };
+  if (existsSync(STATE_PATH)) {
+    try {
+      const text = readFileSync(STATE_PATH, "utf-8");
+      const raw = parseYaml(text) ?? {};
+      for (const key of [
+        "hiddenSessions",
+        "hiddenSubAgents",
+        "hiddenProjects"
+      ]) {
+        if (Array.isArray(raw[key])) {
+          state[key] = raw[key].filter(
+            (s) => typeof s === "string"
+          );
+        }
+      }
+    } catch {
+    }
+  }
+  for (const key of [
+    "hiddenSessions",
+    "hiddenSubAgents",
+    "hiddenProjects"
+  ]) {
+    if (updates[key] !== void 0) {
+      state[key] = updates[key];
+    }
+  }
+  writeState(state);
+}
+function hideSession(id) {
+  const config = loadGlobalConfig();
+  if (config.hiddenSessions.includes(id)) return;
+  updateState({ hiddenSessions: [...config.hiddenSessions, id] });
+}
+function hideSubAgent(id) {
+  const config = loadGlobalConfig();
+  if (config.hiddenSubAgents.includes(id)) return;
+  updateState({ hiddenSubAgents: [...config.hiddenSubAgents, id] });
+}
+function hideProject(name) {
+  const config = loadGlobalConfig();
+  if (config.hiddenProjects.includes(name)) return;
+  updateState({ hiddenProjects: [...config.hiddenProjects, name] });
+}
+function hasProjectLevelConfig() {
+  const candidate = join(process.cwd(), ".agenthud", "config.yaml");
+  if (candidate === join(homedir(), ".agenthud", "config.yaml")) return false;
+  return existsSync(candidate);
+}
+
+// src/cli.ts
 var ALL_TYPES = [
   "response",
   "bash",
@@ -19,7 +310,6 @@ var ALL_TYPES = [
   "glob",
   "user"
 ];
-var DEFAULT_TYPES = ["user", "response", "bash", "edit", "thinking"];
 var KNOWN_WATCH_FLAGS = /* @__PURE__ */ new Set([
   "-w",
   "--watch",
@@ -46,7 +336,15 @@ var KNOWN_SUMMARY_FLAGS = /* @__PURE__ */ new Set([
   "--force",
   "--model",
   "-y",
-  "--yes"
+  "--yes",
+  "--include",
+  "--format",
+  "--detail-limit",
+  "--with-git",
+  "-o",
+  "--open",
+  "-I",
+  "--open-index"
 ]);
 var KNOWN_SUBCOMMANDS = /* @__PURE__ */ new Set(["watch", "report", "summary"]);
 function getHelp() {
@@ -81,7 +379,8 @@ Commands:
                                 project into the timeline
 
   summary [--date DATE | --last Nd | --from DATE --to DATE]
-          [--prompt TEXT] [--force] [--model NAME] [-y]
+          [--include TYPES] [--detail-limit N] [--with-git]
+          [--prompt TEXT] [--force] [--model NAME] [-y] [-o]
                                 Generate an LLM summary via the claude
                                 CLI. A single day produces a daily
                                 summary; a date range produces a
@@ -91,12 +390,27 @@ Commands:
                                 (e.g. --last 7d)
     --from YYYY-MM-DD           Range start (use with --to)
     --to YYYY-MM-DD             Range end (use with --from)
+    --include TYPES             Activity types fed to the LLM
+                                (same shape as report's --include)
+    --detail-limit N            Max chars per activity detail in the
+                                LLM payload (0 = unlimited)
+    --with-git                  Merge git commits into the LLM payload
     --prompt TEXT               Override prompt for this run (daily only)
     --force                     Regenerate even if cached
     --model NAME                Pass --model to claude (e.g. "sonnet",
                                 "haiku", or a full model id)
     -y, --yes                   Skip confirmation prompts for new daily
                                 summaries
+    -o, --open                  Launch the resulting summary in your OS
+                                default app once it's written (or read
+                                back from cache).
+    -I, --open-index            Launch ~/.agenthud/summaries/index.md
+                                in your OS default app. Combinable with
+                                -o (e.g. -oI opens both).
+
+  Defaults for report and summary live under \`report:\` and \`summary:\`
+  in ~/.agenthud/config.yaml. Flags override config values per-run; the
+  effective values are printed to stderr at the start of each run.
 
 Global options:
   -V, --version                 Show version number
@@ -112,7 +426,7 @@ Config: ~/.agenthud/config.yaml
 function getVersion() {
   const __dirname2 = dirname(fileURLToPath(import.meta.url));
   const packageJson = JSON.parse(
-    readFileSync(join(__dirname2, "..", "package.json"), "utf-8")
+    readFileSync2(join2(__dirname2, "..", "package.json"), "utf-8")
   );
   return packageJson.version;
 }
@@ -138,11 +452,24 @@ function parseLocalMidnight(dateStr) {
   if (Number.isNaN(date.getTime())) return null;
   return date;
 }
+function formatEffectiveOptionsLine(command, fields) {
+  const parts = [];
+  parts.push(`include=[${fields.include.join(",")}]`);
+  if (fields.detailLimit !== void 0) {
+    parts.push(
+      `detail-limit=${fields.detailLimit === 0 ? "\u221E" : fields.detailLimit}`
+    );
+  }
+  parts.push(`with-git=${fields.withGit ? "on" : "off"}`);
+  if (fields.format) parts.push(`format=${fields.format}`);
+  if (fields.model) parts.push(`model=${fields.model}`);
+  return `${command} \u2192 ${parts.join(" ")}`;
+}
 function todayLocalMidnight() {
   const now = /* @__PURE__ */ new Date();
   return new Date(now.getFullYear(), now.getMonth(), now.getDate());
 }
-function parseArgs(args) {
+function parseArgs(args, config) {
   if (args[0] === "watch") args = args.slice(1);
   if (args.includes("--help") || args.includes("-h")) {
     return { mode: "watch", command: "help" };
@@ -156,7 +483,7 @@ function parseArgs(args) {
   if (args[0] === "report") {
     const rest = args.slice(1);
     let reportDate = todayLocalMidnight();
-    let reportInclude = DEFAULT_TYPES;
+    let reportInclude = config?.report.include ?? DEFAULT_INCLUDE_TYPES;
     let reportError;
     const FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
       "--date",
@@ -204,7 +531,7 @@ function parseArgs(args) {
         }
       }
     }
-    let reportFormat = "markdown";
+    let reportFormat = config?.report.format ?? "markdown";
     const formatIdx = rest.indexOf("--format");
     if (formatIdx !== -1) {
       const fmt = rest[formatIdx + 1];
@@ -216,7 +543,7 @@ function parseArgs(args) {
         reportError = "Invalid format: missing value for --format.";
       }
     }
-    let reportDetailLimit;
+    let reportDetailLimit = config?.report.detailLimit;
     const detailLimitIdx = rest.indexOf("--detail-limit");
     if (detailLimitIdx !== -1) {
       const val = rest[detailLimitIdx + 1];
@@ -227,7 +554,7 @@ function parseArgs(args) {
         reportDetailLimit = n;
       }
     }
-    const reportWithGit = rest.includes("--with-git");
+    const reportWithGit = rest.includes("--with-git") || (config?.report.withGit ?? false);
     return {
       mode: "report",
       reportDate,
@@ -254,7 +581,10 @@ function parseArgs(args) {
       "--from",
       "--to",
       "--prompt",
-      "--model"
+      "--model",
+      "--include",
+      "--format",
+      "--detail-limit"
     ]);
     for (let i = 0; i < rest.length; i++) {
       const arg = rest[i];
@@ -352,239 +682,91 @@ function parseArgs(args) {
       if (!val) {
         summaryError = "Invalid --model: missing value (e.g. --model sonnet).";
       } else {
-        summaryModel = val;
-      }
-    }
-    if (rest.includes("--force")) summaryForce = true;
-    if (rest.includes("-y") || rest.includes("--yes")) summaryAssumeYes = true;
-    return {
-      mode: "summary",
-      summaryDate,
-      summaryFrom,
-      summaryTo,
-      summaryPrompt,
-      summaryForce,
-      summaryAssumeYes,
-      summaryModel,
-      summaryError
-    };
-  }
-  if (args[0] && !args[0].startsWith("-") && !KNOWN_SUBCOMMANDS.has(args[0])) {
-    return {
-      mode: "watch",
-      error: `Unknown command: "${args[0]}". Run agenthud --help for usage.`
-    };
-  }
-  for (const arg of args) {
-    if (arg.startsWith("-") && !KNOWN_WATCH_FLAGS.has(arg)) {
-      return {
-        mode: "watch",
-        error: `Unknown option: "${arg}". Run agenthud --help for usage.`
-      };
-    }
-  }
-  return args.includes("--cwd") ? { mode: "watch", scopeToCwd: true } : { mode: "watch" };
-}
-
-// src/config/globalConfig.ts
-import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join as join2 } 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 DEFAULT_GLOBAL_CONFIG = {
-  refreshIntervalMs: 2e3,
-  hiddenSessions: [],
-  hiddenSubAgents: [],
-  // [] 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;
-  const n = parseInt(match[1], 10);
-  return match[2] === "m" ? n * 60 * 1e3 : n * 1e3;
-}
-function ensureAgenthudDir() {
-  const dir = join2(homedir(), ".agenthud");
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-}
-function writeDefaultConfig() {
-  ensureAgenthudDir();
-  const defaultYaml = `# AgentHUD user settings.
-# App-managed state (hidden sessions/projects) lives in state.yaml.
-
-# How often to poll for activity updates
-refreshInterval: 2s
-
-# Activity filter presets (cycle with 'f' key in viewer)
-# Each list is one preset. Use "all" (or "*") to show everything.
-# Types: response, user, bash, edit, thinking, read, glob, commit
-filterPresets:
-  - ["all"]
-  - ["response", "user"]
-  - ["commit"]
-`;
-  try {
-    writeFileSync(CONFIG_PATH, defaultYaml, "utf-8");
-  } catch {
-  }
-}
-function writeState(state) {
-  ensureAgenthudDir();
-  try {
-    writeFileSync(STATE_PATH, stringifyYaml(state), "utf-8");
-  } catch {
-  }
-}
-function rewriteConfigWithoutHideFields(raw) {
-  const cleaned = {};
-  for (const [k, v] of Object.entries(raw)) {
-    if (k === "hiddenSessions" || k === "hiddenSubAgents" || k === "hiddenProjects")
-      continue;
-    cleaned[k] = v;
-  }
-  try {
-    writeFileSync(CONFIG_PATH, stringifyYaml(cleaned), "utf-8");
-  } catch {
-  }
-}
-function loadGlobalConfig() {
-  const config = { ...DEFAULT_GLOBAL_CONFIG };
-  let configRaw = {};
-  let configHadHideFields = false;
-  if (existsSync(CONFIG_PATH)) {
-    try {
-      const text = readFileSync2(CONFIG_PATH, "utf-8");
-      configRaw = parseYaml(text) ?? {};
-    } catch {
-      configRaw = {};
-    }
-  } else {
-    writeDefaultConfig();
-  }
-  if (typeof configRaw.refreshInterval === "string") {
-    const ms = parseInterval(configRaw.refreshInterval);
-    if (ms !== null) config.refreshIntervalMs = ms;
-  }
-  if (Array.isArray(configRaw.filterPresets)) {
-    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 = {};
-  for (const key of [
-    "hiddenSessions",
-    "hiddenSubAgents",
-    "hiddenProjects"
-  ]) {
-    if (Array.isArray(configRaw[key])) {
-      configHadHideFields = true;
-      legacyHidden[key] = configRaw[key].filter(
-        (s) => typeof s === "string"
-      );
-    }
-  }
-  let stateRaw = {};
-  if (existsSync(STATE_PATH)) {
-    try {
-      const text = readFileSync2(STATE_PATH, "utf-8");
-      stateRaw = parseYaml(text) ?? {};
-    } catch {
-      stateRaw = {};
-    }
-  }
-  for (const key of [
-    "hiddenSessions",
-    "hiddenSubAgents",
-    "hiddenProjects"
-  ]) {
-    if (Array.isArray(stateRaw[key])) {
-      config[key] = stateRaw[key].filter(
-        (s) => typeof s === "string"
-      );
-    }
-  }
-  if (configHadHideFields) {
-    const merged = {
-      hiddenSessions: config.hiddenSessions.length > 0 ? config.hiddenSessions : legacyHidden.hiddenSessions ?? [],
-      hiddenSubAgents: config.hiddenSubAgents.length > 0 ? config.hiddenSubAgents : legacyHidden.hiddenSubAgents ?? [],
-      hiddenProjects: config.hiddenProjects.length > 0 ? config.hiddenProjects : legacyHidden.hiddenProjects ?? []
-    };
-    writeState(merged);
-    rewriteConfigWithoutHideFields(configRaw);
-    config.hiddenSessions = merged.hiddenSessions;
-    config.hiddenSubAgents = merged.hiddenSubAgents;
-    config.hiddenProjects = merged.hiddenProjects;
-  }
-  return config;
-}
-function updateState(updates) {
-  let state = {
-    hiddenSessions: [],
-    hiddenSubAgents: [],
-    hiddenProjects: []
-  };
-  if (existsSync(STATE_PATH)) {
-    try {
-      const text = readFileSync2(STATE_PATH, "utf-8");
-      const raw = parseYaml(text) ?? {};
-      for (const key of [
-        "hiddenSessions",
-        "hiddenSubAgents",
-        "hiddenProjects"
-      ]) {
-        if (Array.isArray(raw[key])) {
-          state[key] = raw[key].filter(
-            (s) => typeof s === "string"
-          );
+        summaryModel = val;
+      }
+    }
+    if (rest.includes("--force")) summaryForce = true;
+    if (rest.includes("-y") || rest.includes("--yes")) summaryAssumeYes = true;
+    const summaryOpen = rest.includes("--open") || rest.includes("-o") || void 0;
+    const summaryOpenIndex = rest.includes("--open-index") || rest.includes("-I") || void 0;
+    let summaryInclude = config?.summary.include ?? config?.report.include ?? DEFAULT_INCLUDE_TYPES;
+    const summaryIncludeIdx = rest.indexOf("--include");
+    if (summaryIncludeIdx !== -1) {
+      const includeStr = rest[summaryIncludeIdx + 1];
+      if (!includeStr) {
+        summaryError = summaryError ?? "Invalid --include: missing value.";
+      } else if (includeStr === "all") {
+        summaryInclude = ALL_TYPES;
+      } else {
+        const tokens = includeStr.split(",").map((s) => s.trim()).filter(Boolean);
+        const unknown = tokens.filter((t) => !ALL_TYPES.includes(t));
+        if (unknown.length > 0) {
+          summaryError = summaryError ?? `Unknown --include type${unknown.length > 1 ? "s" : ""}: ${unknown.map((u) => `"${u}"`).join(", ")}. Valid types: ${ALL_TYPES.join(", ")} (or "all").`;
+        } else {
+          summaryInclude = tokens;
         }
       }
-    } catch {
     }
+    let summaryFormat = config?.summary.format ?? config?.report.format ?? "markdown";
+    const summaryFormatIdx = rest.indexOf("--format");
+    if (summaryFormatIdx !== -1) {
+      const fmt = rest[summaryFormatIdx + 1];
+      if (fmt === "json" || fmt === "markdown") {
+        summaryFormat = fmt;
+      } else if (fmt) {
+        summaryError = summaryError ?? `Invalid format: "${fmt}". Use "markdown" or "json".`;
+      } else {
+        summaryError = summaryError ?? "Invalid format: missing value for --format.";
+      }
+    }
+    let summaryDetailLimit = config?.summary.detailLimit ?? config?.report.detailLimit;
+    const summaryDetailLimitIdx = rest.indexOf("--detail-limit");
+    if (summaryDetailLimitIdx !== -1) {
+      const val = rest[summaryDetailLimitIdx + 1];
+      const n = Number(val);
+      if (!val || Number.isNaN(n) || n < 0 || !Number.isInteger(n)) {
+        summaryError = summaryError ?? `Invalid --detail-limit: "${val}". Must be a non-negative integer.`;
+      } else {
+        summaryDetailLimit = n;
+      }
+    }
+    const summaryWithGit = rest.includes("--with-git") || (config?.summary.withGit ?? config?.report.withGit ?? false);
+    if (summaryModel === void 0 && config?.summary.model) {
+      summaryModel = config.summary.model;
+    }
+    return {
+      mode: "summary",
+      summaryDate,
+      summaryFrom,
+      summaryTo,
+      summaryPrompt,
+      summaryForce,
+      summaryAssumeYes,
+      summaryModel,
+      summaryInclude,
+      summaryFormat,
+      summaryDetailLimit,
+      summaryWithGit,
+      summaryOpen,
+      summaryOpenIndex,
+      summaryError
+    };
   }
-  for (const key of [
-    "hiddenSessions",
-    "hiddenSubAgents",
-    "hiddenProjects"
-  ]) {
-    if (updates[key] !== void 0) {
-      state[key] = updates[key];
+  if (args[0] && !args[0].startsWith("-") && !KNOWN_SUBCOMMANDS.has(args[0])) {
+    return {
+      mode: "watch",
+      error: `Unknown command: "${args[0]}". Run agenthud --help for usage.`
+    };
+  }
+  for (const arg of args) {
+    if (arg.startsWith("-") && !KNOWN_WATCH_FLAGS.has(arg)) {
+      return {
+        mode: "watch",
+        error: `Unknown option: "${arg}". Run agenthud --help for usage.`
+      };
     }
   }
-  writeState(state);
-}
-function hideSession(id) {
-  const config = loadGlobalConfig();
-  if (config.hiddenSessions.includes(id)) return;
-  updateState({ hiddenSessions: [...config.hiddenSessions, id] });
-}
-function hideSubAgent(id) {
-  const config = loadGlobalConfig();
-  if (config.hiddenSubAgents.includes(id)) return;
-  updateState({ hiddenSubAgents: [...config.hiddenSubAgents, id] });
-}
-function hideProject(name) {
-  const config = loadGlobalConfig();
-  if (config.hiddenProjects.includes(name)) return;
-  updateState({ hiddenProjects: [...config.hiddenProjects, name] });
-}
-function hasProjectLevelConfig() {
-  const candidate = join2(process.cwd(), ".agenthud", "config.yaml");
-  if (candidate === join2(homedir(), ".agenthud", "config.yaml")) return false;
-  return existsSync(candidate);
+  return args.includes("--cwd") ? { mode: "watch", scopeToCwd: true } : { mode: "watch" };
 }
 
 // src/data/reportGenerator.ts
@@ -1481,56 +1663,435 @@ function discoverSessions(config, options2) {
 }
 
 // src/data/summaryRunner.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import {
   copyFileSync,
   createWriteStream,
-  existsSync as existsSync4,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync5,
-  unlinkSync
+  readFileSync as readFileSync7,
+  unlinkSync,
+  writeFileSync as writeFileSync3
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname2, join as join4 } from "path";
+import { dirname as dirname2, join as join6 } from "path";
 import { createInterface } from "readline";
 import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/utils/openInDefaultApp.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { join as join4 } from "path";
+function buildOpenCommand(platform, path, opts = {}) {
+  switch (platform) {
+    case "darwin":
+      return { command: "open", args: [path] };
+    case "linux":
+      if (opts.wslView) return { command: "wslview", args: [path] };
+      return { command: "xdg-open", args: [path] };
+    case "win32":
+      return { command: "cmd", args: ["/c", "start", "", path] };
+    default:
+      return null;
+  }
+}
+function isWSL() {
+  if (process.env.WSL_DISTRO_NAME) return true;
+  try {
+    const ver = readFileSync5("/proc/version", "utf-8");
+    return /microsoft|wsl/i.test(ver);
+  } catch {
+    return false;
+  }
+}
+function commandExists(command) {
+  const PATH = process.env.PATH ?? "";
+  const sep = process.platform === "win32" ? ";" : ":";
+  const exts = process.platform === "win32" ? (process.env.PATHEXT?.split(";") ?? [".EXE", ".CMD", ".BAT"]).map(
+    (e) => e.toLowerCase()
+  ) : [""];
+  for (const dir of PATH.split(sep)) {
+    if (!dir) continue;
+    const full = join4(dir, command);
+    for (const ext of exts) {
+      try {
+        if (existsSync4(full + ext)) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+async function openInDefaultApp(path) {
+  const wslView = isWSL() && commandExists("wslview");
+  const cmd = buildOpenCommand(process.platform, path, { wslView });
+  if (!cmd) {
+    process.stderr.write(
+      `agenthud: --open: no known opener for platform "${process.platform}"
+`
+    );
+    return;
+  }
+  if (!commandExists(cmd.command)) {
+    process.stderr.write(
+      `agenthud: --open: '${cmd.command}' is not on PATH; cannot open ${path}
+`
+    );
+    if (isWSL()) {
+      process.stderr.write(
+        "agenthud: hint: on WSL install `wslu` (provides wslview) so files open with the Windows host's default app \u2014 e.g. `sudo apt install wslu`\n"
+      );
+    }
+    return;
+  }
+  await new Promise((resolve2) => {
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      resolve2();
+    };
+    let child;
+    try {
+      child = spawn(cmd.command, cmd.args, {
+        detached: true,
+        stdio: "ignore"
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`agenthud: --open failed: ${msg}
+`);
+      finish();
+      return;
+    }
+    child.on("error", (err) => {
+      process.stderr.write(`agenthud: --open failed: ${err.message}
+`);
+      finish();
+    });
+    child.on("exit", (code) => {
+      if (code !== null && code !== 0) {
+        process.stderr.write(
+          `agenthud: --open: '${cmd.command}' exited with code ${code}
+`
+        );
+      }
+      finish();
+    });
+    setTimeout(() => {
+      if (!settled) {
+        child.unref();
+        finish();
+      }
+    }, 200).unref();
+  });
+}
+
+// src/data/summariesIndex.ts
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
+var INDEX_HEADER_MARKER = "<!-- agenthud-summaries-index -->";
+var BACKLINK_START_MARKER = "<!-- agenthud-backlinks-start -->";
+var BACKLINK_END_MARKER = "<!-- agenthud-backlinks-end -->";
+var DAILY_RE = /^(\d{4})-(\d{2})-(\d{2})\.md$/;
+var RANGE_RE = /^range-(\d{4})-(\d{2})-(\d{2})_(\d{4})-(\d{2})-(\d{2})\.md$/;
+function makeLocalDate(y, m, d) {
+  const date = new Date(y, m - 1, d);
+  if (date.getFullYear() !== y || date.getMonth() !== m - 1 || date.getDate() !== d) {
+    return null;
+  }
+  return date;
+}
+function parseSummaryFilename(name) {
+  const range = RANGE_RE.exec(name);
+  if (range) {
+    const from = makeLocalDate(
+      Number(range[1]),
+      Number(range[2]),
+      Number(range[3])
+    );
+    const to = makeLocalDate(
+      Number(range[4]),
+      Number(range[5]),
+      Number(range[6])
+    );
+    if (!from || !to) return null;
+    return { kind: "range", from, to, filename: name };
+  }
+  const daily = DAILY_RE.exec(name);
+  if (daily) {
+    const date = makeLocalDate(
+      Number(daily[1]),
+      Number(daily[2]),
+      Number(daily[3])
+    );
+    if (!date) return null;
+    return { kind: "daily", date, filename: name };
+  }
+  return null;
+}
+function listSummaries(dir) {
+  if (!existsSync5(dir)) return [];
+  let names;
+  try {
+    names = readdirSync2(dir);
+  } catch {
+    return [];
+  }
+  const entries = names.map((n) => parseSummaryFilename(n)).filter((e) => e !== null);
+  const anchor = (e) => e.kind === "range" ? e.from : e.date;
+  entries.sort((a, b) => {
+    const da = anchor(a);
+    const db = anchor(b);
+    if (da.getFullYear() !== db.getFullYear()) {
+      return db.getFullYear() - da.getFullYear();
+    }
+    if (da.getMonth() !== db.getMonth()) {
+      return db.getMonth() - da.getMonth();
+    }
+    if (a.kind !== b.kind) return a.kind === "range" ? -1 : 1;
+    return db.getTime() - da.getTime();
+  });
+  return entries;
+}
+var MONTHS = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var WEEKDAYS_SHORT = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var WEEKDAYS_LONG = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday"
+];
+function formatDateKey(d) {
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function formatDateLabel(d) {
+  return `${formatDateKey(d)} (${WEEKDAYS_SHORT[d.getDay()]})`;
+}
+function entryAnchor(e) {
+  return e.kind === "range" ? e.from : e.date;
+}
+function buildIndexMarkdown(entries, snippets) {
+  const lines = [INDEX_HEADER_MARKER, "", "# AgentHUD summaries", ""];
+  if (entries.length === 0) {
+    lines.push("_No summaries yet. Run `agenthud summary` to create one._");
+    return `${lines.join("\n")}
+`;
+  }
+  const byYear = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const a = entryAnchor(entry);
+    const y = a.getFullYear();
+    const m = a.getMonth();
+    const months = byYear.get(y) ?? /* @__PURE__ */ new Map();
+    const bucket = months.get(m) ?? [];
+    bucket.push(entry);
+    months.set(m, bucket);
+    byYear.set(y, months);
+  }
+  for (const [year, months] of byYear) {
+    lines.push(`## ${year}`, "");
+    for (const [month, bucket] of months) {
+      lines.push(`### ${MONTHS[month]}`);
+      for (const entry of bucket) {
+        const snippet = snippets?.get(entry.filename);
+        const trail = snippet ? ` \u2014 ${snippet}` : "";
+        if (entry.kind === "range") {
+          const fromIso = formatDateKey(entry.from);
+          const toIso = formatDateKey(entry.to);
+          lines.push(
+            `- [Range: ${fromIso} \u2192 ${toIso}](./${entry.filename}) \xB7 weekly${trail}`
+          );
+        } else {
+          lines.push(
+            `- [${formatDateLabel(entry.date)}](./${entry.filename})${trail}`
+          );
+        }
+      }
+      lines.push("");
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function buildTitleLine(entry) {
+  if (entry.kind === "range") {
+    return `# Range: ${formatDateKey(entry.from)} \u2192 ${formatDateKey(entry.to)}`;
+  }
+  const iso = formatDateKey(entry.date);
+  const weekday = WEEKDAYS_LONG[entry.date.getDay()];
+  return `# ${iso} (${weekday})`;
+}
+function buildHeaderBlock(currentFilename, entries) {
+  const parts = ["[\u2190 all summaries](./index.md)"];
+  const me = entries.find((e) => e.filename === currentFilename);
+  if (me && me.kind === "daily") {
+    const dailies = entries.filter((e) => e.kind === "daily").sort((a, b) => a.date.getTime() - b.date.getTime());
+    const idx = dailies.findIndex((e) => e.filename === currentFilename);
+    if (idx > 0) {
+      const prev = dailies[idx - 1];
+      parts.push(
+        `[\u2190 ${formatDateLabel(prev.date)}](./${prev.filename})`
+      );
+    }
+    if (idx >= 0 && idx < dailies.length - 1) {
+      const next = dailies[idx + 1];
+      parts.push(
+        `[${formatDateLabel(next.date)} \u2192](./${next.filename})`
+      );
+    }
+  }
+  const backlinkLine = parts.join(" \xB7 ");
+  const title = me ? buildTitleLine(me) : "";
+  return `${BACKLINK_START_MARKER}
+${backlinkLine}
+
+${title}
+${BACKLINK_END_MARKER}
+
+`;
+}
+function stripExistingHeaderBlock(content) {
+  if (!content.startsWith(BACKLINK_START_MARKER)) return content;
+  const endIdx = content.indexOf(BACKLINK_END_MARKER);
+  if (endIdx === -1) return content;
+  let cut = endIdx + BACKLINK_END_MARKER.length;
+  while (cut < content.length && (content[cut] === "\n" || content[cut] === "\r")) {
+    cut++;
+  }
+  return content.slice(cut);
+}
+function prependHeaderBlock(content, block) {
+  return block + stripExistingHeaderBlock(content);
+}
+function extractContextSnippet(content, maxChars = 200) {
+  const body = stripExistingHeaderBlock(content);
+  for (const raw of body.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (line.startsWith("#")) continue;
+    if (line.startsWith("<!--")) continue;
+    if (line.length <= maxChars) return line;
+    return `${line.slice(0, maxChars - 1).trimEnd()}\u2026`;
+  }
+  return null;
+}
+function regenerateIndex(summariesDir2) {
+  const entries = listSummaries(summariesDir2);
+  const snippets = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const path = join5(summariesDir2, entry.filename);
+    try {
+      const content = readFileSync6(path, "utf-8");
+      const snippet = extractContextSnippet(content);
+      if (snippet) snippets.set(entry.filename, snippet);
+      const block = buildHeaderBlock(entry.filename, entries);
+      const updated = prependHeaderBlock(content, block);
+      if (updated !== content) {
+        writeFileSync2(path, updated, "utf-8");
+      }
+    } catch {
+    }
+  }
+  const indexPath = join5(summariesDir2, "index.md");
+  try {
+    writeFileSync2(
+      indexPath,
+      buildIndexMarkdown(entries, snippets),
+      "utf-8"
+    );
+  } catch (err) {
+    process.stderr.write(
+      `warning: cannot write summaries index (${err.message})
+`
+    );
+  }
+}
+
+// src/utils/stderrTicker.ts
+function formatTickerLine(label, elapsedSeconds, dots) {
+  const tail = ".".repeat(dots % 4).padEnd(3, " ");
+  return `${label}${tail} ${elapsedSeconds}s`;
+}
+function startStderrTicker(label, options2 = {}) {
+  const intervalMs = options2.intervalMs ?? 500;
+  const stream = options2.stream ?? process.stderr;
+  const start = Date.now();
+  let ticks = 0;
+  const id = setInterval(() => {
+    ticks++;
+    const elapsed = Math.floor((Date.now() - start) / 1e3);
+    stream.write(`\r${formatTickerLine(label, elapsed, ticks)}`);
+  }, intervalMs);
+  return function stop() {
+    clearInterval(id);
+    if (ticks > 0) stream.write("\r\x1B[K");
+  };
+}
+
+// src/data/summaryRunner.ts
 function agenthudHomeDir() {
-  const dir = join4(homedir3(), ".agenthud");
-  if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
+  const dir = join6(homedir3(), ".agenthud");
+  if (!existsSync6(dir)) mkdirSync2(dir, { recursive: true });
   return dir;
 }
 function summariesDir() {
-  const dir = join4(agenthudHomeDir(), "summaries");
-  if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
+  const dir = join6(agenthudHomeDir(), "summaries");
+  if (!existsSync6(dir)) mkdirSync2(dir, { recursive: true });
   return dir;
 }
 function promptFilename(kind) {
   return kind === "daily" ? "summary-prompt.md" : "summary-range-prompt.md";
 }
 function userPromptPath(kind) {
-  return join4(homedir3(), ".agenthud", promptFilename(kind));
+  return join6(homedir3(), ".agenthud", promptFilename(kind));
+}
+function formatPromptSource(kind, override) {
+  if (kind === "daily" && override) {
+    return "<inline> (from --prompt)";
+  }
+  const home = homedir3();
+  const path = userPromptPath(kind);
+  const abbreviated = path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+  return abbreviated.replace(/\\/g, "/");
 }
 function templatePath(kind) {
   const here = dirname2(fileURLToPath2(import.meta.url));
-  return join4(here, "templates", promptFilename(kind));
+  return join6(here, "templates", promptFilename(kind));
 }
 function dateKey(d) {
   return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
 }
 function dailyCachePath(date) {
-  return join4(summariesDir(), `${dateKey(date)}.md`);
+  return join6(summariesDir(), `${dateKey(date)}.md`);
 }
 function rangeCachePath(from, to) {
-  return join4(summariesDir(), `range-${dateKey(from)}_${dateKey(to)}.md`);
+  return join6(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(kind) {
   const p = userPromptPath(kind);
-  if (existsSync4(p)) return;
+  if (existsSync6(p)) return;
   const dir = dirname2(p);
-  if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
+  if (!existsSync6(dir)) mkdirSync2(dir, { recursive: true });
   try {
     copyFileSync(templatePath(kind), p);
   } catch {
@@ -1539,14 +2100,14 @@ function ensureUserPromptFile(kind) {
 function resolvePrompt(kind, override) {
   if (override) return override;
   const p = userPromptPath(kind);
-  if (existsSync4(p)) {
+  if (existsSync6(p)) {
     try {
-      return readFileSync5(p, "utf-8");
+      return readFileSync7(p, "utf-8");
     } catch {
     }
   }
   try {
-    return readFileSync5(templatePath(kind), "utf-8");
+    return readFileSync7(templatePath(kind), "utf-8");
   } catch {
     return "Summarize the input below.";
   }
@@ -1601,7 +2162,7 @@ function spawnClaude(opts) {
     ];
     if (opts.model) args.push("--model", opts.model);
     args.push(opts.prompt);
-    const proc = spawn(
+    const proc = spawn2(
       "claude",
       args,
       {
@@ -1722,11 +2283,11 @@ async function generateDailySummary(opts) {
   const isToday = isSameLocalDay2(opts.date, opts.today);
   const cached = dailyCachePath(opts.date);
   const dateLabel = dateKey(opts.date);
-  if (!isToday && !opts.force && existsSync4(cached)) {
+  if (!isToday && !opts.force && existsSync6(cached)) {
     try {
-      const content = readFileSync5(cached, "utf-8");
+      const content = readFileSync7(cached, "utf-8");
       if (opts.announce) {
-        process.stderr.write(`agenthud: cached summary from ${cached}
+        process.stderr.write(`cached summary from ${cached}
 `);
       }
       if (opts.streamToStdout) {
@@ -1744,7 +2305,7 @@ async function generateDailySummary(opts) {
     }
   }
   if (opts.announce) {
-    process.stderr.write(`agenthud: scanning sessions for ${dateLabel}...
+    process.stderr.write(`scanning sessions for ${dateLabel}...
 `);
   }
   const config = loadGlobalConfig();
@@ -1755,28 +2316,58 @@ async function generateDailySummary(opts) {
   ];
   const reportMarkdown = generateReport(flatSessions, {
     date: opts.date,
-    include: ["response", "bash", "edit", "thinking"],
+    include: opts.include,
+    // The LLM only ingests markdown — the format option on summary is
+    // for the report-extraction *export* surface (post-LLM), not for
+    // the payload itself, so this stays fixed.
     format: "markdown",
-    detailLimit: 0,
-    withGit: true
+    detailLimit: opts.detailLimit,
+    withGit: opts.withGit
   });
   const reportBytes = Buffer.byteLength(reportMarkdown, "utf-8");
   const estimatedTokens = Math.ceil(reportBytes / 4);
+  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;
   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 = (reportBytes / 1024).toFixed(1);
     process.stderr.write(
-      `agenthud: input: ${sessionCount} sessions, ${activityCount} activities, ${commitCount} commits (${reportLines.length} lines, ${sizeKb}KB \u2248 ${estimatedTokens.toLocaleString()} tokens)
+      `input: ${sessionCount} sessions, ${activityCount} activities, ${commitCount} commits (${reportLines.length} lines, ${sizeKb}KB \u2248 ${estimatedTokens.toLocaleString()} tokens)
 `
     );
   }
+  if (sessionCount === 0 && activityCount === 0 && commitCount === 0) {
+    const stub = `## Context
+
+No activity recorded for ${dateLabel}.
+No claude call was issued \u2014 the report was empty.
+`;
+    try {
+      writeFileSync3(cached, stub, "utf-8");
+    } catch {
+    }
+    if (opts.announce) {
+      process.stderr.write(
+        `${dateLabel} has no activity \u2014 wrote stub to ${cached}, skipped claude
+`
+      );
+    }
+    if (opts.streamToStdout) {
+      process.stdout.write(stub);
+    }
+    return {
+      code: 0,
+      markdown: stub,
+      fromCache: false,
+      skipped: false,
+      usage: null
+    };
+  }
   if (opts.confirmBeforeSpawn) {
     const proceed = await opts.confirmBeforeSpawn();
     if (!proceed) {
@@ -1812,13 +2403,15 @@ async function generateDailySummary(opts) {
       }
     }
   }
-  if (opts.announce) {
+  const showTicker = opts.announce && !opts.streamToStdout;
+  if (opts.announce && !showTicker) {
     process.stderr.write(
-      `agenthud: sending to claude (this may take a minute)...
+      `sending to claude (this may take a minute)...
 
 `
     );
   }
+  const stopTicker = showTicker ? startStderrTicker("sending to claude") : null;
   const prompt = resolvePrompt("daily", opts.promptOverride);
   const result = await spawnClaude({
     prompt,
@@ -1827,12 +2420,13 @@ async function generateDailySummary(opts) {
     streamToStdout: opts.streamToStdout,
     model: opts.model
   });
+  if (stopTicker) stopTicker();
   if (opts.announce && result.code === 0) {
     process.stderr.write("\n");
-    process.stderr.write(`agenthud: saved to ${cached}
+    process.stderr.write(`saved to ${cached}
 `);
     if (result.usage) {
-      process.stderr.write(`agenthud: ${formatUsage(result.usage)}
+      process.stderr.write(`${formatUsage(result.usage)}
 `);
     }
   }
@@ -1850,10 +2444,25 @@ async function runSummary(options2) {
     today: options2.today,
     force: options2.force,
     promptOverride: options2.prompt,
-    streamToStdout: true,
+    streamToStdout: !options2.open,
     announce: true,
-    model: options2.model
+    model: options2.model,
+    include: options2.include,
+    detailLimit: options2.detailLimit,
+    withGit: options2.withGit
   });
+  if (res.code === 0 && !res.skipped) {
+    try {
+      regenerateIndex(summariesDir());
+    } catch {
+    }
+  }
+  if (options2.open && res.code === 0 && !res.skipped) {
+    await openInDefaultApp(dailyCachePath(options2.date));
+  }
+  if (options2.openIndex && res.code === 0 && !res.skipped) {
+    await openInDefaultApp(join6(summariesDir(), "index.md"));
+  }
   return res.code;
 }
 async function runRangeSummary(options2) {
@@ -1867,16 +2476,26 @@ async function runRangeSummary(options2) {
     options2.force,
     dates,
     options2.today,
-    existsSync4(rangeCache)
+    existsSync6(rangeCache)
   )) {
     try {
-      const content = readFileSync5(rangeCache, "utf-8");
+      const content = readFileSync7(rangeCache, "utf-8");
       process.stderr.write(
-        `agenthud: cached range summary from ${rangeCache}
+        `cached range summary from ${rangeCache}
 `
       );
-      process.stdout.write(content);
-      if (!content.endsWith("\n")) process.stdout.write("\n");
+      if (!options2.open) {
+        process.stdout.write(content);
+        if (!content.endsWith("\n")) process.stdout.write("\n");
+      }
+      try {
+        regenerateIndex(summariesDir());
+      } catch {
+      }
+      if (options2.open) await openInDefaultApp(rangeCache);
+      if (options2.openIndex) {
+        await openInDefaultApp(join6(summariesDir(), "index.md"));
+      }
       return 0;
     } catch {
     }
@@ -1885,15 +2504,15 @@ async function runRangeSummary(options2) {
   let missingCount = 0;
   for (const d of dates) {
     const isToday = isSameLocalDay2(d, options2.today);
-    if (!isToday && existsSync4(dailyCachePath(d))) cachedCount++;
+    if (!isToday && existsSync6(dailyCachePath(d))) cachedCount++;
     else missingCount++;
   }
   process.stderr.write(
-    `agenthud: range ${fromLabel} \u2192 ${toLabel} (${dates.length} days)
+    `range ${fromLabel} \u2192 ${toLabel} (${dates.length} days)
 `
   );
   process.stderr.write(
-    `agenthud: ${cachedCount} cached, ${missingCount} to generate
+    `${cachedCount} cached, ${missingCount} to generate
 `
   );
   const dailyMarkdowns = [];
@@ -1902,9 +2521,9 @@ async function runRangeSummary(options2) {
     const label = dateKey(d);
     const isToday = isSameLocalDay2(d, options2.today);
     process.stderr.write(`
-agenthud: --- ${label} ---
+--- ${label} ---
 `);
-    const willPrompt = !options2.assumeYes && (isToday || !existsSync4(dailyCachePath(d)));
+    const willPrompt = !options2.assumeYes && (isToday || !existsSync6(dailyCachePath(d)));
     const confirmer = willPrompt ? async () => {
       const hint = isToday ? " (today \u2014 regenerated every time)" : "";
       return ask(`Generate this summary${hint}? [Y/n] `, true);
@@ -1917,7 +2536,10 @@ agenthud: --- ${label} ---
       announce: true,
       confirmBeforeSpawn: confirmer,
       assumeYes: options2.assumeYes,
-      model: options2.model
+      model: options2.model,
+      include: options2.include,
+      detailLimit: options2.detailLimit,
+      withGit: options2.withGit
     });
     if (res.skipped) {
       process.stderr.write(`agenthud: ${label} \u2014 skipped by user.
@@ -1934,7 +2556,7 @@ agenthud: --- ${label} ---
     }
     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.
+      process.stderr.write(`${label} has no activity \u2014 skipping.
 `);
       continue;
     }
@@ -1949,37 +2571,51 @@ agenthud: --- ${label} ---
 ${markdown}`).join("\n\n---\n\n");
   process.stderr.write(
     `
-agenthud: combining ${dailyMarkdowns.length} daily summaries into range summary...
+combining ${dailyMarkdowns.length} daily summaries into range summary...
 `
   );
-  process.stderr.write(
-    `agenthud: sending to claude (this may take a minute)...
+  const metaStreams = !options2.open;
+  if (!metaStreams) {
+  } else {
+    process.stderr.write(
+      `sending to claude (this may take a minute)...
 
 `
-  );
+    );
+  }
+  const stopMetaTicker = metaStreams ? null : startStderrTicker("sending to claude");
   const metaPrompt = resolvePrompt("range");
   const metaResult = await spawnClaude({
     prompt: metaPrompt,
     stdin: metaInput,
     cachePath: rangeCache,
-    streamToStdout: true,
+    streamToStdout: metaStreams,
     model: options2.model
   });
+  if (stopMetaTicker) stopMetaTicker();
   if (metaResult.code !== 0) {
     return metaResult.code;
   }
   process.stderr.write("\n");
-  process.stderr.write(`agenthud: saved to ${rangeCache}
+  process.stderr.write(`saved to ${rangeCache}
 `);
   if (metaResult.usage) {
-    process.stderr.write(`agenthud: ${formatUsage(metaResult.usage)}
+    process.stderr.write(`${formatUsage(metaResult.usage)}
 `);
   }
+  try {
+    regenerateIndex(summariesDir());
+  } catch {
+  }
+  if (options2.open) await openInDefaultApp(rangeCache);
+  if (options2.openIndex) {
+    await openInDefaultApp(join6(summariesDir(), "index.md"));
+  }
   return 0;
 }
 
 // src/ui/App.tsx
-import { existsSync as existsSync5, watch } from "fs";
+import { existsSync as existsSync7, watch } from "fs";
 import { basename as basename3 } from "path";
 import { Box as Box5, Text as Text5, useApp, useInput, useStdout } from "ink";
 import { useCallback, useEffect as useEffect3, useMemo, useRef, useState as useState3 } from "react";
@@ -2416,6 +3052,7 @@ var SECTIONS = [
     title: "Project tree",
     rows: [
       ["\u2191 \u2193 / k j", "Move selection"],
+      ["\u2190", "Jump to parent (sub-agent \u2192 session, session \u2192 project)"],
       ["PgUp / Ctrl+B", "Page up"],
       ["PgDn / Ctrl+F", "Page down"],
       ["\u21B5", "Expand/collapse project, session, or summary"],
@@ -2565,6 +3202,7 @@ function useHotkeys({
   onHelpScroll,
   onHelpScrollToTop,
   onToggleTracking,
+  onJumpToParent,
   filterLabel,
   trackingOn = false
 }) {
@@ -2684,6 +3322,10 @@ function useHotkeys({
         onHide();
         return;
       }
+      if (key.leftArrow && onJumpToParent) {
+        onJumpToParent();
+        return;
+      }
       if (key.upArrow || input === "k") {
         onScrollUp();
         return;
@@ -2717,6 +3359,7 @@ function useHotkeys({
     ...trackingItems,
     "Tab: viewer",
     "\u2191\u2193/jk: select",
+    "\u2190: parent",
     "PgUp/Dn: page",
     "\u21B5: expand",
     "h: hide",
@@ -3194,7 +3837,8 @@ function appendSubAgentRows(result, session, expandedIds) {
   const sessionExpandedKey = `__expanded-session-${session.id}`;
   const sessionHidden = isCold ? !expandedIds.has(sessionExpandedKey) : expandedIds.has(sessionCollapsedKey);
   if (sessionHidden) return;
-  if (expandedIds.has(session.id)) {
+  const subAgentsFullyExpanded = expandedIds.has(session.id) || isCold && expandedIds.has(sessionExpandedKey);
+  if (subAgentsFullyExpanded) {
     result.push(...session.subAgents);
   } else {
     result.push(
@@ -3322,6 +3966,26 @@ function collectAllIds(tree) {
   }
   return ids;
 }
+function findParentTarget(currentId, tree, flat) {
+  if (currentId.startsWith("__sub-") && currentId.endsWith("__")) {
+    return currentId.slice("__sub-".length, -"__".length);
+  }
+  const allProjects = [...tree.projects, ...tree.coldProjects];
+  const allSessions = allProjects.flatMap((p) => p.sessions);
+  for (const session of allSessions) {
+    if (session.subAgents.some((sa) => sa.id === currentId)) {
+      return session.id;
+    }
+  }
+  for (const project of allProjects) {
+    if (project.sessions.some((s) => s.id === currentId)) {
+      return `__proj-${project.name}__`;
+    }
+  }
+  const idx = flat.findIndex((row) => row.id === currentId);
+  if (idx <= 0) return currentId;
+  return flat[idx - 1]?.id ?? currentId;
+}
 function initialSelectedId(tree) {
   const firstProject = tree.projects[0];
   if (firstProject) return `__proj-${firstProject.name}__`;
@@ -3496,7 +4160,7 @@ function App({
   useEffect3(() => {
     if (!isWatchMode) return;
     const projectsDir = getProjectsDir();
-    const usePolling = process.platform === "linux" || !existsSync5(projectsDir);
+    const usePolling = process.platform === "linux" || !existsSync7(projectsDir);
     if (usePolling) {
       const timer = setInterval(
         () => refreshRef.current(),
@@ -3590,6 +4254,13 @@ function App({
       });
     },
     trackingOn: tracking,
+    onJumpToParent: () => {
+      if (focus !== "tree") return;
+      stopTracking();
+      if (!selectedId) return;
+      const target = findParentTarget(selectedId, sessionTree, allFlat);
+      if (target && target !== selectedId) setSelectedId(target);
+    },
     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++.
@@ -4031,15 +4702,16 @@ function installAltScreenCleanup() {
 }
 
 // src/utils/legacyConfig.ts
-import { join as join5, resolve } from "path";
+import { join as join7, resolve } from "path";
 function isLegacyProjectConfig(cwd, home) {
-  const legacy = resolve(join5(cwd, ".agenthud", "config.yaml"));
-  const global = resolve(join5(home, ".agenthud", "config.yaml"));
+  const legacy = resolve(join7(cwd, ".agenthud", "config.yaml"));
+  const global = resolve(join7(home, ".agenthud", "config.yaml"));
   return legacy !== global;
 }
 
 // src/main.ts
-var options = parseArgs(process.argv.slice(2));
+var globalConfig = loadGlobalConfig();
+var options = parseArgs(process.argv.slice(2), globalConfig);
 if (options.error) {
   process.stderr.write(`agenthud: ${options.error}
 `);
@@ -4053,8 +4725,8 @@ if (options.command === "version") {
   console.log(getVersion());
   process.exit(0);
 }
-var legacyConfig = join6(process.cwd(), ".agenthud", "config.yaml");
-if (isLegacyProjectConfig(process.cwd(), homedir5()) && existsSync6(legacyConfig)) {
+var legacyConfig = join8(process.cwd(), ".agenthud", "config.yaml");
+if (isLegacyProjectConfig(process.cwd(), homedir5()) && existsSync8(legacyConfig)) {
   console.log(
     "The project-level config file (.agenthud/config.yaml) is no longer supported."
   );
@@ -4080,8 +4752,16 @@ if (options.mode === "report") {
 `);
     process.exit(1);
   }
-  const config = loadGlobalConfig();
-  const tree = discoverSessions(config);
+  process.stderr.write(
+    `${formatEffectiveOptionsLine("report", {
+      include: options.reportInclude,
+      detailLimit: options.reportDetailLimit,
+      withGit: options.reportWithGit ?? false,
+      format: options.reportFormat
+    })}
+`
+  );
+  const tree = discoverSessions(globalConfig);
   const flatSessions = [
     ...tree.projects.flatMap((p) => p.sessions),
     ...tree.coldProjects.flatMap((p) => p.sessions)
@@ -4103,6 +4783,23 @@ if (options.mode === "summary") {
 `);
     process.exit(1);
   }
+  process.stderr.write(
+    `${formatEffectiveOptionsLine("summary", {
+      include: options.summaryInclude,
+      detailLimit: options.summaryDetailLimit,
+      withGit: options.summaryWithGit ?? false,
+      model: options.summaryModel
+    })}
+`
+  );
+  const isRangeMode = !!(options.summaryFrom && options.summaryTo);
+  process.stderr.write(
+    `prompt = ${formatPromptSource(
+      isRangeMode ? "range" : "daily",
+      options.summaryPrompt
+    )}
+`
+  );
   const today = /* @__PURE__ */ new Date();
   if (options.summaryFrom && options.summaryTo) {
     const exitCode2 = await runRangeSummary({
@@ -4111,7 +4808,12 @@ if (options.mode === "summary") {
       today,
       force: options.summaryForce ?? false,
       assumeYes: options.summaryAssumeYes ?? false,
-      model: options.summaryModel
+      model: options.summaryModel,
+      include: options.summaryInclude,
+      detailLimit: options.summaryDetailLimit,
+      withGit: options.summaryWithGit,
+      open: options.summaryOpen,
+      openIndex: options.summaryOpenIndex
     });
     process.exit(exitCode2);
   }
@@ -4120,7 +4822,12 @@ if (options.mode === "summary") {
     prompt: options.summaryPrompt,
     force: options.summaryForce ?? false,
     today,
-    model: options.summaryModel
+    model: options.summaryModel,
+    include: options.summaryInclude,
+    detailLimit: options.summaryDetailLimit,
+    withGit: options.summaryWithGit,
+    open: options.summaryOpen,
+    openIndex: options.summaryOpenIndex
   });
   process.exit(exitCode);
 }
@@ -4129,7 +4836,7 @@ if (options.scopeToCwd) {
   const projectsDir = getProjectsDir();
   let registered = [];
   try {
-    registered = readdirSync2(projectsDir).map(decodeProjectPath);
+    registered = readdirSync3(projectsDir).map(decodeProjectPath);
   } catch {
   }
   const safeReal = (p) => {
@@ -4150,7 +4857,7 @@ if (options.scopeToCwd) {
     process.exit(1);
   }
   scopeToProject = match;
-  process.stderr.write(`agenthud: scope = ${match}
+  process.stderr.write(`scope = ${match}
 `);
 }
 if (options.mode === "watch") {