@workscribe/cli 2.0.0 → 2.0.1

package/dist/index.js

@@ -1374,6 +1374,34 @@ var init_migrate = __esm({
   }
 });
 
+// src/db/session-lookup.ts
+function findRecentSessionsForRepo(db, lookup, limit) {
+  return db.prepare(RECENT_SESSIONS_FOR_REPO).all({
+    repo_name: lookup.repoName,
+    other_repo_name: lookup.otherRepoName,
+    roots: JSON.stringify(lookup.roots),
+    limit
+  });
+}
+var RECENT_SESSIONS_FOR_REPO;
+var init_session_lookup = __esm({
+  "src/db/session-lookup.ts"() {
+    "use strict";
+    RECENT_SESSIONS_FOR_REPO = `
+  SELECT s.* FROM sessions s
+  WHERE s.repo_name = $repo_name
+     OR (s.repo_name = $other_repo_name AND EXISTS (
+          SELECT 1 FROM session_events se
+          INNER JOIN events e ON e.id = se.event_id
+          INNER JOIN json_each($roots) root
+          WHERE se.session_id = s.id
+            AND (e.cwd = root.value OR substr(e.cwd, 1, length(root.value) + 1) = root.value || '/')
+        ))
+  ORDER BY s.started_at DESC
+  LIMIT $limit`;
+  }
+});
+
 // src/db/index.ts
 function getDb() {
   if (_db) return _db;
@@ -1404,9 +1432,8 @@ function insertEvent(params) {
   `);
   stmt.run(params);
 }
-function getRecentSessionsByRepo(repoName, limit) {
-  const db = getDb();
-  return db.prepare("SELECT * FROM sessions WHERE repo_name = $repo_name ORDER BY started_at DESC LIMIT $limit").all({ repo_name: repoName, limit });
+function getRecentSessionsForRepo(lookup, limit) {
+  return findRecentSessionsForRepo(getDb(), lookup, limit);
 }
 function getLastSessionTouchingFile(filePath) {
   const db = getDb();
@@ -1572,6 +1599,7 @@ var init_db = __esm({
     init_paths();
     init_migrations();
     init_migrate();
+    init_session_lookup();
     _db = null;
   }
 });
@@ -1627,7 +1655,7 @@ var init_redact = __esm({
   }
 });
 
-// src/capture/git.ts
+// src/capture/repo-name.ts
 function parseOwnerAndRepo(url) {
   const normalized = url.trim().replace(/^[^/]+:(?!\/\/)/, (match) => match.replace(":", "/"));
   const segments = normalized.split("/").filter(Boolean);
@@ -1636,16 +1664,24 @@ function parseOwnerAndRepo(url) {
   const owner = segments[segments.length - 2];
   return owner && repo ? { owner, repo } : null;
 }
-function nameFromRemote(root, qualifyWithOwner) {
+function formatRepoName(remote, qualify) {
+  return qualify ? `${remote.owner}/${remote.repo}` : remote.repo;
+}
+var init_repo_name = __esm({
+  "src/capture/repo-name.ts"() {
+    "use strict";
+  }
+});
+
+// src/capture/git.ts
+function remoteOf(root) {
   try {
     const url = (0, import_child_process.execSync)("git remote get-url origin", {
       cwd: root,
       timeout: 2e3,
       stdio: "pipe"
     }).toString().trim();
-    const parsed = parseOwnerAndRepo(url);
-    if (!parsed) return null;
-    return qualifyWithOwner ? `${parsed.owner}/${parsed.repo}` : parsed.repo;
+    return parseOwnerAndRepo(url);
   } catch {
     return null;
   }
@@ -1660,35 +1696,46 @@ function nameFromPackageJson(root) {
     return null;
   }
 }
-function getGitContext(cwd, nameOverride, qualifyRepoName = false) {
+function currentBranch(cwd) {
+  try {
+    return (0, import_child_process.execSync)("git branch --show-current", {
+      cwd,
+      timeout: 2e3,
+      stdio: "pipe"
+    }).toString().trim() || null;
+  } catch {
+    return null;
+  }
+}
+function nameRepo(root, nameOverride, qualifyRepoName) {
+  if (nameOverride !== null) return { repoName: nameOverride, remote: null };
+  const remote = remoteOf(root);
+  if (remote) return { repoName: formatRepoName(remote, qualifyRepoName), remote };
+  return { repoName: nameFromPackageJson(root) ?? import_path6.default.basename(root), remote: null };
+}
+function getRepoContext(cwd, config) {
+  let root;
   try {
-    const root = (0, import_child_process.execSync)("git rev-parse --show-toplevel", {
+    root = (0, import_child_process.execSync)("git rev-parse --show-toplevel", {
       cwd,
       timeout: 2e3,
       stdio: "pipe"
     }).toString().trim();
-    const repoName = nameOverride ?? nameFromRemote(root, qualifyRepoName) ?? nameFromPackageJson(root) ?? import_path6.default.basename(root);
-    let branch = null;
-    try {
-      branch = (0, import_child_process.execSync)("git branch --show-current", {
-        cwd,
-        timeout: 2e3,
-        stdio: "pipe"
-      }).toString().trim() || null;
-    } catch {
-    }
-    return { repoName, branch };
   } catch {
-    return { repoName: null, branch: null };
+    return NOT_A_REPO;
   }
+  const naming = nameRepo(root, config.projects?.[cwd] ?? null, config.git.qualifyRepoName);
+  return { ...naming, branch: currentBranch(cwd), root };
 }
-var import_child_process, import_path6, import_fs8;
+var import_child_process, import_path6, import_fs8, NOT_A_REPO;
 var init_git = __esm({
   "src/capture/git.ts"() {
     "use strict";
     import_child_process = require("child_process");
     import_path6 = __toESM(require("path"));
     import_fs8 = __toESM(require("fs"));
+    init_repo_name();
+    NOT_A_REPO = { repoName: null, branch: null, root: null, remote: null };
   }
 });
 
@@ -1818,8 +1865,7 @@ function captureCommand(opts) {
       }
     }
     const command2 = opts.command ?? opts.file ?? opts.type;
-    const nameOverride2 = config.projects?.[cwd] ?? null;
-    const { repoName: repoName2, branch: branch2 } = getGitContext(cwd, nameOverride2, config.git.qualifyRepoName);
+    const { repoName: repoName2, branch: branch2 } = getRepoContext(cwd, config);
     insertEvent({
       captured_at: (/* @__PURE__ */ new Date()).toISOString(),
       command: command2,
@@ -1840,8 +1886,7 @@ function captureCommand(opts) {
   const last = getLastEvent();
   if (isDuplicate(command, cwd, last ?? void 0)) return;
   const safeCommand = redact(command, config.redact.extra);
-  const nameOverride = config.projects?.[cwd] ?? null;
-  const { repoName, branch } = getGitContext(cwd, nameOverride);
+  const { repoName, branch } = getRepoContext(cwd, config);
   const { category, metadata } = normalizeCommand(safeCommand);
   if (category === "ai_session" && config.capture.aiTools === false) return;
   if (category === "other") {
@@ -2105,10 +2150,112 @@ var init_completion_scripts = __esm({
   }
 });
 
+// src/utils/backup.ts
+function backUpFile(file) {
+  const base = `${file}.workscribe-backup-${Date.now()}`;
+  for (let attempt = 1; attempt <= MAX_BACKUP_ATTEMPTS; attempt++) {
+    const backup = attempt === 1 ? base : `${base}-${attempt}`;
+    try {
+      import_fs12.default.copyFileSync(file, backup, import_fs12.default.constants.COPYFILE_EXCL);
+      return backup;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+  }
+  throw new Error(`Couldn't back up ${file}: too many backups named ${base}`);
+}
+var import_fs12, MAX_BACKUP_ATTEMPTS;
+var init_backup = __esm({
+  "src/utils/backup.ts"() {
+    "use strict";
+    import_fs12 = __toESM(require("fs"));
+    MAX_BACKUP_ATTEMPTS = 100;
+  }
+});
+
+// src/capture/completions-block.ts
+function completionsBlock(shellName, file) {
+  const guardedSource = shellName === "zsh" ? `if [ -f "${file}" ]; then ${ZSH_COMPINIT}; source "${file}"; fi` : `[ -f "${file}" ] && source "${file}"`;
+  return `${COMPLETIONS_MARKER}
+${guardedSource}`;
+}
+function splitLines(content) {
+  return { lines: content.split("\n"), lineEnding: content.includes("\r\n") ? "\r" : "" };
+}
+function bare(line) {
+  return (line ?? "").replace(/\r$/, "");
+}
+function blockLengthAfterMarker(lines, markerIndex) {
+  const next = bare(lines[markerIndex + 1]);
+  if (GUARDED_ZSH.test(next) || GUARDED_BASH.test(next) || UNGUARDED_SOURCE.test(next)) return 1;
+  if (next === ZSH_COMPINIT && UNGUARDED_SOURCE.test(bare(lines[markerIndex + 2]))) return 2;
+  return 0;
+}
+function findBlocks(lines) {
+  const blocks = [];
+  for (let index = 0; index < lines.length; index++) {
+    if (bare(lines[index]) !== COMPLETIONS_MARKER) continue;
+    const length = blockLengthAfterMarker(lines, index);
+    if (length === 0) continue;
+    blocks.push({ first: index, last: index + length });
+    index += length;
+  }
+  return blocks;
+}
+function blockText(lines, block) {
+  return lines.slice(block.first, block.last + 1).map(bare).join("\n");
+}
+function hasCompletionsBlock(content) {
+  return findBlocks(splitLines(content).lines).length > 0;
+}
+function isCompletionsBlockOutdated(content, currentBlock) {
+  const { lines } = splitLines(content);
+  const blocks = findBlocks(lines);
+  if (blocks.length === 0) return false;
+  return blocks.length > 1 || blockText(lines, blocks[0]) !== currentBlock;
+}
+function rebuild(content, replacement) {
+  const { lines, lineEnding } = splitLines(content);
+  const blocks = findBlocks(lines);
+  if (blocks.length === 0) return content;
+  const dropped = /* @__PURE__ */ new Set();
+  blocks.forEach((block, blockIndex) => {
+    const isReplaced = blockIndex === 0 && replacement !== null;
+    for (let index = block.first; index <= block.last; index++) dropped.add(index);
+    if (!isReplaced && block.first > 0 && bare(lines[block.first - 1]) === "") dropped.add(block.first - 1);
+  });
+  const replacementLines = replacement === null ? [] : replacement.split("\n").map((line) => line + lineEnding);
+  return lines.flatMap((line, index) => {
+    if (replacement !== null && index === blocks[0].first) return replacementLines;
+    return dropped.has(index) ? [] : [line];
+  }).join("\n");
+}
+function replaceCompletionsBlock(content, newBlock) {
+  return rebuild(content, newBlock);
+}
+function removeCompletionsBlock(content) {
+  return rebuild(content, null);
+}
+var COMPLETIONS_MARKER, ZSH_COMPINIT, OWN_SCRIPT, GUARDED_ZSH, GUARDED_BASH, UNGUARDED_SOURCE;
+var init_completions_block = __esm({
+  "src/capture/completions-block.ts"() {
+    "use strict";
+    COMPLETIONS_MARKER = "# Workscribe completions";
+    ZSH_COMPINIT = "autoload -Uz compinit && compinit";
+    OWN_SCRIPT = '"[^"]*completion\\.(?:zsh|bash)"';
+    GUARDED_ZSH = new RegExp(`^if \\[ -f ${OWN_SCRIPT} \\]; then ${ZSH_COMPINIT}; source ${OWN_SCRIPT}; fi$`);
+    GUARDED_BASH = new RegExp(`^\\[ -f ${OWN_SCRIPT} \\] && source ${OWN_SCRIPT}$`);
+    UNGUARDED_SOURCE = new RegExp(`^source ${OWN_SCRIPT}$`);
+  }
+});
+
 // src/capture/shell-hook.ts
+function backUp(rcFile) {
+  log.info(`Backed up ${rcFile} \u2192 ${import_path9.default.basename(backUpFile(rcFile))}`);
+}
 function getInstalledHookBlock(rcFile) {
-  if (!import_fs12.default.existsSync(rcFile)) return null;
-  const content = import_fs12.default.readFileSync(rcFile, "utf-8");
+  if (!import_fs13.default.existsSync(rcFile)) return null;
+  const content = import_fs13.default.readFileSync(rcFile, "utf-8");
   const startIdx = content.indexOf(HOOK_START);
   const endIdx = content.indexOf(HOOK_END);
   if (startIdx === -1 || endIdx === -1) return null;
@@ -2123,34 +2270,28 @@ function isHookOutdated(rcFile, hookContent) {
   return installed.trim() !== hookContent.trim();
 }
 function installHook(rcFile, hookContent) {
-  const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs12.default.copyFileSync(rcFile, backup);
-  log.info(`Backed up ${rcFile} \u2192 ${import_path9.default.basename(backup)}`);
-  import_fs12.default.appendFileSync(rcFile, `
+  backUp(rcFile);
+  import_fs13.default.appendFileSync(rcFile, `
 ${hookContent}
 `);
 }
 function updateHook(rcFile, hookContent) {
-  const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs12.default.copyFileSync(rcFile, backup);
-  log.info(`Backed up ${rcFile} \u2192 ${import_path9.default.basename(backup)}`);
-  const content = import_fs12.default.readFileSync(rcFile, "utf-8");
+  backUp(rcFile);
+  const content = import_fs13.default.readFileSync(rcFile, "utf-8");
   const startIdx = content.indexOf(HOOK_START);
   const endIdx = content.indexOf(HOOK_END) + HOOK_END.length;
-  import_fs12.default.writeFileSync(rcFile, content.slice(0, startIdx) + hookContent + content.slice(endIdx));
+  import_fs13.default.writeFileSync(rcFile, content.slice(0, startIdx) + hookContent + content.slice(endIdx));
 }
 function removeHook(rcFile) {
-  const backup = `${rcFile}.workscribe-backup-${Date.now()}`;
-  import_fs12.default.copyFileSync(rcFile, backup);
-  log.info(`Backed up ${rcFile} \u2192 ${import_path9.default.basename(backup)}`);
-  const content = import_fs12.default.readFileSync(rcFile, "utf-8");
+  backUp(rcFile);
+  const content = import_fs13.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_fs12.default.writeFileSync(rcFile, before + after);
+  import_fs13.default.writeFileSync(rcFile, before + after);
 }
 function resolveWorkscribeBinary() {
   try {
@@ -2167,53 +2308,86 @@ function injectBinaryPath(hookContent, binaryPath, nodePath) {
 }
 function isCompletionsInstalled(shell) {
   if (shell.name === "fish") {
-    return import_fs12.default.existsSync(import_path9.default.join(FISH_COMPLETIONS_DIR, "workscribe.fish"));
+    return import_fs13.default.existsSync(import_path9.default.join(FISH_COMPLETIONS_DIR, "workscribe.fish"));
   }
   try {
-    return import_fs12.default.readFileSync(shell.rcFile, "utf-8").includes(COMPLETIONS_MARKER);
+    return import_fs13.default.readFileSync(shell.rcFile, "utf-8").includes(COMPLETIONS_MARKER);
   } catch {
     return false;
   }
 }
-function installCompletions(shell, commands) {
+function completionScriptFile(shellName) {
+  return import_path9.default.join(WORKSCRIBE_DIR, `completion.${shellName}`);
+}
+function readRcFile(rcFile) {
+  try {
+    return import_fs13.default.readFileSync(rcFile, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function writeCompletionScript(shell, commands) {
   if (shell.name === "fish") {
-    if (!import_fs12.default.existsSync(FISH_COMPLETIONS_DIR)) {
-      import_fs12.default.mkdirSync(FISH_COMPLETIONS_DIR, { recursive: true });
-    }
-    import_fs12.default.writeFileSync(import_path9.default.join(FISH_COMPLETIONS_DIR, "workscribe.fish"), fishCompletion(commands), { mode: 420 });
-  } else {
-    const script = shell.name === "zsh" ? zshCompletion(commands) : bashCompletion(commands);
-    const cacheFile = import_path9.default.join(WORKSCRIBE_DIR, `completion.${shell.name}`);
-    import_fs12.default.writeFileSync(cacheFile, script, { mode: 420 });
-    if (!isCompletionsInstalled(shell)) {
-      const sourceLine = shell.name === "zsh" ? `
-${COMPLETIONS_MARKER}
-autoload -Uz compinit && compinit
-source "${cacheFile}"
-` : `
-${COMPLETIONS_MARKER}
-source "${cacheFile}"
-`;
-      import_fs12.default.appendFileSync(shell.rcFile, sourceLine);
-    }
+    import_fs13.default.mkdirSync(FISH_COMPLETIONS_DIR, { recursive: true });
+    import_fs13.default.writeFileSync(FISH_COMPLETIONS_FILE, fishCompletion(commands), { mode: 420 });
+    return;
   }
+  const script = shell.name === "zsh" ? zshCompletion(commands) : bashCompletion(commands);
+  import_fs13.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true });
+  import_fs13.default.writeFileSync(completionScriptFile(shell.name), script, { mode: 420 });
+}
+function installCompletions(shell, commands) {
+  writeCompletionScript(shell, commands);
+  if (shell.name !== "fish" && !isCompletionsInstalled(shell)) {
+    import_fs13.default.appendFileSync(shell.rcFile, `
+${completionsBlock(shell.name, completionScriptFile(shell.name))}
+`);
+  }
+}
+function isCompletionsOutdated(shell) {
+  if (shell.name === "fish") return false;
+  const content = readRcFile(shell.rcFile);
+  return content !== null && isCompletionsBlockOutdated(content, completionsBlock(shell.name, completionScriptFile(shell.name)));
+}
+function updateCompletions(shell) {
+  const content = readRcFile(shell.rcFile);
+  if (content === null || !hasCompletionsBlock(content)) return;
+  backUp(shell.rcFile);
+  import_fs13.default.writeFileSync(
+    shell.rcFile,
+    replaceCompletionsBlock(content, completionsBlock(shell.name, completionScriptFile(shell.name)))
+  );
+}
+function removeCompletions(rcFile) {
+  const content = readRcFile(rcFile);
+  if (content === null || !hasCompletionsBlock(content)) return false;
+  backUp(rcFile);
+  import_fs13.default.writeFileSync(rcFile, removeCompletionsBlock(content));
+  return true;
+}
+function removeFishCompletions() {
+  if (!import_fs13.default.existsSync(FISH_COMPLETIONS_FILE)) return false;
+  import_fs13.default.rmSync(FISH_COMPLETIONS_FILE, { force: true });
+  return true;
 }
-var import_fs12, import_path9, import_os3, import_child_process3, FISH_COMPLETIONS_DIR, HOOK_START, HOOK_END, HOOK_PREAMBLE, COMPLETIONS_MARKER;
+var import_fs13, import_path9, import_os3, import_child_process3, FISH_COMPLETIONS_DIR, HOOK_START, HOOK_END, HOOK_PREAMBLE, FISH_COMPLETIONS_FILE;
 var init_shell_hook = __esm({
   "src/capture/shell-hook.ts"() {
     "use strict";
-    import_fs12 = __toESM(require("fs"));
+    import_fs13 = __toESM(require("fs"));
     import_path9 = __toESM(require("path"));
     import_os3 = __toESM(require("os"));
     import_child_process3 = require("child_process");
     init_logger();
     init_completion_scripts();
     init_paths();
+    init_backup();
+    init_completions_block();
     FISH_COMPLETIONS_DIR = import_path9.default.join(import_os3.default.homedir(), ".config", "fish", "completions");
     HOOK_START = "# workscribe:hook:start";
     HOOK_END = "# workscribe:hook:end";
     HOOK_PREAMBLE = "# Workscribe \u2014 developer work journal";
-    COMPLETIONS_MARKER = "# Workscribe completions";
+    FISH_COMPLETIONS_FILE = import_path9.default.join(FISH_COMPLETIONS_DIR, "workscribe.fish");
   }
 });
 
@@ -2234,11 +2408,43 @@ var init_utils = __esm({
   }
 });
 
+// src/capture/hooks/claude-code-command.ts
+function buildHookCommand(options) {
+  if (!options.binaryPath) return `${BARE_GUARD}workscribe ${options.args}${GUARD_SUFFIX}`;
+  const { nodePath, binaryPath, args } = options;
+  return `test -x "${nodePath}" && test -x "${binaryPath}" && "${nodePath}" "${binaryPath}" ${args}${GUARD_SUFFIX}`;
+}
+function withoutLeadingGuards(command) {
+  return command.trimStart().replace(LEADING_PATH_GUARDS, "");
+}
+function isPinnedCommand(command) {
+  const invocation = withoutLeadingGuards(command);
+  return invocation.startsWith('"') || invocation.startsWith("/");
+}
+function isGuardedCommand(command) {
+  const trimmed = command.trim();
+  const hasLeadingGuard = LEADING_PATH_GUARDS.test(trimmed) || trimmed.startsWith(BARE_GUARD);
+  return hasLeadingGuard && trimmed.endsWith(GUARD_SUFFIX);
+}
+function pinnedNodePath(command) {
+  return withoutLeadingGuards(command).match(/^"([^"]+)"/)?.[1] ?? null;
+}
+var HOOK_MARKER, GUARD_SUFFIX, LEADING_PATH_GUARDS, BARE_GUARD;
+var init_claude_code_command = __esm({
+  "src/capture/hooks/claude-code-command.ts"() {
+    "use strict";
+    HOOK_MARKER = "_hook --source claude-code";
+    GUARD_SUFFIX = " || true";
+    LEADING_PATH_GUARDS = /^(?:test -x "[^"]*" && )+/;
+    BARE_GUARD = "command -v workscribe >/dev/null 2>&1 && ";
+  }
+});
+
 // src/capture/hooks/claude-code.ts
 function readSettings() {
-  if (!import_fs13.default.existsSync(CLAUDE_SETTINGS_PATH)) return {};
+  if (!import_fs14.default.existsSync(CLAUDE_SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(import_fs13.default.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
+    return JSON.parse(import_fs14.default.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
@@ -2264,10 +2470,6 @@ function findWorkscribeHookCommands(settings) {
     userPromptSubmit: commandsForEvent(hooks, "UserPromptSubmit")
   };
 }
-function isPinnedCommand(command) {
-  const trimmed = command.trimStart();
-  return trimmed.startsWith('"') || trimmed.startsWith("/");
-}
 function withoutWorkscribeEntries(entries) {
   return entries.map((entry) => {
     const record = entry;
@@ -2279,11 +2481,29 @@ function withoutWorkscribeEntries(entries) {
     return { ...record, hooks: filteredHooks };
   }).filter((entry) => entry.hooks.length > 0);
 }
-function checkHookHealth() {
+function isExecutable(filePath) {
+  try {
+    import_fs14.default.accessSync(filePath, import_fs14.default.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function allWorkscribeCommands() {
   const { postToolUse, userPromptSubmit } = findWorkscribeHookCommands(readSettings());
-  const allCommands = [...postToolUse, ...userPromptSubmit];
-  if (allCommands.length === 0) return { installed: false, pinned: true, confirmedBroken: null };
-  if (allCommands.every(isPinnedCommand)) return { installed: true, pinned: true, confirmedBroken: null };
+  return [...postToolUse, ...userPromptSubmit];
+}
+function checkHookHealth() {
+  const allCommands = allWorkscribeCommands();
+  if (allCommands.length === 0) {
+    return { installed: false, pinned: true, guarded: true, nodeMissing: false, confirmedBroken: null };
+  }
+  const guarded = allCommands.every(isGuardedCommand);
+  const nodePaths = allCommands.map(pinnedNodePath).filter((nodePath) => nodePath !== null);
+  const nodeMissing = nodePaths.some((nodePath) => !isExecutable(nodePath));
+  if (allCommands.every(isPinnedCommand)) {
+    return { installed: true, pinned: true, guarded, nodeMissing, confirmedBroken: null };
+  }
   let confirmedBroken;
   try {
     (0, import_child_process5.execFileSync)("workscribe", ["--version"], { stdio: "ignore", timeout: 2e3 });
@@ -2291,48 +2511,76 @@ function checkHookHealth() {
   } catch {
     confirmedBroken = true;
   }
-  return { installed: true, pinned: false, confirmedBroken };
+  return { installed: true, pinned: false, guarded, nodeMissing, confirmedBroken };
+}
+function readSettingsStrictly() {
+  if (!import_fs14.default.existsSync(CLAUDE_SETTINGS_PATH)) return "missing";
+  try {
+    const parsed = JSON.parse(import_fs14.default.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : "unreadable";
+  } catch {
+    return "unreadable";
+  }
 }
-var import_fs13, import_path10, import_os4, import_child_process5, CLAUDE_SETTINGS_PATH, HOOK_MARKER, claudeCodeIntegration;
+function hooksWithoutWorkscribe(hooks) {
+  let removedAny = false;
+  const remaining = {};
+  for (const [eventName, entries] of Object.entries(hooks)) {
+    if (!Array.isArray(entries)) {
+      remaining[eventName] = entries;
+      continue;
+    }
+    const kept = withoutWorkscribeEntries(entries);
+    if (commandsForEvent(hooks, eventName).length > 0) removedAny = true;
+    if (kept.length > 0) remaining[eventName] = kept;
+  }
+  return removedAny ? remaining : null;
+}
+function isHookCurrent() {
+  const { postToolUse, userPromptSubmit } = findWorkscribeHookCommands(readSettings());
+  if (postToolUse.length === 0 || userPromptSubmit.length === 0) return false;
+  return [...postToolUse, ...userPromptSubmit].every((command) => {
+    const nodePath = pinnedNodePath(command);
+    return isPinnedCommand(command) && isGuardedCommand(command) && nodePath !== null && isExecutable(nodePath);
+  });
+}
+var import_fs14, import_path10, import_os4, import_child_process5, CLAUDE_SETTINGS_PATH, claudeCodeIntegration;
 var init_claude_code = __esm({
   "src/capture/hooks/claude-code.ts"() {
     "use strict";
-    import_fs13 = __toESM(require("fs"));
+    import_fs14 = __toESM(require("fs"));
     import_path10 = __toESM(require("path"));
     import_os4 = __toESM(require("os"));
     import_child_process5 = require("child_process");
     init_utils();
     init_shell_hook();
+    init_backup();
+    init_claude_code_command();
     CLAUDE_SETTINGS_PATH = import_path10.default.join(import_os4.default.homedir(), ".claude", "settings.json");
-    HOOK_MARKER = "_hook --source claude-code";
     claudeCodeIntegration = {
       displayName: "Claude Code",
       isInstalled() {
         return isCommandInstalled("claude");
       },
-      // "Installed" means a *correctly pinned* hook is present, not just any
-      // workscribe hook — this is deliberate: it makes `workscribe init`'s
-      // existing prompt-and-install flow naturally offer to repair a stale,
-      // unpinned hook from before this fix, with no new UI code needed there.
+      // "Installed" means a *current* hook is present, not just any workscribe hook — so `workscribe init` offers to
+      // update a stale one (unpinned, unguarded, or pinned to a Node that's gone) through its outdated-hook prompt
       isHookInstalled() {
-        const { postToolUse, userPromptSubmit } = findWorkscribeHookCommands(readSettings());
-        if (postToolUse.length === 0 || userPromptSubmit.length === 0) return false;
-        return [...postToolUse, ...userPromptSubmit].every(isPinnedCommand);
+        return isHookCurrent();
       },
       install() {
         const settings = readSettings();
         const existingHooks = settings.hooks ?? {};
         const existingPostToolUse = withoutWorkscribeEntries(existingHooks.PostToolUse ?? []);
         const existingUserPromptSubmit = withoutWorkscribeEntries(existingHooks.UserPromptSubmit ?? []);
-        const workscribeBinary = resolveWorkscribeBinary();
-        const baseCommand = workscribeBinary ? `"${process.execPath}" "${workscribeBinary}"` : "workscribe";
+        const binaryPath = resolveWorkscribeBinary();
+        const command = (args) => buildHookCommand({ nodePath: process.execPath, binaryPath, args });
         settings.hooks = {
           ...existingHooks,
           PostToolUse: [
             ...existingPostToolUse,
             {
               matcher: "Bash",
-              hooks: [{ type: "command", command: `${baseCommand} ${HOOK_MARKER}`, async: true }]
+              hooks: [{ type: "command", command: command(HOOK_MARKER), async: true }]
             }
           ],
           UserPromptSubmit: [
@@ -2341,14 +2589,33 @@ var init_claude_code = __esm({
               hooks: [
                 {
                   type: "command",
-                  command: `${baseCommand} ${HOOK_MARKER} --event UserPromptSubmit`
+                  command: command(`${HOOK_MARKER} --event UserPromptSubmit`)
                 }
               ]
             }
           ]
         };
-        import_fs13.default.mkdirSync(import_path10.default.dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
-        import_fs13.default.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+        import_fs14.default.mkdirSync(import_path10.default.dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
+        import_fs14.default.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+      },
+      // Some workscribe hook is present, but not all of them are current (pinned and guarded) — including a
+      // half-installed one where only PostToolUse or only UserPromptSubmit exists
+      isHookOutdated() {
+        return allWorkscribeCommands().length > 0 && !isHookCurrent();
+      },
+      uninstall() {
+        const settings = readSettingsStrictly();
+        if (settings === "missing") return "not-installed";
+        if (settings === "unreadable") return "unreadable";
+        const hooks = settings.hooks;
+        if (hooks === null || typeof hooks !== "object" || Array.isArray(hooks)) return "not-installed";
+        const remainingHooks = hooksWithoutWorkscribe(hooks);
+        if (!remainingHooks) return "not-installed";
+        const updated = { ...settings, hooks: remainingHooks };
+        if (Object.keys(remainingHooks).length === 0) delete updated.hooks;
+        backUpFile(CLAUDE_SETTINGS_PATH);
+        import_fs14.default.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(updated, null, 2));
+        return "removed";
       }
     };
   }
@@ -2469,10 +2736,10 @@ function defaultDetectionEnvironment() {
     homeDir: import_os5.default.homedir(),
     // `which` spawns a process, so each command is looked up at most once per run
     isCommandInstalled: memoize(isCommandInstalled),
-    pathExists: (absolutePath) => import_fs14.default.existsSync(absolutePath),
+    pathExists: (absolutePath) => import_fs15.default.existsSync(absolutePath),
     listDirectory: (absolutePath) => {
       try {
-        return import_fs14.default.readdirSync(absolutePath);
+        return import_fs15.default.readdirSync(absolutePath);
       } catch {
         return [];
       }
@@ -2493,11 +2760,11 @@ function isAgentPresent(agent, environment) {
 function detectAgents(environment = defaultDetectionEnvironment()) {
   return SKILL_AGENTS.filter((agent) => isAgentPresent(agent, environment));
 }
-var import_fs14, import_os5, import_path11;
+var import_fs15, import_os5, import_path11;
 var init_detect = __esm({
   "src/skills/detect.ts"() {
     "use strict";
-    import_fs14 = __toESM(require("fs"));
+    import_fs15 = __toESM(require("fs"));
     import_os5 = __toESM(require("os"));
     import_path11 = __toESM(require("path"));
     init_utils();
@@ -2548,7 +2815,7 @@ function isSkillMarker(value) {
 }
 function readMarker(skillDir) {
   try {
-    const parsed = JSON.parse(import_fs15.default.readFileSync(import_path12.default.join(skillDir, MARKER_FILE), "utf-8"));
+    const parsed = JSON.parse(import_fs16.default.readFileSync(import_path12.default.join(skillDir, MARKER_FILE), "utf-8"));
     return isSkillMarker(parsed) ? parsed : null;
   } catch {
     return null;
@@ -2557,62 +2824,62 @@ function readMarker(skillDir) {
 function readInstallState(skillsFolder, currentVersion) {
   const skillDir = import_path12.default.join(skillsFolder, SKILL_NAME);
   return describeInstallState({
-    folderExists: import_fs15.default.existsSync(skillDir),
+    folderExists: import_fs16.default.existsSync(skillDir),
     marker: readMarker(skillDir),
     currentVersion
   });
 }
 function copyDirectory(from, to) {
-  import_fs15.default.mkdirSync(to, { recursive: true });
-  for (const entry of import_fs15.default.readdirSync(from, { withFileTypes: true })) {
+  import_fs16.default.mkdirSync(to, { recursive: true });
+  for (const entry of import_fs16.default.readdirSync(from, { withFileTypes: true })) {
     const source = import_path12.default.join(from, entry.name);
     const destination = import_path12.default.join(to, entry.name);
     if (entry.isDirectory()) copyDirectory(source, destination);
-    else import_fs15.default.copyFileSync(source, destination);
+    else import_fs16.default.copyFileSync(source, destination);
   }
 }
 function swapInto(skillDir, preparedDir) {
   const previousDir = import_path12.default.join(import_path12.default.dirname(skillDir), `.${SKILL_NAME}.old-${process.pid}`);
-  import_fs15.default.rmSync(previousDir, { recursive: true, force: true });
-  const hadPrevious = import_fs15.default.existsSync(skillDir);
-  if (hadPrevious) import_fs15.default.renameSync(skillDir, previousDir);
+  import_fs16.default.rmSync(previousDir, { recursive: true, force: true });
+  const hadPrevious = import_fs16.default.existsSync(skillDir);
+  if (hadPrevious) import_fs16.default.renameSync(skillDir, previousDir);
   try {
-    import_fs15.default.renameSync(preparedDir, skillDir);
+    import_fs16.default.renameSync(preparedDir, skillDir);
   } catch (error) {
-    if (hadPrevious) import_fs15.default.renameSync(previousDir, skillDir);
+    if (hadPrevious) import_fs16.default.renameSync(previousDir, skillDir);
     throw error;
   }
-  if (hadPrevious) import_fs15.default.rmSync(previousDir, { recursive: true, force: true });
+  if (hadPrevious) import_fs16.default.rmSync(previousDir, { recursive: true, force: true });
 }
 function installSkill(options) {
   const state = readInstallState(options.skillsFolder, options.version);
   if (state.kind === "installed") return "up-to-date";
   if (state.kind === "not-ours" && !options.force) return "skipped-not-ours";
-  import_fs15.default.mkdirSync(options.skillsFolder, { recursive: true });
+  import_fs16.default.mkdirSync(options.skillsFolder, { recursive: true });
   const preparedDir = import_path12.default.join(options.skillsFolder, `.${SKILL_NAME}.tmp-${process.pid}`);
-  import_fs15.default.rmSync(preparedDir, { recursive: true, force: true });
+  import_fs16.default.rmSync(preparedDir, { recursive: true, force: true });
   try {
     copyDirectory(options.sourceDir, preparedDir);
     const marker = { version: options.version, installedAt: (/* @__PURE__ */ new Date()).toISOString() };
-    import_fs15.default.writeFileSync(import_path12.default.join(preparedDir, MARKER_FILE), JSON.stringify(marker, null, 2));
+    import_fs16.default.writeFileSync(import_path12.default.join(preparedDir, MARKER_FILE), JSON.stringify(marker, null, 2));
     swapInto(import_path12.default.join(options.skillsFolder, SKILL_NAME), preparedDir);
   } finally {
-    import_fs15.default.rmSync(preparedDir, { recursive: true, force: true });
+    import_fs16.default.rmSync(preparedDir, { recursive: true, force: true });
   }
   return state.kind === "not-installed" ? "installed" : "updated";
 }
 function uninstallSkill(skillsFolder) {
   const skillDir = import_path12.default.join(skillsFolder, SKILL_NAME);
-  if (!import_fs15.default.existsSync(skillDir)) return "not-installed";
+  if (!import_fs16.default.existsSync(skillDir)) return "not-installed";
   if (!readMarker(skillDir)) return "skipped-not-ours";
-  import_fs15.default.rmSync(skillDir, { recursive: true, force: true });
+  import_fs16.default.rmSync(skillDir, { recursive: true, force: true });
   return "removed";
 }
-var import_fs15, import_path12;
+var import_fs16, import_path12;
 var init_installer = __esm({
   "src/skills/installer.ts"() {
     "use strict";
-    import_fs15 = __toESM(require("fs"));
+    import_fs16 = __toESM(require("fs"));
     import_path12 = __toESM(require("path"));
     init_agents();
     init_state();
@@ -2628,7 +2895,7 @@ function packagedSkillCandidates(fromDirectory) {
 }
 function resolvePackagedSkillDir(fromDirectory = __dirname) {
   const found = packagedSkillCandidates(fromDirectory).find(
-    (candidate) => import_fs16.default.existsSync(import_path13.default.join(candidate, SKILL_ENTRY_FILE))
+    (candidate) => import_fs17.default.existsSync(import_path13.default.join(candidate, SKILL_ENTRY_FILE))
   );
   if (!found) {
     throw new Error(
@@ -2637,11 +2904,11 @@ function resolvePackagedSkillDir(fromDirectory = __dirname) {
   }
   return found;
 }
-var import_fs16, import_path13, SKILL_ENTRY_FILE;
+var import_fs17, import_path13, SKILL_ENTRY_FILE;
 var init_package_path = __esm({
   "src/skills/package-path.ts"() {
     "use strict";
-    import_fs16 = __toESM(require("fs"));
+    import_fs17 = __toESM(require("fs"));
     import_path13 = __toESM(require("path"));
     init_agents();
     SKILL_ENTRY_FILE = "SKILL.md";
@@ -2739,10 +3006,10 @@ function installIntoFolder(options) {
     const outcome = installSkill({
       sourceDir: options.sourceDir,
       skillsFolder: target.skillsFolder,
-      version: "2.0.0",
+      version: "2.0.1",
       force: options.force
     });
-    return describeInstallOutcome({ ...target, outcome, version: "2.0.0" });
+    return describeInstallOutcome({ ...target, outcome, version: "2.0.1" });
   } catch (error) {
     return describeInstallFailure({ ...target, error });
   }
@@ -2761,8 +3028,8 @@ function removeSkills(agents, options) {
 }
 function formatAgentSkillLine(agent, homeDir = import_os6.default.homedir()) {
   const location = displayPath(import_path14.default.join(homeDir, agent.skillsFolder, SKILL_NAME), homeDir);
-  const installState = readInstallState(import_path14.default.join(homeDir, agent.skillsFolder), "2.0.0");
-  const status = describeSkillStatus(installState, "2.0.0");
+  const installState = readInstallState(import_path14.default.join(homeDir, agent.skillsFolder), "2.0.1");
+  const status = describeSkillStatus(installState, "2.0.1");
   return `${agent.name.padEnd(AGENT_NAME_COLUMN_WIDTH)} ${STATUS_COLOURS[status.level](status.text)}  ${import_chalk2.default.dim(location)}`;
 }
 function formatUndetectedAgentLine(agent) {
@@ -2875,19 +3142,19 @@ function step(current, total, label) {
 function runDataDirectoriesStep() {
   step(1, TOTAL_STEPS, "Creating data directories");
   for (const dir of REQUIRED_DIRS) {
-    if (!import_fs17.default.existsSync(dir)) {
-      import_fs17.default.mkdirSync(dir, { recursive: true, mode: 448 });
+    if (!import_fs18.default.existsSync(dir)) {
+      import_fs18.default.mkdirSync(dir, { recursive: true, mode: 448 });
       log.success(`Created ${dir}`);
     } else {
       try {
-        import_fs17.default.chmodSync(dir, 448);
+        import_fs18.default.chmodSync(dir, 448);
       } catch {
       }
       log.info(`${dir} already exists`);
     }
   }
-  if (!import_fs17.default.existsSync(PROFILES_DIR)) {
-    import_fs17.default.mkdirSync(PROFILES_DIR, { recursive: true, mode: 448 });
+  if (!import_fs18.default.existsSync(PROFILES_DIR)) {
+    import_fs18.default.mkdirSync(PROFILES_DIR, { recursive: true, mode: 448 });
   }
 }
 async function initDatabaseAndConfig() {
@@ -2924,18 +3191,18 @@ async function runShellHookStep(program) {
     return null;
   }
   const hookFile = import_path15.default.join(__dirname, "..", "shell", `hook.${shell.name}`);
-  if (!import_fs17.default.existsSync(hookFile)) {
+  if (!import_fs18.default.existsSync(hookFile)) {
     log.warn(`Hook template not found at ${hookFile}`);
     return shell;
   }
-  const hookContent = import_fs17.default.readFileSync(hookFile, "utf-8");
+  const hookContent = import_fs18.default.readFileSync(hookFile, "utf-8");
   const binaryPath = resolveWorkscribeBinary();
   const hookWithPath = binaryPath ? injectBinaryPath(hookContent, binaryPath, process.execPath) : hookContent;
   if (shell.name === "fish") {
     const confDir = import_path15.default.dirname(shell.rcFile);
-    if (!import_fs17.default.existsSync(confDir)) import_fs17.default.mkdirSync(confDir, { recursive: true });
+    if (!import_fs18.default.existsSync(confDir)) import_fs18.default.mkdirSync(confDir, { recursive: true });
   }
-  if (!import_fs17.default.existsSync(shell.rcFile)) import_fs17.default.writeFileSync(shell.rcFile, "");
+  if (!import_fs18.default.existsSync(shell.rcFile)) import_fs18.default.writeFileSync(shell.rcFile, "");
   if (!isHookInstalled(shell.rcFile)) {
     log.plain("");
     log.plain(import_chalk3.default.dim("  Workscribe adds a lightweight hook to your shell that captures each"));
@@ -2962,7 +3229,7 @@ async function runShellHookStep(program) {
     log.info(`Shell hook up to date in ${shell.rcFile}`);
   }
   if (isCompletionsInstalled(shell)) {
-    log.info("Shell completions already installed");
+    await refreshCompletions(shell, program);
   } else {
     const { installComps } = await (0, import_prompts2.default)({
       type: "confirm",
@@ -2981,6 +3248,29 @@ async function runShellHookStep(program) {
   }
   return shell;
 }
+async function refreshCompletions(shell, program) {
+  try {
+    writeCompletionScript(shell, getPublicCommands(program));
+  } catch (error) {
+    log.warn(`Could not refresh shell completions: ${error.message}`);
+  }
+  if (!isCompletionsOutdated(shell)) {
+    log.info("Shell completions already installed");
+    return;
+  }
+  const { updateShellCompletions } = await (0, import_prompts2.default)({
+    type: "confirm",
+    name: "updateShellCompletions",
+    message: `Shell completions in ${shell.rcFile} are outdated (they error in new terminals if Workscribe is removed). Update?`,
+    initial: true
+  });
+  if (!updateShellCompletions) {
+    log.info("Shell completions update skipped");
+    return;
+  }
+  updateCompletions(shell);
+  log.success(`Shell completions updated in ${shell.rcFile}`);
+}
 async function runAIToolsStep() {
   step(4, TOTAL_STEPS, "Detecting AI coding tools");
   const installedTools = loadAIToolRegistry().filter(
@@ -2994,6 +3284,19 @@ async function runAIToolsStep() {
     const integration = AI_HOOK_INTEGRATIONS[tool.hook];
     if (integration.isHookInstalled()) {
       log.info(`${integration.displayName} session hook already installed`);
+    } else if (integration.isHookOutdated?.()) {
+      const { updateAiHook } = await (0, import_prompts2.default)({
+        type: "confirm",
+        name: "updateAiHook",
+        message: `${integration.displayName} session hook is outdated. Update?`,
+        initial: true
+      });
+      if (updateAiHook) {
+        integration.install();
+        log.success(`${integration.displayName} session hook updated`);
+      } else {
+        log.info(`${integration.displayName} hook update skipped \u2014 re-run workscribe init to update later`);
+      }
     } else {
       const { install } = await (0, import_prompts2.default)({
         type: "confirm",
@@ -3012,10 +3315,10 @@ async function runAIToolsStep() {
 }
 async function offerSkillInstall(group, sourceDir) {
   const target = describeTarget(group);
-  const state = readInstallState(target.skillsFolder, "2.0.0");
+  const state = readInstallState(target.skillsFolder, "2.0.1");
   const knownOutcome = outcomeWithoutPrompt(state);
   if (knownOutcome) {
-    printMessage(describeInstallOutcome({ ...target, outcome: knownOutcome, version: "2.0.0" }));
+    printMessage(describeInstallOutcome({ ...target, outcome: knownOutcome, version: "2.0.1" }));
     return;
   }
   const { installSkill: shouldInstall } = await (0, import_prompts2.default)({
@@ -3112,17 +3415,17 @@ function registerInit(program) {
     await runAIToolsStep();
     await runAgentSkillStep();
     await runProfileDetectionStep(config);
-    if (!import_fs17.default.existsSync(CONFIG_PATH)) {
+    if (!import_fs18.default.existsSync(CONFIG_PATH)) {
       writeConfig(config);
     }
     printNextSteps(shell);
   });
 }
-var import_fs17, import_path15, import_os7, import_prompts2, import_chalk3, TOTAL_STEPS;
+var import_fs18, import_path15, import_os7, import_prompts2, import_chalk3, TOTAL_STEPS;
 var init_init = __esm({
   "src/cli/init.ts"() {
     "use strict";
-    import_fs17 = __toESM(require("fs"));
+    import_fs18 = __toESM(require("fs"));
     import_path15 = __toESM(require("path"));
     import_os7 = __toESM(require("os"));
     import_prompts2 = __toESM(require("prompts"));
@@ -3234,7 +3537,7 @@ function registerStatus(program) {
     const total = getEventCount();
     const todayEvents = getEventsForDate(todayDate());
     const last = getLastEvent();
-    const isPaused = import_fs18.default.existsSync(PAUSE_FLAG_PATH);
+    const isPaused = import_fs19.default.existsSync(PAUSE_FLAG_PATH);
     log.plain("");
     log.plain(import_chalk4.default.bold("  Workscribe Status"));
     log.plain("");
@@ -3280,6 +3583,18 @@ function registerStatus(program) {
         );
       }
       log.plain(import_chalk4.default.dim("     Run workscribe init to repair it"));
+    } else if (hookHealth.installed && hookHealth.nodeMissing) {
+      log.plain("");
+      log.plain(
+        `  ${import_chalk4.default.yellow("\u26A0")}  The Node.js version the Claude Code hook uses is gone \u2014 Claude Code activity is not being captured.`
+      );
+      log.plain(import_chalk4.default.dim("     Run workscribe init to repair it"));
+    } else if (hookHealth.installed && !hookHealth.guarded) {
+      log.plain("");
+      log.plain(
+        `  ${import_chalk4.default.yellow("\u26A0")}  Claude Code hook is from an older version \u2014 it will show errors in Claude Code if Workscribe is ever removed.`
+      );
+      log.plain(import_chalk4.default.dim("     Run workscribe init to update it"));
     }
     const { total: weekTotal, otherCount } = getRecentOtherRate(7);
     if (weekTotal > 0) {
@@ -3299,11 +3614,11 @@ function registerStatus(program) {
     log.plain("");
   });
 }
-var import_fs18, import_chalk4, AGENT_SKILL_LABEL;
+var import_fs19, import_chalk4, AGENT_SKILL_LABEL;
 var init_status = __esm({
   "src/cli/status.ts"() {
     "use strict";
-    import_fs18 = __toESM(require("fs"));
+    import_fs19 = __toESM(require("fs"));
     import_chalk4 = __toESM(require("chalk"));
     init_db();
     init_config();
@@ -3798,13 +4113,13 @@ function isStdinInteractive() {
   return Boolean(process.stdin.isTTY);
 }
 function readAllStdin() {
-  return import_fs19.default.readFileSync(STDIN_FILE_DESCRIPTOR, "utf-8");
+  return import_fs20.default.readFileSync(STDIN_FILE_DESCRIPTOR, "utf-8");
 }
-var import_fs19, STDIN_FILE_DESCRIPTOR;
+var import_fs20, STDIN_FILE_DESCRIPTOR;
 var init_stdin = __esm({
   "src/utils/stdin.ts"() {
     "use strict";
-    import_fs19 = __toESM(require("fs"));
+    import_fs20 = __toESM(require("fs"));
     STDIN_FILE_DESCRIPTOR = 0;
   }
 });
@@ -4539,19 +4854,19 @@ function registerExport(program) {
     const payload = buildDayPayload(date, sessions, locationContextFrom(config));
     const summary = await createSummaryWriter(config).summarize(payload);
     const outputPath = options.output ?? import_path17.default.join(EXPORTS_DIR, `workscribe-${date}.md`);
-    if (!import_fs20.default.existsSync(EXPORTS_DIR)) import_fs20.default.mkdirSync(EXPORTS_DIR, { recursive: true, mode: 448 });
-    import_fs20.default.writeFileSync(outputPath, `# Work Summary \u2014 ${date}
+    if (!import_fs21.default.existsSync(EXPORTS_DIR)) import_fs21.default.mkdirSync(EXPORTS_DIR, { recursive: true, mode: 448 });
+    import_fs21.default.writeFileSync(outputPath, `# Work Summary \u2014 ${date}
 
 ${summary}
 `, { encoding: "utf-8", mode: 384 });
     log.success(`Saved: ${outputPath}`);
   });
 }
-var import_fs20, import_path17;
+var import_fs21, import_path17;
 var init_export = __esm({
   "src/cli/export.ts"() {
     "use strict";
-    import_fs20 = __toESM(require("fs"));
+    import_fs21 = __toESM(require("fs"));
     import_path17 = __toESM(require("path"));
     init_detector();
     init_config();
@@ -4643,27 +4958,27 @@ var init_config2 = __esm({
 // src/cli/pause.ts
 function registerPause(program) {
   program.command("pause").description("Pause capture temporarily").action(() => {
-    if (import_fs21.default.existsSync(PAUSE_FLAG_PATH)) {
+    if (import_fs22.default.existsSync(PAUSE_FLAG_PATH)) {
       log.info("Capture is already paused. Run workscribe resume to restart.");
       return;
     }
-    import_fs21.default.writeFileSync(PAUSE_FLAG_PATH, "", { mode: 384 });
+    import_fs22.default.writeFileSync(PAUSE_FLAG_PATH, "", { mode: 384 });
     log.success("Capture paused. Run workscribe resume to restart.");
   });
   program.command("resume").description("Resume capture after a pause").action(() => {
-    if (!import_fs21.default.existsSync(PAUSE_FLAG_PATH)) {
+    if (!import_fs22.default.existsSync(PAUSE_FLAG_PATH)) {
       log.info("Capture is not paused.");
       return;
     }
-    import_fs21.default.rmSync(PAUSE_FLAG_PATH);
+    import_fs22.default.rmSync(PAUSE_FLAG_PATH);
     log.success("Capture resumed.");
   });
 }
-var import_fs21;
+var import_fs22;
 var init_pause = __esm({
   "src/cli/pause.ts"() {
     "use strict";
-    import_fs21 = __toESM(require("fs"));
+    import_fs22 = __toESM(require("fs"));
     init_paths();
     init_logger();
   }
@@ -4765,6 +5080,22 @@ var init_clear = __esm({
 });
 
 // src/cli/uninstall.ts
+function completionRcFiles() {
+  return [".zshrc", ".bashrc", ".bash_profile"].map((file) => import_path18.default.join(import_os11.default.homedir(), file));
+}
+function removeCompletionsAndToolHooks() {
+  for (const rcFile of completionRcFiles()) {
+    if (removeCompletions(rcFile)) log.success(`Shell completions removed from ${rcFile}`);
+  }
+  if (removeFishCompletions()) log.success("Fish completions removed");
+  const outcome = claudeCodeIntegration.uninstall?.();
+  if (outcome === "removed") log.success("Claude Code session hook removed from ~/.claude/settings.json");
+  if (outcome === "unreadable") {
+    log.warn(
+      "Couldn't read ~/.claude/settings.json, so the Claude Code session hook was left in place. Fix the file's JSON, then run: workscribe uninstall --hooks-only"
+    );
+  }
+}
 function detectShellRcFiles() {
   const candidates = [
     { name: "zsh", rcFile: import_path18.default.join(import_os11.default.homedir(), ".zshrc") },
@@ -4772,10 +5103,15 @@ function detectShellRcFiles() {
     { name: "bash", rcFile: import_path18.default.join(import_os11.default.homedir(), ".bash_profile") },
     { name: "fish", rcFile: import_path18.default.join(import_os11.default.homedir(), ".config", "fish", "conf.d", "workscribe.fish") }
   ];
-  return candidates.filter((candidate) => import_fs22.default.existsSync(candidate.rcFile) && isHookInstalled(candidate.rcFile));
+  return candidates.filter((candidate) => import_fs23.default.existsSync(candidate.rcFile) && isHookInstalled(candidate.rcFile));
 }
 function registerUninstall(program) {
-  program.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) => {
+  program.command("uninstall").description(
+    "Remove shell hooks, completions, the Claude Code hook and the agent skill; optionally delete all data"
+  ).option(
+    "--hooks-only",
+    "remove shell hooks, completions and the Claude Code hook only \u2014 keep the agent skill and skip the data prompt"
+  ).action(async (options) => {
     log.plain(import_chalk10.default.bold("\n  Workscribe \u2014 Uninstall\n"));
     const hooked = detectShellRcFiles();
     if (hooked.length === 0) {
@@ -4783,7 +5119,7 @@ function registerUninstall(program) {
     } else {
       for (const { name, rcFile } of hooked) {
         if (name === "fish") {
-          import_fs22.default.unlinkSync(rcFile);
+          import_fs23.default.unlinkSync(rcFile);
           log.success(`Shell hook removed: ${rcFile}`);
           log.plain(`  ${import_chalk10.default.dim("Restart your terminal to take effect")}`);
         } else {
@@ -4796,9 +5132,10 @@ function registerUninstall(program) {
         }
       }
     }
-    if (opts.hooksOnly) return;
+    removeCompletionsAndToolHooks();
+    if (options.hooksOnly) return;
     removeSkills(SKILL_AGENTS, { reportMissing: false });
-    const existingDirs = [...new Set(REQUIRED_DIRS)].filter((dir) => import_fs22.default.existsSync(dir));
+    const existingDirs = [...new Set(REQUIRED_DIRS)].filter((dir) => import_fs23.default.existsSync(dir));
     if (existingDirs.length > 0) {
       log.plain("");
       const { deleteData } = await (0, import_prompts4.default)({
@@ -4809,7 +5146,7 @@ function registerUninstall(program) {
       });
       if (deleteData) {
         for (const dir of existingDirs) {
-          import_fs22.default.rmSync(dir, { recursive: true, force: true });
+          import_fs23.default.rmSync(dir, { recursive: true, force: true });
           log.success(`Deleted ${dir}`);
         }
       } else {
@@ -4821,17 +5158,18 @@ function registerUninstall(program) {
     log.plain("");
   });
 }
-var import_fs22, import_path18, import_os11, import_prompts4, import_chalk10;
+var import_fs23, import_path18, import_os11, import_prompts4, import_chalk10;
 var init_uninstall = __esm({
   "src/cli/uninstall.ts"() {
     "use strict";
-    import_fs22 = __toESM(require("fs"));
+    import_fs23 = __toESM(require("fs"));
     import_path18 = __toESM(require("path"));
     import_os11 = __toESM(require("os"));
     import_prompts4 = __toESM(require("prompts"));
     import_chalk10 = __toESM(require("chalk"));
     init_paths();
     init_shell_hook();
+    init_claude_code();
     init_logger();
     init_agents();
     init_actions();
@@ -4882,7 +5220,7 @@ function registerProfile(program) {
       log.plain(import_chalk11.default.dim("  " + "\u2500".repeat(60)));
       for (const entry of entries) {
         const badge = activeNames.has(entry.name) ? import_chalk11.default.green(" [active]") : "";
-        const installed = import_fs23.default.existsSync(import_path19.default.join(PROFILES_DIR, `${entry.name}.json`)) ? import_chalk11.default.dim(" installed") : "";
+        const installed = import_fs24.default.existsSync(import_path19.default.join(PROFILES_DIR, `${entry.name}.json`)) ? import_chalk11.default.dim(" installed") : "";
         log.plain(`  ${import_chalk11.default.cyan(entry.name.padEnd(18))} ${entry.displayName.padEnd(28)}${badge}${installed}`);
         if (entry.description) log.plain(`  ${import_chalk11.default.dim(" ".repeat(18) + entry.description)}`);
       }
@@ -4919,7 +5257,7 @@ function registerProfile(program) {
       }
       activeNames.delete(name);
       const cachePath = import_path19.default.join(PROFILES_DIR, `${name}.json`);
-      if (import_fs23.default.existsSync(cachePath)) import_fs23.default.unlinkSync(cachePath);
+      if (import_fs24.default.existsSync(cachePath)) import_fs24.default.unlinkSync(cachePath);
       log.success(`Profile "${name}" removed`);
     }
     config.capture.profiles = [...activeNames];
@@ -5046,11 +5384,11 @@ function registerProfile(program) {
     }
   });
 }
-var import_fs23, import_path19, import_chalk11, MIN_SUGGEST_COUNT;
+var import_fs24, import_path19, import_chalk11, MIN_SUGGEST_COUNT;
 var init_profile = __esm({
   "src/cli/profile.ts"() {
     "use strict";
-    import_fs23 = __toESM(require("fs"));
+    import_fs24 = __toESM(require("fs"));
     import_path19 = __toESM(require("path"));
     import_chalk11 = __toESM(require("chalk"));
     init_config();
@@ -5063,14 +5401,42 @@ var init_profile = __esm({
   }
 });
 
+// src/utils/working-directory.ts
+function realPath(target) {
+  try {
+    return import_fs25.default.realpathSync(target);
+  } catch {
+    return null;
+  }
+}
+function currentDirectory(where = { pwd: process.env.PWD, cwd: process.cwd() }) {
+  if (where.pwd && realPath(where.pwd) === realPath(where.cwd)) return where.pwd;
+  return where.cwd;
+}
+function rootForms(cwd, root) {
+  const resolvedCwd = realPath(cwd);
+  if (!resolvedCwd) return [root];
+  const reached = import_path20.default.resolve(cwd, import_path20.default.relative(resolvedCwd, root));
+  return [.../* @__PURE__ */ new Set([root, reached])];
+}
+var import_fs25, import_path20;
+var init_working_directory = __esm({
+  "src/utils/working-directory.ts"() {
+    "use strict";
+    import_fs25 = __toESM(require("fs"));
+    import_path20 = __toESM(require("path"));
+  }
+});
+
 // src/cli/note.ts
 function registerNote(program) {
   program.command("note <text>").description("Attach a free-text annotation to the current session").action((text) => {
-    const { repoName, branch } = getGitContext(process.cwd());
+    const directory = currentDirectory();
+    const { repoName, branch } = getRepoContext(directory, readConfig());
     insertEvent({
       captured_at: (/* @__PURE__ */ new Date()).toISOString(),
       command: "workscribe note",
-      cwd: process.cwd(),
+      cwd: directory,
       exit_code: null,
       duration_ms: null,
       repo_name: repoName,
@@ -5088,6 +5454,8 @@ var init_note = __esm({
     "use strict";
     init_db();
     init_git();
+    init_config();
+    init_working_directory();
     init_logger();
   }
 });
@@ -5118,8 +5486,8 @@ var init_week = __esm({
 
 // src/cli/bug-report.ts
 function tailFile(filePath, lines) {
-  if (!import_fs24.default.existsSync(filePath)) return "(no debug log found \u2014 set WORKSCRIBE_DEBUG=1 to enable)";
-  const content = import_fs24.default.readFileSync(filePath, "utf-8");
+  if (!import_fs26.default.existsSync(filePath)) return "(no debug log found \u2014 set WORKSCRIBE_DEBUG=1 to enable)";
+  const content = import_fs26.default.readFileSync(filePath, "utf-8");
   const allLines = content.split("\n");
   return allLines.slice(-lines).join("\n");
 }
@@ -5137,9 +5505,9 @@ function redactConfig() {
 function registerBugReport(program) {
   program.command("bug-report").description("Generate a diagnostic report for filing a bug").action(() => {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const reportPath = import_path20.default.join(WORKSCRIBE_DIR, `bug-report-${timestamp}.txt`);
+    const reportPath = import_path21.default.join(WORKSCRIBE_DIR, `bug-report-${timestamp}.txt`);
     const systemInfo = [
-      `Workscribe version : ${"2.0.0"}`,
+      `Workscribe version : ${"2.0.1"}`,
       `Node.js version    : ${process.version}`,
       `Platform           : ${process.platform}`,
       `Architecture       : ${process.arch}`,
@@ -5161,17 +5529,17 @@ function registerBugReport(program) {
       tailFile(DEBUG_LOG_PATH, DEBUG_LOG_TAIL_LINES)
     ].join("\n");
     try {
-      if (!import_fs24.default.existsSync(WORKSCRIBE_DIR)) {
-        import_fs24.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true, mode: 448 });
+      if (!import_fs26.default.existsSync(WORKSCRIBE_DIR)) {
+        import_fs26.default.mkdirSync(WORKSCRIBE_DIR, { recursive: true, mode: 448 });
       }
-      import_fs24.default.writeFileSync(reportPath, report, { mode: 384 });
+      import_fs26.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 ${"2.0.0"}`,
-      body: `<!-- Attach ${import_path20.default.basename(reportPath)} or paste the relevant sections below -->
+      title: `Bug report \u2014 workscribe ${"2.0.1"}`,
+      body: `<!-- Attach ${import_path21.default.basename(reportPath)} or paste the relevant sections below -->
 
 **Describe the issue:**
 
@@ -5188,13 +5556,13 @@ function registerBugReport(program) {
     log.plain("");
   });
 }
-var import_fs24, import_os12, import_path20, import_chalk12, GITHUB_ISSUES_URL, DEBUG_LOG_TAIL_LINES;
+var import_fs26, import_os12, import_path21, import_chalk12, GITHUB_ISSUES_URL, DEBUG_LOG_TAIL_LINES;
 var init_bug_report = __esm({
   "src/cli/bug-report.ts"() {
     "use strict";
-    import_fs24 = __toESM(require("fs"));
+    import_fs26 = __toESM(require("fs"));
     import_os12 = __toESM(require("os"));
-    import_path20 = __toESM(require("path"));
+    import_path21 = __toESM(require("path"));
     import_chalk12 = __toESM(require("chalk"));
     init_paths();
     init_config();
@@ -5320,7 +5688,7 @@ function printSessionContext(session, heading) {
 function registerContext(program) {
   program.command("context").description("Show the last session for the current repo").option("--file <path>", "narrow to last session that touched this file").option("--json", "output as JSON instead of formatted text \u2014 null when no session is found").action((opts) => {
     if (opts.file) {
-      const normalizedFile = import_path21.default.normalize(opts.file);
+      const normalizedFile = import_path22.default.normalize(opts.file);
       const session = getLastSessionTouchingFile(normalizedFile);
       if (!session) {
         if (opts.json) log.plain(JSON.stringify(null));
@@ -5331,16 +5699,20 @@ function registerContext(program) {
         log.plain(JSON.stringify(toContextJson(session)));
         return;
       }
-      printSessionContext(session, `Last session touching ${import_path21.default.basename(normalizedFile)}`);
+      printSessionContext(session, `Last session touching ${import_path22.default.basename(normalizedFile)}`);
       return;
     }
-    const { repoName } = getGitContext(process.cwd(), null, readConfig().git.qualifyRepoName);
+    const config = readConfig();
+    const directory = currentDirectory();
+    const { repoName, root, remote } = getRepoContext(directory, config);
     if (!repoName) {
       if (opts.json) log.plain(JSON.stringify(null));
       else log.plain("  Not in a git repository. Run workscribe context from a project directory.");
       return;
     }
-    const sessions = getRecentSessionsByRepo(repoName, 1);
+    const otherRepoName = remote ? formatRepoName(remote, !config.git.qualifyRepoName) : null;
+    const roots = root ? rootForms(directory, root) : [];
+    const sessions = getRecentSessionsForRepo({ repoName, otherRepoName, roots }, 1);
     if (sessions.length === 0) {
       if (opts.json) log.plain(JSON.stringify(null));
       else log.plain(`  No sessions found for ${repoName}`);
@@ -5353,14 +5725,16 @@ function registerContext(program) {
     printSessionContext(sessions[0], `Last session on ${repoName}`);
   });
 }
-var import_path21, import_chalk14;
+var import_path22, import_chalk14;
 var init_context = __esm({
   "src/cli/context.ts"() {
     "use strict";
-    import_path21 = __toESM(require("path"));
+    import_path22 = __toESM(require("path"));
     import_chalk14 = __toESM(require("chalk"));
     init_db();
     init_git();
+    init_repo_name();
+    init_working_directory();
     init_config();
     init_format();
     init_logger();
@@ -5448,7 +5822,7 @@ var init_skill = __esm({
 // src/utils/update-check.ts
 function readCache() {
   try {
-    return JSON.parse(import_fs25.default.readFileSync(UPDATE_CHECK_PATH, "utf-8"));
+    return JSON.parse(import_fs27.default.readFileSync(UPDATE_CHECK_PATH, "utf-8"));
   } catch {
     return null;
   }
@@ -5456,7 +5830,7 @@ function readCache() {
 function writeCache(updates) {
   try {
     const current = readCache() ?? {};
-    import_fs25.default.writeFileSync(UPDATE_CHECK_PATH, JSON.stringify({ ...current, ...updates }), { mode: 384 });
+    import_fs27.default.writeFileSync(UPDATE_CHECK_PATH, JSON.stringify({ ...current, ...updates }), { mode: 384 });
   } catch {
   }
 }
@@ -5469,7 +5843,7 @@ function isNewer(latest, current) {
   return latestPatch > currentPatch;
 }
 function checkForUpdate() {
-  const current = "2.0.0";
+  const current = "2.0.1";
   const cache = readCache();
   if (cache && isNewer(cache.latestVersion, current)) {
     process.stderr.write(
@@ -5492,7 +5866,7 @@ function checkForUpdate() {
 function buildTelemetryPayload(config) {
   return {
     installId: config.telemetry.installId,
-    cliVersion: "2.0.0",
+    cliVersion: "2.0.1",
     platform: import_os13.default.platform(),
     nodeVersion: process.version
   };
@@ -5517,11 +5891,11 @@ function pingTelemetry() {
     debugLog("pingTelemetry", error);
   });
 }
-var import_fs25, import_os13, CHECK_INTERVAL_MS;
+var import_fs27, import_os13, CHECK_INTERVAL_MS;
 var init_update_check = __esm({
   "src/utils/update-check.ts"() {
     "use strict";
-    import_fs25 = __toESM(require("fs"));
+    import_fs27 = __toESM(require("fs"));
     import_os13 = __toESM(require("os"));
     init_paths();
     init_config();
@@ -5568,7 +5942,7 @@ var require_main = __commonJS({
       pingTelemetry();
     }
     var program = new import_commander.Command();
-    program.name("workscribe").description("Automatic developer work journal").version("2.0.0");
+    program.name("workscribe").description("Automatic developer work journal").version("2.0.1");
     registerCapture(program);
     registerHook(program);
     registerInit(program);