@workscribe/cli 1.9.0 → 1.11.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,8 +26,22 @@ 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_fs7 = __toESM(require("fs"));
+var import_fs9 = __toESM(require("fs"));
 
 // src/db/index.ts
 var import_node_sqlite = require("node:sqlite");
@@ -43,6 +57,7 @@ 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");
 
 // src/db/migrations/001_initial_schema.ts
 var initial_schema_default = {
@@ -85,8 +100,27 @@ var initial_schema_default = {
   `
 };
 
+// src/db/migrations/002_semantic_categories.ts
+var migration = {
+  version: 2,
+  description: "Rename granular categories to 13 universal semantic categories",
+  sql: `
+    UPDATE events SET category = 'shipping'        WHERE category IN ('code_commit','code_push','code_merge');
+    UPDATE events SET category = 'versioning'      WHERE category IN ('code_pull','branch_switch','code_stash','git_other');
+    UPDATE events SET category = 'building'        WHERE category = 'build';
+    UPDATE events SET category = 'running'         WHERE category IN ('server_run','script_run');
+    UPDATE events SET category = 'testing'         WHERE category = 'test_run';
+    UPDATE events SET category = 'linting'         WHERE category = 'lint_run';
+    UPDATE events SET category = 'dependencies'    WHERE category IN ('dependency_install','dependency_remove');
+    UPDATE events SET category = 'infrastructure'  WHERE category = 'infrastructure';
+    UPDATE events SET category = 'files'           WHERE category IN ('file_ops','environment');
+    UPDATE events SET category = 'exploring'       WHERE category IN ('code_search','code_read');
+  `
+};
+var semantic_categories_default = migration;
+
 // src/db/migrations/index.ts
-var MIGRATIONS = [initial_schema_default];
+var MIGRATIONS = [initial_schema_default, semantic_categories_default];
 
 // src/db/index.ts
 var _db = null;
@@ -123,13 +157,13 @@ function applyMigrations(db) {
   const applied = new Set(
     db.prepare("SELECT version FROM schema_migrations").all().map((row) => row.version)
   );
-  for (const migration of MIGRATIONS) {
-    if (applied.has(migration.version)) continue;
+  for (const migration2 of MIGRATIONS) {
+    if (applied.has(migration2.version)) continue;
     db.exec("BEGIN");
     try {
-      db.exec(migration.sql);
+      db.exec(migration2.sql);
       db.prepare("INSERT INTO schema_migrations (version, applied_at) VALUES ($version, datetime('now'))").run({
-        version: migration.version
+        version: migration2.version
       });
       db.exec("COMMIT");
     } catch (err) {
@@ -137,7 +171,7 @@ function applyMigrations(db) {
         db.exec("ROLLBACK");
       } catch {
       }
-      throw new Error(`Migration ${migration.version} (${migration.description}) failed: ${err.message}`);
+      throw new Error(`Migration ${migration2.version} (${migration2.description}) failed: ${err.message}`);
     }
   }
 }
@@ -232,6 +266,28 @@ function deleteEventsForDate(date) {
   const result = db.prepare(`DELETE FROM events WHERE date(captured_at, 'localtime') = $date`).run({ date });
   return result.changes;
 }
+function getOtherEventToolCounts(days) {
+  const db = getDb();
+  return db.prepare(
+    `SELECT json_extract(metadata, '$.tool') as tool, COUNT(*) as count
+       FROM events
+       WHERE category = 'other'
+         AND captured_at >= datetime('now', $offset)
+         AND json_extract(metadata, '$.tool') IS NOT NULL
+       GROUP BY tool
+       ORDER BY count DESC`
+  ).all({ offset: `-${days} days` });
+}
+function getRecentOtherRate(days) {
+  const db = getDb();
+  const row = db.prepare(
+    `SELECT COUNT(*) as total,
+              SUM(CASE WHEN category = 'other' THEN 1 ELSE 0 END) as otherCount
+       FROM events
+       WHERE captured_at >= datetime('now', $offset)`
+  ).get({ offset: `-${days} days` });
+  return row;
+}
 function clearSessionsForDate(date) {
   const db = getDb();
   db.prepare(
@@ -265,7 +321,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;
@@ -475,6 +534,240 @@ function loadAIToolRegistry() {
   return [...filteredBuiltins, ...userEntries];
 }
 
+// src/profiles/loader.ts
+var import_fs8 = __toESM(require("fs"));
+var import_path6 = __toESM(require("path"));
+
+// src/config/index.ts
+var import_fs6 = __toESM(require("fs"));
+var DEFAULTS = {
+  ai: {
+    provider: "",
+    apiKey: "",
+    model: "",
+    baseUrl: ""
+  },
+  session: {
+    idleTimeout: 30
+  },
+  capture: {
+    ignore: ["cd", "ls", "ll", "la", "ls -la", "ls -l", "ls -a", "pwd", "clear", "exit", "history", "man"],
+    aiTools: true,
+    includeAiderPrompt: true,
+    profiles: []
+  },
+  redact: {
+    extra: []
+  },
+  summary: {
+    format: "markdown"
+  }
+};
+function readConfig() {
+  if (!import_fs6.default.existsSync(CONFIG_PATH)) return { ...DEFAULTS };
+  try {
+    const raw = import_fs6.default.readFileSync(CONFIG_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    return deepMerge(DEFAULTS, parsed);
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+function writeConfig(config) {
+  import_fs6.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+  try {
+    import_fs6.default.chmodSync(CONFIG_PATH, 384);
+  } catch {
+  }
+}
+function getConfigValue(config, key) {
+  const parts = key.split(".");
+  let cur = config;
+  for (const part of parts) {
+    if (cur == null || typeof cur !== "object") return void 0;
+    cur = cur[part];
+  }
+  return cur;
+}
+function setConfigValue(config, key, value) {
+  const parts = key.split(".");
+  const result = JSON.parse(JSON.stringify(config));
+  let cur = result;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (cur[part] == null || typeof cur[part] !== "object") {
+      cur[part] = {};
+    }
+    cur = cur[part];
+  }
+  const lastKey = parts[parts.length - 1];
+  if (value === "true") cur[lastKey] = true;
+  else if (value === "false") cur[lastKey] = false;
+  else if (!isNaN(Number(value))) cur[lastKey] = Number(value);
+  else cur[lastKey] = value;
+  return result;
+}
+function deepMerge(defaults, overrides) {
+  const result = { ...defaults };
+  for (const key of Object.keys(overrides)) {
+    const val = overrides[key];
+    if (val !== null && typeof val === "object" && !Array.isArray(val) && typeof defaults[key] === "object") {
+      result[key] = deepMerge(defaults[key], val);
+    } else if (val !== void 0) {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+
+// src/profiles/schema.ts
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isValidRule(rule) {
+  if (!rule || typeof rule !== "object") return false;
+  const { pattern, category } = rule;
+  return isNonEmptyString(pattern) && isNonEmptyString(category);
+}
+function isValidProfile(candidate) {
+  if (!candidate || typeof candidate !== "object") return false;
+  const { name, displayName, version, rules } = candidate;
+  if (!isNonEmptyString(name) || !isNonEmptyString(displayName) || !isNonEmptyString(version)) return false;
+  if (!Array.isArray(rules)) return false;
+  return rules.every(isValidRule);
+}
+function isValidManifest(m) {
+  return Array.isArray(m) && m.every((e) => e && typeof e === "object" && typeof e.name === "string");
+}
+
+// src/profiles/fetcher.ts
+var import_fs7 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
+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`);
+  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`);
+  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();
+  if (!isValidProfile(data)) throw new Error(`Profile "${name}" failed schema validation`);
+  return data;
+}
+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 });
+  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 });
+  return manifest;
+}
+function readCachedManifest() {
+  if (!import_fs7.default.existsSync(manifestCachePath())) return null;
+  try {
+    const data = JSON.parse(import_fs7.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 });
+  }
+}
+
+// src/profiles/loader.ts
+function compileRule(profileName, rule) {
+  let regex;
+  try {
+    regex = new RegExp(rule.pattern);
+  } catch {
+    debugLog("profiles", `Profile "${profileName}": invalid pattern "${rule.pattern}" \u2014 skipping rule`);
+    return null;
+  }
+  return {
+    match(cmd) {
+      const match = cmd.match(regex);
+      if (!match) return null;
+      const metadata = {};
+      for (const [key, value] of Object.entries(rule.metadata ?? {})) {
+        metadata[key] = value.replace(/\$(\d+)/g, (_, index) => match[Number(index)] ?? "");
+      }
+      return { category: rule.category, metadata };
+    }
+  };
+}
+function loadProfileFromDisk(name) {
+  const filePath = import_path6.default.join(PROFILES_DIR, `${name}.json`);
+  if (!import_fs8.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"));
+  } catch {
+    debugLog("profiles", `Profile "${name}" contains invalid JSON \u2014 skipping`);
+    return null;
+  }
+  if (!isValidProfile(candidate)) {
+    debugLog("profiles", `Profile "${name}" failed schema validation \u2014 skipping`);
+    return null;
+  }
+  return candidate;
+}
+function getActiveProfileRules() {
+  const activeNames = readConfig().capture.profiles;
+  if (activeNames.length === 0) return [];
+  return activeNames.flatMap((name) => {
+    const profile = loadProfileFromDisk(name);
+    if (!profile) return [];
+    return profile.rules.flatMap((rule) => {
+      const compiled = compileRule(profile.name, rule);
+      return compiled ? [compiled] : [];
+    });
+  });
+}
+function getActiveProfileAiContexts() {
+  const activeNames = readConfig().capture.profiles;
+  if (activeNames.length === 0) return [];
+  return activeNames.flatMap((name) => {
+    const profile = loadProfileFromDisk(name);
+    return profile?.aiContext ? [profile.aiContext] : [];
+  });
+}
+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) => {
+    const profile = loadProfileFromDisk(file.replace(/\.json$/, ""));
+    return profile ? [profile] : [];
+  });
+}
+function detectProfilesForDirectory(dir) {
+  const manifest = readCachedManifest();
+  if (!manifest) return [];
+  const activeNames = new Set(readConfig().capture.profiles);
+  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)));
+  });
+}
+
 // src/normalize/patterns.ts
 function makeRule(pattern, category, extract = () => ({})) {
   return {
@@ -490,114 +783,131 @@ function extractPackages(cmd, afterKeyword) {
   if (idx === -1) return [];
   return cmd.slice(idx + afterKeyword.length).trim().split(/\s+/).filter((part) => part && !part.startsWith("-"));
 }
-var RULES = [
+var BASE_RULES = [
   // ─── Git operations ───────────────────────────────────────────────────────
-  makeRule(/^git\s+commit\b/, "code_commit", (_m, cmd) => {
+  makeRule(/^git\s+commit\b/, "shipping", (_m, cmd) => {
     const msgMatch = cmd.match(/-m\s+["']?([^"']+)["']?/);
     return { message: msgMatch ? msgMatch[1].trim() : null };
   }),
-  makeRule(/^git\s+push\b/, "code_push", (_m, cmd) => {
+  makeRule(/^git\s+push\b/, "shipping", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
     return { remote: parts[2] ?? "origin", branch: parts[3] ?? null };
   }),
-  makeRule(/^git\s+(pull|fetch)\b/, "code_pull", (_m, cmd) => {
+  makeRule(/^git\s+(pull|fetch)\b/, "versioning", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
     return { subcommand: parts[1], remote: parts[2] ?? "origin" };
   }),
-  makeRule(/^git\s+(checkout|switch)\b/, "branch_switch", (_m, cmd) => {
+  makeRule(/^git\s+(checkout|switch)\b/, "versioning", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
     const branch = parts.find((part) => !part.startsWith("-") && part !== "git" && part !== parts[1]);
     return { branch: branch ?? null };
   }),
-  makeRule(/^git\s+(merge|rebase)\b/, "code_merge", (_m, cmd) => {
+  makeRule(/^git\s+(merge|rebase)\b/, "shipping", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
     return { subcommand: parts[1], target: parts[2] ?? null };
   }),
-  makeRule(/^git\s+stash\b/, "code_stash", (_m, cmd) => {
+  makeRule(/^git\s+stash\b/, "versioning", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
     return { subcommand: parts[2] ?? "push" };
   }),
-  makeRule(/^git\s+/, "git_other", (_m, cmd) => {
+  makeRule(/^git\s+/, "versioning", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
     return { subcommand: parts[1] ?? null };
   }),
-  // ─── Package managers — install ───────────────────────────────────────────
-  makeRule(/^npm\s+(install|i|add)\b/, "dependency_install", (_m, cmd) => ({
+  // ─── Releasing ────────────────────────────────────────────────────────────
+  makeRule(/^npm\s+publish\b/, "releasing", () => ({ tool: "npm" })),
+  makeRule(/^cargo\s+publish\b/, "releasing", () => ({ tool: "cargo" })),
+  makeRule(/^gem\s+push\b/, "releasing", () => ({ tool: "gem" })),
+  makeRule(/^docker\s+push\b/, "releasing", (_m, cmd) => ({ tool: "docker", image: cmd.split(/\s+/)[2] ?? null })),
+  makeRule(/^gh\s+release\b/, "releasing", (_m, cmd) => ({ tool: "gh", subcommand: cmd.split(/\s+/)[2] ?? null })),
+  makeRule(/^fly\s+(deploy|launch)\b/, "releasing", (match) => ({ tool: "fly", subcommand: match[1] })),
+  makeRule(/^vercel\s+(deploy|build|--prod)\b/, "releasing", () => ({ tool: "vercel" })),
+  makeRule(/^netlify\s+deploy\b/, "releasing", () => ({ tool: "netlify" })),
+  makeRule(/^railway\s+up\b/, "releasing", () => ({ tool: "railway" })),
+  makeRule(/^wrangler\s+deploy\b/, "releasing", () => ({ tool: "wrangler" })),
+  // ─── Dependencies ─────────────────────────────────────────────────────────
+  makeRule(/^npm\s+(install|i|add)\b/, "dependencies", (_m, cmd) => ({
     tool: "npm",
     packages: extractPackages(cmd, cmd.includes("install") ? "install" : cmd.includes(" i ") ? " i " : "add")
   })),
-  makeRule(/^(yarn|pnpm)\s+(install|add)\b/, "dependency_install", (m, cmd) => ({
+  makeRule(/^(yarn|pnpm)\s+(install|add)\b/, "dependencies", (m, cmd) => ({
     tool: m[1],
     packages: extractPackages(cmd, "add")
   })),
-  makeRule(/^bun\s+(install|add)\b/, "dependency_install", (_m, cmd) => ({
+  makeRule(/^bun\s+(install|add)\b/, "dependencies", (_m, cmd) => ({
     tool: "bun",
     packages: extractPackages(cmd, "add")
   })),
-  makeRule(/^pip\s+(install)\b/, "dependency_install", (_m, cmd) => ({
+  makeRule(/^pip\s+(install)\b/, "dependencies", (_m, cmd) => ({
     tool: "pip",
     packages: extractPackages(cmd, "install")
   })),
-  makeRule(/^cargo\s+add\b/, "dependency_install", (_m, cmd) => ({
+  makeRule(/^cargo\s+add\b/, "dependencies", (_m, cmd) => ({
     tool: "cargo",
     packages: extractPackages(cmd, "add")
   })),
-  makeRule(/^(brew)\s+install\b/, "dependency_install", (_m, cmd) => ({
+  makeRule(/^(brew)\s+install\b/, "dependencies", (_m, cmd) => ({
     tool: "brew",
     packages: extractPackages(cmd, "install")
   })),
-  makeRule(/^go\s+get\b/, "dependency_install", (_m, cmd) => ({
+  makeRule(/^go\s+get\b/, "dependencies", (_m, cmd) => ({
     tool: "go",
     packages: extractPackages(cmd, "get")
   })),
-  // ─── Package managers — remove ────────────────────────────────────────────
-  makeRule(/^npm\s+(uninstall|remove|rm)\b/, "dependency_remove", (_m, cmd) => ({
+  makeRule(/^npm\s+(uninstall|remove|rm)\b/, "dependencies", (_m, cmd) => ({
     tool: "npm",
     packages: extractPackages(cmd, cmd.split(/\s+/)[1])
   })),
-  makeRule(/^(yarn|pnpm)\s+remove\b/, "dependency_remove", (m, cmd) => ({
+  makeRule(/^(yarn|pnpm)\s+remove\b/, "dependencies", (m, cmd) => ({
     tool: m[1],
     packages: extractPackages(cmd, "remove")
   })),
-  makeRule(/^bun\s+remove\b/, "dependency_remove", (_m, cmd) => ({
+  makeRule(/^bun\s+remove\b/, "dependencies", (_m, cmd) => ({
     tool: "bun",
     packages: extractPackages(cmd, "remove")
   })),
-  makeRule(/^pip\s+uninstall\b/, "dependency_remove", (_m, cmd) => ({
+  makeRule(/^pip\s+uninstall\b/, "dependencies", (_m, cmd) => ({
     tool: "pip",
     packages: extractPackages(cmd, "uninstall")
   })),
+  // Runtime version managers
+  makeRule(/^nvm\b/, "dependencies", (_m, cmd) => ({ tool: "nvm", subcommand: cmd.split(/\s+/)[1] ?? null })),
+  makeRule(/^(fnm|volta)\b/, "dependencies", (m, cmd) => ({ tool: m[1], subcommand: cmd.split(/\s+/)[1] ?? null })),
+  makeRule(/^(rbenv|pyenv|asdf)\b/, "dependencies", (m, cmd) => ({
+    tool: m[1],
+    subcommand: cmd.split(/\s+/)[1] ?? null
+  })),
   // ─── Tests ────────────────────────────────────────────────────────────────
-  makeRule(/^npm\s+(test|run\s+test)\b/, "test_run", () => ({ tool: "npm" })),
-  makeRule(/^yarn\s+test\b/, "test_run", () => ({ tool: "yarn" })),
-  makeRule(/^pnpm\s+test\b/, "test_run", () => ({ tool: "pnpm" })),
-  makeRule(/^bun\s+test\b/, "test_run", () => ({ tool: "bun" })),
-  makeRule(/^(jest|vitest)\b/, "test_run", (match) => ({ tool: match[1] })),
-  makeRule(/^pytest\b/, "test_run", () => ({ tool: "pytest" })),
-  makeRule(/^go\s+test\b/, "test_run", () => ({ tool: "go" })),
-  makeRule(/^cargo\s+test\b/, "test_run", () => ({ tool: "cargo" })),
-  makeRule(/^rspec\b/, "test_run", () => ({ tool: "rspec" })),
-  makeRule(/^(php\s+)?phpunit\b/, "test_run", () => ({ tool: "phpunit" })),
+  makeRule(/^npm\s+(test|run\s+test)\b/, "testing", () => ({ tool: "npm" })),
+  makeRule(/^yarn\s+test\b/, "testing", () => ({ tool: "yarn" })),
+  makeRule(/^pnpm\s+test\b/, "testing", () => ({ tool: "pnpm" })),
+  makeRule(/^bun\s+test\b/, "testing", () => ({ tool: "bun" })),
+  makeRule(/^(jest|vitest)\b/, "testing", (match) => ({ tool: match[1] })),
+  makeRule(/^pytest\b/, "testing", () => ({ tool: "pytest" })),
+  makeRule(/^go\s+test\b/, "testing", () => ({ tool: "go" })),
+  makeRule(/^cargo\s+test\b/, "testing", () => ({ tool: "cargo" })),
+  makeRule(/^rspec\b/, "testing", () => ({ tool: "rspec" })),
+  makeRule(/^(php\s+)?phpunit\b/, "testing", () => ({ tool: "phpunit" })),
   // ─── Build ────────────────────────────────────────────────────────────────
-  makeRule(/^npm\s+run\s+build\b/, "build", () => ({ tool: "npm" })),
-  makeRule(/^(yarn|pnpm)\s+build\b/, "build", (match) => ({ tool: match[1] })),
-  makeRule(/^bun\s+run\s+build\b/, "build", () => ({ tool: "bun" })),
-  makeRule(/^(make|gmake)\b/, "build", (match) => ({ tool: match[1] })),
-  makeRule(/^cargo\s+build\b/, "build", () => ({ tool: "cargo" })),
-  makeRule(/^go\s+build\b/, "build", () => ({ tool: "go" })),
-  makeRule(/^docker\s+build\b/, "build", () => ({ tool: "docker" })),
-  makeRule(/^(mvn|gradle)\b/, "build", (match) => ({ tool: match[1] })),
-  // ─── Dev server ───────────────────────────────────────────────────────────
-  makeRule(/^npm\s+run\s+(dev|start|serve)\b/, "server_run", (_m, cmd) => ({
+  makeRule(/^npm\s+run\s+build\b/, "building", () => ({ tool: "npm" })),
+  makeRule(/^(yarn|pnpm)\s+build\b/, "building", (match) => ({ tool: match[1] })),
+  makeRule(/^bun\s+run\s+build\b/, "building", () => ({ tool: "bun" })),
+  makeRule(/^(make|gmake)\b/, "building", (match) => ({ tool: match[1] })),
+  makeRule(/^cargo\s+build\b/, "building", () => ({ tool: "cargo" })),
+  makeRule(/^go\s+build\b/, "building", () => ({ tool: "go" })),
+  makeRule(/^docker\s+build\b/, "building", () => ({ tool: "docker" })),
+  makeRule(/^(mvn|gradle)\b/, "building", (match) => ({ tool: match[1] })),
+  // ─── Dev server / running ─────────────────────────────────────────────────
+  makeRule(/^npm\s+run\s+(dev|start|serve)\b/, "running", (_m, cmd) => ({
     tool: "npm",
     script: cmd.split(/\s+/)[2]
   })),
-  makeRule(/^(yarn|pnpm)\s+(dev|start)\b/, "server_run", (match) => ({ tool: match[1], script: match[2] })),
-  makeRule(/^bun\s+run\s+(dev|start|serve)\b/, "server_run", (_m, cmd) => ({
+  makeRule(/^(yarn|pnpm)\s+(dev|start)\b/, "running", (match) => ({ tool: match[1], script: match[2] })),
+  makeRule(/^bun\s+run\s+(dev|start|serve)\b/, "running", (_m, cmd) => ({
     tool: "bun",
     script: cmd.split(/\s+/)[2]
   })),
-  makeRule(/^python\s+.*manage\.py\s+runserver\b/, "server_run", () => ({ tool: "django" })),
+  makeRule(/^python\s+.*manage\.py\s+runserver\b/, "running", () => ({ tool: "django" })),
   // ─── Infrastructure ───────────────────────────────────────────────────────
   makeRule(/^ssh\b/, "infrastructure", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
@@ -611,7 +921,7 @@ var RULES = [
     const parts = cmd.split(/\s+/);
     return { tool: m[1], subcommand: parts[1] ?? null };
   }),
-  makeRule(/^docker\s+(run|compose|ps|stop|start|rm|exec)\b/, "infrastructure", (m, cmd) => {
+  makeRule(/^docker\s+(run|compose|ps|stop|start|rm|exec)\b/, "infrastructure", (_m, cmd) => {
     const parts = cmd.split(/\s+/);
     return { tool: "docker", subcommand: parts[1] };
   }),
@@ -619,62 +929,76 @@ var RULES = [
     const parts = cmd.split(/\s+/);
     return { tool: m[1], subcommand: parts[1] ?? null };
   }),
+  // ─── Database ─────────────────────────────────────────────────────────────
+  makeRule(/^(psql|pgcli)\b/, "database", (m) => ({ tool: m[1] })),
+  makeRule(/^(mysql|mycli)\b/, "database", (m) => ({ tool: m[1] })),
+  makeRule(/^sqlite3\b/, "database", () => ({ tool: "sqlite3" })),
+  makeRule(/^(mongosh|mongo)\b/, "database", (m) => ({ tool: m[1] })),
+  makeRule(/^redis-cli\b/, "database", () => ({ tool: "redis-cli" })),
   // ─── npx ─────────────────────────────────────────────────────────────────
-  makeRule(/^npx\s+(jest|vitest|mocha|ava|tap)\b/, "test_run", (_m, cmd) => ({
+  makeRule(/^npx\s+(jest|vitest|mocha|ava|tap)\b/, "testing", (_m, cmd) => ({
     tool: cmd.split(/\s+/)[1]
   })),
-  makeRule(/^npx\s+tsc\b/, "build", () => ({ tool: "tsc" })),
-  makeRule(/^npx\s+(eslint|tslint|biome)\b/, "lint_run", (_m, cmd) => ({
+  makeRule(/^npx\s+tsc\b/, "building", () => ({ tool: "tsc" })),
+  makeRule(/^npx\s+(eslint|tslint|biome)\b/, "linting", (_m, cmd) => ({
     tool: cmd.split(/\s+/)[1]
   })),
-  makeRule(/^npx\s+(prettier|dprint)\b/, "lint_run", (_m, cmd) => ({
+  makeRule(/^npx\s+(prettier|dprint)\b/, "linting", (_m, cmd) => ({
     tool: cmd.split(/\s+/)[1]
   })),
-  makeRule(/^npx\s+\S+/, "script_run", (_m, cmd) => ({
+  makeRule(/^npx\s+\S+/, "running", (_m, cmd) => ({
     tool: cmd.split(/\s+/)[1]
   })),
   // ─── Scripts ──────────────────────────────────────────────────────────────
-  makeRule(/^(bash|sh|zsh|fish)\s+\S+/, "script_run", (match) => ({ shell: match[1] })),
-  makeRule(/^node\s+\S+\.(?:js|mjs|cjs)\b/, "script_run", () => ({ runtime: "node" })),
-  makeRule(/^python3?\s+\S+\.py\b/, "script_run", () => ({ runtime: "python" })),
-  // ─── Environment ──────────────────────────────────────────────────────────
-  makeRule(/^export\s+\w+=/, "environment", (_m, cmd) => {
-    const varName = cmd.match(/^export\s+(\w+)=/)?.[1] ?? null;
-    return { variable: varName };
-  }),
-  makeRule(/^source\s+/, "environment", () => ({})),
+  makeRule(/^(bash|sh|zsh|fish)\s+\S+/, "running", (match) => ({ shell: match[1] })),
+  makeRule(/^node\s+\S+\.(?:js|mjs|cjs)\b/, "running", () => ({ runtime: "node" })),
+  makeRule(/^python3?\s+\S+\.py\b/, "running", () => ({ runtime: "python" })),
+  // ─── Linting / code quality ───────────────────────────────────────────────
+  makeRule(/^(eslint|tslint|biome)\b/, "linting", (match) => ({ tool: match[1] })),
+  makeRule(/^(prettier|dprint)\b/, "linting", (match) => ({ tool: match[1] })),
   // ─── generic run scripts ──────────────────────────────────────────────────
-  makeRule(/^npm\s+run\s+\S+/, "script_run", (_m, cmd) => ({
+  makeRule(/^npm\s+run\s+\S+/, "running", (_m, cmd) => ({
     tool: "npm",
     script: cmd.split(/\s+/)[2]
   })),
-  makeRule(/^bun\s+run\s+\S+/, "script_run", (_m, cmd) => ({
+  makeRule(/^bun\s+run\s+\S+/, "running", (_m, cmd) => ({
     tool: "bun",
     script: cmd.split(/\s+/)[2]
   })),
   // ─── Code search ─────────────────────────────────────────────────────────
-  makeRule(/^(grep|egrep|fgrep)\b/, "code_search", (match) => ({ tool: match[1] })),
-  makeRule(/^(rg|ag|ack|ripgrep)\b/, "code_search", (match) => ({ tool: match[1] })),
-  makeRule(/^find\s/, "code_search", () => ({ tool: "find" })),
+  makeRule(/^(grep|egrep|fgrep)\b/, "exploring", (match) => ({ tool: match[1] })),
+  makeRule(/^(rg|ag|ack|ripgrep)\b/, "exploring", (match) => ({ tool: match[1] })),
+  makeRule(/^find\s/, "exploring", () => ({ tool: "find" })),
   // ─── Code read ────────────────────────────────────────────────────────────
-  makeRule(/^(cat|bat|less|more)\s+\S+/, "code_read", (match) => ({ tool: match[1] })),
-  makeRule(/^(head|tail)\b/, "code_read", (match) => ({ tool: match[1] })),
+  makeRule(/^(cat|bat|less|more)\s+\S+/, "exploring", (match) => ({ tool: match[1] })),
+  makeRule(/^(head|tail)\b/, "exploring", (match) => ({ tool: match[1] })),
   // ─── File operations ──────────────────────────────────────────────────────
-  makeRule(/^(cp|rsync)\b/, "file_ops", (match) => ({ tool: match[1] })),
-  makeRule(/^(mv)\b/, "file_ops", () => ({ tool: "mv" })),
-  makeRule(/^(rm|rmdir)\b/, "file_ops", (match) => ({ tool: match[1] })),
-  makeRule(/^(mkdir|touch|ln)\b/, "file_ops", (match) => ({ tool: match[1] })),
-  makeRule(/^(chmod|chown|chgrp)\b/, "file_ops", (match) => ({ tool: match[1] })),
-  // ─── AI terminal tools (registry-driven) ─────────────────────────────────
-  ...loadAIToolRegistry().flatMap((entry) => {
+  makeRule(/^(cp|rsync)\b/, "files", (match) => ({ tool: match[1] })),
+  makeRule(/^(mv)\b/, "files", () => ({ tool: "mv" })),
+  makeRule(/^(rm|rmdir)\b/, "files", (match) => ({ tool: match[1] })),
+  makeRule(/^(mkdir|touch|ln)\b/, "files", (match) => ({ tool: match[1] })),
+  makeRule(/^(chmod|chown|chgrp)\b/, "files", (match) => ({ tool: match[1] })),
+  // ─── Environment ──────────────────────────────────────────────────────────
+  makeRule(/^export\s+\w+=/, "files", (_m, cmd) => {
+    const varName = cmd.match(/^export\s+(\w+)=/)?.[1] ?? null;
+    return { variable: varName };
+  }),
+  makeRule(/^source\s+/, "files", () => ({}))
+];
+function aiToolRules() {
+  return loadAIToolRegistry().flatMap((entry) => {
     try {
       return [makeRule(new RegExp(entry.pattern), "ai_session", () => ({ tool: entry.tool }))];
     } catch {
       debugLog("registry", `Skipping tool "${entry.tool}" \u2014 invalid pattern: ${entry.pattern}`);
       return [];
     }
-  })
-];
+  });
+}
+function buildRules(profileRules = []) {
+  return [...BASE_RULES, ...profileRules, ...aiToolRules()];
+}
+var RULES = buildRules(getActiveProfileRules());
 function normalizeCommand(command) {
   let trimmed = command.trim().replace(/\s+/g, " ");
   trimmed = trimmed.replace(/^(git)\s+-C\s+\S+\s+/, "$1 ");
@@ -685,87 +1009,6 @@ function normalizeCommand(command) {
   return { category: "other", metadata: {} };
 }
 
-// src/config/index.ts
-var import_fs6 = __toESM(require("fs"));
-var DEFAULTS = {
-  ai: {
-    provider: "",
-    apiKey: "",
-    model: "",
-    baseUrl: ""
-  },
-  session: {
-    idleTimeout: 30
-  },
-  capture: {
-    ignore: ["cd", "ls", "ll", "la", "ls -la", "ls -l", "ls -a", "pwd", "clear", "exit", "history", "man"],
-    aiTools: true,
-    includeAiderPrompt: true
-  },
-  redact: {
-    extra: []
-  },
-  summary: {
-    format: "markdown"
-  }
-};
-function readConfig() {
-  if (!import_fs6.default.existsSync(CONFIG_PATH)) return { ...DEFAULTS };
-  try {
-    const raw = import_fs6.default.readFileSync(CONFIG_PATH, "utf-8");
-    const parsed = JSON.parse(raw);
-    return deepMerge(DEFAULTS, parsed);
-  } catch {
-    return { ...DEFAULTS };
-  }
-}
-function writeConfig(config) {
-  import_fs6.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
-  try {
-    import_fs6.default.chmodSync(CONFIG_PATH, 384);
-  } catch {
-  }
-}
-function getConfigValue(config, key) {
-  const parts = key.split(".");
-  let cur = config;
-  for (const part of parts) {
-    if (cur == null || typeof cur !== "object") return void 0;
-    cur = cur[part];
-  }
-  return cur;
-}
-function setConfigValue(config, key, value) {
-  const parts = key.split(".");
-  const result = JSON.parse(JSON.stringify(config));
-  let cur = result;
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i];
-    if (cur[part] == null || typeof cur[part] !== "object") {
-      cur[part] = {};
-    }
-    cur = cur[part];
-  }
-  const lastKey = parts[parts.length - 1];
-  if (value === "true") cur[lastKey] = true;
-  else if (value === "false") cur[lastKey] = false;
-  else if (!isNaN(Number(value))) cur[lastKey] = Number(value);
-  else cur[lastKey] = value;
-  return result;
-}
-function deepMerge(defaults, overrides) {
-  const result = { ...defaults };
-  for (const key of Object.keys(overrides)) {
-    const val = overrides[key];
-    if (val !== null && typeof val === "object" && !Array.isArray(val) && typeof defaults[key] === "object") {
-      result[key] = deepMerge(defaults[key], val);
-    } else if (val !== void 0) {
-      result[key] = val;
-    }
-  }
-  return result;
-}
-
 // src/capture/filter.ts
 function normalizeForFilter(cmd) {
   return cmd.trim().replace(/\s+/g, " ");
@@ -789,7 +1032,7 @@ function isDuplicate(command, cwd, lastEvent, dedupWindowMs = 5e3, now = Date.no
 
 // src/capture/index.ts
 function captureCommand(opts) {
-  if (import_fs7.default.existsSync(PAUSE_FLAG_PATH)) return;
+  if (import_fs9.default.existsSync(PAUSE_FLAG_PATH)) return;
   const config = readConfig();
   const { command, cwd, exitCode, durationMs } = opts;
   if (shouldFilter(command, config.capture.ignore)) return;
@@ -833,8 +1076,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({
@@ -887,25 +1133,423 @@ function registerHook(program2) {
 }
 
 // src/cli/init.ts
-var import_fs10 = __toESM(require("fs"));
-var import_path7 = __toESM(require("path"));
+var import_fs12 = __toESM(require("fs"));
+var import_path9 = __toESM(require("path"));
 var import_os4 = __toESM(require("os"));
 var import_prompts = __toESM(require("prompts"));
 var import_chalk2 = __toESM(require("chalk"));
 
-// src/capture/shell-hook.ts
-var import_fs8 = __toESM(require("fs"));
-var import_path5 = __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_fs8.default.existsSync(rcFile)) return null;
-  const content = import_fs8.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 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/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.
+
+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");
+}
+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);
+      }
+    }
+  }
+  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}`);
+      }
+    }
+    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/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`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/ai/providers/index.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/providers/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_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);
 }
 function isHookInstalled(rcFile) {
   return getInstalledHookBlock(rcFile) !== null;
@@ -917,38 +1561,38 @@ function isHookOutdated(rcFile, hookContent) {
 }
 function installHook(rcFile, hookContent) {
   const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs8.default.copyFileSync(rcFile, backup);
-  log.info(`Backed up ${rcFile} \u2192 ${import_path5.default.basename(backup)}`);
-  import_fs8.default.appendFileSync(rcFile, `
+  import_fs10.default.copyFileSync(rcFile, backup);
+  log.info(`Backed up ${rcFile} \u2192 ${import_path7.default.basename(backup)}`);
+  import_fs10.default.appendFileSync(rcFile, `
 ${hookContent}
 `);
 }
 function updateHook(rcFile, hookContent) {
   const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs8.default.copyFileSync(rcFile, backup);
-  log.info(`Backed up ${rcFile} \u2192 ${import_path5.default.basename(backup)}`);
-  const content = import_fs8.default.readFileSync(rcFile, "utf-8");
+  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_fs8.default.writeFileSync(rcFile, content.slice(0, startIdx) + hookContent + content.slice(endIdx));
+  import_fs10.default.writeFileSync(rcFile, content.slice(0, startIdx) + hookContent + content.slice(endIdx));
 }
 function removeHook(rcFile) {
   const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs8.default.copyFileSync(rcFile, backup);
-  log.info(`Backed up ${rcFile} \u2192 ${import_path5.default.basename(backup)}`);
-  const content = import_fs8.default.readFileSync(rcFile, "utf-8");
+  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_fs8.default.writeFileSync(rcFile, before + after);
+  import_fs10.default.writeFileSync(rcFile, before + after);
 }
 
 // src/capture/hooks/claude-code.ts
