@workscribe/cli 1.10.0 → 1.12.0

package/dist/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --disable-warning=ExperimentalWarning
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -26,24 +26,46 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 // src/index.ts
 var import_commander = require("commander");
 
+// src/utils/node-version.ts
+function assertNodeVersion(nodeVersion) {
+  const major = Number(nodeVersion.split(".")[0]);
+  if (major < 22) {
+    process.stderr.write(
+      `workscribe requires Node.js 22 or later (you have v${nodeVersion}).
+Upgrade at https://nodejs.org or via your version manager:
+  nvm install 22 && nvm use 22
+`
+    );
+    process.exit(1);
+  }
+}
+
 // src/capture/index.ts
-var import_fs9 = __toESM(require("fs"));
+var import_fs10 = __toESM(require("fs"));
 
 // src/db/index.ts
 var import_node_sqlite = require("node:sqlite");
-var import_fs = __toESM(require("fs"));
+var import_fs2 = __toESM(require("fs"));
 
 // src/utils/paths.ts
 var import_path = __toESM(require("path"));
 var import_os = __toESM(require("os"));
-var WORKSCRIBE_DIR = import_path.default.join(import_os.default.homedir(), ".workscribe");
-var DB_PATH = import_path.default.join(WORKSCRIBE_DIR, "workscribe.db");
-var CONFIG_PATH = import_path.default.join(WORKSCRIBE_DIR, "config.json");
-var DEBUG_LOG_PATH = import_path.default.join(WORKSCRIBE_DIR, "debug.log");
-var EXPORTS_DIR = import_path.default.join(WORKSCRIBE_DIR, "exports");
-var PAUSE_FLAG_PATH = import_path.default.join(WORKSCRIBE_DIR, "paused");
-var WEEKLY_CACHE_DIR = import_path.default.join(WORKSCRIBE_DIR, "weekly-cache");
-var PROFILES_DIR = import_path.default.join(WORKSCRIBE_DIR, "profiles");
+var import_fs = __toESM(require("fs"));
+var LEGACY_DIR = import_path.default.join(import_os.default.homedir(), ".workscribe");
+var USE_XDG = !import_fs.default.existsSync(LEGACY_DIR);
+var xdgDataDir = USE_XDG ? import_path.default.join(process.env.XDG_DATA_HOME ?? import_path.default.join(import_os.default.homedir(), ".local", "share"), "workscribe") : LEGACY_DIR;
+var xdgConfigDir = USE_XDG ? import_path.default.join(process.env.XDG_CONFIG_HOME ?? import_path.default.join(import_os.default.homedir(), ".config"), "workscribe") : LEGACY_DIR;
+var xdgStateDir = USE_XDG ? import_path.default.join(process.env.XDG_STATE_HOME ?? import_path.default.join(import_os.default.homedir(), ".local", "state"), "workscribe") : LEGACY_DIR;
+var REQUIRED_DIRS = [.../* @__PURE__ */ new Set([xdgDataDir, xdgConfigDir, xdgStateDir])];
+var WORKSCRIBE_DIR = xdgDataDir;
+var DB_PATH = import_path.default.join(xdgDataDir, "workscribe.db");
+var CONFIG_PATH = import_path.default.join(xdgConfigDir, "config.json");
+var DEBUG_LOG_PATH = import_path.default.join(xdgStateDir, "debug.log");
+var UPDATE_CHECK_PATH = import_path.default.join(xdgStateDir, "update-check.json");
+var EXPORTS_DIR = import_path.default.join(xdgDataDir, "exports");
+var PAUSE_FLAG_PATH = import_path.default.join(xdgStateDir, "paused");
+var WEEKLY_CACHE_DIR = import_path.default.join(xdgDataDir, "weekly-cache");
+var PROFILES_DIR = import_path.default.join(xdgDataDir, "profiles");
 
 // src/db/migrations/001_initial_schema.ts
 var initial_schema_default = {
@@ -112,12 +134,12 @@ var MIGRATIONS = [initial_schema_default, semantic_categories_default];
 var _db = null;
 function getDb() {
   if (_db) return _db;
-  if (!import_fs.default.existsSync(WORKSCRIBE_DIR)) {
-    import_fs.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true });
+  if (!import_fs2.default.existsSync(WORKSCRIBE_DIR)) {
+    import_fs2.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true });
   }
   const db = new import_node_sqlite.DatabaseSync(DB_PATH);
   try {
-    import_fs.default.chmodSync(DB_PATH, 384);
+    import_fs2.default.chmodSync(DB_PATH, 384);
   } catch {
   }
   db.exec("PRAGMA journal_mode = WAL");
