@workscribe/cli 1.11.0 → 1.12.0

package/dist/index.js

@@ -41,23 +41,31 @@ Upgrade at https://nodejs.org or via your version manager:
 }
 
 // src/capture/index.ts
-var import_fs9 = __toESM(require("fs"));
+var import_fs10 = __toESM(require("fs"));
 
 // src/db/index.ts
 var import_node_sqlite = require("node:sqlite");
-var import_fs = __toESM(require("fs"));
+var import_fs2 = __toESM(require("fs"));
 
 // src/utils/paths.ts
 var import_path = __toESM(require("path"));
 var import_os = __toESM(require("os"));
-var WORKSCRIBE_DIR = import_path.default.join(import_os.default.homedir(), ".workscribe");
-var DB_PATH = import_path.default.join(WORKSCRIBE_DIR, "workscribe.db");
-var CONFIG_PATH = import_path.default.join(WORKSCRIBE_DIR, "config.json");
-var DEBUG_LOG_PATH = import_path.default.join(WORKSCRIBE_DIR, "debug.log");
-var EXPORTS_DIR = import_path.default.join(WORKSCRIBE_DIR, "exports");
-var PAUSE_FLAG_PATH = import_path.default.join(WORKSCRIBE_DIR, "paused");
-var WEEKLY_CACHE_DIR = import_path.default.join(WORKSCRIBE_DIR, "weekly-cache");
-var PROFILES_DIR = import_path.default.join(WORKSCRIBE_DIR, "profiles");
+var import_fs = __toESM(require("fs"));
+var LEGACY_DIR = import_path.default.join(import_os.default.homedir(), ".workscribe");
+var USE_XDG = !import_fs.default.existsSync(LEGACY_DIR);
+var xdgDataDir = USE_XDG ? import_path.default.join(process.env.XDG_DATA_HOME ?? import_path.default.join(import_os.default.homedir(), ".local", "share"), "workscribe") : LEGACY_DIR;
+var xdgConfigDir = USE_XDG ? import_path.default.join(process.env.XDG_CONFIG_HOME ?? import_path.default.join(import_os.default.homedir(), ".config"), "workscribe") : LEGACY_DIR;
+var xdgStateDir = USE_XDG ? import_path.default.join(process.env.XDG_STATE_HOME ?? import_path.default.join(import_os.default.homedir(), ".local", "state"), "workscribe") : LEGACY_DIR;
+var REQUIRED_DIRS = [.../* @__PURE__ */ new Set([xdgDataDir, xdgConfigDir, xdgStateDir])];
+var WORKSCRIBE_DIR = xdgDataDir;
+var DB_PATH = import_path.default.join(xdgDataDir, "workscribe.db");
+var CONFIG_PATH = import_path.default.join(xdgConfigDir, "config.json");
+var DEBUG_LOG_PATH = import_path.default.join(xdgStateDir, "debug.log");
+var UPDATE_CHECK_PATH = import_path.default.join(xdgStateDir, "update-check.json");
+var EXPORTS_DIR = import_path.default.join(xdgDataDir, "exports");
+var PAUSE_FLAG_PATH = import_path.default.join(xdgStateDir, "paused");
+var WEEKLY_CACHE_DIR = import_path.default.join(xdgDataDir, "weekly-cache");
+var PROFILES_DIR = import_path.default.join(xdgDataDir, "profiles");
 
 // src/db/migrations/001_initial_schema.ts
 var initial_schema_default = {
@@ -126,12 +134,12 @@ var MIGRATIONS = [initial_schema_default, semantic_categories_default];
 var _db = null;
 function getDb() {
   if (_db) return _db;
-  if (!import_fs.default.existsSync(WORKSCRIBE_DIR)) {
-    import_fs.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true });
+  if (!import_fs2.default.existsSync(WORKSCRIBE_DIR)) {
+    import_fs2.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true });
   }
   const db = new import_node_sqlite.DatabaseSync(DB_PATH);
   try {
-    import_fs.default.chmodSync(DB_PATH, 384);
+    import_fs2.default.chmodSync(DB_PATH, 384);
   } catch {
   }
   db.exec("PRAGMA journal_mode = WAL");