-var import_fs9 = __toESM(require("fs"));
-var import_path6 = __toESM(require("path"));
+var import_fs11 = __toESM(require("fs"));
+var import_path8 = __toESM(require("path"));
 var import_os3 = __toESM(require("os"));
 
 // src/capture/hooks/utils.ts
@@ -963,11 +1607,11 @@ function isCommandInstalled(cmd) {
 }
 
 // src/capture/hooks/claude-code.ts
-var CLAUDE_SETTINGS_PATH = import_path6.default.join(import_os3.default.homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = import_path8.default.join(import_os3.default.homedir(), ".claude", "settings.json");
 function readSettings() {
-  if (!import_fs9.default.existsSync(CLAUDE_SETTINGS_PATH)) return {};
+  if (!import_fs11.default.existsSync(CLAUDE_SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(import_fs9.default.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
+    return JSON.parse(import_fs11.default.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
@@ -1002,8 +1646,8 @@ var claudeCodeIntegration = {
         }
       ]
     };
-    import_fs9.default.mkdirSync(import_path6.default.dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
-    import_fs9.default.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+    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));
   }
 };
 
@@ -1015,36 +1659,54 @@ var AI_HOOK_INTEGRATIONS = {
 // src/cli/init.ts
 function detectShell() {
   const shell = process.env.SHELL ?? "";
-  if (shell.includes("zsh")) return { name: "zsh", rcFile: import_path7.default.join(import_os4.default.homedir(), ".zshrc") };
-  if (shell.includes("bash")) return { name: "bash", rcFile: import_path7.default.join(import_os4.default.homedir(), ".bashrc") };
+  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;
 }
+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"));
-    if (!import_fs10.default.existsSync(WORKSCRIBE_DIR)) {
-      import_fs10.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true, mode: 448 });
+    step(1, TOTAL_STEPS, "Creating data directory");
+    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_fs10.default.chmodSync(WORKSCRIBE_DIR, 448);
+        import_fs12.default.chmodSync(WORKSCRIBE_DIR, 448);
       } catch {
       }