@@ -307,7 +329,10 @@ var BUILTIN_PATTERNS = [
   // Values after long-form secret flags (single-char flags like -t/-p/-k are too ambiguous)
   /(?<=--(password|passwd|secret|token|key|api[-_]?key|auth[-_]?token)\s+)\S+/gi,
   // export VAR=VALUE where VAR looks sensitive
-  /(?<=export\s+(?:[A-Z_]*(?:TOKEN|SECRET|KEY|PASSWORD|PASS|AUTH|CREDENTIAL)[A-Z_]*)=)\S+/gi
+  /(?<=export\s+(?:[A-Z_]*(?:TOKEN|SECRET|KEY|PASSWORD|PASS|AUTH|CREDENTIAL)[A-Z_]*)=)\S+/gi,
+  // Inline assignment: VAR_WITH_SENSITIVE_KEYWORD=value cmd  (e.g. API_KEY=secret npm start)
+  // Lookbehind matches only the variable-name= prefix, so only the value is replaced
+  /(?<=[A-Z_][A-Z0-9_]*(?:TOKEN|SECRET|KEY|PASSWORD|PASS|AUTH|CREDENTIAL)[A-Z0-9_]*=)\S+/gi
 ];
 function redact(command, extraPatterns = []) {
   let result = command;
@@ -328,7 +353,7 @@ function redact(command, extraPatterns = []) {
 // src/capture/git.ts
 var import_child_process = require("child_process");
 var import_path2 = __toESM(require("path"));
-var import_fs2 = __toESM(require("fs"));
+var import_fs3 = __toESM(require("fs"));
 function nameFromRemote(root) {
   try {
     const url = (0, import_child_process.execSync)("git remote get-url origin", {
@@ -344,7 +369,7 @@ function nameFromRemote(root) {
 }
 function nameFromPackageJson(root) {
   try {
-    const raw = import_fs2.default.readFileSync(import_path2.default.join(root, "package.json"), "utf-8");
+    const raw = import_fs3.default.readFileSync(import_path2.default.join(root, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (!pkg.name) return null;
     return pkg.name.replace(/^@[^/]+\//, "");
@@ -388,14 +413,14 @@ function getCommitsSince(sha, cwd) {
 }
 
 // src/capture/aider.ts
-var import_fs3 = __toESM(require("fs"));
+var import_fs4 = __toESM(require("fs"));
 var import_path3 = __toESM(require("path"));
 var HISTORY_FILE = ".aider.chat.history.md";
 var PROMPT_MAX_LENGTH = 200;
 function readLastAiderPrompt(cwd) {
   try {
     const histPath = import_path3.default.join(cwd, HISTORY_FILE);
-    const content = import_fs3.default.readFileSync(histPath, "utf-8");
+    const content = import_fs4.default.readFileSync(histPath, "utf-8");
     const matches = [...content.matchAll(/^> (.+)$/gm)];
     if (!matches.length) return null;
     return matches[matches.length - 1][1].trim().slice(0, PROMPT_MAX_LENGTH);
@@ -405,7 +430,7 @@ function readLastAiderPrompt(cwd) {
 }
 
 // src/config/registry.ts
-var import_fs5 = __toESM(require("fs"));
+var import_fs6 = __toESM(require("fs"));
 var import_os2 = __toESM(require("os"));
 var import_path4 = __toESM(require("path"));
 
@@ -471,7 +496,7 @@ var ai_tools_default = [
 
 // src/utils/logger.ts
 var import_chalk = __toESM(require("chalk"));
-var import_fs4 = __toESM(require("fs"));
+var import_fs5 = __toESM(require("fs"));
 var isDebug = process.env.WORKSCRIBE_DEBUG === "1";
 var log = {
   info: (msg) => console.log(import_chalk.default.cyan("\u2192"), msg),
@@ -485,7 +510,7 @@ function debugLog(context, error) {
   const entry = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${context}] ${error instanceof Error ? error.stack : String(error)}
 `;
   try {
-    import_fs4.default.appendFileSync(DEBUG_LOG_PATH, entry, { mode: 384 });
+    import_fs5.default.appendFileSync(DEBUG_LOG_PATH, entry, { mode: 384 });
   } catch {
   }
 }
@@ -495,8 +520,8 @@ var USER_REGISTRY_PATH = import_path4.default.join(import_os2.default.homedir(),
 function loadAIToolRegistry() {
   let userEntries = [];
   try {
-    if (import_fs5.default.existsSync(USER_REGISTRY_PATH)) {
-      const raw = import_fs5.default.readFileSync(USER_REGISTRY_PATH, "utf-8");
+    if (import_fs6.default.existsSync(USER_REGISTRY_PATH)) {
+      const raw = import_fs6.default.readFileSync(USER_REGISTRY_PATH, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed)) {
         userEntries = parsed.filter((entry) => typeof entry.tool === "string" && typeof entry.pattern === "string").map((entry) => ({
@@ -518,11 +543,11 @@ function loadAIToolRegistry() {
 }
 
 // src/profiles/loader.ts
-var import_fs8 = __toESM(require("fs"));
+var import_fs9 = __toESM(require("fs"));
 var import_path6 = __toESM(require("path"));
 
 // src/config/index.ts
-var import_fs6 = __toESM(require("fs"));
+var import_fs7 = __toESM(require("fs"));
 var DEFAULTS = {
   ai: {
     provider: "",
@@ -547,9 +572,9 @@ var DEFAULTS = {
   }
 };
 function readConfig() {
-  if (!import_fs6.default.existsSync(CONFIG_PATH)) return { ...DEFAULTS };
+  if (!import_fs7.default.existsSync(CONFIG_PATH)) return { ...DEFAULTS };
   try {
-    const raw = import_fs6.default.readFileSync(CONFIG_PATH, "utf-8");
+    const raw = import_fs7.default.readFileSync(CONFIG_PATH, "utf-8");
     const parsed = JSON.parse(raw);
     return deepMerge(DEFAULTS, parsed);
   } catch {
@@ -557,9 +582,9 @@ function readConfig() {
   }
 }
 function writeConfig(config) {
-  import_fs6.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+  import_fs7.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
   try {
-    import_fs6.default.chmodSync(CONFIG_PATH, 384);
+    import_fs7.default.chmodSync(CONFIG_PATH, 384);
   } catch {
   }
 }
@@ -624,21 +649,57 @@ function isValidManifest(m) {
 }
 
 // src/profiles/fetcher.ts
-var import_fs7 = __toESM(require("fs"));
+var import_fs8 = __toESM(require("fs"));
 var import_path5 = __toESM(require("path"));
+
+// src/utils/fetch.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ENOTFOUND",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "EHOSTUNREACH",
+  "ENETUNREACH"
+]);
+function isNetworkError(err) {
+  if (!(err instanceof Error)) return false;
+  const cause = err.cause;
+  const code = err.code ?? (cause instanceof Error ? cause.code : void 0);
+  return NETWORK_ERROR_CODES.has(code ?? "");
+}
+async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } catch (err) {
+    if (err.name === "AbortError") {
+      throw new Error(`Request timed out after ${timeoutMs / 1e3}s`);
+    }
+    if (isNetworkError(err)) {
+      throw new Error("No internet connection \u2014 try again when you're online");
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/profiles/fetcher.ts
 var REGISTRY_BASE = "https://raw.githubusercontent.com/workscribe/profiles/main";
 function manifestCachePath() {
   return import_path5.default.join(PROFILES_DIR, "manifest.json");
 }
 async function fetchManifest() {
-  const response = await fetch(`${REGISTRY_BASE}/manifest.json`);
+  const response = await fetchWithTimeout(`${REGISTRY_BASE}/manifest.json`, {});
   if (!response.ok) throw new Error(`Registry unreachable (${response.status})`);
   const data = await response.json();
   if (!isValidManifest(data)) throw new Error("Manifest format unrecognised");
   return data;
 }
 async function fetchProfile(name) {
-  const response = await fetch(`${REGISTRY_BASE}/${name}.json`);
+  const response = await fetchWithTimeout(`${REGISTRY_BASE}/${name}.json`, {});
   if (response.status === 404) throw new Error(`Profile "${name}" not found in registry`);
   if (!response.ok) throw new Error(`Registry unreachable (${response.status})`);
   const data = await response.json();
@@ -649,27 +710,27 @@ async function installProfile(name) {
   ensureProfilesDir();
   const profile = await fetchProfile(name);
   const dest = import_path5.default.join(PROFILES_DIR, `${name}.json`);
-  import_fs7.default.writeFileSync(dest, JSON.stringify(profile, null, 2), { encoding: "utf-8", mode: 384 });
+  import_fs8.default.writeFileSync(dest, JSON.stringify(profile, null, 2), { encoding: "utf-8", mode: 384 });
   debugLog("profiles", `Installed profile "${name}" to ${dest}`);
 }
 async function cacheManifest() {
   ensureProfilesDir();
   const manifest = await fetchManifest();
-  import_fs7.default.writeFileSync(manifestCachePath(), JSON.stringify(manifest, null, 2), { encoding: "utf-8", mode: 384 });
+  import_fs8.default.writeFileSync(manifestCachePath(), JSON.stringify(manifest, null, 2), { encoding: "utf-8", mode: 384 });
   return manifest;
 }
 function readCachedManifest() {
-  if (!import_fs7.default.existsSync(manifestCachePath())) return null;
+  if (!import_fs8.default.existsSync(manifestCachePath())) return null;
   try {
-    const data = JSON.parse(import_fs7.default.readFileSync(manifestCachePath(), "utf-8"));
+    const data = JSON.parse(import_fs8.default.readFileSync(manifestCachePath(), "utf-8"));
     return isValidManifest(data) ? data : null;
   } catch {
     return null;
   }
 }
 function ensureProfilesDir() {
-  if (!import_fs7.default.existsSync(PROFILES_DIR)) {
-    import_fs7.default.mkdirSync(PROFILES_DIR, { recursive: true, mode: 448 });
+  if (!import_fs8.default.existsSync(PROFILES_DIR)) {
+    import_fs8.default.mkdirSync(PROFILES_DIR, { recursive: true, mode: 448 });
   }
 }
 
@@ -696,13 +757,13 @@ function compileRule(profileName, rule) {
 }
 function loadProfileFromDisk(name) {
   const filePath = import_path6.default.join(PROFILES_DIR, `${name}.json`);
-  if (!import_fs8.default.existsSync(filePath)) {
+  if (!import_fs9.default.existsSync(filePath)) {
     debugLog("profiles", `Profile "${name}" not found in cache \u2014 run: workscribe profile add ${name}`);
     return null;
   }
   let candidate;
   try {
-    candidate = JSON.parse(import_fs8.default.readFileSync(filePath, "utf-8"));
+    candidate = JSON.parse(import_fs9.default.readFileSync(filePath, "utf-8"));
   } catch {
     debugLog("profiles", `Profile "${name}" contains invalid JSON \u2014 skipping`);
     return null;
@@ -734,8 +795,8 @@ function getActiveProfileAiContexts() {
   });
 }
 function getCachedProfiles() {
-  if (!import_fs8.default.existsSync(PROFILES_DIR)) return [];
-  return import_fs8.default.readdirSync(PROFILES_DIR).filter((file) => file.endsWith(".json") && file !== "manifest.json").flatMap((file) => {
+  if (!import_fs9.default.existsSync(PROFILES_DIR)) return [];
+  return import_fs9.default.readdirSync(PROFILES_DIR).filter((file) => file.endsWith(".json") && file !== "manifest.json").flatMap((file) => {
     const profile = loadProfileFromDisk(file.replace(/\.json$/, ""));
     return profile ? [profile] : [];
   });
@@ -747,7 +808,7 @@ function detectProfilesForDirectory(dir) {
   return manifest.filter((entry) => {
     if (activeNames.has(entry.name)) return false;
     const indicatorFiles = entry.detect?.files ?? [];
-    return indicatorFiles.length > 0 && indicatorFiles.every((file) => import_fs8.default.existsSync(import_path6.default.join(dir, file)));
+    return indicatorFiles.length > 0 && indicatorFiles.every((file) => import_fs9.default.existsSync(import_path6.default.join(dir, file)));
   });
 }
 
@@ -1015,7 +1076,7 @@ function isDuplicate(command, cwd, lastEvent, dedupWindowMs = 5e3, now = Date.no
 
 // src/capture/index.ts
 function captureCommand(opts) {
-  if (import_fs9.default.existsSync(PAUSE_FLAG_PATH)) return;
+  if (import_fs10.default.existsSync(PAUSE_FLAG_PATH)) return;
   const config = readConfig();
   const { command, cwd, exitCode, durationMs } = opts;
   if (shouldFilter(command, config.capture.ignore)) return;
@@ -1059,8 +1120,11 @@ function captureCommand(opts) {
 }
 
 // src/cli/capture.ts
+var CAPTURE_HANG_TIMEOUT_MS = 5e3;
 function registerCapture(program2) {
   program2.command("_capture").description("Internal: capture a shell command event (called by shell hook)").option("--cmd <command>", "command that was executed").option("--cwd <path>", "working directory").option("--exit <code>", "exit code", parseInt).option("--duration <ms>", "duration in milliseconds", parseInt).option("--git-before <sha>", "git HEAD SHA before this command ran").action((opts) => {
+    const hangGuard = setTimeout(() => process.exit(0), CAPTURE_HANG_TIMEOUT_MS);
+    hangGuard.unref();
     try {
       if (!opts.cmd || !opts.cwd) return;
       captureCommand({
@@ -1113,188 +1177,723 @@ function registerHook(program2) {
 }
 
 // src/cli/init.ts
-var import_fs12 = __toESM(require("fs"));
+var import_fs13 = __toESM(require("fs"));
 var import_path9 = __toESM(require("path"));
-var import_os4 = __toESM(require("os"));
+var import_os5 = __toESM(require("os"));
 var import_prompts = __toESM(require("prompts"));
 var import_chalk2 = __toESM(require("chalk"));
 
-// src/capture/shell-hook.ts
-var import_fs10 = __toESM(require("fs"));
-var import_path7 = __toESM(require("path"));
-var HOOK_START = "# workscribe:hook:start";
-var HOOK_END = "# workscribe:hook:end";
-var HOOK_PREAMBLE = "# Workscribe \u2014 developer work journal";
-function getInstalledHookBlock(rcFile) {
-  if (!import_fs10.default.existsSync(rcFile)) return null;
-  const content = import_fs10.default.readFileSync(rcFile, "utf-8");
-  const startIdx = content.indexOf(HOOK_START);
-  const endIdx = content.indexOf(HOOK_END);
-  if (startIdx === -1 || endIdx === -1) return null;
-  return content.slice(startIdx, endIdx + HOOK_END.length);
+// src/utils/format.ts
+function formatDuration(minutes) {
+  if (minutes < 60) return `${Math.round(minutes)}m`;
+  const h = Math.floor(minutes / 60);
+  const m = Math.round(minutes % 60);
+  return m > 0 ? `${h}h ${m}m` : `${h}h`;
 }
-function isHookInstalled(rcFile) {
-  return getInstalledHookBlock(rcFile) !== null;
+function formatDate(isoString) {
+  return new Date(isoString).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
 }
-function isHookOutdated(rcFile, hookContent) {
-  const installed = getInstalledHookBlock(rcFile);
-  if (!installed) return false;
-  return installed.trim() !== hookContent.trim();
+function todayDate() {
+  return localDateStr(/* @__PURE__ */ new Date());
 }
-function installHook(rcFile, hookContent) {
-  const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs10.default.copyFileSync(rcFile, backup);
-  log.info(`Backed up ${rcFile} \u2192 ${import_path7.default.basename(backup)}`);
-  import_fs10.default.appendFileSync(rcFile, `
-${hookContent}
-`);
+function parseDate(input) {
+  const d = /* @__PURE__ */ new Date(input + "T00:00:00");
+  if (isNaN(d.getTime())) throw new Error(`Invalid date: ${input}`);
+  return input;
 }
-function updateHook(rcFile, hookContent) {
-  const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs10.default.copyFileSync(rcFile, backup);
-  log.info(`Backed up ${rcFile} \u2192 ${import_path7.default.basename(backup)}`);
-  const content = import_fs10.default.readFileSync(rcFile, "utf-8");
-  const startIdx = content.indexOf(HOOK_START);
-  const endIdx = content.indexOf(HOOK_END) + HOOK_END.length;
-  import_fs10.default.writeFileSync(rcFile, content.slice(0, startIdx) + hookContent + content.slice(endIdx));
+function localDateStr(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
 }
-function removeHook(rcFile) {
-  const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs10.default.copyFileSync(rcFile, backup);
-  log.info(`Backed up ${rcFile} \u2192 ${import_path7.default.basename(backup)}`);
-  const content = import_fs10.default.readFileSync(rcFile, "utf-8");
-  const startIdx = content.indexOf(HOOK_START);
-  const endIdx = content.indexOf(HOOK_END) + HOOK_END.length;
-  const preambleIdx = content.lastIndexOf(HOOK_PREAMBLE, startIdx);
-  const blockStart = preambleIdx !== -1 ? preambleIdx : startIdx;
-  const before = content.slice(0, blockStart).replace(/\n+$/, "\n");
-  const after = content.slice(endIdx).replace(/^\n/, "");
-  import_fs10.default.writeFileSync(rcFile, before + after);
+function startOfWeek(dateStr) {
+  const d = /* @__PURE__ */ new Date(dateStr + "T00:00:00");
+  const day = d.getDay();
+  const diff = day === 0 ? -6 : 1 - day;
+  d.setDate(d.getDate() + diff);
+  return localDateStr(d);
 }
-
-// src/capture/hooks/claude-code.ts
-var import_fs11 = __toESM(require("fs"));
-var import_path8 = __toESM(require("path"));
-var import_os3 = __toESM(require("os"));
-
-// src/capture/hooks/utils.ts
-var import_child_process3 = require("child_process");
-function isCommandInstalled(cmd) {
-  try {
-    (0, import_child_process3.execSync)(`which ${cmd}`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
+function eachDayOfRange(start, end) {
+  const days = [];
+  const cur = /* @__PURE__ */ new Date(start + "T00:00:00");
+  const last = /* @__PURE__ */ new Date(end + "T00:00:00");
+  while (cur <= last) {
+    days.push(localDateStr(cur));
+    cur.setDate(cur.getDate() + 1);
   }
+  return days;
 }
-
-// src/capture/hooks/claude-code.ts
-var CLAUDE_SETTINGS_PATH = import_path8.default.join(import_os3.default.homedir(), ".claude", "settings.json");
-function readSettings() {
-  if (!import_fs11.default.existsSync(CLAUDE_SETTINGS_PATH)) return {};
-  try {
-    return JSON.parse(import_fs11.default.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
-  } catch {
-    return {};
-  }
+function isoWeekKey(dateStr) {
+  const d = /* @__PURE__ */ new Date(dateStr + "T00:00:00");
+  const jan4 = new Date(d.getFullYear(), 0, 4);
+  const weekNum = Math.ceil(((d.getTime() - jan4.getTime()) / 864e5 + jan4.getDay() + 1) / 7);
+  return `${d.getFullYear()}-W${String(weekNum).padStart(2, "0")}`;
 }
-var claudeCodeIntegration = {
-  displayName: "Claude Code",
-  isInstalled() {
-    return isCommandInstalled("claude");
-  },
-  isHookInstalled() {
-    const settings = readSettings();
-    const postToolUse = settings.hooks?.PostToolUse ?? [];
-    return postToolUse.some((entry) => {
-      const hooks = entry.hooks ?? [];
-      return hooks.some((hookItem) => {
-        const hook = hookItem;
-        return typeof hook.command === "string" && hook.command.includes("workscribe _hook");
-      });
-    });
-  },
-  install() {
-    const settings = readSettings();
-    const existingHooks = settings.hooks ?? {};
-    const existingPostToolUse = existingHooks.PostToolUse ?? [];
-    settings.hooks = {
-      ...existingHooks,
-      PostToolUse: [
-        ...existingPostToolUse,
-        {
-          matcher: "Bash",
-          hooks: [{ type: "command", command: "workscribe _hook --source claude-code", async: true }]
-        }
-      ]
-    };
-    import_fs11.default.mkdirSync(import_path8.default.dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
-    import_fs11.default.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
-  }
-};
 
-// src/capture/hooks/index.ts
-var AI_HOOK_INTEGRATIONS = {
-  "claude-code": claudeCodeIntegration
-};
+// src/ai/prompt.ts
+var SYSTEM_PROMPT = `You write short developer work summaries. Focus on what the developer accomplished and what changed \u2014 not which tools or commands were used.
 
-// src/cli/init.ts
-function detectShell() {
-  const shell = process.env.SHELL ?? "";
-  if (shell.includes("zsh")) return { name: "zsh", rcFile: import_path9.default.join(import_os4.default.homedir(), ".zshrc") };
-  if (shell.includes("bash")) return { name: "bash", rcFile: import_path9.default.join(import_os4.default.homedir(), ".bashrc") };
-  return null;
+Here is an example:
+
+INPUT:
+Project: api-service
+Branch: feature/auth
+Duration: 2h 00m
+Events:
+  - versioning {"branch":"feature/auth"}
+  - 2x dependencies {"tool":"npm","packages":["bcrypt","jsonwebtoken"]}
+  - 8x testing [failed]
+  - testing
+  - 2x files {"tool":"mkdir"}
+  - shipping {"message":"fix: auth token validation"}
+  - shipping {"remote":"origin","branch":"feature/auth"}
+
+OUTPUT:
+- Added authentication dependencies (bcrypt, JWT)
+- Debugged and resolved failing auth tests
+- Committed and pushed the token validation fix
+
+RULES \u2014 follow these exactly:
+
+1. Interpret repeated events as patterns, not individual steps.
+   - Many testing [failed] followed by a passing test = debugging a failure. Say "resolved failing X tests", not "ran tests multiple times".
+   - Many versioning events = branch housekeeping. Fold into context, do not list each git command.
+
+2. Omit utility commands entirely. File size checks, file reads, grep searches, and cat commands are research steps \u2014 they are not outcomes and must not appear in the summary.
+
+3. Do not name the AI tool. For ai_session events: focus on what was built or committed. If a commits array is present in metadata, use those commit messages. Never write "via Claude Code", "using Claude Code", or similar \u2014 omit the tool name entirely.
+
+4. For other events with a hint field: describe the developer's intent, not the raw command.
+
+5. For dependencies events: infer the purpose from package names and describe the domain (bcrypt/jsonwebtoken \u2192 authentication, prisma/pg \u2192 database, jest/vitest \u2192 testing). For unfamiliar packages, name them directly.
+
+6. Fold supporting events into the narrative. Building, shipping, versioning, and file operations are context \u2014 only make them a bullet when they are the primary activity (e.g. a standalone build fix or deploy with no accompanying commits).
+
+7. Stick to what the events show. Do not infer subject matter from the branch name. Do not add details not derivable from the events.
+
+Maximum 5 bullets. Output ONLY the bullet points, nothing else.`;
+function getSystemPrompt() {
+  const contexts = getActiveProfileAiContexts();
+  if (contexts.length === 0) return SYSTEM_PROMPT;
+  return SYSTEM_PROMPT + "\n\n" + contexts.join("\n");
 }
-function registerInit(program2) {
-  program2.command("init").description("Set up Workscribe and install or update shell hooks").action(async () => {
-    log.plain(import_chalk2.default.bold("\n  Workscribe \u2014 Developer Work Journal\n"));
-    if (!import_fs12.default.existsSync(WORKSCRIBE_DIR)) {
-      import_fs12.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true, mode: 448 });
-      log.success(`Created ${WORKSCRIBE_DIR}`);
-    } else {
-      try {
-        import_fs12.default.chmodSync(WORKSCRIBE_DIR, 448);
-      } catch {
+var DEFAULT_EXCLUDED_CATEGORIES = /* @__PURE__ */ new Set(["exploring", "note", "linting"]);
+function buildExcludedSet(includeCategories = []) {
+  const excluded = new Set(DEFAULT_EXCLUDED_CATEGORIES);
+  for (const cat of includeCategories) excluded.delete(cat);
+  return excluded;
+}
+function countExcludedEvents(sessions, excluded) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    for (const event of session.events) {
+      if (excluded.has(event.category)) {
+        counts.set(event.category, (counts.get(event.category) ?? 0) + 1);
       }
     }
-    if (!import_fs12.default.existsSync(PROFILES_DIR)) {
-      import_fs12.default.mkdirSync(PROFILES_DIR, { recursive: true, mode: 448 });
-    }
-    getDb();
-    log.success("Database initialized");
-    const shell = detectShell();
-    if (!shell) {
-      log.warn("Could not detect shell. Supported: zsh, bash");
-      log.plain(`Manually add the hook from: ${import_chalk2.default.cyan("shell/hook.zsh")} or ${import_chalk2.default.cyan("shell/hook.bash")}`);
-    } else {
-      const hookFile = import_path9.default.join(__dirname, "..", "shell", `hook.${shell.name}`);
-      if (!import_fs12.default.existsSync(hookFile)) {
-        log.warn(`Hook template not found at ${hookFile}`);
-      } else {
-        const hookContent = import_fs12.default.readFileSync(hookFile, "utf-8");
-        if (!import_fs12.default.existsSync(shell.rcFile)) import_fs12.default.writeFileSync(shell.rcFile, "");
-        if (!isHookInstalled(shell.rcFile)) {
-          installHook(shell.rcFile, hookContent);
-          log.success(`Shell hook installed in ${shell.rcFile}`);
-        } else if (isHookOutdated(shell.rcFile, hookContent)) {
-          const { update } = await (0, import_prompts.default)({
-            type: "confirm",
-            name: "update",
-            message: `Shell hook in ${shell.rcFile} is outdated. Update?`,
-            initial: true
-          });
-          if (update) {
-            updateHook(shell.rcFile, hookContent);
-            log.success(`Shell hook updated in ${shell.rcFile}`);
-          } else {
-            log.info("Shell hook update skipped");
-          }
-        } else {
-          log.info(`Shell hook up to date in ${shell.rcFile}`);
-        }
+  }
+  return counts;
+}
+function buildUserMessage(payload, includeCategories = []) {
+  const excluded = buildExcludedSet(includeCategories);
+  const lines = [`Date: ${payload.date}`, ""];
+  for (const session of payload.sessions) {
+    lines.push(`Project: ${session.project ?? "unknown"}`);
+    if (session.branch) lines.push(`Branch: ${session.branch}`);
+    lines.push(`Duration: ${formatDuration(session.durationMinutes)}`);
+    for (const event of session.events) {
+      if (event.category === "note") {
+        lines.push(`NOTE: ${event.metadata.text}`);
       }
     }
-    const installedTools = loadAIToolRegistry().filter(
+    lines.push("Events:");
+    const counts = /* @__PURE__ */ new Map();
+    for (const event of session.events) {
+      if (excluded.has(event.category)) continue;
+      const failed = event.exitCode !== null && event.exitCode !== 0 ? " [failed]" : "";
+      let key;
+      if (event.hint) {
+        key = `other  [${event.hint}]${failed}`;
+      } else {
+        const meta = Object.keys(event.metadata).length > 0 ? ` ${JSON.stringify(event.metadata)}` : "";
+        key = `${event.category}${meta}${failed}`;
+      }
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    for (const [key, count] of counts) {
+      lines.push(`  - ${count > 1 ? `${count}x ` : ""}${key}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var WEEKLY_SYSTEM_PROMPT = `You write short weekly developer summaries. Here is an example:
+
+INPUT:
+Week: 2026-05-18 to 2026-05-22
+
+Monday 2026-05-18:
+  Project: api-service (feature/auth) \u2014 2h 10m
+  Events: 3x code_commit, 2x test_run, dependency_install
+
+Tuesday 2026-05-19:
+  Project: api-service (feature/auth) \u2014 1h 30m
+  Events: 2x code_commit, test_run, build
+
+Wednesday 2026-05-20:
+  Project: dashboard (main) \u2014 3h 00m
+  Events: 4x code_commit, 2x build, test_run
+
+Thursday 2026-05-21:
+  Project: api-service (feature/auth) \u2014 1h 00m
+  Events: code_commit {"message":"feat: merge auth"}, branch_switch
+
+Friday 2026-05-22:
+  Project: dashboard (main) \u2014 2h 00m
+  Events: 3x code_commit, build
+
+OUTPUT:
+## Week of 18 May \u2014 9h 40m across 2 projects
+
+**api-service** (Mon\u2013Thu): Built and shipped the auth feature \u2014 JWT setup, token validation fixes, and final merge.
+**dashboard** (Wed, Fri): Active development across 7 commits with builds passing.
+
+Now summarise the following week. Output ONLY the summary \u2014 a one-line header then one bullet per active project. Maximum 4 bullets.`;
+var DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+function buildWeeklyMessage(payload) {
+  const lines = [`Week: ${payload.weekStart} to ${payload.weekEnd}`, ""];
+  for (const { date, sessions } of payload.days) {
+    const dayName = DAY_NAMES[(/* @__PURE__ */ new Date(date + "T00:00:00")).getDay()];
+    lines.push(`${dayName} ${date}:`);
+    for (const session of sessions) {
+      const project = session.project ?? "unknown";
+      const branch = session.branch ? ` (${session.branch})` : "";
+      lines.push(`  Project: ${project}${branch} \u2014 ${formatDuration(session.durationMinutes)}`);
+      for (const event of session.events) {
+        if (event.category === "note") {
+          lines.push(`  NOTE: ${event.metadata.text}`);
+        }
+      }
+      const excluded = buildExcludedSet();
+      const counts = /* @__PURE__ */ new Map();
+      for (const event of session.events) {
+        if (excluded.has(event.category)) continue;
+        const failed = event.exitCode !== null && event.exitCode !== 0 ? " [failed]" : "";
+        let key;
+        if (event.hint) {
+          key = `other  [${event.hint}]${failed}`;
+        } else {
+          const meta = Object.keys(event.metadata).length > 0 ? ` ${JSON.stringify(event.metadata)}` : "";
+          key = `${event.category}${meta}${failed}`;
+        }
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+      }
+      const eventLine = [...counts.entries()].map(([key, count]) => `${count > 1 ? `${count}x ` : ""}${key}`).join(", ");
+      lines.push(`  Events: ${eventLine}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/ai/generic-provider.ts
+var GenericProvider = class {
+  constructor(config, model, apiKey, baseUrl, includeCategories = []) {
+    this.config = config;
+    this.model = model;
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+    this.includeCategories = includeCategories;
+  }
+  config;
+  model;
+  apiKey;
+  baseUrl;
+  includeCategories;
+  async call(system, userMsg, maxTokens) {
+    const response = await fetchWithTimeout(this.config.chatUrl(this.baseUrl), {
+      method: "POST",
+      headers: this.config.headers(this.apiKey),
+      body: JSON.stringify(this.config.buildChatBody(this.model, system, userMsg, maxTokens))
+    });
+    if (!response.ok) {
+      throw new Error(this.config.chatError(response.status, await response.text()));
+    }
+    return this.config.parseText(await response.json());
+  }
+  async summarize(payload) {
+    return this.call(getSystemPrompt(), buildUserMessage(payload, this.includeCategories), this.config.dailyTokens);
+  }
+  async summarizeWeek(payload) {
+    return this.call(WEEKLY_SYSTEM_PROMPT, buildWeeklyMessage(payload), this.config.weeklyTokens);
+  }
+  async validate() {
+    const isPost = this.config.validateMethod === "POST";
+    const response = await fetchWithTimeout(this.config.validateUrl(this.baseUrl), {
+      method: this.config.validateMethod,
+      headers: isPost ? this.config.headers(this.apiKey) : void 0,
+      body: isPost && this.config.buildValidateBody ? JSON.stringify(this.config.buildValidateBody(this.model)) : void 0
+    });
+    if (!response.ok) {
+      throw new Error(this.config.validateError(response.status, await response.text(), this.baseUrl));
+    }
+  }
+};
+
+// src/ai/provider-config.ts
+var PROVIDER_CONFIGS = {
+  anthropic: {
+    defaultModel: "claude-haiku-4-5-20251001",
+    defaultBaseUrl: "https://api.anthropic.com/v1",
+    dailyTokens: 1024,
+    weeklyTokens: 1024,
+    chatUrl: (baseUrl) => `${baseUrl}/messages`,
+    validateUrl: (baseUrl) => `${baseUrl}/messages`,
+    validateMethod: "POST",
+    headers: (apiKey) => ({
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    }),
+    buildChatBody: (model, system, userMsg, maxTokens) => ({
+      model,
+      max_tokens: maxTokens,
+      system,
+      messages: [{ role: "user", content: userMsg }]
+    }),
+    buildValidateBody: (model) => ({
+      model,
+      max_tokens: 1,
+      messages: [{ role: "user", content: "." }]
+    }),
+    parseText: (json) => {
+      const data = json;
+      return data.content.find((b) => b.type === "text")?.text ?? "";
+    },
+    chatError: (status, body) => `Anthropic API error ${status}: ${body}`,
+    validateError: (status, body) => `Anthropic API error ${status}: ${body}`
+  },
+  openai: {
+    defaultModel: "gpt-4o-mini",
+    defaultBaseUrl: "https://api.openai.com/v1",
+    dailyTokens: 1024,
+    weeklyTokens: 1024,
+    chatUrl: (baseUrl) => `${baseUrl}/chat/completions`,
+    validateUrl: (baseUrl) => `${baseUrl}/chat/completions`,
+    validateMethod: "POST",
+    headers: (apiKey) => ({
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    }),
+    buildChatBody: (model, system, userMsg, maxTokens) => ({
+      model,
+      messages: [
+        { role: "system", content: system },
+        { role: "user", content: userMsg }
+      ],
+      max_tokens: maxTokens
+    }),
+    buildValidateBody: (model) => ({
+      model,
+      messages: [{ role: "user", content: "." }],
+      max_tokens: 1
+    }),
+    parseText: (json) => {
+      const data = json;
+      return data.choices[0]?.message?.content ?? "";
+    },
+    chatError: (status, body) => `OpenAI API error ${status}: ${body}`,
+    validateError: (status, body) => `OpenAI API error ${status}: ${body}`
+  },
+  ollama: {
+    defaultModel: "llama3",
+    defaultBaseUrl: "http://localhost:11434",
+    dailyTokens: 300,
+    weeklyTokens: 400,
+    chatUrl: (baseUrl) => `${baseUrl}/api/chat`,
+    validateUrl: (baseUrl) => `${baseUrl}/api/tags`,
+    validateMethod: "GET",
+    headers: () => ({ "Content-Type": "application/json" }),
+    buildChatBody: (model, system, userMsg, maxTokens) => ({
+      model,
+      stream: false,
+      messages: [
+        { role: "system", content: system },
+        { role: "user", content: userMsg }
+      ],
+      options: { num_predict: maxTokens, temperature: 0.3 }
+    }),
+    parseText: (json) => {
+      return json.message?.content ?? "";
+    },
+    chatError: (status, body) => `Ollama error ${status}: ${body}. Is Ollama running? Try: ollama serve`,
+    validateError: (_status, _body, baseUrl) => `Ollama is not reachable at ${baseUrl}. Is it running? Try: ollama serve`
+  }
+};
+
+// src/ai/router.ts
+function getProvider(config) {
+  const { provider, apiKey = "", model, baseUrl } = config.ai;
+  if (!provider) {
+    throw new Error(
+      "No AI provider configured.\nRun: workscribe config set ai.provider <anthropic|openai|ollama|openai-compatible>"
+    );
+  }
+  const configKey = provider === "openai-compatible" ? "openai" : provider;
+  const providerConfig = PROVIDER_CONFIGS[configKey];
+  if (!providerConfig) {
+    throw new Error(
+      `Unknown provider: "${provider}"
+Supported providers: anthropic, openai, ollama, openai-compatible`
+    );
+  }
+  if (provider !== "ollama" && !apiKey) {
+    throw new Error(`${provider} requires an API key.
+Run: workscribe config set ai.apiKey <your-key>`);
+  }
+  if (provider === "openai-compatible" && !baseUrl) {
+    throw new Error("openai-compatible requires a base URL.\nRun: workscribe config set ai.baseUrl <url>");
+  }
+  return new GenericProvider(
+    providerConfig,
+    model || providerConfig.defaultModel,
+    apiKey,
+    baseUrl || providerConfig.defaultBaseUrl,
+    config.summary?.includeCategories ?? []
+  );
+}
+
+// src/capture/shell-hook.ts
+var import_fs11 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
+var import_os3 = __toESM(require("os"));
+
+// src/utils/completion-scripts.ts
+function bashCompletion(commands) {
+  const names = commands.map((command) => command.name).join(" ");
+  return `_workscribe_completion() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  local commands="${names}"
+  case "$prev" in
+    completions) COMPREPLY=( $(compgen -W "bash zsh fish" -- "$cur") ); return ;;
+    config)      COMPREPLY=( $(compgen -W "get set list" -- "$cur") ); return ;;
+    profile)     COMPREPLY=( $(compgen -W "list add remove update detect suggest" -- "$cur") ); return ;;
+  esac
+  COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
+}
+complete -F _workscribe_completion workscribe`;
+}
+function zshCompletion(commands) {
+  const commandList = commands.map((command) => `    '${command.name}:${command.description}'`).join("\n");
+  return `#compdef workscribe
+_workscribe() {
+  local state
+  _arguments '1: :->command' '*: :->args'
+  case $state in
+    command)
+      local -a commands
+      commands=(
+${commandList}
+      )
+      _describe 'command' commands
+      ;;
+    args)
+      case $words[2] in
+        completions) local -a shells; shells=('bash' 'zsh' 'fish'); _describe 'shell' shells ;;
+        config)      local -a sub; sub=('get:Get a value' 'set:Set a value' 'list:List all values'); _describe 'subcommand' sub ;;
+        profile)     local -a sub; sub=('list' 'add' 'remove' 'update' 'detect' 'suggest'); _describe 'subcommand' sub ;;
+      esac
+      ;;
+  esac
+}
+_workscribe`;
+}
+function fishCompletion(commands) {
+  const lines = [
+    "complete -c workscribe -f",
+    ...commands.map(
+      (command) => `complete -c workscribe -n "__fish_use_subcommand" -a ${command.name.padEnd(12)} -d "${command.description}"`
+    ),
+    'complete -c workscribe -n "__fish_seen_subcommand_from completions" -a "bash zsh fish"',
+    'complete -c workscribe -n "__fish_seen_subcommand_from config"      -a "get set list"',
+    'complete -c workscribe -n "__fish_seen_subcommand_from profile"     -a "list add remove update detect suggest"'
+  ];
+  return lines.join("\n");
+}
+
+// src/capture/shell-hook.ts
+var FISH_COMPLETIONS_DIR = import_path7.default.join(import_os3.default.homedir(), ".config", "fish", "completions");
+var HOOK_START = "# workscribe:hook:start";
+var HOOK_END = "# workscribe:hook:end";
+var HOOK_PREAMBLE = "# Workscribe \u2014 developer work journal";
+function getInstalledHookBlock(rcFile) {
+  if (!import_fs11.default.existsSync(rcFile)) return null;
+  const content = import_fs11.default.readFileSync(rcFile, "utf-8");
+  const startIdx = content.indexOf(HOOK_START);
+  const endIdx = content.indexOf(HOOK_END);
+  if (startIdx === -1 || endIdx === -1) return null;
+  return content.slice(startIdx, endIdx + HOOK_END.length);
+}
+function isHookInstalled(rcFile) {
+  return getInstalledHookBlock(rcFile) !== null;
+}
+function isHookOutdated(rcFile, hookContent) {
+  const installed = getInstalledHookBlock(rcFile);
+  if (!installed) return false;
+  return installed.trim() !== hookContent.trim();
+}
+function installHook(rcFile, hookContent) {
+  const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
+  import_fs11.default.copyFileSync(rcFile, backup);
+  log.info(`Backed up ${rcFile} \u2192 ${import_path7.default.basename(backup)}`);
+  import_fs11.default.appendFileSync(rcFile, `
+${hookContent}
+`);
+}
+function updateHook(rcFile, hookContent) {
+  const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
+  import_fs11.default.copyFileSync(rcFile, backup);
+  log.info(`Backed up ${rcFile} \u2192 ${import_path7.default.basename(backup)}`);
+  const content = import_fs11.default.readFileSync(rcFile, "utf-8");
+  const startIdx = content.indexOf(HOOK_START);
+  const endIdx = content.indexOf(HOOK_END) + HOOK_END.length;
+  import_fs11.default.writeFileSync(rcFile, content.slice(0, startIdx) + hookContent + content.slice(endIdx));
+}
+function removeHook(rcFile) {
+  const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
+  import_fs11.default.copyFileSync(rcFile, backup);
+  log.info(`Backed up ${rcFile} \u2192 ${import_path7.default.basename(backup)}`);
+  const content = import_fs11.default.readFileSync(rcFile, "utf-8");
+  const startIdx = content.indexOf(HOOK_START);
+  const endIdx = content.indexOf(HOOK_END) + HOOK_END.length;
+  const preambleIdx = content.lastIndexOf(HOOK_PREAMBLE, startIdx);
+  const blockStart = preambleIdx !== -1 ? preambleIdx : startIdx;
+  const before = content.slice(0, blockStart).replace(/\n+$/, "\n");
+  const after = content.slice(endIdx).replace(/^\n/, "");
+  import_fs11.default.writeFileSync(rcFile, before + after);
+}
+function isCompletionsInstalled(shell) {
+  if (shell.name === "fish") {
+    return import_fs11.default.existsSync(import_path7.default.join(FISH_COMPLETIONS_DIR, "workscribe.fish"));
+  }
+  try {
+    return import_fs11.default.readFileSync(shell.rcFile, "utf-8").includes("workscribe completions");
+  } catch {
+    return false;
+  }
+}
+function installCompletions(shell, commands) {
+  if (shell.name === "fish") {
+    if (!import_fs11.default.existsSync(FISH_COMPLETIONS_DIR)) {
+      import_fs11.default.mkdirSync(FISH_COMPLETIONS_DIR, { recursive: true });
+    }
+    import_fs11.default.writeFileSync(import_path7.default.join(FISH_COMPLETIONS_DIR, "workscribe.fish"), fishCompletion(commands), { mode: 420 });
+  } else {
+    const script = shell.name === "zsh" ? zshCompletion(commands) : bashCompletion(commands);
+    const cacheFile = import_path7.default.join(WORKSCRIBE_DIR, `completion.${shell.name}`);
+    import_fs11.default.writeFileSync(cacheFile, script, { mode: 420 });
+    const sourceLine = shell.name === "zsh" ? `
+# Workscribe completions
+autoload -Uz compinit && compinit
+source "${cacheFile}"
+` : `
+# Workscribe completions
+source "${cacheFile}"
+`;
+    import_fs11.default.appendFileSync(shell.rcFile, sourceLine);
+  }
+}
+
+// src/capture/hooks/claude-code.ts
+var import_fs12 = __toESM(require("fs"));
+var import_path8 = __toESM(require("path"));
+var import_os4 = __toESM(require("os"));
+
+// src/capture/hooks/utils.ts
+var import_child_process3 = require("child_process");
+function isCommandInstalled(cmd) {
+  try {
+    (0, import_child_process3.execSync)(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/capture/hooks/claude-code.ts
+var CLAUDE_SETTINGS_PATH = import_path8.default.join(import_os4.default.homedir(), ".claude", "settings.json");
+function readSettings() {
+  if (!import_fs12.default.existsSync(CLAUDE_SETTINGS_PATH)) return {};
+  try {
+    return JSON.parse(import_fs12.default.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+var claudeCodeIntegration = {
+  displayName: "Claude Code",
+  isInstalled() {
+    return isCommandInstalled("claude");
+  },
+  isHookInstalled() {
+    const settings = readSettings();
+    const postToolUse = settings.hooks?.PostToolUse ?? [];
+    return postToolUse.some((entry) => {
+      const hooks = entry.hooks ?? [];
+      return hooks.some((hookItem) => {
+        const hook = hookItem;
+        return typeof hook.command === "string" && hook.command.includes("workscribe _hook");
+      });
+    });
+  },
+  install() {
+    const settings = readSettings();
+    const existingHooks = settings.hooks ?? {};
+    const existingPostToolUse = existingHooks.PostToolUse ?? [];
+    settings.hooks = {
+      ...existingHooks,
+      PostToolUse: [
+        ...existingPostToolUse,
+        {
+          matcher: "Bash",
+          hooks: [{ type: "command", command: "workscribe _hook --source claude-code", async: true }]
+        }
+      ]
+    };
+    import_fs12.default.mkdirSync(import_path8.default.dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
+    import_fs12.default.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  }
+};
+
+// src/capture/hooks/index.ts
+var AI_HOOK_INTEGRATIONS = {
+  "claude-code": claudeCodeIntegration
+};
+
+// src/cli/completions.ts
+var HIDDEN_COMMANDS = /* @__PURE__ */ new Set(["_capture", "_hook"]);
+function getPublicCommands(program2) {
+  return program2.commands.filter((command) => !HIDDEN_COMMANDS.has(command.name())).map((command) => ({ name: command.name(), description: command.description() }));
+}
+function registerCompletions(program2) {
+  program2.command("completions [shell]").description("Print shell completion script (bash, zsh, fish)").action((shell) => {
+    const detected = shell ?? (process.env.SHELL ?? "").split("/").at(-1);
+    if (!detected || !["bash", "zsh", "fish"].includes(detected)) {
+      log.error(`Unknown shell: "${detected ?? ""}". Supported: bash, zsh, fish`);
+      log.plain(`  Usage: workscribe completions <bash|zsh|fish>`);
+      process.exit(1);
+    }
+    const commands = getPublicCommands(program2);
+    const script = detected === "bash" ? bashCompletion(commands) : detected === "zsh" ? zshCompletion(commands) : fishCompletion(commands);
+    process.stdout.write(script + "\n");
+  });
+}
+
+// src/cli/init.ts
+function detectShell() {
+  const shell = process.env.SHELL ?? "";
+  if (shell.includes("zsh")) return { name: "zsh", rcFile: import_path9.default.join(import_os5.default.homedir(), ".zshrc") };
+  if (shell.includes("bash")) return { name: "bash", rcFile: import_path9.default.join(import_os5.default.homedir(), ".bashrc") };
+  if (shell.includes("fish")) {
+    const confDir = import_path9.default.join(import_os5.default.homedir(), ".config", "fish", "conf.d");
+    return { name: "fish", rcFile: import_path9.default.join(confDir, "workscribe.fish") };
+  }
+  return null;
+}
+function step(current, total, label) {
+  log.plain(import_chalk2.default.bold(`
+  [${current}/${total}] ${label}`));
+}
+function registerInit(program2) {
+  program2.command("init").description("Set up Workscribe and install or update shell hooks").action(async () => {
+    const TOTAL_STEPS = 5;
+    log.plain(import_chalk2.default.bold("\n  Workscribe \u2014 Developer Work Journal\n"));
+    step(1, TOTAL_STEPS, "Creating data directories");
+    for (const dir of REQUIRED_DIRS) {
+      if (!import_fs13.default.existsSync(dir)) {
+        import_fs13.default.mkdirSync(dir, { recursive: true, mode: 448 });
+        log.success(`Created ${dir}`);
+      } else {
+        try {
+          import_fs13.default.chmodSync(dir, 448);
+        } catch {
+        }
+        log.info(`${dir} already exists`);
+      }
+    }
+    if (!import_fs13.default.existsSync(PROFILES_DIR)) {
+      import_fs13.default.mkdirSync(PROFILES_DIR, { recursive: true, mode: 448 });
+    }
+    step(2, TOTAL_STEPS, "Initialising database");
+    getDb();
+    log.success("Database ready");
+    step(3, TOTAL_STEPS, "Installing shell hook");
+    const shell = detectShell();
+    if (!shell) {
+      log.warn("Could not detect shell. Supported: zsh, bash, fish");
+      log.plain(
+        `  Manually add the hook from: ${import_chalk2.default.cyan("shell/hook.zsh")}, ${import_chalk2.default.cyan("shell/hook.bash")}, or ${import_chalk2.default.cyan("shell/hook.fish")}`
+      );
+    } else {
+      const hookFile = import_path9.default.join(__dirname, "..", "shell", `hook.${shell.name}`);
+      if (!import_fs13.default.existsSync(hookFile)) {
+        log.warn(`Hook template not found at ${hookFile}`);
+      } else {
+        const hookContent = import_fs13.default.readFileSync(hookFile, "utf-8");
+        if (shell.name === "fish") {
+          const confDir = import_path9.default.dirname(shell.rcFile);
+          if (!import_fs13.default.existsSync(confDir)) import_fs13.default.mkdirSync(confDir, { recursive: true });
+        }
+        if (!import_fs13.default.existsSync(shell.rcFile)) import_fs13.default.writeFileSync(shell.rcFile, "");
+        if (!isHookInstalled(shell.rcFile)) {
+          log.plain("");
+          log.plain(import_chalk2.default.dim("  Workscribe adds a lightweight hook to your shell that captures each"));
+          log.plain(import_chalk2.default.dim("  command you run \u2014 the text, exit code, duration, and working directory."));
+          log.plain(import_chalk2.default.dim("  It runs in the background and adds no latency to your terminal."));
+          log.plain(import_chalk2.default.dim("  Credentials and secrets are redacted before anything is stored."));
+          log.plain("");
+          installHook(shell.rcFile, hookContent);
+          log.success(`Shell hook installed in ${shell.rcFile}`);
+        } else if (isHookOutdated(shell.rcFile, hookContent)) {
+          const { update } = await (0, import_prompts.default)({
+            type: "confirm",
+            name: "update",
+            message: `Shell hook in ${shell.rcFile} is outdated. Update?`,
+            initial: true
+          });
+          if (update) {
+            updateHook(shell.rcFile, hookContent);
+            log.success(`Shell hook updated in ${shell.rcFile}`);
+          } else {
+            log.info("Shell hook update skipped");
+          }
+        } else {
+          log.info(`Shell hook up to date in ${shell.rcFile}`);
+        }
+        if (isCompletionsInstalled(shell)) {
+          log.info("Shell completions already installed");
+        } else {
+          const { installComps } = await (0, import_prompts.default)({
+            type: "confirm",
+            name: "installComps",
+            message: "Install shell completions (tab-complete workscribe commands)?",
+            initial: true
+          });
+          if (installComps) {
+            try {
+              installCompletions(shell, getPublicCommands(program2));
+              log.success("Shell completions installed");
+            } catch (error) {
+              log.warn(`Completions install failed: ${error.message}`);
+            }
+          }
+        }
+      }
+    }
+    step(4, TOTAL_STEPS, "Detecting AI coding tools");
+    const installedTools = loadAIToolRegistry().filter(
       (entry) => entry.hook !== null && AI_HOOK_INTEGRATIONS[entry.hook]?.isInstalled()
     );
     if (installedTools.length === 0) {
@@ -1348,6 +1947,8 @@ function registerInit(program2) {
     } catch {
       log.info("Could not reach profile registry \u2014 run workscribe profile detect after connecting");
     }
+    step(5, TOTAL_STEPS, "Configuring AI provider");
+    let providerConfigured = !!config.ai.provider;
     if (config.ai.provider) {
       log.info(`AI provider already configured: ${import_chalk2.default.cyan(config.ai.provider)}`);
     } else {
@@ -1364,7 +1965,10 @@ function registerInit(program2) {
           { title: "Skip \u2014 configure later", value: "skip" }
         ]
       });
-      if (provider && provider !== "skip") {
+      if (!provider || provider === "skip") {
+        providerConfigured = false;
+        log.info("Skipped \u2014 run later: workscribe config set ai.provider <provider>");
+      } else {
         config.ai.provider = provider;
         if (provider === "ollama") {
           log.plain(`
@@ -1389,90 +1993,78 @@ function registerInit(program2) {
             if (baseUrl) config.ai.baseUrl = baseUrl;
           }
         }
-        writeConfig(config);
-        log.success(`AI provider set to ${import_chalk2.default.cyan(provider)}`);
-      } else if (provider === "skip" || !provider) {
-        log.info("Skipped \u2014 run later: workscribe config set ai.provider <provider>");
+        log.plain("");
+        log.info(`Validating ${import_chalk2.default.cyan(provider)} connection\u2026`);
+        try {
+          const testProvider = getProvider(config);
+          await testProvider.validate();
+          log.success("API key verified");
+          writeConfig(config);
+          providerConfigured = true;
+        } catch (error) {
+          log.warn(`Validation failed: ${error.message}`);
+          const { retry } = await (0, import_prompts.default)({
+            type: "confirm",
+            name: "retry",
+            message: "Save anyway and configure later?",
+            initial: false
+          });
+          if (retry) {
+            writeConfig(config);
+            providerConfigured = false;
+            log.info("Config saved \u2014 run workscribe config set ai.apiKey <key> to update");
+          } else {
+            log.info("API key not saved \u2014 run workscribe init again to configure");
+            providerConfigured = false;
+          }
+        }
       }
     }
-    if (!import_fs12.default.existsSync(CONFIG_PATH)) {
+    if (!import_fs13.default.existsSync(CONFIG_PATH)) {
       writeConfig(config);
-      log.success("Config file created");
     }
     log.plain("");
     log.plain(import_chalk2.default.bold("  Setup complete!"));
+    log.plain("");
     if (shell) {
+      log.plain(`  Activate capture now:`);
+      if (shell.name === "fish") {
+        log.plain(`    Restart your terminal`);
+        log.plain(`    ${import_chalk2.default.dim(`or run: source ${shell.rcFile}`)}`);
+      } else {
+        log.plain(`    ${import_chalk2.default.cyan(`source ${shell.rcFile}`)}`);
+        log.plain(`  Or restart your terminal.`);
+      }
       log.plain("");
-      log.plain(`  Activate capture now:  ${import_chalk2.default.cyan(`source ${shell.rcFile}`)}`);
-      log.plain(`  Or restart your terminal.`);
     }
-    log.plain("");
-    log.plain(`  ${import_chalk2.default.dim("workscribe summary")}   \u2014 generate today's work summary`);
-    log.plain(`  ${import_chalk2.default.dim("workscribe status")}    \u2014 check capture is working`);
+    if (providerConfigured) {
+      log.plain(`  Then run a few commands and generate your first summary:`);
+      log.plain(`    ${import_chalk2.default.cyan("workscribe summary")}`);
+      log.plain("");
+      log.plain(`  Check capture is working:`);
+      log.plain(`    ${import_chalk2.default.cyan("workscribe status")}`);
+    } else {
+      log.plain(`  Before generating summaries, configure an AI provider:`);
+      log.plain(`    ${import_chalk2.default.cyan("workscribe config set ai.provider anthropic")}`);
+      log.plain(`    ${import_chalk2.default.cyan("workscribe config set ai.apiKey <your-key>")}`);
+      log.plain("");
+      log.plain(`  Then run:`);
+      log.plain(`    ${import_chalk2.default.cyan("workscribe summary")}`);
+    }
     log.plain("");
   });
 }
 
 // src/cli/status.ts
-var import_fs13 = __toESM(require("fs"));
+var import_fs14 = __toESM(require("fs"));
 var import_chalk3 = __toESM(require("chalk"));
-
-// src/utils/format.ts
-function formatDuration(minutes) {
-  if (minutes < 60) return `${Math.round(minutes)}m`;
-  const h = Math.floor(minutes / 60);
-  const m = Math.round(minutes % 60);
-  return m > 0 ? `${h}h ${m}m` : `${h}h`;
-}
-function formatDate(isoString) {
-  return new Date(isoString).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
-}
-function todayDate() {
-  return localDateStr(/* @__PURE__ */ new Date());
-}
-function parseDate(input) {
-  const d = /* @__PURE__ */ new Date(input + "T00:00:00");
-  if (isNaN(d.getTime())) throw new Error(`Invalid date: ${input}`);
-  return input;
-}
-function localDateStr(d) {
-  const y = d.getFullYear();
-  const m = String(d.getMonth() + 1).padStart(2, "0");
-  const day = String(d.getDate()).padStart(2, "0");
-  return `${y}-${m}-${day}`;
-}
-function startOfWeek(dateStr) {
-  const d = /* @__PURE__ */ new Date(dateStr + "T00:00:00");
-  const day = d.getDay();
-  const diff = day === 0 ? -6 : 1 - day;
-  d.setDate(d.getDate() + diff);
-  return localDateStr(d);
-}
-function eachDayOfRange(start, end) {
-  const days = [];
-  const cur = /* @__PURE__ */ new Date(start + "T00:00:00");
-  const last = /* @__PURE__ */ new Date(end + "T00:00:00");
-  while (cur <= last) {
-    days.push(localDateStr(cur));
-    cur.setDate(cur.getDate() + 1);
-  }
-  return days;
-}
-function isoWeekKey(dateStr) {
-  const d = /* @__PURE__ */ new Date(dateStr + "T00:00:00");
-  const jan4 = new Date(d.getFullYear(), 0, 4);
-  const weekNum = Math.ceil(((d.getTime() - jan4.getTime()) / 864e5 + jan4.getDay() + 1) / 7);
-  return `${d.getFullYear()}-W${String(weekNum).padStart(2, "0")}`;
-}
-
-// src/cli/status.ts
 function registerStatus(program2) {
   program2.command("status").description("Show capture status and event counts").action(() => {
     const config = readConfig();
     const total = getEventCount();
     const todayEvents = getEventsForDate(todayDate());
     const last = getLastEvent();
-    const isPaused = import_fs13.default.existsSync(PAUSE_FLAG_PATH);
+    const isPaused = import_fs14.default.existsSync(PAUSE_FLAG_PATH);
     log.plain("");
     log.plain(import_chalk3.default.bold("  Workscribe Status"));
     log.plain("");
@@ -1515,181 +2107,28 @@ function registerStatus(program2) {
 }
 
 // src/cli/events.ts
-var import_chalk4 = __toESM(require("chalk"));
-var CATEGORY_COLORS = {
-  shipping: import_chalk4.default.green,
-  versioning: import_chalk4.default.blue,
-  building: import_chalk4.default.cyan,
-  running: import_chalk4.default.white,
-  testing: import_chalk4.default.magenta,
-  linting: import_chalk4.default.yellow,
-  dependencies: import_chalk4.default.yellow,
-  infrastructure: import_chalk4.default.red,
-  releasing: import_chalk4.default.bold.green,
-  database: import_chalk4.default.bold.blue,
-  files: import_chalk4.default.dim.yellow,
-  exploring: import_chalk4.default.dim.cyan,
-  ai_session: import_chalk4.default.bold.magenta,
-  other: import_chalk4.default.gray
-};
-var AI_TOOL_DISPLAY_NAMES = Object.fromEntries(
-  loadAIToolRegistry().map((entry) => [entry.tool, entry.displayName])
-);
-function registerEvents(program2) {
-  program2.command("events").description("List captured events").option("--date <YYYY-MM-DD>", "date to list events for (default: today)").option("--limit <n>", "max events to show", parseInt).action((opts) => {
-    let date = todayDate();
-    if (opts.date) {
-      try {
-        date = parseDate(opts.date);
-      } catch (e) {
-        log.error(e.message);
-        process.exit(1);
-      }
-    }
-    const events = getEventsForDate(date);
-    const limit = opts.limit ?? events.length;
-    if (events.length === 0) {
-      log.plain(`No events captured for ${date}`);
-      return;
-    }
-    log.plain("");
-    log.plain(import_chalk4.default.bold(`  Events for ${date}  (${events.length} total)`));
-    log.plain("");
-    for (const event of events.slice(0, limit)) {
-      const colorFn = CATEGORY_COLORS[event.category] ?? import_chalk4.default.gray;
-      const time = formatDate(event.captured_at);
-      const category = colorFn(event.category.padEnd(20));
-      const repo = event.repo_name ? import_chalk4.default.dim(` [${event.repo_name}]`) : "";
-      const exitBadge = event.exit_code && event.exit_code !== 0 ? import_chalk4.default.red(` \u2717${event.exit_code}`) : "";
-      let cmdDisplay;
-      if (event.category === "ai_session") {
-        let meta = {};
-        try {
-          meta = event.metadata ? JSON.parse(event.metadata) : {};
-        } catch {
-        }
-        const toolKey = typeof meta.tool === "string" ? meta.tool : "";
-        const toolName = AI_TOOL_DISPLAY_NAMES[toolKey] ?? toolKey;
-        cmdDisplay = import_chalk4.default.white(toolName.padEnd(20)) + import_chalk4.default.magenta(" \u2726");
-      } else {
-        cmdDisplay = import_chalk4.default.dim(event.command.slice(0, 55));
-      }
-      log.plain(`  ${import_chalk4.default.dim(time)}  ${category}  ${cmdDisplay}${repo}${exitBadge}`);
-    }
-    if (limit < events.length) {
-      log.plain("");
-      log.plain(import_chalk4.default.dim(`  \u2026 and ${events.length - limit} more (remove --limit to see all)`));
-    }
-    log.plain("");
-  });
-}
-
-// src/cli/sessions.ts
-var import_chalk5 = __toESM(require("chalk"));
-
-// src/sessions/grouper.ts
-function splitByIdleGap(events, idleMs) {
-  if (events.length === 0) return [];
-  const groups = [[events[0]]];
-  for (let i = 1; i < events.length; i++) {
-    const prev = new Date(events[i - 1].captured_at).getTime();
-    const curr = new Date(events[i].captured_at).getTime();
-    if (curr - prev >= idleMs) {
-      groups.push([events[i]]);
-    } else {
-      groups[groups.length - 1].push(events[i]);
-    }
-  }
-  return groups;
-}
-function splitByRepo(events) {
-  if (events.length === 0) return [];
-  const groups = [[events[0]]];
-  for (let i = 1; i < events.length; i++) {
-    const prevRepo = events[i - 1].repo_name;
-    const currRepo = events[i].repo_name;
-    if (currRepo !== prevRepo) {
-      groups.push([events[i]]);
-    } else {
-      groups[groups.length - 1].push(events[i]);
-    }
-  }
-  return groups;
-}
-function minutesBetween(start, end) {
-  return (new Date(end).getTime() - new Date(start).getTime()) / 6e4;
-}
-
-// src/sessions/detector.ts
-function getOrBuildSessions(date) {
-  const existing = getSessionsForDate(date);
-  const events = getEventsForDate(date);
-  if (events.length === 0) return [];
-  const cachedEventCount = existing.reduce((sum, sessionRow) => sum + sessionRow.event_count, 0);
-  if (existing.length > 0 && cachedEventCount === events.length) {
-    return existing.map((sessionRow) => ({
-      id: sessionRow.id,
-      date: sessionRow.date,
-      startedAt: sessionRow.started_at,
-      endedAt: sessionRow.ended_at,
-      repoName: sessionRow.repo_name,
-      durationMinutes: minutesBetween(sessionRow.started_at, sessionRow.ended_at),
-      eventCount: sessionRow.event_count,
-      summary: sessionRow.summary,
-      events: getEventsBySessionId(sessionRow.id)
-    }));
-  }
-  const savedSummaries = /* @__PURE__ */ new Map();
-  for (const s of existing) {
-    if (s.summary) savedSummaries.set(`${s.repo_name}|${s.started_at}`, s.summary);
-  }
-  clearSessionsForDate(date);
-  return buildSessions(date, events, savedSummaries);
-}
-function buildSessions(date, events, savedSummaries = /* @__PURE__ */ new Map()) {
-  const config = readConfig();
-  const idleMs = config.session.idleTimeout * 60 * 1e3;
-  const sessions = [];
-  const timeGroups = splitByIdleGap(events, idleMs);
-  for (const group of timeGroups) {
-    if (group.length === 0) continue;
-    const repoGroups = splitByRepo(group);
-    for (const repoGroup of repoGroups) {
-      if (repoGroup.length === 0) continue;
-      const first = repoGroup[0];
-      const last = repoGroup[repoGroup.length - 1];
-      const repoName = last.repo_name ?? first.repo_name ?? null;
-      const summary = savedSummaries.get(`${repoName}|${first.captured_at}`) ?? null;
-      const sessionId = insertSession({
-        date,
-        started_at: first.captured_at,
-        ended_at: last.captured_at,
-        repo_name: repoName,
-        event_count: repoGroup.length,
-        summary
-      });
-      for (const event of repoGroup) {
-        insertSessionEvent(sessionId, event.id);
-      }
-      sessions.push({
-        id: sessionId,
-        date,
-        startedAt: first.captured_at,
-        endedAt: last.captured_at,
-        repoName,
-        durationMinutes: minutesBetween(first.captured_at, last.captured_at),
-        eventCount: repoGroup.length,
-        summary,
-        events: repoGroup
-      });
-    }
-  }
-  return sessions;
-}
-
-// src/cli/sessions.ts
-function registerSessions(program2) {
-  program2.command("sessions").description("List detected work sessions").option("--date <YYYY-MM-DD>", "date to show sessions for (default: today)").action((opts) => {
+var import_chalk4 = __toESM(require("chalk"));
+var CATEGORY_COLORS = {
+  shipping: import_chalk4.default.green,
+  versioning: import_chalk4.default.blue,
+  building: import_chalk4.default.cyan,
+  running: import_chalk4.default.white,
+  testing: import_chalk4.default.magenta,
+  linting: import_chalk4.default.yellow,
+  dependencies: import_chalk4.default.yellow,
+  infrastructure: import_chalk4.default.red,
+  releasing: import_chalk4.default.bold.green,
+  database: import_chalk4.default.bold.blue,
+  files: import_chalk4.default.dim.yellow,
+  exploring: import_chalk4.default.dim.cyan,
+  ai_session: import_chalk4.default.bold.magenta,
+  other: import_chalk4.default.gray
+};
+var AI_TOOL_DISPLAY_NAMES = Object.fromEntries(
+  loadAIToolRegistry().map((entry) => [entry.tool, entry.displayName])
+);
+function registerEvents(program2) {
+  program2.command("events").description("List captured events").option("--date <YYYY-MM-DD>", "date to list events for (default: today)").option("--limit <n>", "max events to show", parseInt).action((opts) => {
     let date = todayDate();
     if (opts.date) {
       try {
@@ -1699,383 +2138,196 @@ function registerSessions(program2) {
         process.exit(1);
       }
     }
-    const sessions = getOrBuildSessions(date);
-    if (sessions.length === 0) {
-      log.plain(`No sessions detected for ${date}`);
+    const events = getEventsForDate(date);
+    const limit = opts.limit ?? events.length;
+    if (events.length === 0) {
+      log.plain(`No events captured for ${date}`);
       return;
     }
     log.plain("");
-    log.plain(import_chalk5.default.bold(`  Sessions for ${date}  (${sessions.length} session${sessions.length > 1 ? "s" : ""})`));
-    log.plain("");
-    for (const session of sessions) {
-      const start = formatDate(session.startedAt);
-      const end = formatDate(session.endedAt);
-      const duration = formatDuration(session.durationMinutes);
-      const repo = session.repoName ? import_chalk5.default.cyan(session.repoName) : import_chalk5.default.gray("no repo");
-      log.plain(
-        `  ${import_chalk5.default.dim(start)} \u2013 ${import_chalk5.default.dim(end)}  ${repo}  ${import_chalk5.default.dim(duration)}  ${import_chalk5.default.dim(session.eventCount + " events")}`
-      );
-    }
+    log.plain(import_chalk4.default.bold(`  Events for ${date}  (${events.length} total)`));
     log.plain("");
-  });
-}
-
-// src/cli/summary.ts
-var import_chalk6 = __toESM(require("chalk"));
-var import_fs14 = __toESM(require("fs"));
-var import_os5 = __toESM(require("os"));
-var import_path10 = __toESM(require("path"));
-
-// src/ai/prompt.ts
-var SYSTEM_PROMPT = `You write short developer work summaries. Here is an example:
-
-INPUT:
-Project: api-service
-Branch: feature/auth
-Duration: 2h 00m
-Events:
-  - versioning {"branch":"feature/auth"}
-  - 2x dependencies {"tool":"npm","packages":["bcrypt","jsonwebtoken"]}
-  - 2x testing {"tool":"jest"} [failed]
-  - testing {"tool":"jest"}
-  - 2x files {"tool":"mkdir"}
-  - shipping {"message":"fix: auth token validation"}
-  - shipping {"remote":"origin","branch":"feature/auth"}
-
-OUTPUT:
-- Switched to the authentication feature branch and added authentication dependencies (bcrypt, JWT)
-- Resolved failing auth tests
-- Committed and pushed authentication fixes
-
-For dependencies events with a packages field: infer the purpose of packages from their names and describe the domain, not just the packages. Examples: bcrypt/jsonwebtoken \u2192 authentication, prisma/mongoose/pg \u2192 database, jest/vitest/mocha \u2192 testing, axios/got/node-fetch \u2192 HTTP client, stripe/paypal \u2192 payments, socket.io/ws \u2192 real-time. Use your knowledge of common packages. For unfamiliar packages, name them directly without guessing their domain.
-
-Events like shipping (pushes), building, versioning (branch switches, stash), files (file ops, env vars), and infrastructure provide context \u2014 fold them into the surrounding narrative rather than listing them as separate bullets. Only surface them directly when they are the main activity (e.g. a standalone build fix, a deploy, or a significant restructure with no accompanying commits).
-
-For ai_session events: describe what was built during the AI session using the tool name (e.g. "via Claude Code"). If a commits array is present in metadata, use those commit messages to describe what was built. Group all activity from the session into one narrative bullet.
-
-For other events with a hint field: interpret the command snippet and describe the activity in plain language. Do not quote the raw command.
-
-Maximum 5 bullets. Output ONLY the bullet points, nothing else.`;
-function getSystemPrompt() {
-  const contexts = getActiveProfileAiContexts();
-  if (contexts.length === 0) return SYSTEM_PROMPT;
-  return SYSTEM_PROMPT + "\n\n" + contexts.join("\n");
-}
-var EXCLUDED = /* @__PURE__ */ new Set(["exploring"]);
-function buildUserMessage(payload) {
-  const lines = [`Date: ${payload.date}`, ""];
-  for (const session of payload.sessions) {
-    lines.push(`Project: ${session.project ?? "unknown"}`);
-    if (session.branch) lines.push(`Branch: ${session.branch}`);
-    lines.push(`Duration: ${formatDuration(session.durationMinutes)}`);
-    lines.push("Events:");
-    const counts = /* @__PURE__ */ new Map();
-    for (const event of session.events) {
-      if (EXCLUDED.has(event.category)) continue;
-      const failed = event.exitCode !== null && event.exitCode !== 0 ? " [failed]" : "";
-      let key;
-      if (event.hint) {
-        key = `other  [${event.hint}]${failed}`;
+    for (const event of events.slice(0, limit)) {
+      const colorFn = CATEGORY_COLORS[event.category] ?? import_chalk4.default.gray;
+      const time = formatDate(event.captured_at);
+      const category = colorFn(event.category.padEnd(20));
+      const repo = event.repo_name ? import_chalk4.default.dim(` [${event.repo_name}]`) : "";
+      const exitBadge = event.exit_code && event.exit_code !== 0 ? import_chalk4.default.red(` \u2717${event.exit_code}`) : "";
+      let cmdDisplay;
+      if (event.category === "ai_session") {
+        let meta = {};
+        try {
+          meta = event.metadata ? JSON.parse(event.metadata) : {};
+        } catch {
+        }
+        const toolKey = typeof meta.tool === "string" ? meta.tool : "";
+        const toolName = AI_TOOL_DISPLAY_NAMES[toolKey] ?? toolKey;
+        cmdDisplay = import_chalk4.default.white(toolName.padEnd(20)) + import_chalk4.default.magenta(" \u2726");
       } else {
-        const meta = Object.keys(event.metadata).length > 0 ? ` ${JSON.stringify(event.metadata)}` : "";
-        key = `${event.category}${meta}${failed}`;
+        cmdDisplay = import_chalk4.default.dim(event.command.slice(0, 55));
       }
-      counts.set(key, (counts.get(key) ?? 0) + 1);
+      log.plain(`  ${import_chalk4.default.dim(time)}  ${category}  ${cmdDisplay}${repo}${exitBadge}`);
     }
-    for (const [key, count] of counts) {
-      lines.push(`  - ${count > 1 ? `${count}x ` : ""}${key}`);
+    if (limit < events.length) {
+      log.plain("");
+      log.plain(import_chalk4.default.dim(`  \u2026 and ${events.length - limit} more (remove --limit to see all)`));
     }
-    lines.push("");
-  }
-  return lines.join("\n");
+    log.plain("");
+  });
 }
-var WEEKLY_SYSTEM_PROMPT = `You write short weekly developer summaries. Here is an example:
-
-INPUT:
-Week: 2026-05-18 to 2026-05-22
-
-Monday 2026-05-18:
-  Project: api-service (feature/auth) \u2014 2h 10m
-  Events: 3x code_commit, 2x test_run, dependency_install
-
-Tuesday 2026-05-19:
-  Project: api-service (feature/auth) \u2014 1h 30m
-  Events: 2x code_commit, test_run, build
-
-Wednesday 2026-05-20:
-  Project: dashboard (main) \u2014 3h 00m
-  Events: 4x code_commit, 2x build, test_run
-
-Thursday 2026-05-21:
-  Project: api-service (feature/auth) \u2014 1h 00m
-  Events: code_commit {"message":"feat: merge auth"}, branch_switch
-
-Friday 2026-05-22:
-  Project: dashboard (main) \u2014 2h 00m
-  Events: 3x code_commit, build
-
-OUTPUT:
-## Week of 18 May \u2014 9h 40m across 2 projects
-
-**api-service** (Mon\u2013Thu): Built and shipped the auth feature \u2014 JWT setup, token validation fixes, and final merge.
-**dashboard** (Wed, Fri): Active development across 7 commits with builds passing.
 
-Now summarise the following week. Output ONLY the summary \u2014 a one-line header then one bullet per active project. Maximum 4 bullets.`;
-var DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
-function buildWeeklyMessage(payload) {
-  const lines = [`Week: ${payload.weekStart} to ${payload.weekEnd}`, ""];
-  for (const { date, sessions } of payload.days) {
-    const dayName = DAY_NAMES[(/* @__PURE__ */ new Date(date + "T00:00:00")).getDay()];
-    lines.push(`${dayName} ${date}:`);
-    for (const s of sessions) {
-      const project = s.project ?? "unknown";
-      const branch = s.branch ? ` (${s.branch})` : "";
-      lines.push(`  Project: ${project}${branch} \u2014 ${formatDuration(s.durationMinutes)}`);
-      const counts = /* @__PURE__ */ new Map();
-      for (const e of s.events) {
-        if (EXCLUDED.has(e.category)) continue;
-        const failed = e.exitCode !== null && e.exitCode !== 0 ? " [failed]" : "";
-        let key;
-        if (e.hint) {
-          key = `other  [${e.hint}]${failed}`;
-        } else {
-          const meta = Object.keys(e.metadata).length > 0 ? ` ${JSON.stringify(e.metadata)}` : "";
-          key = `${e.category}${meta}${failed}`;
-        }
-        counts.set(key, (counts.get(key) ?? 0) + 1);
-      }
-      const eventLine = [...counts.entries()].map(([k, n]) => `${n > 1 ? `${n}x ` : ""}${k}`).join(", ");
-      lines.push(`  Events: ${eventLine}`);
-    }
-    lines.push("");
-  }
-  return lines.join("\n");
-}
+// src/cli/sessions.ts
+var import_chalk5 = __toESM(require("chalk"));
 
-// src/ai/fetch.ts
-var DEFAULT_TIMEOUT_MS = 3e4;
-async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await fetch(url, { ...init, signal: controller.signal });
-  } catch (err) {
-    if (err.name === "AbortError") {
-      throw new Error(`Request timed out after ${timeoutMs / 1e3}s`);
+// src/sessions/grouper.ts
+function splitByIdleGap(events, idleMs) {
+  if (events.length === 0) return [];
+  const groups = [[events[0]]];
+  for (let i = 1; i < events.length; i++) {
+    const prev = new Date(events[i - 1].captured_at).getTime();
+    const curr = new Date(events[i].captured_at).getTime();
+    if (curr - prev >= idleMs) {
+      groups.push([events[i]]);
+    } else {
+      groups[groups.length - 1].push(events[i]);
     }
-    throw err;
-  } finally {
-    clearTimeout(timer);
   }
+  return groups;
 }
-
-// src/ai/providers/anthropic.ts
-var AnthropicProvider = class {
-  apiKey;
-  model;
-  constructor(apiKey, model) {
-    this.apiKey = apiKey;
-    this.model = model || "claude-haiku-4-5-20251001";
-  }
-  async summarize(payload) {
-    const response = await fetchWithTimeout("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.apiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify({
-        model: this.model,
-        max_tokens: 1024,
-        system: getSystemPrompt(),
-        messages: [{ role: "user", content: buildUserMessage(payload) }]
-      })
-    });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`Anthropic API error ${response.status}: ${body}`);
-    }
-    const data = await response.json();
-    return data.content.find((block) => block.type === "text")?.text ?? "";
-  }
-  async summarizeWeek(payload) {
-    const response = await fetchWithTimeout("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.apiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify({
-        model: this.model,
-        max_tokens: 1024,
-        system: WEEKLY_SYSTEM_PROMPT,
-        messages: [{ role: "user", content: buildWeeklyMessage(payload) }]
-      })
-    });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`Anthropic API error ${response.status}: ${body}`);
-    }
-    const data = await response.json();
-    return data.content.find((block) => block.type === "text")?.text ?? "";
-  }
-};
-
-// src/ai/providers/openai.ts
-var OpenAIProvider = class {
-  apiKey;
-  model;
-  baseUrl;
-  constructor(apiKey, model, baseUrl) {
-    this.apiKey = apiKey;
-    this.model = model || "gpt-4o-mini";
-    this.baseUrl = baseUrl || "https://api.openai.com/v1";
-  }
-  async summarize(payload) {
-    const response = await fetchWithTimeout(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.model,
-        messages: [
-          { role: "system", content: getSystemPrompt() },
-          { role: "user", content: buildUserMessage(payload) }
-        ],
-        max_tokens: 1024
-      })
-    });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`OpenAI API error ${response.status}: ${body}`);
-    }
-    const data = await response.json();
-    return data.choices[0]?.message?.content ?? "";
-  }
-  async summarizeWeek(payload) {
-    const response = await fetchWithTimeout(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.model,
-        messages: [
-          { role: "system", content: WEEKLY_SYSTEM_PROMPT },
-          { role: "user", content: buildWeeklyMessage(payload) }
-        ],
-        max_tokens: 1024
-      })
-    });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`OpenAI API error ${response.status}: ${body}`);
-    }
-    const data = await response.json();
-    return data.choices[0]?.message?.content ?? "";
-  }
-};
-
-// src/ai/providers/ollama.ts
-var OllamaProvider = class {
-  model;
-  baseUrl;
-  constructor(model, baseUrl) {
-    this.model = model || "llama3";
-    this.baseUrl = baseUrl || "http://localhost:11434";
-  }
-  async summarize(payload) {
-    const response = await fetchWithTimeout(`${this.baseUrl}/api/chat`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: this.model,
-        stream: false,
-        messages: [
-          { role: "system", content: getSystemPrompt() },
-          { role: "user", content: buildUserMessage(payload) }
-        ],
-        options: {
-          num_predict: 300,
-          // hard cap on output tokens — forces conciseness
-          temperature: 0.3
-          // lower temperature = more focused, less wandering
-        }
-      })
-    });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`Ollama error ${response.status}: ${body}. Is Ollama running? Try: ollama serve`);
-    }
-    const data = await response.json();
-    return data.message?.content ?? "";
-  }
-  async summarizeWeek(payload) {
-    const response = await fetchWithTimeout(`${this.baseUrl}/api/chat`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: this.model,
-        stream: false,
-        messages: [
-          { role: "system", content: WEEKLY_SYSTEM_PROMPT },
-          { role: "user", content: buildWeeklyMessage(payload) }
-        ],
-        options: {
-          num_predict: 400,
-          temperature: 0.3
-        }
-      })
-    });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`Ollama error ${response.status}: ${body}. Is Ollama running? Try: ollama serve`);
+function splitByRepo(events) {
+  if (events.length === 0) return [];
+  const groups = [[events[0]]];
+  for (let i = 1; i < events.length; i++) {
+    const prevRepo = events[i - 1].repo_name;
+    const currRepo = events[i].repo_name;
+    if (currRepo !== prevRepo) {
+      groups.push([events[i]]);
+    } else {
+      groups[groups.length - 1].push(events[i]);
     }
-    const data = await response.json();
-    return data.message?.content ?? "";
   }
-};
+  return groups;
+}
+function minutesBetween(start, end) {
+  return (new Date(end).getTime() - new Date(start).getTime()) / 6e4;
+}
 