@@ -345,7 +353,7 @@ function redact(command, extraPatterns = []) {
 // src/capture/git.ts
 var import_child_process = require("child_process");
 var import_path2 = __toESM(require("path"));
-var import_fs2 = __toESM(require("fs"));
+var import_fs3 = __toESM(require("fs"));
 function nameFromRemote(root) {
   try {
     const url = (0, import_child_process.execSync)("git remote get-url origin", {
@@ -361,7 +369,7 @@ function nameFromRemote(root) {
 }
 function nameFromPackageJson(root) {
   try {
-    const raw = import_fs2.default.readFileSync(import_path2.default.join(root, "package.json"), "utf-8");
+    const raw = import_fs3.default.readFileSync(import_path2.default.join(root, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (!pkg.name) return null;
     return pkg.name.replace(/^@[^/]+\//, "");
@@ -405,14 +413,14 @@ function getCommitsSince(sha, cwd) {
 }
 
 // src/capture/aider.ts
-var import_fs3 = __toESM(require("fs"));
+var import_fs4 = __toESM(require("fs"));
 var import_path3 = __toESM(require("path"));
 var HISTORY_FILE = ".aider.chat.history.md";
 var PROMPT_MAX_LENGTH = 200;
 function readLastAiderPrompt(cwd) {
   try {
     const histPath = import_path3.default.join(cwd, HISTORY_FILE);
-    const content = import_fs3.default.readFileSync(histPath, "utf-8");
+    const content = import_fs4.default.readFileSync(histPath, "utf-8");
     const matches = [...content.matchAll(/^> (.+)$/gm)];
     if (!matches.length) return null;
     return matches[matches.length - 1][1].trim().slice(0, PROMPT_MAX_LENGTH);
@@ -422,7 +430,7 @@ function readLastAiderPrompt(cwd) {
 }
 
 // src/config/registry.ts
-var import_fs5 = __toESM(require("fs"));
+var import_fs6 = __toESM(require("fs"));
 var import_os2 = __toESM(require("os"));
 var import_path4 = __toESM(require("path"));
 
@@ -488,7 +496,7 @@ var ai_tools_default = [
 
 // src/utils/logger.ts
 var import_chalk = __toESM(require("chalk"));
-var import_fs4 = __toESM(require("fs"));
+var import_fs5 = __toESM(require("fs"));
 var isDebug = process.env.WORKSCRIBE_DEBUG === "1";
 var log = {
   info: (msg) => console.log(import_chalk.default.cyan("\u2192"), msg),
@@ -502,7 +510,7 @@ function debugLog(context, error) {
   const entry = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${context}] ${error instanceof Error ? error.stack : String(error)}
 `;
   try {
-    import_fs4.default.appendFileSync(DEBUG_LOG_PATH, entry, { mode: 384 });
+    import_fs5.default.appendFileSync(DEBUG_LOG_PATH, entry, { mode: 384 });
   } catch {
   }
 }
@@ -512,8 +520,8 @@ var USER_REGISTRY_PATH = import_path4.default.join(import_os2.default.homedir(),
 function loadAIToolRegistry() {
   let userEntries = [];
   try {
-    if (import_fs5.default.existsSync(USER_REGISTRY_PATH)) {
-      const raw = import_fs5.default.readFileSync(USER_REGISTRY_PATH, "utf-8");
+    if (import_fs6.default.existsSync(USER_REGISTRY_PATH)) {
+      const raw = import_fs6.default.readFileSync(USER_REGISTRY_PATH, "utf-8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed)) {
         userEntries = parsed.filter((entry) => typeof entry.tool === "string" && typeof entry.pattern === "string").map((entry) => ({
@@ -535,11 +543,11 @@ function loadAIToolRegistry() {
 }
 
 // src/profiles/loader.ts
-var import_fs8 = __toESM(require("fs"));
+var import_fs9 = __toESM(require("fs"));
 var import_path6 = __toESM(require("path"));
 
 // src/config/index.ts
-var import_fs6 = __toESM(require("fs"));
+var import_fs7 = __toESM(require("fs"));
 var DEFAULTS = {
   ai: {
     provider: "",
@@ -564,9 +572,9 @@ var DEFAULTS = {
   }
 };
 function readConfig() {
-  if (!import_fs6.default.existsSync(CONFIG_PATH)) return { ...DEFAULTS };
+  if (!import_fs7.default.existsSync(CONFIG_PATH)) return { ...DEFAULTS };
   try {
-    const raw = import_fs6.default.readFileSync(CONFIG_PATH, "utf-8");
+    const raw = import_fs7.default.readFileSync(CONFIG_PATH, "utf-8");
     const parsed = JSON.parse(raw);
     return deepMerge(DEFAULTS, parsed);
   } catch {
@@ -574,9 +582,9 @@ function readConfig() {
   }
 }
 function writeConfig(config) {
-  import_fs6.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+  import_fs7.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
   try {
-    import_fs6.default.chmodSync(CONFIG_PATH, 384);
+    import_fs7.default.chmodSync(CONFIG_PATH, 384);
   } catch {
   }
 }
@@ -641,21 +649,57 @@ function isValidManifest(m) {
 }
 
 // src/profiles/fetcher.ts
-var import_fs7 = __toESM(require("fs"));
+var import_fs8 = __toESM(require("fs"));
 var import_path5 = __toESM(require("path"));
+
+// src/utils/fetch.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ENOTFOUND",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "EHOSTUNREACH",
+  "ENETUNREACH"
+]);
+function isNetworkError(err) {
+  if (!(err instanceof Error)) return false;
+  const cause = err.cause;
+  const code = err.code ?? (cause instanceof Error ? cause.code : void 0);
+  return NETWORK_ERROR_CODES.has(code ?? "");
+}
+async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } catch (err) {
+    if (err.name === "AbortError") {
+      throw new Error(`Request timed out after ${timeoutMs / 1e3}s`);
+    }
+    if (isNetworkError(err)) {
+      throw new Error("No internet connection \u2014 try again when you're online");
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/profiles/fetcher.ts
 var REGISTRY_BASE = "https://raw.githubusercontent.com/workscribe/profiles/main";
 function manifestCachePath() {
   return import_path5.default.join(PROFILES_DIR, "manifest.json");
 }
 async function fetchManifest() {
-  const response = await fetch(`${REGISTRY_BASE}/manifest.json`);
+  const response = await fetchWithTimeout(`${REGISTRY_BASE}/manifest.json`, {});
   if (!response.ok) throw new Error(`Registry unreachable (${response.status})`);
   const data = await response.json();
   if (!isValidManifest(data)) throw new Error("Manifest format unrecognised");
   return data;
 }
 async function fetchProfile(name) {
-  const response = await fetch(`${REGISTRY_BASE}/${name}.json`);
+  const response = await fetchWithTimeout(`${REGISTRY_BASE}/${name}.json`, {});
   if (response.status === 404) throw new Error(`Profile "${name}" not found in registry`);
   if (!response.ok) throw new Error(`Registry unreachable (${response.status})`);
   const data = await response.json();
@@ -666,27 +710,27 @@ async function installProfile(name) {
   ensureProfilesDir();
   const profile = await fetchProfile(name);
   const dest = import_path5.default.join(PROFILES_DIR, `${name}.json`);
-  import_fs7.default.writeFileSync(dest, JSON.stringify(profile, null, 2), { encoding: "utf-8", mode: 384 });
+  import_fs8.default.writeFileSync(dest, JSON.stringify(profile, null, 2), { encoding: "utf-8", mode: 384 });
   debugLog("profiles", `Installed profile "${name}" to ${dest}`);
 }
 async function cacheManifest() {
   ensureProfilesDir();
   const manifest = await fetchManifest();
-  import_fs7.default.writeFileSync(manifestCachePath(), JSON.stringify(manifest, null, 2), { encoding: "utf-8", mode: 384 });
+  import_fs8.default.writeFileSync(manifestCachePath(), JSON.stringify(manifest, null, 2), { encoding: "utf-8", mode: 384 });
   return manifest;
 }
 function readCachedManifest() {
-  if (!import_fs7.default.existsSync(manifestCachePath())) return null;
+  if (!import_fs8.default.existsSync(manifestCachePath())) return null;
   try {
-    const data = JSON.parse(import_fs7.default.readFileSync(manifestCachePath(), "utf-8"));
+    const data = JSON.parse(import_fs8.default.readFileSync(manifestCachePath(), "utf-8"));
     return isValidManifest(data) ? data : null;
   } catch {
     return null;
   }
 }
 function ensureProfilesDir() {
-  if (!import_fs7.default.existsSync(PROFILES_DIR)) {
-    import_fs7.default.mkdirSync(PROFILES_DIR, { recursive: true, mode: 448 });
+  if (!import_fs8.default.existsSync(PROFILES_DIR)) {
+    import_fs8.default.mkdirSync(PROFILES_DIR, { recursive: true, mode: 448 });
   }
 }
 
@@ -713,13 +757,13 @@ function compileRule(profileName, rule) {
 }
 function loadProfileFromDisk(name) {
   const filePath = import_path6.default.join(PROFILES_DIR, `${name}.json`);
-  if (!import_fs8.default.existsSync(filePath)) {
+  if (!import_fs9.default.existsSync(filePath)) {
     debugLog("profiles", `Profile "${name}" not found in cache \u2014 run: workscribe profile add ${name}`);
     return null;
   }
   let candidate;
   try {
-    candidate = JSON.parse(import_fs8.default.readFileSync(filePath, "utf-8"));
+    candidate = JSON.parse(import_fs9.default.readFileSync(filePath, "utf-8"));
   } catch {
     debugLog("profiles", `Profile "${name}" contains invalid JSON \u2014 skipping`);
     return null;
@@ -751,8 +795,8 @@ function getActiveProfileAiContexts() {
   });
 }
 function getCachedProfiles() {
-  if (!import_fs8.default.existsSync(PROFILES_DIR)) return [];
-  return import_fs8.default.readdirSync(PROFILES_DIR).filter((file) => file.endsWith(".json") && file !== "manifest.json").flatMap((file) => {
+  if (!import_fs9.default.existsSync(PROFILES_DIR)) return [];
+  return import_fs9.default.readdirSync(PROFILES_DIR).filter((file) => file.endsWith(".json") && file !== "manifest.json").flatMap((file) => {
     const profile = loadProfileFromDisk(file.replace(/\.json$/, ""));
     return profile ? [profile] : [];
   });
@@ -764,7 +808,7 @@ function detectProfilesForDirectory(dir) {
   return manifest.filter((entry) => {
     if (activeNames.has(entry.name)) return false;
     const indicatorFiles = entry.detect?.files ?? [];
-    return indicatorFiles.length > 0 && indicatorFiles.every((file) => import_fs8.default.existsSync(import_path6.default.join(dir, file)));
+    return indicatorFiles.length > 0 && indicatorFiles.every((file) => import_fs9.default.existsSync(import_path6.default.join(dir, file)));
   });
 }
 
@@ -1032,7 +1076,7 @@ function isDuplicate(command, cwd, lastEvent, dedupWindowMs = 5e3, now = Date.no
 
 // src/capture/index.ts
 function captureCommand(opts) {
-  if (import_fs9.default.existsSync(PAUSE_FLAG_PATH)) return;
+  if (import_fs10.default.existsSync(PAUSE_FLAG_PATH)) return;
   const config = readConfig();
   const { command, cwd, exitCode, durationMs } = opts;
   if (shouldFilter(command, config.capture.ignore)) return;
@@ -1133,9 +1177,9 @@ function registerHook(program2) {
 }
 
 // src/cli/init.ts
-var import_fs12 = __toESM(require("fs"));
+var import_fs13 = __toESM(require("fs"));
 var import_path9 = __toESM(require("path"));
-var import_os4 = __toESM(require("os"));
+var import_os5 = __toESM(require("os"));
 var import_prompts = __toESM(require("prompts"));
 var import_chalk2 = __toESM(require("chalk"));
 
@@ -1353,24 +1397,7 @@ function buildWeeklyMessage(payload) {
   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
+// src/ai/generic-provider.ts
 var GenericProvider = class {
   constructor(config, model, apiKey, baseUrl, includeCategories = []) {
     this.config = config;
@@ -1414,7 +1441,7 @@ var GenericProvider = class {
   }
 };
 
-// src/ai/providers/config.ts
+// src/ai/provider-config.ts
 var PROVIDER_CONFIGS = {
   anthropic: {
     defaultModel: "claude-haiku-4-5-20251001",
@@ -1538,14 +1565,72 @@ Run: workscribe config set ai.apiKey <your-key>`);
 }
 
 // src/capture/shell-hook.ts
-var import_fs10 = __toESM(require("fs"));
+var import_fs11 = __toESM(require("fs"));
 var import_path7 = __toESM(require("path"));
+var import_os3 = __toESM(require("os"));
+
+// src/utils/completion-scripts.ts
+function bashCompletion(commands) {
+  const names = commands.map((command) => command.name).join(" ");
+  return `_workscribe_completion() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  local commands="${names}"
+  case "$prev" in
+    completions) COMPREPLY=( $(compgen -W "bash zsh fish" -- "$cur") ); return ;;
+    config)      COMPREPLY=( $(compgen -W "get set list" -- "$cur") ); return ;;
+    profile)     COMPREPLY=( $(compgen -W "list add remove update detect suggest" -- "$cur") ); return ;;
+  esac
+  COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
+}
+complete -F _workscribe_completion workscribe`;
+}
+function zshCompletion(commands) {
+  const commandList = commands.map((command) => `    '${command.name}:${command.description}'`).join("\n");
+  return `#compdef workscribe
+_workscribe() {
+  local state
+  _arguments '1: :->command' '*: :->args'
+  case $state in
+    command)
+      local -a commands
+      commands=(
+${commandList}
+      )
+      _describe 'command' commands
+      ;;
+    args)
+      case $words[2] in
+        completions) local -a shells; shells=('bash' 'zsh' 'fish'); _describe 'shell' shells ;;
+        config)      local -a sub; sub=('get:Get a value' 'set:Set a value' 'list:List all values'); _describe 'subcommand' sub ;;
+        profile)     local -a sub; sub=('list' 'add' 'remove' 'update' 'detect' 'suggest'); _describe 'subcommand' sub ;;
+      esac
+      ;;
+  esac
+}
+_workscribe`;
+}
+function fishCompletion(commands) {
+  const lines = [
+    "complete -c workscribe -f",
+    ...commands.map(
+      (command) => `complete -c workscribe -n "__fish_use_subcommand" -a ${command.name.padEnd(12)} -d "${command.description}"`
+    ),
+    'complete -c workscribe -n "__fish_seen_subcommand_from completions" -a "bash zsh fish"',
+    'complete -c workscribe -n "__fish_seen_subcommand_from config"      -a "get set list"',
+    'complete -c workscribe -n "__fish_seen_subcommand_from profile"     -a "list add remove update detect suggest"'
+  ];
+  return lines.join("\n");
+}
+
+// src/capture/shell-hook.ts
+var FISH_COMPLETIONS_DIR = import_path7.default.join(import_os3.default.homedir(), ".config", "fish", "completions");
 var HOOK_START = "# workscribe:hook:start";
 var HOOK_END = "# workscribe:hook:end";
 var HOOK_PREAMBLE = "# Workscribe \u2014 developer work journal";
 function getInstalledHookBlock(rcFile) {
-  if (!import_fs10.default.existsSync(rcFile)) return null;
-  const content = import_fs10.default.readFileSync(rcFile, "utf-8");
+  if (!import_fs11.default.existsSync(rcFile)) return null;
+  const content = import_fs11.default.readFileSync(rcFile, "utf-8");
   const startIdx = content.indexOf(HOOK_START);
   const endIdx = content.indexOf(HOOK_END);
   if (startIdx === -1 || endIdx === -1) return null;
@@ -1561,39 +1646,70 @@ function isHookOutdated(rcFile, hookContent) {
 }
 function installHook(rcFile, hookContent) {
   const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs10.default.copyFileSync(rcFile, backup);
+  import_fs11.default.copyFileSync(rcFile, backup);
   log.info(`Backed up ${rcFile} \u2192 ${import_path7.default.basename(backup)}`);
-  import_fs10.default.appendFileSync(rcFile, `
+  import_fs11.default.appendFileSync(rcFile, `
 ${hookContent}
 `);
 }
 function updateHook(rcFile, hookContent) {
   const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs10.default.copyFileSync(rcFile, backup);
+  import_fs11.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 content = import_fs11.default.readFileSync(rcFile, "utf-8");
   const startIdx = content.indexOf(HOOK_START);
   const endIdx = content.indexOf(HOOK_END) + HOOK_END.length;
-  import_fs10.default.writeFileSync(rcFile, content.slice(0, startIdx) + hookContent + content.slice(endIdx));
+  import_fs11.default.writeFileSync(rcFile, content.slice(0, startIdx) + hookContent + content.slice(endIdx));
 }
 function removeHook(rcFile) {
   const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs10.default.copyFileSync(rcFile, backup);
+  import_fs11.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 content = import_fs11.default.readFileSync(rcFile, "utf-8");
   const startIdx = content.indexOf(HOOK_START);
   const endIdx = content.indexOf(HOOK_END) + HOOK_END.length;
   const preambleIdx = content.lastIndexOf(HOOK_PREAMBLE, startIdx);
   const blockStart = preambleIdx !== -1 ? preambleIdx : startIdx;
   const before = content.slice(0, blockStart).replace(/\n+$/, "\n");
   const after = content.slice(endIdx).replace(/^\n/, "");
-  import_fs10.default.writeFileSync(rcFile, before + after);
+  import_fs11.default.writeFileSync(rcFile, before + after);
+}
+function isCompletionsInstalled(shell) {
+  if (shell.name === "fish") {
+    return import_fs11.default.existsSync(import_path7.default.join(FISH_COMPLETIONS_DIR, "workscribe.fish"));
+  }
+  try {
+    return import_fs11.default.readFileSync(shell.rcFile, "utf-8").includes("workscribe completions");
+  } catch {
+    return false;
+  }
+}
+function installCompletions(shell, commands) {
+  if (shell.name === "fish") {
+    if (!import_fs11.default.existsSync(FISH_COMPLETIONS_DIR)) {
+      import_fs11.default.mkdirSync(FISH_COMPLETIONS_DIR, { recursive: true });
+    }
+    import_fs11.default.writeFileSync(import_path7.default.join(FISH_COMPLETIONS_DIR, "workscribe.fish"), fishCompletion(commands), { mode: 420 });
+  } else {
+    const script = shell.name === "zsh" ? zshCompletion(commands) : bashCompletion(commands);
+    const cacheFile = import_path7.default.join(WORKSCRIBE_DIR, `completion.${shell.name}`);
+    import_fs11.default.writeFileSync(cacheFile, script, { mode: 420 });
+    const sourceLine = shell.name === "zsh" ? `
+# Workscribe completions
+autoload -Uz compinit && compinit
+source "${cacheFile}"
+` : `
+# Workscribe completions
+source "${cacheFile}"
+`;
+    import_fs11.default.appendFileSync(shell.rcFile, sourceLine);
+  }
 }
 
 // src/capture/hooks/claude-code.ts
-var import_fs11 = __toESM(require("fs"));
+var import_fs12 = __toESM(require("fs"));
 var import_path8 = __toESM(require("path"));
-var import_os3 = __toESM(require("os"));
+var import_os4 = __toESM(require("os"));
 
 // src/capture/hooks/utils.ts
 var import_child_process3 = require("child_process");
@@ -1607,11 +1723,11 @@ function isCommandInstalled(cmd) {
 }
 
 // src/capture/hooks/claude-code.ts
-var CLAUDE_SETTINGS_PATH = import_path8.default.join(import_os3.default.homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = import_path8.default.join(import_os4.default.homedir(), ".claude", "settings.json");
 function readSettings() {
-  if (!import_fs11.default.existsSync(CLAUDE_SETTINGS_PATH)) return {};
+  if (!import_fs12.default.existsSync(CLAUDE_SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(import_fs11.default.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
+    return JSON.parse(import_fs12.default.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
@@ -1646,8 +1762,8 @@ var claudeCodeIntegration = {
         }
       ]
     };
-    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));
+    import_fs12.default.mkdirSync(import_path8.default.dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
+    import_fs12.default.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
   }
 };
 
@@ -1656,11 +1772,34 @@ var AI_HOOK_INTEGRATIONS = {
   "claude-code": claudeCodeIntegration
 };
 
+// src/cli/completions.ts
+var HIDDEN_COMMANDS = /* @__PURE__ */ new Set(["_capture", "_hook"]);
+function getPublicCommands(program2) {
+  return program2.commands.filter((command) => !HIDDEN_COMMANDS.has(command.name())).map((command) => ({ name: command.name(), description: command.description() }));
+}
+function registerCompletions(program2) {
+  program2.command("completions [shell]").description("Print shell completion script (bash, zsh, fish)").action((shell) => {
+    const detected = shell ?? (process.env.SHELL ?? "").split("/").at(-1);
+    if (!detected || !["bash", "zsh", "fish"].includes(detected)) {
+      log.error(`Unknown shell: "${detected ?? ""}". Supported: bash, zsh, fish`);
+      log.plain(`  Usage: workscribe completions <bash|zsh|fish>`);
+      process.exit(1);
+    }
+    const commands = getPublicCommands(program2);
+    const script = detected === "bash" ? bashCompletion(commands) : detected === "zsh" ? zshCompletion(commands) : fishCompletion(commands);
+    process.stdout.write(script + "\n");
+  });
+}
+
 // src/cli/init.ts
 function detectShell() {
   const shell = process.env.SHELL ?? "";
-  if (shell.includes("zsh")) return { name: "zsh", rcFile: import_path9.default.join(import_os4.default.homedir(), ".zshrc") };
-  if (shell.includes("bash")) return { name: "bash", rcFile: import_path9.default.join(import_os4.default.homedir(), ".bashrc") };
+  if (shell.includes("zsh")) return { name: "zsh", rcFile: import_path9.default.join(import_os5.default.homedir(), ".zshrc") };
+  if (shell.includes("bash")) return { name: "bash", rcFile: import_path9.default.join(import_os5.default.homedir(), ".bashrc") };
+  if (shell.includes("fish")) {
+    const confDir = import_path9.default.join(import_os5.default.homedir(), ".config", "fish", "conf.d");
+    return { name: "fish", rcFile: import_path9.default.join(confDir, "workscribe.fish") };
+  }
   return null;
 }
 function step(current, total, label) {
@@ -1671,19 +1810,21 @@ function registerInit(program2) {
   program2.command("init").description("Set up Workscribe and install or update shell hooks").action(async () => {
     const TOTAL_STEPS = 5;
     log.plain(import_chalk2.default.bold("\n  Workscribe \u2014 Developer Work Journal\n"));
-    step(1, TOTAL_STEPS, "Creating data 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_fs12.default.chmodSync(WORKSCRIBE_DIR, 448);
-      } catch {
+    step(1, TOTAL_STEPS, "Creating data directories");
+    for (const dir of REQUIRED_DIRS) {
+      if (!import_fs13.default.existsSync(dir)) {
+        import_fs13.default.mkdirSync(dir, { recursive: true, mode: 448 });
+        log.success(`Created ${dir}`);
+      } else {
+        try {
+          import_fs13.default.chmodSync(dir, 448);
+        } catch {
+        }
+        log.info(`${dir} already exists`);
       }
-      log.info(`${WORKSCRIBE_DIR} already exists`);
     }
-    if (!import_fs12.default.existsSync(PROFILES_DIR)) {
-      import_fs12.default.mkdirSync(PROFILES_DIR, { recursive: true, mode: 448 });
+    if (!import_fs13.default.existsSync(PROFILES_DIR)) {
+      import_fs13.default.mkdirSync(PROFILES_DIR, { recursive: true, mode: 448 });
     }
     step(2, TOTAL_STEPS, "Initialising database");
     getDb();
@@ -1691,15 +1832,21 @@ function registerInit(program2) {
     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")}`);
+      log.warn("Could not detect shell. Supported: zsh, bash, fish");
+      log.plain(
+        `  Manually add the hook from: ${import_chalk2.default.cyan("shell/hook.zsh")}, ${import_chalk2.default.cyan("shell/hook.bash")}, or ${import_chalk2.default.cyan("shell/hook.fish")}`
+      );
     } else {
       const hookFile = import_path9.default.join(__dirname, "..", "shell", `hook.${shell.name}`);
-      if (!import_fs12.default.existsSync(hookFile)) {
+      if (!import_fs13.default.existsSync(hookFile)) {
         log.warn(`Hook template not found at ${hookFile}`);
       } else {
-        const hookContent = import_fs12.default.readFileSync(hookFile, "utf-8");
-        if (!import_fs12.default.existsSync(shell.rcFile)) import_fs12.default.writeFileSync(shell.rcFile, "");
+        const hookContent = import_fs13.default.readFileSync(hookFile, "utf-8");
+        if (shell.name === "fish") {
+          const confDir = import_path9.default.dirname(shell.rcFile);
+          if (!import_fs13.default.existsSync(confDir)) import_fs13.default.mkdirSync(confDir, { recursive: true });
+        }
+        if (!import_fs13.default.existsSync(shell.rcFile)) import_fs13.default.writeFileSync(shell.rcFile, "");
         if (!isHookInstalled(shell.rcFile)) {
           log.plain("");
           log.plain(import_chalk2.default.dim("  Workscribe adds a lightweight hook to your shell that captures each"));
@@ -1725,6 +1872,24 @@ function registerInit(program2) {
         } else {
           log.info(`Shell hook up to date in ${shell.rcFile}`);
         }
+        if (isCompletionsInstalled(shell)) {
+          log.info("Shell completions already installed");
+        } else {
+          const { installComps } = await (0, import_prompts.default)({
+            type: "confirm",
+            name: "installComps",
+            message: "Install shell completions (tab-complete workscribe commands)?",
+            initial: true
+          });
+          if (installComps) {
+            try {
+              installCompletions(shell, getPublicCommands(program2));
+              log.success("Shell completions installed");
+            } catch (error) {
+              log.warn(`Completions install failed: ${error.message}`);
+            }
+          }
+        }
       }
     }
     step(4, TOTAL_STEPS, "Detecting AI coding tools");
@@ -1855,7 +2020,7 @@ function registerInit(program2) {
         }
       }
     }
-    if (!import_fs12.default.existsSync(CONFIG_PATH)) {
+    if (!import_fs13.default.existsSync(CONFIG_PATH)) {
       writeConfig(config);
     }
     log.plain("");
@@ -1863,8 +2028,13 @@ function registerInit(program2) {
     log.plain("");
     if (shell) {
       log.plain(`  Activate capture now:`);
-      log.plain(`    ${import_chalk2.default.cyan(`source ${shell.rcFile}`)}`);
-      log.plain(`  Or restart your terminal.`);
+      if (shell.name === "fish") {
+        log.plain(`    Restart your terminal`);
+        log.plain(`    ${import_chalk2.default.dim(`or run: source ${shell.rcFile}`)}`);
+      } else {
+        log.plain(`    ${import_chalk2.default.cyan(`source ${shell.rcFile}`)}`);
+        log.plain(`  Or restart your terminal.`);
+      }
       log.plain("");
     }
     if (providerConfigured) {
@@ -1886,7 +2056,7 @@ function registerInit(program2) {
 }
 
 // src/cli/status.ts
-var import_fs13 = __toESM(require("fs"));
+var import_fs14 = __toESM(require("fs"));
 var import_chalk3 = __toESM(require("chalk"));
 function registerStatus(program2) {
   program2.command("status").description("Show capture status and event counts").action(() => {
@@ -1894,7 +2064,7 @@ function registerStatus(program2) {
     const total = getEventCount();
     const todayEvents = getEventsForDate(todayDate());
     const last = getLastEvent();
-    const isPaused = import_fs13.default.existsSync(PAUSE_FLAG_PATH);
+    const isPaused = import_fs14.default.existsSync(PAUSE_FLAG_PATH);
     log.plain("");
     log.plain(import_chalk3.default.bold("  Workscribe Status"));
     log.plain("");
@@ -2154,8 +2324,8 @@ function registerSessions(program2) {
 
 // src/cli/summary.ts
 var import_chalk6 = __toESM(require("chalk"));
-var import_fs14 = __toESM(require("fs"));
-var import_os5 = __toESM(require("os"));
+var import_fs15 = __toESM(require("fs"));
+var import_os6 = __toESM(require("os"));
 var import_path10 = __toESM(require("path"));
 
 // src/integrations/webhook.ts
@@ -2224,7 +2394,7 @@ async function handleWebhook(opts, config, summary) {
   if (webhookUrl) {
     try {
       log.info("Posting to webhook\u2026");
-      const username = import_os5.default.userInfo().username;
+      const username = import_os6.default.userInfo().username;
       const body = isSlackWebhookUrl(webhookUrl) ? formatForSlack(summary, username) : summary;
       await postToWebhook(webhookUrl, body);
       log.success("Posted.");
@@ -2262,8 +2432,8 @@ function registerSummary(program2) {
       }
       const cacheKey = isoWeekKey(today);
       const cacheFile = import_path10.default.join(WEEKLY_CACHE_DIR, `${cacheKey}.md`);
-      if (!opts.fresh && import_fs14.default.existsSync(cacheFile)) {
-        const cached = import_fs14.default.readFileSync(cacheFile, "utf-8");
+      if (!opts.fresh && import_fs15.default.existsSync(cacheFile)) {
+        const cached = import_fs15.default.readFileSync(cacheFile, "utf-8");
         log.plain("");
         log.plain(cached);
         log.plain("");
@@ -2279,8 +2449,8 @@ function registerSummary(program2) {
         log.plain("");
         log.plain(summary);
         log.plain("");
-        import_fs14.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
-        import_fs14.default.writeFileSync(cacheFile, summary, { encoding: "utf-8", mode: 384 });
+        import_fs15.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
+        import_fs15.default.writeFileSync(cacheFile, summary, { encoding: "utf-8", mode: 384 });
         await handleWebhook(opts, config, summary);
       } catch (error) {
         log.error(`Weekly summary failed [${config.ai.provider}]: ${error.message}`);
@@ -2398,7 +2568,7 @@ ${bullets.trim()}`;
 }
 
 // src/cli/export.ts
-var import_fs15 = __toESM(require("fs"));
+var import_fs16 = __toESM(require("fs"));
 var import_path11 = __toESM(require("path"));
 function eventRowToPayload2(row) {
   let metadata = {};
@@ -2456,8 +2626,8 @@ function registerExport(program2) {
     log.info(`Generating summary via ${config.ai.provider}\u2026`);
     const summary = await provider.summarize(payload);
     const outputPath = opts.output ?? import_path11.default.join(EXPORTS_DIR, `workscribe-${date}.md`);
-    if (!import_fs15.default.existsSync(EXPORTS_DIR)) import_fs15.default.mkdirSync(EXPORTS_DIR, { recursive: true, mode: 448 });
-    import_fs15.default.writeFileSync(outputPath, `# Work Summary \u2014 ${date}
+    if (!import_fs16.default.existsSync(EXPORTS_DIR)) import_fs16.default.mkdirSync(EXPORTS_DIR, { recursive: true, mode: 448 });
+    import_fs16.default.writeFileSync(outputPath, `# Work Summary \u2014 ${date}
 
 ${summary}
 `, { encoding: "utf-8", mode: 384 });
@@ -2529,22 +2699,22 @@ function printConfig(obj, indent) {
 }
 
 // src/cli/pause.ts
-var import_fs16 = __toESM(require("fs"));
+var import_fs17 = __toESM(require("fs"));
 function registerPause(program2) {
   program2.command("pause").description("Pause capture temporarily").action(() => {
-    if (import_fs16.default.existsSync(PAUSE_FLAG_PATH)) {
+    if (import_fs17.default.existsSync(PAUSE_FLAG_PATH)) {
       log.info("Capture is already paused. Run workscribe resume to restart.");
       return;
     }
-    import_fs16.default.writeFileSync(PAUSE_FLAG_PATH, "", { mode: 384 });
+    import_fs17.default.writeFileSync(PAUSE_FLAG_PATH, "", { mode: 384 });
     log.success("Capture paused. Run workscribe resume to restart.");
   });
   program2.command("resume").description("Resume capture after a pause").action(() => {
-    if (!import_fs16.default.existsSync(PAUSE_FLAG_PATH)) {
+    if (!import_fs17.default.existsSync(PAUSE_FLAG_PATH)) {
       log.info("Capture is not paused.");
       return;
     }
-    import_fs16.default.rmSync(PAUSE_FLAG_PATH);
+    import_fs17.default.rmSync(PAUSE_FLAG_PATH);
     log.success("Capture resumed.");
   });
 }
@@ -2629,18 +2799,19 @@ function registerClear(program2) {
 }
 
 // src/cli/uninstall.ts
-var import_fs17 = __toESM(require("fs"));
+var import_fs18 = __toESM(require("fs"));
 var import_path12 = __toESM(require("path"));
-var import_os6 = __toESM(require("os"));
+var import_os7 = __toESM(require("os"));
 var import_prompts3 = __toESM(require("prompts"));
 var import_chalk9 = __toESM(require("chalk"));
 function detectShellRcFiles() {
   const candidates = [
-    { name: "zsh", rcFile: import_path12.default.join(import_os6.default.homedir(), ".zshrc") },
-    { name: "bash", rcFile: import_path12.default.join(import_os6.default.homedir(), ".bashrc") },
-    { name: "bash", rcFile: import_path12.default.join(import_os6.default.homedir(), ".bash_profile") }
+    { name: "zsh", rcFile: import_path12.default.join(import_os7.default.homedir(), ".zshrc") },
+    { name: "bash", rcFile: import_path12.default.join(import_os7.default.homedir(), ".bashrc") },
+    { name: "bash", rcFile: import_path12.default.join(import_os7.default.homedir(), ".bash_profile") },
+    { name: "fish", rcFile: import_path12.default.join(import_os7.default.homedir(), ".config", "fish", "conf.d", "workscribe.fish") }
   ];
-  return candidates.filter((candidate) => import_fs17.default.existsSync(candidate.rcFile) && isHookInstalled(candidate.rcFile));
+  return candidates.filter((candidate) => import_fs18.default.existsSync(candidate.rcFile) && isHookInstalled(candidate.rcFile));
 }
 function registerUninstall(program2) {
   program2.command("uninstall").description("Remove shell hooks and optionally delete all Workscribe data").option("--hooks-only", "remove shell hooks only, skip data deletion prompt (used by npm preuninstall)").action(async (opts) => {
@@ -2650,16 +2821,23 @@ function registerUninstall(program2) {
       log.info("No shell hooks found");
     } else {
       for (const { name, rcFile } of hooked) {
-        removeHook(rcFile);
-        log.success(`Shell hook removed from ${rcFile}`);
-        log.plain(`  ${import_chalk9.default.dim(`Run: source ${rcFile}`)}  (or restart your terminal to take effect)`);
-        log.plain(
-          `  ${import_chalk9.default.dim(`${name === "zsh" ? "unfunction" : "unset -f"} _workscribe_preexec _workscribe_precmd`)}`
-        );
+        if (name === "fish") {
+          import_fs18.default.unlinkSync(rcFile);
+          log.success(`Shell hook removed: ${rcFile}`);
+          log.plain(`  ${import_chalk9.default.dim("Restart your terminal to take effect")}`);
+        } else {
+          removeHook(rcFile);
+          log.success(`Shell hook removed from ${rcFile}`);
+          log.plain(`  ${import_chalk9.default.dim(`Run: source ${rcFile}`)}  (or restart your terminal to take effect)`);
+          log.plain(
+            `  ${import_chalk9.default.dim(`${name === "zsh" ? "unfunction" : "unset -f"} _workscribe_preexec _workscribe_precmd`)}`
+          );
+        }
       }
     }
     if (opts.hooksOnly) return;
-    if (import_fs17.default.existsSync(WORKSCRIBE_DIR)) {
+    const existingDirs = [...new Set(REQUIRED_DIRS)].filter((dir) => import_fs18.default.existsSync(dir));
+    if (existingDirs.length > 0) {
       log.plain("");
       const { deleteData } = await (0, import_prompts3.default)({
         type: "confirm",
@@ -2668,8 +2846,10 @@ function registerUninstall(program2) {
         initial: false
       });
       if (deleteData) {
-        import_fs17.default.rmSync(WORKSCRIBE_DIR, { recursive: true, force: true });
-        log.success(`Deleted ${WORKSCRIBE_DIR}`);
+        for (const dir of existingDirs) {
+          import_fs18.default.rmSync(dir, { recursive: true, force: true });
+          log.success(`Deleted ${dir}`);
+        }
       } else {
         log.info(`Data kept at ${WORKSCRIBE_DIR}`);
       }
@@ -2681,7 +2861,7 @@ function registerUninstall(program2) {
 }
 
 // src/cli/profile.ts
-var import_fs18 = __toESM(require("fs"));
+var import_fs19 = __toESM(require("fs"));
 var import_path13 = __toESM(require("path"));
 var import_chalk10 = __toESM(require("chalk"));
 var MIN_SUGGEST_COUNT = 5;
@@ -2728,7 +2908,7 @@ function registerProfile(program2) {
       log.plain(import_chalk10.default.dim("  " + "\u2500".repeat(60)));
       for (const entry of entries) {
         const badge = activeNames.has(entry.name) ? import_chalk10.default.green(" [active]") : "";
-        const installed = import_fs18.default.existsSync(import_path13.default.join(PROFILES_DIR, `${entry.name}.json`)) ? import_chalk10.default.dim(" installed") : "";
+        const installed = import_fs19.default.existsSync(import_path13.default.join(PROFILES_DIR, `${entry.name}.json`)) ? import_chalk10.default.dim(" installed") : "";
         log.plain(`  ${import_chalk10.default.cyan(entry.name.padEnd(18))} ${entry.displayName.padEnd(28)}${badge}${installed}`);
         if (entry.description) log.plain(`  ${import_chalk10.default.dim(" ".repeat(18) + entry.description)}`);
       }
@@ -2765,7 +2945,7 @@ function registerProfile(program2) {
       }
       activeNames.delete(name);
       const cachePath = import_path13.default.join(PROFILES_DIR, `${name}.json`);
-      if (import_fs18.default.existsSync(cachePath)) import_fs18.default.unlinkSync(cachePath);
+      if (import_fs19.default.existsSync(cachePath)) import_fs19.default.unlinkSync(cachePath);
       log.success(`Profile "${name}" removed`);
     }
     config.capture.profiles = [...activeNames];
@@ -2829,14 +3009,37 @@ function registerProfile(program2) {
     const suggestions = [];
     for (const entry of manifest) {
       if (activeNames.has(entry.name)) continue;
-      const matchedCount = toolCounts.filter((tc) => entry.keywords.some((kw) => tc.tool.toLowerCase().includes(kw.toLowerCase()))).reduce((sum, tc) => sum + tc.count, 0);
+      const matchedCount = toolCounts.filter(
+        (toolCount) => entry.keywords.some((keyword) => toolCount.tool.toLowerCase().includes(keyword.toLowerCase()))
+      ).reduce((total, toolCount) => total + toolCount.count, 0);
       if (matchedCount >= MIN_SUGGEST_COUNT) {
         suggestions.push({ entry, count: matchedCount });
       }
     }
     suggestions.sort((a, b) => b.count - a.count);
     if (suggestions.length === 0) {
-      log.plain("No profile matches found. Your commands are well covered.");
+      const activeEntries = manifest.filter((entry) => activeNames.has(entry.name));
+      const isToolCoveredByActiveProfile = (tool) => activeEntries.some(
+        (entry) => entry.keywords.some((keyword) => tool.toLowerCase().includes(keyword.toLowerCase()))
+      );
+      const uncoveredTools = toolCounts.filter((toolCount) => !isToolCoveredByActiveProfile(toolCount.tool));
+      if (uncoveredTools.length === 0) {
+        log.plain("");
+        log.plain("Your active profiles cover all unclassified commands.");
+        log.plain(import_chalk10.default.dim("  Future captures will be classified correctly."));
+        log.plain("");
+      } else {
+        log.plain("");
+        log.plain("No profile matches found for your unclassified commands.");
+        log.plain("");
+        log.plain(import_chalk10.default.dim("  Top unclassified tools:"));
+        for (const { tool, count } of uncoveredTools.slice(0, 5)) {
+          log.plain(import_chalk10.default.dim(`    ${tool.padEnd(24)} ${count} event${count === 1 ? "" : "s"}`));
+        }
+        log.plain("");
+        log.plain(import_chalk10.default.dim("  Run workscribe events --category other to review them."));
+        log.plain("");
+      }
       return;
     }
     log.plain("");
@@ -2848,8 +3051,25 @@ function registerProfile(program2) {
       );
     }
     log.plain("");
-    log.plain(`  Run: ${import_chalk10.default.cyan("workscribe profile add " + suggestions.map((s) => s.entry.name).join(" "))}`);
+    log.plain(
+      `  Run: ${import_chalk10.default.cyan("workscribe profile add " + suggestions.map((suggestion) => suggestion.entry.name).join(" "))}`
+    );
     log.plain("");
+    const allCoveredEntries = [
+      ...manifest.filter((entry) => activeNames.has(entry.name)),
+      ...suggestions.map((suggestion) => suggestion.entry)
+    ];
+    const isToolCoveredAfterInstall = (tool) => allCoveredEntries.some(
+      (entry) => entry.keywords.some((keyword) => tool.toLowerCase().includes(keyword.toLowerCase()))
+    );
+    const stillUncovered = toolCounts.filter((toolCount) => !isToolCoveredAfterInstall(toolCount.tool)).slice(0, 5);
+    if (stillUncovered.length > 0) {
+      log.plain(import_chalk10.default.dim("  Still uncovered after installing:"));
+      for (const { tool, count } of stillUncovered) {
+        log.plain(import_chalk10.default.dim(`    ${tool.padEnd(24)} ${count} event${count === 1 ? "" : "s"}`));
+      }
+      log.plain("");
+    }
   });
 }
 
@@ -2874,9 +3094,9 @@ function registerNote(program2) {
 
 // src/cli/week.ts
 var import_chalk11 = __toESM(require("chalk"));
-var import_fs19 = __toESM(require("fs"));
+var import_fs20 = __toESM(require("fs"));
 var import_path14 = __toESM(require("path"));
-var import_os7 = __toESM(require("os"));
+var import_os8 = __toESM(require("os"));
 function eventRowToPayload3(row) {
   let metadata = {};
   try {
@@ -2915,7 +3135,7 @@ async function postSummary(opts, config, summary) {
   }
   try {
     log.info("Posting to webhook\u2026");
-    const username = import_os7.default.userInfo().username;
+    const username = import_os8.default.userInfo().username;
     const body = isSlackWebhookUrl(webhookUrl) ? formatForSlack(summary, username) : summary;
     await postToWebhook(webhookUrl, body);
     log.success("Posted.");
@@ -2949,8 +3169,8 @@ function registerWeek(program2) {
     }
     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");
+    if (!opts.fresh && import_fs20.default.existsSync(cacheFile)) {
+      const cached = import_fs20.default.readFileSync(cacheFile, "utf-8");
       log.plain("");
       log.plain(cached);
       log.plain("");
@@ -2966,8 +3186,8 @@ function registerWeek(program2) {
       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 });
+      import_fs20.default.mkdirSync(WEEKLY_CACHE_DIR, { recursive: true });
+      import_fs20.default.writeFileSync(cacheFile, summary, { encoding: "utf-8", mode: 384 });
       await postSummary(opts, config, summary);
     } catch (error) {
       log.error(`Weekly digest failed [${config.ai.provider}]: ${error.message}`);
@@ -2976,10 +3196,136 @@ function registerWeek(program2) {
   });
 }
 
+// src/cli/bug-report.ts
+var import_fs21 = __toESM(require("fs"));
+var import_os9 = __toESM(require("os"));
+var import_path15 = __toESM(require("path"));
+var import_chalk12 = __toESM(require("chalk"));
+var GITHUB_ISSUES_URL = "https://github.com/workscribe/workscribe/issues/new";
+var DEBUG_LOG_TAIL_LINES = 100;
+function tailFile(filePath, lines) {
+  if (!import_fs21.default.existsSync(filePath)) return "(no debug log found \u2014 set WORKSCRIBE_DEBUG=1 to enable)";
+  const content = import_fs21.default.readFileSync(filePath, "utf-8");
+  const allLines = content.split("\n");
+  return allLines.slice(-lines).join("\n");
+}
+function redactConfig() {
+  try {
+    const config = readConfig();
+    if (config.ai.apiKey) config.ai.apiKey = "<redacted>";
+    if (config.integrations?.slackWebhook) config.integrations.slackWebhook = "<redacted>";
+    if (config.integrations?.webhook) config.integrations.webhook = "<redacted>";
+    return JSON.stringify(config, null, 2);
+  } catch {
+    return "(could not read config)";
+  }
+}
+function registerBugReport(program2) {
+  program2.command("bug-report").description("Generate a diagnostic report for filing a bug").action(() => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const reportPath = import_path15.default.join(WORKSCRIBE_DIR, `bug-report-${timestamp}.txt`);
+    const systemInfo = [
+      `Workscribe version : ${"1.12.0"}`,
+      `Node.js version    : ${process.version}`,
+      `Platform           : ${process.platform}`,
+      `Architecture       : ${process.arch}`,
+      `OS release         : ${import_os9.default.release()}`,
+      `Config path        : ${CONFIG_PATH}`,
+      `Data directory     : ${WORKSCRIBE_DIR}`
+    ].join("\n");
+    const report = [
+      "=== Workscribe Bug Report ===",
+      `Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      "",
+      "--- System ---",
+      systemInfo,
+      "",
+      "--- Config (secrets redacted) ---",
+      redactConfig(),
+      "",
+      `--- Debug log (last ${DEBUG_LOG_TAIL_LINES} lines) ---`,
+      tailFile(DEBUG_LOG_PATH, DEBUG_LOG_TAIL_LINES)
+    ].join("\n");
+    try {
+      if (!import_fs21.default.existsSync(WORKSCRIBE_DIR)) {
+        import_fs21.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true, mode: 448 });
+      }
+      import_fs21.default.writeFileSync(reportPath, report, { mode: 384 });
+    } catch (error) {
+      log.error(`Could not write report: ${error.message}`);
+      process.exit(1);
+    }
+    const params = new URLSearchParams({
+      title: `Bug report \u2014 workscribe ${"1.12.0"}`,
+      body: `<!-- Attach ${import_path15.default.basename(reportPath)} or paste the relevant sections below -->
+
+**Describe the issue:**
+
+**Steps to reproduce:**
+
+**Expected behaviour:**`
+    });
+    log.success(`Report written to: ${import_chalk12.default.cyan(reportPath)}`);
+    log.plain("");
+    log.plain(`  Open a GitHub issue:`);
+    log.plain(`    ${import_chalk12.default.cyan(`${GITHUB_ISSUES_URL}?${params}`)}`);
+    log.plain("");
+    log.plain(import_chalk12.default.dim(`  Attach the report or paste the relevant sections into the issue.`));
+    log.plain("");
+  });
+}
+
+// src/utils/update-check.ts
+var import_fs22 = __toESM(require("fs"));
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function readCache() {
+  try {
+    return JSON.parse(import_fs22.default.readFileSync(UPDATE_CHECK_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    import_fs22.default.writeFileSync(UPDATE_CHECK_PATH, JSON.stringify(cache), { mode: 384 });
+  } catch {
+  }
+}
+function isNewer(latest, current) {
+  const parse = (version) => version.replace(/^v/, "").split(".").map(Number);
+  const [latestMajor, latestMinor, latestPatch] = parse(latest);
+  const [currentMajor, currentMinor, currentPatch] = parse(current);
+  if (latestMajor !== currentMajor) return latestMajor > currentMajor;
+  if (latestMinor !== currentMinor) return latestMinor > currentMinor;
+  return latestPatch > currentPatch;
+}
+function checkForUpdate() {
+  const current = "1.12.0";
+  const cache = readCache();
+  if (cache && isNewer(cache.latestVersion, current)) {
+    process.stderr.write(
+      `
+  Update available ${current} \u2192 ${cache.latestVersion}
+  Run: npm install -g @workscribe/cli
+
+`
+    );
+  }
+  const now = Date.now();
+  if (!cache || now - cache.lastChecked > CHECK_INTERVAL_MS) {
+    fetch("https://registry.npmjs.org/@workscribe/cli/latest").then((response) => response.json()).then((data) => {
+      const latest = data.version;
+      if (latest) writeCache({ lastChecked: now, latestVersion: latest });
+    }).catch(() => {
+    });
+  }
+}
+
 // src/index.ts
 assertNodeVersion(process.versions.node);
+checkForUpdate();
 var program = new import_commander.Command();
-program.name("workscribe").description("Automatic developer work journal").version("1.11.0");
+program.name("workscribe").description("Automatic developer work journal").version("1.12.0");
 registerCapture(program);
 registerHook(program);
 registerInit(program);
@@ -2996,5 +3342,7 @@ registerUninstall(program);
 registerProfile(program);
 registerNote(program);
 registerWeek(program);
+registerBugReport(program);
+registerCompletions(program);
 program.parse();
 //# sourceMappingURL=index.js.map