+      log.info(`${WORKSCRIBE_DIR} already exists`);
     }
+    if (!import_fs12.default.existsSync(PROFILES_DIR)) {
+      import_fs12.default.mkdirSync(PROFILES_DIR, { recursive: true, mode: 448 });
+    }
+    step(2, TOTAL_STEPS, "Initialising database");
     getDb();
-    log.success("Database initialized");
+    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");
       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_path7.default.join(__dirname, "..", "shell", `hook.${shell.name}`);
-      if (!import_fs10.default.existsSync(hookFile)) {
+      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_fs10.default.readFileSync(hookFile, "utf-8");
-        if (!import_fs10.default.existsSync(shell.rcFile)) import_fs10.default.writeFileSync(shell.rcFile, "");
+        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)) {
+          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)) {
@@ -1065,6 +1727,7 @@ function registerInit(program2) {
         }
       }
     }
+    step(4, TOTAL_STEPS, "Detecting AI coding tools");
     const installedTools = loadAIToolRegistry().filter(
       (entry) => entry.hook !== null && AI_HOOK_INTEGRATIONS[entry.hook]?.isInstalled()
     );
@@ -1092,6 +1755,35 @@ function registerInit(program2) {
       }
     }
     const config = readConfig();
+    try {
+      await cacheManifest();
+      const detected = detectProfilesForDirectory(process.cwd());
+      const alreadyActive = new Set(config.capture.profiles);
+      const toPrompt = detected.filter((entry) => !alreadyActive.has(entry.name));
+      if (toPrompt.length > 0) {
+        log.plain("");
+        for (const entry of toPrompt) {
+          const { install } = await (0, import_prompts.default)({
+            type: "confirm",
+            name: "install",
+            message: `${entry.displayName} project detected. Enable the ${entry.displayName} profile?`,
+            initial: true
+          });
+          if (install) {
+            await installProfile(entry.name);
+            config.capture.profiles = [.../* @__PURE__ */ new Set([...config.capture.profiles, entry.name])];
+            log.success(`${entry.displayName} profile enabled`);
+          }
+        }
+        writeConfig(config);
+      } else if (detected.length === 0) {
+        log.info("No project profiles detected \u2014 run workscribe profile detect from your project directory");
+      }
+    } 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 {
@@ -1108,7 +1800,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(`
@@ -1133,90 +1828,73 @@ 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_fs10.default.existsSync(CONFIG_PATH)) {
+    if (!import_fs12.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("");
-      log.plain(`  Activate capture now:  ${import_chalk2.default.cyan(`source ${shell.rcFile}`)}`);
+      log.plain(`  Activate capture now:`);
+      log.plain(`    ${import_chalk2.default.cyan(`source ${shell.rcFile}`)}`);
       log.plain(`  Or restart your terminal.`);
+      log.plain("");
+    }
+    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("");
-    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`);
     log.plain("");
   });
 }
 
 // src/cli/status.ts