-// src/ai/router.ts
-function getProvider(config) {
-  const { provider, apiKey, model, baseUrl } = config.ai;
-  if (!provider) {
-    throw new Error(
-      "No AI provider configured.\nRun: workscribe config set ai.provider <anthropic|openai|ollama|openai-compatible>"
-    );
+// src/sessions/detector.ts
+function getOrBuildSessions(date) {
+  const existing = getSessionsForDate(date);
+  const events = getEventsForDate(date);
+  if (events.length === 0) return [];
+  const cachedEventCount = existing.reduce((sum, sessionRow) => sum + sessionRow.event_count, 0);
+  if (existing.length > 0 && cachedEventCount === events.length) {
+    return existing.map((sessionRow) => ({
+      id: sessionRow.id,
+      date: sessionRow.date,
+      startedAt: sessionRow.started_at,
+      endedAt: sessionRow.ended_at,
+      repoName: sessionRow.repo_name,
+      durationMinutes: minutesBetween(sessionRow.started_at, sessionRow.ended_at),
+      eventCount: sessionRow.event_count,
+      summary: sessionRow.summary,
+      events: getEventsBySessionId(sessionRow.id)
+    }));
   }
-  switch (provider) {
-    case "anthropic": {
-      if (!apiKey) throw new Error("Anthropic requires an API key.\nRun: workscribe config set ai.apiKey <your-key>");
-      return new AnthropicProvider(apiKey, model || void 0);
-    }
-    case "openai": {
-      if (!apiKey) throw new Error("OpenAI requires an API key.\nRun: workscribe config set ai.apiKey <your-key>");
-      return new OpenAIProvider(apiKey, model || void 0);
+  const savedSummaries = /* @__PURE__ */ new Map();
+  for (const s of existing) {
+    if (s.summary) savedSummaries.set(`${s.repo_name}|${s.started_at}`, s.summary);
+  }
+  clearSessionsForDate(date);
+  return buildSessions(date, events, savedSummaries);
+}
+function buildSessions(date, events, savedSummaries = /* @__PURE__ */ new Map()) {
+  const config = readConfig();
+  const idleMs = config.session.idleTimeout * 60 * 1e3;
+  const sessions = [];
+  const timeGroups = splitByIdleGap(events, idleMs);
+  for (const group of timeGroups) {
+    if (group.length === 0) continue;
+    const repoGroups = splitByRepo(group);
+    for (const repoGroup of repoGroups) {
+      if (repoGroup.length === 0) continue;
+      const first = repoGroup[0];
+      const last = repoGroup[repoGroup.length - 1];
+      const repoName = last.repo_name ?? first.repo_name ?? null;
+      const summary = savedSummaries.get(`${repoName}|${first.captured_at}`) ?? null;
+      const sessionId = insertSession({
+        date,
+        started_at: first.captured_at,
+        ended_at: last.captured_at,
+        repo_name: repoName,
+        event_count: repoGroup.length,
+        summary
+      });
+      for (const event of repoGroup) {
+        insertSessionEvent(sessionId, event.id);
+      }
+      sessions.push({
+        id: sessionId,
+        date,
+        startedAt: first.captured_at,
+        endedAt: last.captured_at,
+        repoName,
+        durationMinutes: minutesBetween(first.captured_at, last.captured_at),
+        eventCount: repoGroup.length,
+        summary,
+        events: repoGroup
+      });
     }
-    case "openai-compatible": {
-      if (!apiKey)
-        throw new Error("This provider requires an API key.\nRun: workscribe config set ai.apiKey <your-key>");
-      if (!baseUrl)
-        throw new Error("openai-compatible requires a base URL.\nRun: workscribe config set ai.baseUrl <url>");
-      return new OpenAIProvider(apiKey, model || void 0, baseUrl);
+  }
+  return sessions;
+}
+
+// src/cli/sessions.ts
+function registerSessions(program2) {
+  program2.command("sessions").description("List detected work sessions").option("--date <YYYY-MM-DD>", "date to show sessions for (default: today)").action((opts) => {
+    let date = todayDate();
+    if (opts.date) {
+      try {
+        date = parseDate(opts.date);
+      } catch (error) {
+        log.error(error.message);
+        process.exit(1);
+      }
     }
-    case "ollama": {
-      return new OllamaProvider(model || void 0, baseUrl || void 0);
+    const sessions = getOrBuildSessions(date);
+    if (sessions.length === 0) {
+      log.plain(`No sessions detected for ${date}`);
+      return;
     }
-    default:
-      throw new Error(
-        `Unknown provider: "${provider}"
-Supported providers: anthropic, openai, ollama, openai-compatible`
+    log.plain("");
+    log.plain(import_chalk5.default.bold(`  Sessions for ${date}  (${sessions.length} session${sessions.length > 1 ? "s" : ""})`));
+    log.plain("");
+    for (const session of sessions) {
+      const start = formatDate(session.startedAt);
+      const end = formatDate(session.endedAt);
+      const duration = formatDuration(session.durationMinutes);
+      const repo = session.repoName ? import_chalk5.default.cyan(session.repoName) : import_chalk5.default.gray("no repo");
+      log.plain(
+        `  ${import_chalk5.default.dim(start)} \u2013 ${import_chalk5.default.dim(end)}  ${repo}  ${import_chalk5.default.dim(duration)}  ${import_chalk5.default.dim(session.eventCount + " events")}`
       );
-  }
+      for (const event of session.events) {
+        if (event.category === "note") {
+          let text = "";
+          try {
+            text = JSON.parse(event.metadata ?? "{}").text ?? "";
+          } catch {
+          }
+          if (text) log.plain(`    ${import_chalk5.default.yellow("note")}  ${import_chalk5.default.dim(text)}`);
+        }
+      }
+    }
+    log.plain("");
+  });
 }
 
+// src/cli/summary.ts
+var import_chalk6 = __toESM(require("chalk"));
+var import_fs15 = __toESM(require("fs"));
+var import_os6 = __toESM(require("os"));
+var import_path10 = __toESM(require("path"));
+
 // src/integrations/webhook.ts
 async function postToWebhook(url, text) {
   const response = await fetchWithTimeout(
@@ -2121,7 +2373,7 @@ function eventRowToPayload(row) {
   };
   if (row.category === "other" && typeof metadata.hint === "string") {
     payload.hint = metadata.hint;
-    const { hint: _h, tool: _t, ...rest } = metadata;
+    const { hint: _hint, tool: _tool, ...rest } = metadata;
     payload.metadata = rest;
   }
   return payload;
@@ -2142,25 +2394,25 @@ async function handleWebhook(opts, config, summary) {
   if (webhookUrl) {
     try {
       log.info("Posting to webhook\u2026");
-      const username = import_os5.default.userInfo().username;
+      const username = import_os6.default.userInfo().username;
       const body = isSlackWebhookUrl(webhookUrl) ? formatForSlack(summary, username) : summary;
       await postToWebhook(webhookUrl, body);
       log.success("Posted.");
-    } catch (e) {
-      log.error(`Webhook failed: ${e.message}`);
+    } catch (error) {
+      log.error(`Webhook failed: ${error.message}`);
     }
   } else if (opts.slack && !config.integrations?.slackWebhook) {
     log.warn("--slack requires integrations.slackWebhook to be set in config");
   }
 }
 function registerSummary(program2) {
-  program2.command("summary").description("Generate an AI work summary").option("--date <YYYY-MM-DD>", "date to summarize (default: today)").option("--week", "summarize the current week").option("--fresh", "bypass cache and regenerate").option("--slack", "post summary to Slack webhook from config").option("--webhook <url>", "post summary to a custom webhook URL").action(async (opts) => {
+  program2.command("summary").description("Generate an AI work summary").option("--date <YYYY-MM-DD>", "date to summarize (default: today)").option("--week", "summarize the current week").option("--fresh", "bypass cache and regenerate").option("--verbose", "show all captured events including those not sent to AI").option("--slack", "post summary to Slack webhook from config").option("--webhook <url>", "post summary to a custom webhook URL").action(async (opts) => {
     const config = readConfig();
     let provider;
     try {
       provider = getProvider(config);
-    } catch (e) {
-      log.error(e.message);
+    } catch (error) {
+      log.error(error.message);
       process.exit(1);
     }
     if (opts.week) {
@@ -2180,8 +2432,8 @@ function registerSummary(program2) {
       }
       const cacheKey = isoWeekKey(today);
       const cacheFile = import_path10.default.join(WEEKLY_CACHE_DIR, `${cacheKey}.md`);
-      if (!opts.fresh && import_fs14.default.existsSync(cacheFile)) {
-        const cached = import_fs14.default.readFileSync(cacheFile, "utf-8");
+      if (!opts.fresh && import_fs15.default.existsSync(cacheFile)) {
+        const cached = import_fs15.default.readFileSync(cacheFile, "utf-8");
         log.plain("");
         log.plain(cached);
         log.plain("");
@@ -2197,11 +2449,11 @@ function registerSummary(program2) {
         log.plain("");
         log.plain(summary);
         log.plain("");
-        import_fs14.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
-        import_fs14.default.writeFileSync(cacheFile, summary, { encoding: "utf-8", mode: 384 });
+        import_fs15.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
+        import_fs15.default.writeFileSync(cacheFile, summary, { encoding: "utf-8", mode: 384 });
         await handleWebhook(opts, config, summary);
-      } catch (e) {
-        log.error(`Weekly summary failed [${config.ai.provider}]: ${e.message}`);
+      } catch (error) {
+        log.error(`Weekly summary failed [${config.ai.provider}]: ${error.message}`);
         process.exit(1);
       }
       return;
@@ -2210,8 +2462,8 @@ function registerSummary(program2) {
     if (opts.date) {
       try {
         date = parseDate(opts.date);
-      } catch (e) {
-        log.error(e.message);
+      } catch (error) {
+        log.error(error.message);
         process.exit(1);
       }
     }
@@ -2243,12 +2495,35 @@ function registerSummary(program2) {
         return;
       }
     }
+    const excluded = buildExcludedSet(config.summary?.includeCategories ?? []);
+    const allSessionPayloads = sessions.map((session) => sessionToPayload(session, date));
+    if (opts.verbose) {
+      log.plain("");
+      log.plain(import_chalk6.default.bold("  Captured events (--verbose):"));
+      for (const sessionPayload of allSessionPayloads) {
+        const branch = sessionPayload.branch ? ` (${sessionPayload.branch})` : "";
+        log.plain(
+          import_chalk6.default.dim(
+            `
+  ${sessionPayload.project ?? "unknown"}${branch} \u2014 ${formatDuration(sessionPayload.durationMinutes)}`
+          )
+        );
+        for (const event of sessionPayload.events) {
+          const tag = excluded.has(event.category) ? import_chalk6.default.dim(`  [excluded] ${event.category}`) : `  ${event.category}`;
+          const hint = event.hint ? import_chalk6.default.dim(` [${event.hint}]`) : "";
+          const meta = Object.keys(event.metadata).length > 0 ? import_chalk6.default.dim(` ${JSON.stringify(event.metadata)}`) : "";
+          log.plain(`    ${tag}${hint}${meta}`);
+        }
+      }
+      log.plain("");
+    }
     log.plain("");
     log.info(`Generating summary via ${import_chalk6.default.cyan(config.ai.provider)}\u2026`);
     const allSummaries = [];
     const jsonSessions = [];
-    for (const session of sessions) {
-      const sessionPayload = { date, sessions: [sessionToPayload(session, date)] };
+    for (let index = 0; index < sessions.length; index++) {
+      const session = sessions[index];
+      const sessionPayload = { date, sessions: [allSessionPayloads[index]] };
       try {
         const bullets = await provider.summarize(sessionPayload);
         const project = session.repoName ?? "unknown";
@@ -2267,8 +2542,8 @@ ${bullets.trim()}`;
             bullets: parseBullets(bullets)
           });
         }
-      } catch (e) {
-        log.error(`Summary failed [${config.ai.provider}]: ${e.message}`);
+      } catch (error) {
+        log.error(`Summary failed [${config.ai.provider}]: ${error.message}`);
         process.exit(1);
       }
     }
@@ -2280,12 +2555,20 @@ ${bullets.trim()}`;
       log.plain(fullSummary);
     }
     log.plain("");
+    const excludedCounts = countExcludedEvents(allSessionPayloads, excluded);
+    if (excludedCounts.size > 0) {
+      const total = [...excludedCounts.values()].reduce((sum, count) => sum + count, 0);
+      const breakdown = [...excludedCounts.entries()].map(([category, count]) => `${category} \xD7${count}`).join(", ");
+      log.plain(import_chalk6.default.dim(`  \u2139 ${total} event${total === 1 ? "" : "s"} not included in summary (${breakdown})`));
+      log.plain(import_chalk6.default.dim("    Use --verbose to inspect \xB7 workscribe config set summary.includeCategories to opt in"));
+      log.plain("");
+    }
     await handleWebhook(opts, config, fullSummary);
   });
 }
 
 // src/cli/export.ts
-var import_fs15 = __toESM(require("fs"));
+var import_fs16 = __toESM(require("fs"));
 var import_path11 = __toESM(require("path"));
 function eventRowToPayload2(row) {
   let metadata = {};
@@ -2343,8 +2626,8 @@ function registerExport(program2) {
     log.info(`Generating summary via ${config.ai.provider}\u2026`);
     const summary = await provider.summarize(payload);
     const outputPath = opts.output ?? import_path11.default.join(EXPORTS_DIR, `workscribe-${date}.md`);
-    if (!import_fs15.default.existsSync(EXPORTS_DIR)) import_fs15.default.mkdirSync(EXPORTS_DIR, { recursive: true, mode: 448 });
-    import_fs15.default.writeFileSync(outputPath, `# Work Summary \u2014 ${date}
+    if (!import_fs16.default.existsSync(EXPORTS_DIR)) import_fs16.default.mkdirSync(EXPORTS_DIR, { recursive: true, mode: 448 });
+    import_fs16.default.writeFileSync(outputPath, `# Work Summary \u2014 ${date}
 
 ${summary}
 `, { encoding: "utf-8", mode: 384 });
@@ -2416,22 +2699,22 @@ function printConfig(obj, indent) {
 }
 
 // src/cli/pause.ts
-var import_fs16 = __toESM(require("fs"));
+var import_fs17 = __toESM(require("fs"));
 function registerPause(program2) {
   program2.command("pause").description("Pause capture temporarily").action(() => {
-    if (import_fs16.default.existsSync(PAUSE_FLAG_PATH)) {
+    if (import_fs17.default.existsSync(PAUSE_FLAG_PATH)) {
       log.info("Capture is already paused. Run workscribe resume to restart.");
       return;
     }
-    import_fs16.default.writeFileSync(PAUSE_FLAG_PATH, "", { mode: 384 });
+    import_fs17.default.writeFileSync(PAUSE_FLAG_PATH, "", { mode: 384 });
     log.success("Capture paused. Run workscribe resume to restart.");
   });
   program2.command("resume").description("Resume capture after a pause").action(() => {
-    if (!import_fs16.default.existsSync(PAUSE_FLAG_PATH)) {
+    if (!import_fs17.default.existsSync(PAUSE_FLAG_PATH)) {
       log.info("Capture is not paused.");
       return;
     }
-    import_fs16.default.rmSync(PAUSE_FLAG_PATH);
+    import_fs17.default.rmSync(PAUSE_FLAG_PATH);
     log.success("Capture resumed.");
   });
 }
@@ -2516,18 +2799,19 @@ function registerClear(program2) {
 }
 
 // src/cli/uninstall.ts
-var import_fs17 = __toESM(require("fs"));
+var import_fs18 = __toESM(require("fs"));
 var import_path12 = __toESM(require("path"));
-var import_os6 = __toESM(require("os"));
+var import_os7 = __toESM(require("os"));
 var import_prompts3 = __toESM(require("prompts"));
 var import_chalk9 = __toESM(require("chalk"));
 function detectShellRcFiles() {
   const candidates = [
-    { name: "zsh", rcFile: import_path12.default.join(import_os6.default.homedir(), ".zshrc") },
-    { name: "bash", rcFile: import_path12.default.join(import_os6.default.homedir(), ".bashrc") },
-    { name: "bash", rcFile: import_path12.default.join(import_os6.default.homedir(), ".bash_profile") }
+    { name: "zsh", rcFile: import_path12.default.join(import_os7.default.homedir(), ".zshrc") },
+    { name: "bash", rcFile: import_path12.default.join(import_os7.default.homedir(), ".bashrc") },
+    { name: "bash", rcFile: import_path12.default.join(import_os7.default.homedir(), ".bash_profile") },
+    { name: "fish", rcFile: import_path12.default.join(import_os7.default.homedir(), ".config", "fish", "conf.d", "workscribe.fish") }
   ];
-  return candidates.filter((candidate) => import_fs17.default.existsSync(candidate.rcFile) && isHookInstalled(candidate.rcFile));
+  return candidates.filter((candidate) => import_fs18.default.existsSync(candidate.rcFile) && isHookInstalled(candidate.rcFile));
 }
 function registerUninstall(program2) {
   program2.command("uninstall").description("Remove shell hooks and optionally delete all Workscribe data").option("--hooks-only", "remove shell hooks only, skip data deletion prompt (used by npm preuninstall)").action(async (opts) => {
@@ -2537,16 +2821,23 @@ function registerUninstall(program2) {
       log.info("No shell hooks found");
     } else {
       for (const { name, rcFile } of hooked) {
-        removeHook(rcFile);
-        log.success(`Shell hook removed from ${rcFile}`);
-        log.plain(`  ${import_chalk9.default.dim(`Run: source ${rcFile}`)}  (or restart your terminal to take effect)`);
-        log.plain(
-          `  ${import_chalk9.default.dim(`${name === "zsh" ? "unfunction" : "unset -f"} _workscribe_preexec _workscribe_precmd`)}`
-        );
+        if (name === "fish") {
+          import_fs18.default.unlinkSync(rcFile);
+          log.success(`Shell hook removed: ${rcFile}`);
+          log.plain(`  ${import_chalk9.default.dim("Restart your terminal to take effect")}`);
+        } else {
+          removeHook(rcFile);
+          log.success(`Shell hook removed from ${rcFile}`);
+          log.plain(`  ${import_chalk9.default.dim(`Run: source ${rcFile}`)}  (or restart your terminal to take effect)`);
+          log.plain(
+            `  ${import_chalk9.default.dim(`${name === "zsh" ? "unfunction" : "unset -f"} _workscribe_preexec _workscribe_precmd`)}`
+          );
+        }
       }
     }
     if (opts.hooksOnly) return;
-    if (import_fs17.default.existsSync(WORKSCRIBE_DIR)) {
+    const existingDirs = [...new Set(REQUIRED_DIRS)].filter((dir) => import_fs18.default.existsSync(dir));
+    if (existingDirs.length > 0) {
       log.plain("");
       const { deleteData } = await (0, import_prompts3.default)({
         type: "confirm",
@@ -2555,8 +2846,10 @@ function registerUninstall(program2) {
         initial: false
       });
       if (deleteData) {
-        import_fs17.default.rmSync(WORKSCRIBE_DIR, { recursive: true, force: true });
-        log.success(`Deleted ${WORKSCRIBE_DIR}`);
+        for (const dir of existingDirs) {
+          import_fs18.default.rmSync(dir, { recursive: true, force: true });
+          log.success(`Deleted ${dir}`);
+        }
       } else {
         log.info(`Data kept at ${WORKSCRIBE_DIR}`);
       }
@@ -2568,7 +2861,7 @@ function registerUninstall(program2) {
 }
 
 // src/cli/profile.ts
-var import_fs18 = __toESM(require("fs"));
+var import_fs19 = __toESM(require("fs"));
 var import_path13 = __toESM(require("path"));
 var import_chalk10 = __toESM(require("chalk"));
 var MIN_SUGGEST_COUNT = 5;
@@ -2615,7 +2908,7 @@ function registerProfile(program2) {
       log.plain(import_chalk10.default.dim("  " + "\u2500".repeat(60)));
       for (const entry of entries) {
         const badge = activeNames.has(entry.name) ? import_chalk10.default.green(" [active]") : "";
-        const installed = import_fs18.default.existsSync(import_path13.default.join(PROFILES_DIR, `${entry.name}.json`)) ? import_chalk10.default.dim(" installed") : "";
+        const installed = import_fs19.default.existsSync(import_path13.default.join(PROFILES_DIR, `${entry.name}.json`)) ? import_chalk10.default.dim(" installed") : "";
         log.plain(`  ${import_chalk10.default.cyan(entry.name.padEnd(18))} ${entry.displayName.padEnd(28)}${badge}${installed}`);
         if (entry.description) log.plain(`  ${import_chalk10.default.dim(" ".repeat(18) + entry.description)}`);
       }
@@ -2652,7 +2945,7 @@ function registerProfile(program2) {
       }
       activeNames.delete(name);
       const cachePath = import_path13.default.join(PROFILES_DIR, `${name}.json`);
-      if (import_fs18.default.existsSync(cachePath)) import_fs18.default.unlinkSync(cachePath);
+      if (import_fs19.default.existsSync(cachePath)) import_fs19.default.unlinkSync(cachePath);
       log.success(`Profile "${name}" removed`);
     }
     config.capture.profiles = [...activeNames];
@@ -2716,14 +3009,37 @@ function registerProfile(program2) {
     const suggestions = [];
     for (const entry of manifest) {
       if (activeNames.has(entry.name)) continue;
-      const matchedCount = toolCounts.filter((tc) => entry.keywords.some((kw) => tc.tool.toLowerCase().includes(kw.toLowerCase()))).reduce((sum, tc) => sum + tc.count, 0);
+      const matchedCount = toolCounts.filter(
+        (toolCount) => entry.keywords.some((keyword) => toolCount.tool.toLowerCase().includes(keyword.toLowerCase()))
+      ).reduce((total, toolCount) => total + toolCount.count, 0);
       if (matchedCount >= MIN_SUGGEST_COUNT) {
         suggestions.push({ entry, count: matchedCount });
       }
     }
     suggestions.sort((a, b) => b.count - a.count);
     if (suggestions.length === 0) {
-      log.plain("No profile matches found. Your commands are well covered.");
+      const activeEntries = manifest.filter((entry) => activeNames.has(entry.name));
+      const isToolCoveredByActiveProfile = (tool) => activeEntries.some(
+        (entry) => entry.keywords.some((keyword) => tool.toLowerCase().includes(keyword.toLowerCase()))
+      );
+      const uncoveredTools = toolCounts.filter((toolCount) => !isToolCoveredByActiveProfile(toolCount.tool));
+      if (uncoveredTools.length === 0) {
+        log.plain("");
+        log.plain("Your active profiles cover all unclassified commands.");
+        log.plain(import_chalk10.default.dim("  Future captures will be classified correctly."));
+        log.plain("");
+      } else {
+        log.plain("");
+        log.plain("No profile matches found for your unclassified commands.");
+        log.plain("");
+        log.plain(import_chalk10.default.dim("  Top unclassified tools:"));
+        for (const { tool, count } of uncoveredTools.slice(0, 5)) {
+          log.plain(import_chalk10.default.dim(`    ${tool.padEnd(24)} ${count} event${count === 1 ? "" : "s"}`));
+        }
+        log.plain("");
+        log.plain(import_chalk10.default.dim("  Run workscribe events --category other to review them."));
+        log.plain("");
+      }
       return;
     }
     log.plain("");
@@ -2735,14 +3051,281 @@ function registerProfile(program2) {
       );
     }
     log.plain("");
-    log.plain(`  Run: ${import_chalk10.default.cyan("workscribe profile add " + suggestions.map((s) => s.entry.name).join(" "))}`);
+    log.plain(
+      `  Run: ${import_chalk10.default.cyan("workscribe profile add " + suggestions.map((suggestion) => suggestion.entry.name).join(" "))}`
+    );
+    log.plain("");
+    const allCoveredEntries = [
+      ...manifest.filter((entry) => activeNames.has(entry.name)),
+      ...suggestions.map((suggestion) => suggestion.entry)
+    ];
+    const isToolCoveredAfterInstall = (tool) => allCoveredEntries.some(
+      (entry) => entry.keywords.some((keyword) => tool.toLowerCase().includes(keyword.toLowerCase()))
+    );
+    const stillUncovered = toolCounts.filter((toolCount) => !isToolCoveredAfterInstall(toolCount.tool)).slice(0, 5);
+    if (stillUncovered.length > 0) {
+      log.plain(import_chalk10.default.dim("  Still uncovered after installing:"));
+      for (const { tool, count } of stillUncovered) {
+        log.plain(import_chalk10.default.dim(`    ${tool.padEnd(24)} ${count} event${count === 1 ? "" : "s"}`));
+      }
+      log.plain("");
+    }
+  });
+}
+
+// src/cli/note.ts
+function registerNote(program2) {
+  program2.command("note <text>").description("Attach a free-text annotation to the current session").action((text) => {
+    const { repoName, branch } = getGitContext(process.cwd());
+    insertEvent({
+      captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+      command: "workscribe note",
+      cwd: process.cwd(),
+      exit_code: null,
+      duration_ms: null,
+      repo_name: repoName,
+      branch,
+      category: "note",
+      metadata: JSON.stringify({ text })
+    });
+    log.success(`Note saved${repoName ? ` to ${repoName}` : ""}`);
+  });
+}
+
+// src/cli/week.ts
+var import_chalk11 = __toESM(require("chalk"));
+var import_fs20 = __toESM(require("fs"));
+var import_path14 = __toESM(require("path"));
+var import_os8 = __toESM(require("os"));
+function eventRowToPayload3(row) {
+  let metadata = {};
+  try {
+    if (row.metadata) metadata = JSON.parse(row.metadata);
+  } catch {
+  }
+  const payload = {
+    category: row.category,
+    metadata,
+    exitCode: row.exit_code,
+    durationMs: row.duration_ms
+  };
+  if (row.category === "other" && typeof metadata.hint === "string") {
+    payload.hint = metadata.hint;
+    const { hint: _hint, tool: _tool, ...rest } = metadata;
+    payload.metadata = rest;
+  }
+  return payload;
+}
+function sessionToPayload2(session, date) {
+  return {
+    date,
+    project: session.repoName,
+    branch: session.events[0]?.branch ?? null,
+    startTime: formatDate(session.startedAt),
+    endTime: formatDate(session.endedAt),
+    durationMinutes: session.durationMinutes,
+    events: session.events.map(eventRowToPayload3)
+  };
+}
+async function postSummary(opts, config, summary) {
+  const webhookUrl = opts.webhook ?? (opts.slack ? config.integrations?.slackWebhook : void 0);
+  if (!webhookUrl) {
+    if (opts.slack) log.warn("--slack requires integrations.slackWebhook to be set in config");
+    return;
+  }
+  try {
+    log.info("Posting to webhook\u2026");
+    const username = import_os8.default.userInfo().username;
+    const body = isSlackWebhookUrl(webhookUrl) ? formatForSlack(summary, username) : summary;
+    await postToWebhook(webhookUrl, body);
+    log.success("Posted.");
+  } catch (error) {
+    log.error(`Webhook failed: ${error.message}`);
+  }
+}
+function registerWeek(program2) {
+  program2.command("week").description("Generate an AI weekly digest (Mon\u2013today)").option("--fresh", "bypass cache and regenerate").option("--slack", "post to Slack webhook from config").option("--webhook <url>", "post to a custom webhook URL").action(async (opts) => {
+    const config = readConfig();
+    let provider;
+    try {
+      provider = getProvider(config);
+    } catch (error) {
+      log.error(error.message);
+      process.exit(1);
+    }
+    const today = todayDate();
+    const weekStart = startOfWeek(today);
+    const days = eachDayOfRange(weekStart, today);
+    const weeklyDays = [];
+    for (const day of days) {
+      const sessions = getOrBuildSessions(day);
+      if (sessions.length > 0) {
+        weeklyDays.push({ date: day, sessions: sessions.map((session) => sessionToPayload2(session, day)) });
+      }
+    }
+    if (weeklyDays.length === 0) {
+      log.plain("No activity captured this week.");
+      return;
+    }
+    const cacheKey = isoWeekKey(today);
+    const cacheFile = import_path14.default.join(WEEKLY_CACHE_DIR, `${cacheKey}.md`);
+    if (!opts.fresh && import_fs20.default.existsSync(cacheFile)) {
+      const cached = import_fs20.default.readFileSync(cacheFile, "utf-8");
+      log.plain("");
+      log.plain(cached);
+      log.plain("");
+      log.plain(import_chalk11.default.dim("  (cached \u2014 use --fresh to regenerate)"));
+      await postSummary(opts, config, cached);
+      return;
+    }
+    const payload = { weekStart, weekEnd: today, days: weeklyDays };
+    log.plain("");
+    log.info(`Generating weekly digest via ${import_chalk11.default.cyan(config.ai.provider)}\u2026`);
+    try {
+      const summary = provider.summarizeWeek ? await provider.summarizeWeek(payload) : await provider.summarize({ date: today, sessions: weeklyDays.flatMap((day) => day.sessions) });
+      log.plain("");
+      log.plain(summary);
+      log.plain("");
+      import_fs20.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
+      import_fs20.default.writeFileSync(cacheFile, summary, { encoding: "utf-8", mode: 384 });
+      await postSummary(opts, config, summary);
+    } catch (error) {
+      log.error(`Weekly digest failed [${config.ai.provider}]: ${error.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/bug-report.ts
+var import_fs21 = __toESM(require("fs"));
+var import_os9 = __toESM(require("os"));
+var import_path15 = __toESM(require("path"));
+var import_chalk12 = __toESM(require("chalk"));
+var GITHUB_ISSUES_URL = "https://github.com/workscribe/workscribe/issues/new";
+var DEBUG_LOG_TAIL_LINES = 100;
+function tailFile(filePath, lines) {
+  if (!import_fs21.default.existsSync(filePath)) return "(no debug log found \u2014 set WORKSCRIBE_DEBUG=1 to enable)";
+  const content = import_fs21.default.readFileSync(filePath, "utf-8");
+  const allLines = content.split("\n");
+  return allLines.slice(-lines).join("\n");
+}
+function redactConfig() {
+  try {
+    const config = readConfig();
+    if (config.ai.apiKey) config.ai.apiKey = "<redacted>";
+    if (config.integrations?.slackWebhook) config.integrations.slackWebhook = "<redacted>";
+    if (config.integrations?.webhook) config.integrations.webhook = "<redacted>";
+    return JSON.stringify(config, null, 2);
+  } catch {
+    return "(could not read config)";
+  }
+}
+function registerBugReport(program2) {
+  program2.command("bug-report").description("Generate a diagnostic report for filing a bug").action(() => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const reportPath = import_path15.default.join(WORKSCRIBE_DIR, `bug-report-${timestamp}.txt`);
+    const systemInfo = [
+      `Workscribe version : ${"1.12.0"}`,
+      `Node.js version    : ${process.version}`,
+      `Platform           : ${process.platform}`,
+      `Architecture       : ${process.arch}`,
+      `OS release         : ${import_os9.default.release()}`,
+      `Config path        : ${CONFIG_PATH}`,
+      `Data directory     : ${WORKSCRIBE_DIR}`
+    ].join("\n");
+    const report = [
+      "=== Workscribe Bug Report ===",
+      `Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      "",
+      "--- System ---",
+      systemInfo,
+      "",
+      "--- Config (secrets redacted) ---",
+      redactConfig(),
+      "",
+      `--- Debug log (last ${DEBUG_LOG_TAIL_LINES} lines) ---`,
+      tailFile(DEBUG_LOG_PATH, DEBUG_LOG_TAIL_LINES)
+    ].join("\n");
+    try {
+      if (!import_fs21.default.existsSync(WORKSCRIBE_DIR)) {
+        import_fs21.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true, mode: 448 });
+      }
+      import_fs21.default.writeFileSync(reportPath, report, { mode: 384 });
+    } catch (error) {
+      log.error(`Could not write report: ${error.message}`);
+      process.exit(1);
+    }
+    const params = new URLSearchParams({
+      title: `Bug report \u2014 workscribe ${"1.12.0"}`,
+      body: `<!-- Attach ${import_path15.default.basename(reportPath)} or paste the relevant sections below -->
+
+**Describe the issue:**
+
+**Steps to reproduce:**
+
+**Expected behaviour:**`
+    });
+    log.success(`Report written to: ${import_chalk12.default.cyan(reportPath)}`);
+    log.plain("");
+    log.plain(`  Open a GitHub issue:`);
+    log.plain(`    ${import_chalk12.default.cyan(`${GITHUB_ISSUES_URL}?${params}`)}`);
+    log.plain("");
+    log.plain(import_chalk12.default.dim(`  Attach the report or paste the relevant sections into the issue.`));
     log.plain("");
   });
 }
 
+// src/utils/update-check.ts
+var import_fs22 = __toESM(require("fs"));
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function readCache() {
+  try {
+    return JSON.parse(import_fs22.default.readFileSync(UPDATE_CHECK_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    import_fs22.default.writeFileSync(UPDATE_CHECK_PATH, JSON.stringify(cache), { mode: 384 });
+  } catch {
+  }
+}
+function isNewer(latest, current) {
+  const parse = (version) => version.replace(/^v/, "").split(".").map(Number);
+  const [latestMajor, latestMinor, latestPatch] = parse(latest);
+  const [currentMajor, currentMinor, currentPatch] = parse(current);
+  if (latestMajor !== currentMajor) return latestMajor > currentMajor;
+  if (latestMinor !== currentMinor) return latestMinor > currentMinor;
+  return latestPatch > currentPatch;
+}
+function checkForUpdate() {
+  const current = "1.12.0";
+  const cache = readCache();
+  if (cache && isNewer(cache.latestVersion, current)) {
+    process.stderr.write(
+      `
+  Update available ${current} \u2192 ${cache.latestVersion}
+  Run: npm install -g @workscribe/cli
+
+`
+    );
+  }
+  const now = Date.now();
+  if (!cache || now - cache.lastChecked > CHECK_INTERVAL_MS) {
+    fetch("https://registry.npmjs.org/@workscribe/cli/latest").then((response) => response.json()).then((data) => {
+      const latest = data.version;
+      if (latest) writeCache({ lastChecked: now, latestVersion: latest });
+    }).catch(() => {
+    });
+  }
+}
+
 // src/index.ts
+assertNodeVersion(process.versions.node);
+checkForUpdate();
 var program = new import_commander.Command();
-program.name("workscribe").description("Automatic developer work journal").version("1.10.0");
+program.name("workscribe").description("Automatic developer work journal").version("1.12.0");
 registerCapture(program);
 registerHook(program);
 registerInit(program);
@@ -2757,5 +3340,9 @@ registerUndo(program);
 registerClear(program);
 registerUninstall(program);
 registerProfile(program);
+registerNote(program);
+registerWeek(program);
+registerBugReport(program);
+registerCompletions(program);
 program.parse();
 //# sourceMappingURL=index.js.map