-var import_fs11 = __toESM(require("fs"));
+var import_fs13 = __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_fs11.default.existsSync(PAUSE_FLAG_PATH);
+    const isPaused = import_fs13.default.existsSync(PAUSE_FLAG_PATH);
     log.plain("");
     log.plain(import_chalk3.default.bold("  Workscribe Status"));
     log.plain("");
@@ -1235,6 +1913,25 @@ function registerStatus(program2) {
       `  AI provider  ${config.ai.provider ? import_chalk3.default.cyan(config.ai.provider) : import_chalk3.default.yellow("not configured")}`
     );
     if (config.ai.model) log.plain(`  Model        ${import_chalk3.default.dim(config.ai.model)}`);
+    const activeProfiles = config.capture.profiles;
+    log.plain(
+      `  Profiles     ${activeProfiles.length > 0 ? import_chalk3.default.cyan(activeProfiles.join(", ")) : import_chalk3.default.dim("none")}`
+    );
+    const { total: weekTotal, otherCount } = getRecentOtherRate(7);
+    if (weekTotal > 0) {
+      const otherPct = Math.round(otherCount / weekTotal * 100);
+      if (otherPct >= 25) {
+        log.plain("");
+        log.plain(
+          `  ${import_chalk3.default.yellow("\u26A0")}  ${otherCount} of ${weekTotal} events (${otherPct}%) are uncategorised this week.`
+        );
+        log.plain(
+          import_chalk3.default.dim(
+            "     Run workscribe profile detect  \u2014 scan current directory for matching profiles\n     Run workscribe profile suggest  \u2014 analyse your command history"
+          )
+        );
+      }
+    }
     log.plain("");
   });
 }
@@ -1242,26 +1939,19 @@ function registerStatus(program2) {
 // src/cli/events.ts
 var import_chalk4 = __toESM(require("chalk"));
 var CATEGORY_COLORS = {
-  code_commit: import_chalk4.default.green,
-  code_push: import_chalk4.default.green,
-  code_pull: import_chalk4.default.blue,
-  branch_switch: import_chalk4.default.blue,
-  dependency_install: import_chalk4.default.yellow,
-  dependency_remove: import_chalk4.default.yellow,
-  test_run: import_chalk4.default.magenta,
-  build: import_chalk4.default.cyan,
-  server_run: import_chalk4.default.cyan,
+  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,
-  script_run: import_chalk4.default.white,
-  environment: import_chalk4.default.gray,
-  git_other: import_chalk4.default.blue,
-  code_merge: import_chalk4.default.green,
-  code_stash: import_chalk4.default.blue,
+  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,
-  lint_run: import_chalk4.default.yellow,
-  code_search: import_chalk4.default.dim.cyan,
-  code_read: import_chalk4.default.dim.white,
-  file_ops: import_chalk4.default.yellow,
   other: import_chalk4.default.gray
 };
 var AI_TOOL_DISPLAY_NAMES = Object.fromEntries(
@@ -1346,461 +2036,128 @@ function splitByRepo(events) {
       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) => {
-    let date = todayDate();
-    if (opts.date) {
-      try {
-        date = parseDate(opts.date);
-      } catch (e) {
-        log.error(e.message);
-        process.exit(1);
-      }
-    }
-    const sessions = getOrBuildSessions(date);
-    if (sessions.length === 0) {
-      log.plain(`No sessions detected 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("");
-  });
-}
-
-// src/cli/summary.ts
-var import_chalk6 = __toESM(require("chalk"));
-var import_fs12 = __toESM(require("fs"));
-var import_os5 = __toESM(require("os"));
-var import_path8 = __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:
-  - branch_switch {"branch":"feature/auth"}
-  - 2x dependency_install {"tool":"npm","packages":["bcrypt","jsonwebtoken"]}
-  - 2x test_run {"tool":"jest"} [failed]
-  - test_run {"tool":"jest"}
-  - 2x file_ops {"tool":"mkdir"}
-  - code_commit {"message":"fix: auth token validation"}
-  - code_push {"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 dependency_install events: 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 code_push, build, file_ops, and code_stash 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, 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.
-
-Maximum 5 bullets. Output ONLY the bullet points, nothing else.`;
-var EXCLUDED = /* @__PURE__ */ new Set(["environment", "code_search", "code_read", "server_run", "git_other"]);
-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}`;
-      } 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 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/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`);
-    }
-    throw err;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-// 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: SYSTEM_PROMPT,
-        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: SYSTEM_PROMPT },
-          { 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: SYSTEM_PROMPT },
-          { 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`);
-    }
-    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_fs14 = __toESM(require("fs"));
+var import_os5 = __toESM(require("os"));
+var import_path10 = __toESM(require("path"));
+
 // src/integrations/webhook.ts
 async function postToWebhook(url, text) {
   const response = await fetchWithTimeout(
@@ -1846,7 +2203,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;
@@ -1871,21 +2228,21 @@ async function handleWebhook(opts, config, summary) {
       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) {
@@ -1904,9 +2261,9 @@ function registerSummary(program2) {
         return;
       }
       const cacheKey = isoWeekKey(today);
-      const cacheFile = import_path8.default.join(WEEKLY_CACHE_DIR, `${cacheKey}.md`);
-      if (!opts.fresh && import_fs12.default.existsSync(cacheFile)) {
-        const cached = import_fs12.default.readFileSync(cacheFile, "utf-8");
+      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");
         log.plain("");
         log.plain(cached);
         log.plain("");
@@ -1922,11 +2279,11 @@ function registerSummary(program2) {
         log.plain("");
         log.plain(summary);
         log.plain("");
-        import_fs12.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
-        import_fs12.default.writeFileSync(cacheFile, summary, { encoding: "utf-8", mode: 384 });
+        import_fs14.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
+        import_fs14.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;
@@ -1935,8 +2292,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);
       }
     }
@@ -1968,12 +2325,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";
@@ -1992,8 +2372,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);
       }
     }
@@ -2005,13 +2385,21 @@ ${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_fs13 = __toESM(require("fs"));
-var import_path9 = __toESM(require("path"));
+var import_fs15 = __toESM(require("fs"));
+var import_path11 = __toESM(require("path"));
 function eventRowToPayload2(row) {
   let metadata = {};
   try {
@@ -2067,9 +2455,9 @@ function registerExport(program2) {
     const payload = { date, sessions: sessionPayloads };
     log.info(`Generating summary via ${config.ai.provider}\u2026`);
     const summary = await provider.summarize(payload);
-    const outputPath = opts.output ?? import_path9.default.join(EXPORTS_DIR, `workscribe-${date}.md`);
-    if (!import_fs13.default.existsSync(EXPORTS_DIR)) import_fs13.default.mkdirSync(EXPORTS_DIR, { recursive: true, mode: 448 });
-    import_fs13.default.writeFileSync(outputPath, `# Work Summary \u2014 ${date}
+    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}
 
 ${summary}
 `, { encoding: "utf-8", mode: 384 });
@@ -2141,22 +2529,22 @@ function printConfig(obj, indent) {
 }
 
 // src/cli/pause.ts
-var import_fs14 = __toESM(require("fs"));
+var import_fs16 = __toESM(require("fs"));
 function registerPause(program2) {
   program2.command("pause").description("Pause capture temporarily").action(() => {
-    if (import_fs14.default.existsSync(PAUSE_FLAG_PATH)) {
+    if (import_fs16.default.existsSync(PAUSE_FLAG_PATH)) {
       log.info("Capture is already paused. Run workscribe resume to restart.");
       return;
     }
-    import_fs14.default.writeFileSync(PAUSE_FLAG_PATH, "", { mode: 384 });
+    import_fs16.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_fs14.default.existsSync(PAUSE_FLAG_PATH)) {
+    if (!import_fs16.default.existsSync(PAUSE_FLAG_PATH)) {
       log.info("Capture is not paused.");
       return;
     }
-    import_fs14.default.rmSync(PAUSE_FLAG_PATH);
+    import_fs16.default.rmSync(PAUSE_FLAG_PATH);
     log.success("Capture resumed.");
   });
 }
@@ -2241,18 +2629,18 @@ function registerClear(program2) {
 }
 
 // src/cli/uninstall.ts
-var import_fs15 = __toESM(require("fs"));
-var import_path10 = __toESM(require("path"));
+var import_fs17 = __toESM(require("fs"));
+var import_path12 = __toESM(require("path"));
 var import_os6 = __toESM(require("os"));
 var import_prompts3 = __toESM(require("prompts"));
 var import_chalk9 = __toESM(require("chalk"));
 function detectShellRcFiles() {
   const candidates = [
-    { name: "zsh", rcFile: import_path10.default.join(import_os6.default.homedir(), ".zshrc") },
-    { name: "bash", rcFile: import_path10.default.join(import_os6.default.homedir(), ".bashrc") },
-    { name: "bash", rcFile: import_path10.default.join(import_os6.default.homedir(), ".bash_profile") }
+    { 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") }
   ];
-  return candidates.filter((candidate) => import_fs15.default.existsSync(candidate.rcFile) && isHookInstalled(candidate.rcFile));
+  return candidates.filter((candidate) => import_fs17.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) => {
@@ -2271,7 +2659,7 @@ function registerUninstall(program2) {
       }
     }
     if (opts.hooksOnly) return;
-    if (import_fs15.default.existsSync(WORKSCRIBE_DIR)) {
+    if (import_fs17.default.existsSync(WORKSCRIBE_DIR)) {
       log.plain("");
       const { deleteData } = await (0, import_prompts3.default)({
         type: "confirm",
@@ -2280,7 +2668,7 @@ function registerUninstall(program2) {
         initial: false
       });
       if (deleteData) {
-        import_fs15.default.rmSync(WORKSCRIBE_DIR, { recursive: true, force: true });
+        import_fs17.default.rmSync(WORKSCRIBE_DIR, { recursive: true, force: true });
         log.success(`Deleted ${WORKSCRIBE_DIR}`);
       } else {
         log.info(`Data kept at ${WORKSCRIBE_DIR}`);
@@ -2292,9 +2680,306 @@ function registerUninstall(program2) {
   });
 }
 
+// src/cli/profile.ts
+var import_fs18 = __toESM(require("fs"));
+var import_path13 = __toESM(require("path"));
+var import_chalk10 = __toESM(require("chalk"));
+var MIN_SUGGEST_COUNT = 5;
+function registerProfile(program2) {
+  const profile = program2.command("profile").description("Manage stack profiles for better command tracking");
+  profile.command("list").description("List available profiles from the registry").action(async () => {
+    const config = readConfig();
+    const activeNames = new Set(config.capture.profiles);
+    let manifest = readCachedManifest();
+    let offline = false;
+    if (!manifest) {
+      try {
+        manifest = await cacheManifest();
+      } catch {
+        offline = true;
+        manifest = getCachedProfiles().map((p) => ({
+          name: p.name,
+          displayName: p.displayName,
+          tags: [],
+          description: "",
+          keywords: [],
+          detect: p.detect
+        }));
+      }
+    } else {
+      cacheManifest().catch(() => void 0);
+    }
+    if (offline) {
+      log.warn("Registry unreachable \u2014 showing installed profiles only");
+    }
+    if (manifest.length === 0) {
+      log.plain("No profiles available. Check your connection and try again.");
+      return;
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const entry of manifest) {
+      const tag = entry.tags[0] ?? "other";
+      if (!grouped.has(tag)) grouped.set(tag, []);
+      grouped.get(tag).push(entry);
+    }
+    log.plain("");
+    for (const [tag, entries] of grouped) {
+      log.plain(import_chalk10.default.bold(`  ${tag.charAt(0).toUpperCase() + tag.slice(1)} profiles`));
+      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") : "";
+        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)}`);
+      }
+      log.plain("");
+    }
+  });
+  profile.command("add <names...>").description("Install one or more profiles from the registry").action(async (names) => {
+    const config = readConfig();
+    const activeNames = new Set(config.capture.profiles);
+    for (const name of names) {
+      if (activeNames.has(name)) {
+        log.info(`Profile "${name}" is already active`);
+        continue;
+      }
+      try {
+        log.plain(`Fetching ${import_chalk10.default.cyan(name)}\u2026`);
+        await installProfile(name);
+        activeNames.add(name);
+        log.success(`Profile "${name}" installed`);
+      } catch (err) {
+        log.error(`Failed to install "${name}": ${err.message}`);
+      }
+    }
+    config.capture.profiles = [...activeNames];
+    writeConfig(config);
+  });
+  profile.command("remove <names...>").description("Uninstall one or more profiles").action((names) => {
+    const config = readConfig();
+    const activeNames = new Set(config.capture.profiles);
+    for (const name of names) {
+      if (!activeNames.has(name)) {
+        log.warn(`Profile "${name}" is not active`);
+        continue;
+      }
+      activeNames.delete(name);
+      const cachePath = import_path13.default.join(PROFILES_DIR, `${name}.json`);
+      if (import_fs18.default.existsSync(cachePath)) import_fs18.default.unlinkSync(cachePath);
+      log.success(`Profile "${name}" removed`);
+    }
+    config.capture.profiles = [...activeNames];
+    writeConfig(config);
+  });
+  profile.command("update [name]").description("Re-fetch installed profiles from the registry").action(async (name) => {
+    const config = readConfig();
+    const toUpdate = name ? [name] : config.capture.profiles;
+    if (toUpdate.length === 0) {
+      log.plain("No profiles installed. Run workscribe profile add <name> first.");
+      return;
+    }
+    for (const profileName of toUpdate) {
+      try {
+        log.plain(`Updating ${import_chalk10.default.cyan(profileName)}\u2026`);
+        await installProfile(profileName);
+        log.success(`${profileName} updated`);
+      } catch (err) {
+        log.error(`Failed to update "${profileName}": ${err.message}`);
+      }
+    }
+  });
+  profile.command("detect").description("Scan the current directory and suggest matching profiles").action(() => {
+    const cwd = process.cwd();
+    const matches = detectProfilesForDirectory(cwd);
+    if (matches.length === 0) {
+      const cached = readCachedManifest();
+      if (!cached) {
+        log.plain("No manifest cached. Run workscribe profile list to fetch it first.");
+      } else {
+        log.plain(`No profiles detected for ${import_chalk10.default.dim(cwd)}`);
+        log.plain(import_chalk10.default.dim("Run workscribe profile list to browse available profiles."));
+      }
+      return;
+    }
+    log.plain("");
+    log.plain(import_chalk10.default.bold("  Profiles detected for this directory:"));
+    log.plain("");
+    for (const entry of matches) {
+      const files = entry.detect?.files?.join(", ") ?? "";
+      log.plain(`  ${import_chalk10.default.cyan(entry.name.padEnd(18))} ${entry.displayName}  ${import_chalk10.default.dim("(" + files + ")")}`);
+    }
+    log.plain("");
+    log.plain(`  Run: ${import_chalk10.default.cyan("workscribe profile add " + matches.map((e) => e.name).join(" "))}`);
+    log.plain("");
+  });
+  profile.command("suggest").description("Analyse recent unclassified commands and suggest profiles").option("--days <n>", "number of days to analyse", "30").action((opts) => {
+    const days = Math.max(1, parseInt(opts.days, 10) || 30);
+    const toolCounts = getOtherEventToolCounts(days);
+    if (toolCounts.length === 0) {
+      log.plain("No unclassified commands found in the last " + days + " days.");
+      return;
+    }
+    const manifest = readCachedManifest();
+    if (!manifest) {
+      log.plain("No manifest cached. Run workscribe profile list first.");
+      return;
+    }
+    const config = readConfig();
+    const activeNames = new Set(config.capture.profiles);
+    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);
+      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.");
+      return;
+    }
+    log.plain("");
+    log.plain(import_chalk10.default.bold(`  Analysed last ${days} days of unclassified commands:`));
+    log.plain("");
+    for (const { entry, count } of suggestions) {
+      log.plain(
+        `  ${import_chalk10.default.cyan(entry.name.padEnd(18))} ${String(count).padStart(4)} commands  \u2192  ${entry.displayName}`
+      );
+    }
+    log.plain("");
+    log.plain(`  Run: ${import_chalk10.default.cyan("workscribe profile add " + suggestions.map((s) => s.entry.name).join(" "))}`);
+    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_fs19 = __toESM(require("fs"));
+var import_path14 = __toESM(require("path"));
+var import_os7 = __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_os7.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_fs19.default.existsSync(cacheFile)) {
+      const cached = import_fs19.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_fs19.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
+      import_fs19.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/index.ts
+assertNodeVersion(process.versions.node);
 var program = new import_commander.Command();
-program.name("workscribe").description("Automatic developer work journal").version("1.9.0");
+program.name("workscribe").description("Automatic developer work journal").version("1.11.0");
 registerCapture(program);
 registerHook(program);
 registerInit(program);
@@ -2308,5 +2993,8 @@ registerPause(program);
 registerUndo(program);
 registerClear(program);
 registerUninstall(program);
+registerProfile(program);
+registerNote(program);
+registerWeek(program);
 program.parse();
 //# sourceMappingURL=index.js.map