nexusmem 0.10.2 → 0.10.4

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import pc22 from "picocolors";
 
 // src/config/workspace.ts
@@ -334,7 +334,7 @@ function toSpawnError(err, cwd, args) {
 }
 var BASE_ARGS = ["-c", "core.quotePath=false", "-c", "core.pager=", "--no-pager"];
 var RETRY_DELAYS_MS = [50, 150, 400];
-var realSleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+var realSleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
 async function* gitStream(cwd, args, opts = {}) {
   const sleep = opts.sleep ?? realSleep;
   for (let attempt = 0; ; attempt += 1) {
@@ -361,9 +361,9 @@ async function* runGitOnce(cwd, args, opts) {
   child.stderr.on("data", (chunk2) => {
     if (stderr.length < 64 * 1024) stderr += chunk2;
   });
-  const exited = new Promise((resolve2, reject) => {
+  const exited = new Promise((resolve3, reject) => {
     child.once("error", (err) => reject(toSpawnError(err, cwd, fullArgs)));
-    child.once("close", (code2, signal2) => resolve2({ code: code2 ?? 0, signal: signal2 ?? null }));
+    child.once("close", (code2, signal2) => resolve3({ code: code2 ?? 0, signal: signal2 ?? null }));
   });
   exited.catch(() => {
   });
@@ -507,16 +507,128 @@ async function resolvePowerShellProfilePath(exe = "powershell") {
     return null;
   }
 }
+function resolveBashProfilePath() {
+  return join3(homedir2(), ".bashrc");
+}
+function resolveZshProfilePath() {
+  return join3(homedir2(), ".zshrc");
+}
 
-// src/hooks/powershell.ts
+// src/hooks/bash.ts
 var MARK_START = "# >>> nexusmem shell hook >>>";
 var MARK_END = "# <<< nexusmem shell hook <<<";
-function toPowerShellLiteral(s) {
-  return `'${s.replace(/'/g, "''")}'`;
+function toBashLiteral(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function renderHookSnippet(logPath) {
   return [
     MARK_START,
+    `__nxm_log_path=${toBashLiteral(logPath)}`,
+    '__nxm_cmd_start=""',
+    '__nxm_last_cmd=""',
+    '__nxm_debug_trap_owned=""',
+    "",
+    "__nxm_json_escape() {",
+    "  local s=$1",
+    "  s=${s//\\\\/\\\\\\\\}",
+    '  s=${s//\\"/\\\\\\"}',
+    "  s=${s//$'\\n'/\\\\n}",
+    "  s=${s//$'\\t'/\\\\t}",
+    `  printf '%s' "$s"`,
+    "}",
+    "",
+    "# Sets $__nxm_ms rather than echoing, to avoid a subshell fork on the bash 5+ fast path.",
+    "__nxm_now_ms() {",
+    '  if [ -n "${EPOCHREALTIME:-}" ]; then',
+    "    local es=${EPOCHREALTIME/./}",
+    "    __nxm_ms=$(( es / 1000 ))",
+    "  else",
+    "    __nxm_ms=$(( $(date -u +%s) * 1000 ))",
+    "  fi",
+    "}",
+    "",
+    // A DEBUG trap fires per simple command, so a pipeline sets __nxm_cmd_start
+    // once (first stage) and precmd clears it after logging.
+    "__nxm_preexec() {",
+    '  case "$BASH_COMMAND" in __nxm_*) return ;; esac',
+    '  if [ -z "$__nxm_cmd_start" ]; then',
+    "    __nxm_now_ms; __nxm_cmd_start=$__nxm_ms",
+    "    __nxm_last_cmd=$BASH_COMMAND",
+    "  fi",
+    "}",
+    "",
+    "__nxm_precmd() {",
+    // Must be first: nothing above may run a command that would overwrite $?.
+    "  local __nxm_exit=$?",
+    '  [ -z "$__nxm_debug_trap_owned" ] && return',
+    '  [ -z "$__nxm_last_cmd" ] && return',
+    "",
+    "  local __nxm_dur=null",
+    '  if [ -n "$__nxm_cmd_start" ]; then',
+    "    __nxm_now_ms",
+    "    __nxm_dur=$(( __nxm_ms - __nxm_cmd_start ))",
+    "  fi",
+    "",
+    "  local __nxm_dir",
+    '  __nxm_dir=$(dirname -- "$__nxm_log_path" 2>/dev/null)',
+    '  [ -d "$__nxm_dir" ] || mkdir -p "$__nxm_dir" 2>/dev/null',
+    `  printf '{"ts":"%s","cwd":"%s","exitCode":%s,"durationMs":%s,"command":"%s","shell":"bash-hook"}\\n' \\`,
+    '    "$(date -u +%Y-%m-%dT%H:%M:%S.000Z)" "$(__nxm_json_escape "$PWD")" "$__nxm_exit" "$__nxm_dur" \\',
+    '    "$(__nxm_json_escape "$__nxm_last_cmd")" >> "$__nxm_log_path" 2>/dev/null',
+    "",
+    '  __nxm_cmd_start=""',
+    '  __nxm_last_cmd=""',
+    "}",
+    "",
+    "# Runs first in the chain (before any pre-existing PROMPT_COMMAND) so $? is still the real last-command status above.",
+    'case ";$PROMPT_COMMAND;" in',
+    '  *";__nxm_precmd;"*) ;;',
+    '  *) PROMPT_COMMAND="__nxm_precmd${PROMPT_COMMAND:+; $PROMPT_COMMAND}" ;;',
+    "esac",
+    "",
+    // Installed last, after every other statement in this block has already
+    // run once -- otherwise sourcing this file trips our own trap on our own
+    // remaining setup statements (confirmed live: the case/esac above got
+    // logged as if it were a real command, the one time this was ordered
+    // before the trap install).
+    "# Only takes over an unset DEBUG trap -- never overwrites one another tool",
+    "# (direnv, a debugger, ...) already owns. If something else already holds",
+    "# it, precmd above logs nothing rather than log with no command text.",
+    'if [ -z "$(trap -p DEBUG)" ]; then',
+    "  trap '__nxm_preexec' DEBUG",
+    "  __nxm_debug_trap_owned=1",
+    "fi",
+    MARK_END,
+    ""
+  ].join("\n");
+}
+function isHookInstalled(profileContent) {
+  return profileContent.includes(MARK_START);
+}
+function stripHookSnippet(profileContent) {
+  const startIdx = profileContent.indexOf(MARK_START);
+  const endIdx = profileContent.indexOf(MARK_END);
+  if (startIdx === -1 || endIdx === -1) return profileContent;
+  const afterBlock = profileContent.slice(endIdx + MARK_END.length).replace(/^\r?\n/, "");
+  return profileContent.slice(0, startIdx) + afterBlock;
+}
+function upsertHookSnippet(profileContent, logPath) {
+  const stripped = stripHookSnippet(profileContent).replace(/\s+$/, "");
+  const prefix = stripped.length > 0 ? `${stripped}
+
+` : "";
+  return `${prefix}${renderHookSnippet(logPath)}`;
+}
+
+// src/hooks/powershell.ts
+var MARK_START2 = "# >>> nexusmem shell hook >>>";
+var MARK_END2 = "# <<< nexusmem shell hook <<<";
+function toPowerShellLiteral(s) {
+  return `'${s.replace(/'/g, "''")}'`;
+}
+function renderHookSnippet2(logPath) {
+  return [
+    MARK_START2,
     "if (Test-Path Function:\\prompt) { $function:__ssd_original_prompt = $function:prompt }",
     "$global:__ssd_last_history_id = -1",
     `$global:__ssd_log_path = ${toPowerShellLiteral(logPath)}`,
@@ -544,39 +656,153 @@ function renderHookSnippet(logPath) {
     "  if (Test-Path Function:\\__ssd_original_prompt) { & $function:__ssd_original_prompt }",
     `  else { "PS $($executionContext.SessionState.Path.CurrentLocation)$('>' * ($nestedPromptLevel + 1)) " }`,
     "}",
-    MARK_END,
+    MARK_END2,
     ""
   ].join("\n");
 }
-function isHookInstalled(profileContent) {
-  return profileContent.includes(MARK_START);
+function isHookInstalled2(profileContent) {
+  return profileContent.includes(MARK_START2);
 }
-function stripHookSnippet(profileContent) {
-  const startIdx = profileContent.indexOf(MARK_START);
-  const endIdx = profileContent.indexOf(MARK_END);
+function stripHookSnippet2(profileContent) {
+  const startIdx = profileContent.indexOf(MARK_START2);
+  const endIdx = profileContent.indexOf(MARK_END2);
   if (startIdx === -1 || endIdx === -1) return profileContent;
-  const afterBlock = profileContent.slice(endIdx + MARK_END.length).replace(/^\r?\n/, "");
+  const afterBlock = profileContent.slice(endIdx + MARK_END2.length).replace(/^\r?\n/, "");
   return profileContent.slice(0, startIdx) + afterBlock;
 }
-function upsertHookSnippet(profileContent, logPath) {
-  const stripped = stripHookSnippet(profileContent).replace(/\s+$/, "");
+function upsertHookSnippet2(profileContent, logPath) {
+  const stripped = stripHookSnippet2(profileContent).replace(/\s+$/, "");
   const prefix = stripped.length > 0 ? `${stripped}
 
 ` : "";
-  return `${prefix}${renderHookSnippet(logPath)}`;
+  return `${prefix}${renderHookSnippet2(logPath)}`;
+}
+
+// src/hooks/zsh.ts
+var MARK_START3 = "# >>> nexusmem shell hook >>>";
+var MARK_END3 = "# <<< nexusmem shell hook <<<";
+function toZshLiteral(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function renderHookSnippet3(logPath) {
+  return [
+    MARK_START3,
+    `__nxm_log_path=${toZshLiteral(logPath)}`,
+    '__nxm_cmd_start=""',
+    '__nxm_last_cmd=""',
+    "zmodload zsh/datetime 2>/dev/null",
+    "",
+    "__nxm_json_escape() {",
+    "  local s=$1",
+    "  s=${s//\\\\/\\\\\\\\}",
+    '  s=${s//\\"/\\\\\\"}',
+    "  s=${s//$'\\n'/\\\\n}",
+    "  s=${s//$'\\t'/\\\\t}",
+    `  printf '%s' "$s"`,
+    "}",
+    "",
+    "__nxm_preexec() {",
+    "  __nxm_last_cmd=$1",
+    '  if [ -n "${EPOCHREALTIME:-}" ]; then',
+    "    __nxm_cmd_start=$(printf '%.0f' $(( EPOCHREALTIME * 1000 )))",
+    "  else",
+    "    __nxm_cmd_start=$(( $(date -u +%s) * 1000 ))",
+    "  fi",
+    "}",
+    "",
+    "__nxm_precmd() {",
+    // Must be first: nothing above may run a command that would overwrite $?.
+    "  local __nxm_exit=$?",
+    '  [ -z "$__nxm_last_cmd" ] && return',
+    "",
+    "  local __nxm_dur=null",
+    '  if [ -n "$__nxm_cmd_start" ]; then',
+    "    local __nxm_now",
+    '    if [ -n "${EPOCHREALTIME:-}" ]; then',
+    "      __nxm_now=$(printf '%.0f' $(( EPOCHREALTIME * 1000 )))",
+    "    else",
+    "      __nxm_now=$(( $(date -u +%s) * 1000 ))",
+    "    fi",
+    "    __nxm_dur=$(( __nxm_now - __nxm_cmd_start ))",
+    "  fi",
+    "",
+    "  local __nxm_dir",
+    '  __nxm_dir=$(dirname -- "$__nxm_log_path" 2>/dev/null)',
+    '  [ -d "$__nxm_dir" ] || mkdir -p "$__nxm_dir" 2>/dev/null',
+    `  printf '{"ts":"%s","cwd":"%s","exitCode":%s,"durationMs":%s,"command":"%s","shell":"zsh-hook"}\\n' \\`,
+    '    "$(date -u +%Y-%m-%dT%H:%M:%S.000Z)" "$(__nxm_json_escape "$PWD")" "$__nxm_exit" "$__nxm_dur" \\',
+    '    "$(__nxm_json_escape "$__nxm_last_cmd")" >> "$__nxm_log_path" 2>/dev/null',
+    "",
+    '  __nxm_cmd_start=""',
+    '  __nxm_last_cmd=""',
+    "}",
+    "",
+    // Membership check (not just append) so re-sourcing this file doesn't register twice.
+    "typeset -ga preexec_functions precmd_functions",
+    '(( ${preexec_functions[(Ie)__nxm_preexec]} )) || preexec_functions=(__nxm_preexec "${preexec_functions[@]}")',
+    '(( ${precmd_functions[(Ie)__nxm_precmd]} )) || precmd_functions=(__nxm_precmd "${precmd_functions[@]}")',
+    MARK_END3,
+    ""
+  ].join("\n");
+}
+function isHookInstalled3(profileContent) {
+  return profileContent.includes(MARK_START3);
+}
+function stripHookSnippet3(profileContent) {
+  const startIdx = profileContent.indexOf(MARK_START3);
+  const endIdx = profileContent.indexOf(MARK_END3);
+  if (startIdx === -1 || endIdx === -1) return profileContent;
+  const afterBlock = profileContent.slice(endIdx + MARK_END3.length).replace(/^\r?\n/, "");
+  return profileContent.slice(0, startIdx) + afterBlock;
+}
+function upsertHookSnippet3(profileContent, logPath) {
+  const stripped = stripHookSnippet3(profileContent).replace(/\s+$/, "");
+  const prefix = stripped.length > 0 ? `${stripped}
+
+` : "";
+  return `${prefix}${renderHookSnippet3(logPath)}`;
 }
 
 // src/hooks/install.ts
+var SHELL_MODULES = {
+  pwsh: {
+    isHookInstalled: isHookInstalled2,
+    stripHookSnippet: stripHookSnippet2,
+    upsertHookSnippet: upsertHookSnippet2,
+    resolveProfilePath: async (override) => override ?? await resolvePowerShellProfilePath()
+  },
+  bash: {
+    isHookInstalled,
+    stripHookSnippet,
+    upsertHookSnippet,
+    resolveProfilePath: async (override) => override ?? resolveBashProfilePath()
+  },
+  zsh: {
+    isHookInstalled: isHookInstalled3,
+    stripHookSnippet: stripHookSnippet3,
+    upsertHookSnippet: upsertHookSnippet3,
+    resolveProfilePath: async (override) => override ?? resolveZshProfilePath()
+  }
+};
+function detectShellKind() {
+  if (process.platform === "win32") return "pwsh";
+  return (process.env.SHELL ?? "").includes("zsh") ? "zsh" : "bash";
+}
 var ProfileNotFoundError = class extends Error {
-  constructor() {
-    super("Could not resolve a PowerShell profile path (tried `powershell -Command $PROFILE`). Pass --profile explicitly.");
+  constructor(shell) {
+    super(
+      shell === "pwsh" ? "Could not resolve a PowerShell profile path (tried `powershell -Command $PROFILE`). Pass --profile explicitly." : `Could not resolve a ${shell} profile path. Pass --profile explicitly.`
+    );
+    this.shell = shell;
     this.name = "ProfileNotFoundError";
   }
+  shell;
 };
-async function resolveHookTarget(profileOverride, logPathOverride) {
-  const profilePath = profileOverride ?? await resolvePowerShellProfilePath();
-  if (!profilePath) throw new ProfileNotFoundError();
-  return { profilePath, logPath: logPathOverride ?? hookLogPath() };
+async function resolveHookTarget(shellOverride, profileOverride, logPathOverride) {
+  const shell = shellOverride ?? detectShellKind();
+  const profilePath = await SHELL_MODULES[shell].resolveProfilePath(profileOverride);
+  if (!profilePath) throw new ProfileNotFoundError(shell);
+  return { shell, profilePath, logPath: logPathOverride ?? hookLogPath() };
 }
 async function readProfile(path) {
   try {
@@ -586,66 +812,52 @@ async function readProfile(path) {
   }
 }
 async function installHook(target) {
+  const mod = SHELL_MODULES[target.shell];
   const current = await readProfile(target.profilePath);
-  const alreadyInstalled = isHookInstalled(current);
-  const next = upsertHookSnippet(current, target.logPath);
+  const alreadyInstalled = mod.isHookInstalled(current);
+  const next = mod.upsertHookSnippet(current, target.logPath);
   if (next === current) return { changed: false, alreadyInstalled };
   await mkdir2(dirname(target.profilePath), { recursive: true });
   await writeFile2(target.profilePath, next, "utf8");
   return { changed: true, alreadyInstalled };
 }
 async function removeHook(target) {
+  const mod = SHELL_MODULES[target.shell];
   const current = await readProfile(target.profilePath);
-  if (!isHookInstalled(current)) return { changed: false };
-  await writeFile2(target.profilePath, stripHookSnippet(current), "utf8");
+  if (!mod.isHookInstalled(current)) return { changed: false };
+  await writeFile2(target.profilePath, mod.stripHookSnippet(current), "utf8");
   return { changed: true };
 }
 async function hookStatus(target) {
+  const mod = SHELL_MODULES[target.shell];
   const current = await readProfile(target.profilePath);
-  return { installed: isHookInstalled(current) };
+  return { installed: mod.isHookInstalled(current) };
 }
 
 // src/hooks/install-git-precommit.ts
-import { chmod, mkdir as mkdir3, readFile as readFile3, unlink, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname2, join as join4 } from "path";
+import { join as join5 } from "path";
 
-// src/hooks/git-pre-commit.ts
-var MARK_START2 = "# >>> nexusmem precommit hook >>>";
-var MARK_END2 = "# <<< nexusmem precommit hook <<<";
+// src/hooks/git-hook-snippet.ts
 var SHEBANG = "#!/bin/sh";
-function renderHookSnippet2() {
-  return [
-    MARK_START2,
-    "# Runs `nexusmem precheck` before each commit -- advisory only, never",
-    "# blocks a commit on its own (this hook does not pass --strict).",
-    "# Installed by: nexusmem hook git install",
-    "# Remove with:  nexusmem hook git remove",
-    "if command -v nexusmem >/dev/null 2>&1; then",
-    "  nexusmem precheck",
-    "fi",
-    MARK_END2,
-    ""
-  ].join("\n");
-}
-function isHookInstalled2(content) {
-  return content.includes(MARK_START2);
+function isHookInstalled4(content, markers) {
+  return content.includes(markers.markStart);
 }
-function isForeignHook(content) {
-  return content.trim().length > 0 && !isHookInstalled2(content);
+function isForeignHook(content, markers) {
+  return content.trim().length > 0 && !isHookInstalled4(content, markers);
 }
-function stripHookSnippet2(content) {
-  const startIdx = content.indexOf(MARK_START2);
-  const endIdx = content.indexOf(MARK_END2);
+function stripHookSnippet4(content, markers) {
+  const startIdx = content.indexOf(markers.markStart);
+  const endIdx = content.indexOf(markers.markEnd);
   if (startIdx === -1 || endIdx === -1) return content;
-  const afterBlock = content.slice(endIdx + MARK_END2.length).replace(/^\r?\n/, "");
+  const afterBlock = content.slice(endIdx + markers.markEnd.length).replace(/^\r?\n/, "");
   return content.slice(0, startIdx) + afterBlock;
 }
-function upsertHookSnippet2(content) {
-  const stripped = stripHookSnippet2(content).replace(/\s+$/, "");
+function upsertHookSnippet4(content, markers, renderHookSnippet6) {
+  const stripped = stripHookSnippet4(content, markers).replace(/\s+$/, "");
   const prefix = stripped.length > 0 ? `${stripped}
 
 ` : "";
-  return `${prefix}${renderHookSnippet2()}`;
+  return `${prefix}${renderHookSnippet6()}`;
 }
 function ensureShebang(content) {
   if (content.startsWith("#!")) return content;
@@ -654,20 +866,51 @@ ${content}` : `${SHEBANG}
 `;
 }
 
-// src/hooks/install-git-precommit.ts
-var ForeignGitHookError = class extends Error {
-  constructor(hookPath) {
-    super(
-      `${hookPath} already has a pre-commit hook NexusMem did not install. Pass --force to append nexusmem's check to the end of it, or integrate manually.`
-    );
-    this.hookPath = hookPath;
-    this.name = "ForeignGitHookError";
-  }
-  hookPath;
-};
-function resolveGitHookTarget(repoRoot) {
-  return { hookPath: join4(repoRoot, ".git", "hooks", "pre-commit") };
+// src/hooks/git-pre-commit.ts
+var MARK_START4 = "# >>> nexusmem precommit hook >>>";
+var MARK_END4 = "# <<< nexusmem precommit hook <<<";
+var MARKERS = { markStart: MARK_START4, markEnd: MARK_END4 };
+function renderHookSnippet4() {
+  return [
+    MARK_START4,
+    "# Runs `nexusmem precheck` before each commit -- advisory only, never",
+    "# blocks a commit on its own (this hook does not pass --strict).",
+    "# Installed by: nexusmem hook git install",
+    "# Remove with:  nexusmem hook git remove",
+    "if command -v nexusmem >/dev/null 2>&1; then",
+    "  nexusmem precheck",
+    "fi",
+    MARK_END4,
+    ""
+  ].join("\n");
+}
+function isHookInstalled5(content) {
+  return isHookInstalled4(content, MARKERS);
+}
+function isForeignHook2(content) {
+  return isForeignHook(content, MARKERS);
+}
+function stripHookSnippet5(content) {
+  return stripHookSnippet4(content, MARKERS);
 }
+function upsertHookSnippet5(content) {
+  return upsertHookSnippet4(content, MARKERS, renderHookSnippet4);
+}
+var ensureShebang2 = ensureShebang;
+
+// src/hooks/git-hooks-dir.ts
+import { isAbsolute, join as join4, resolve as resolve2 } from "path";
+async function resolveHooksDir(repoRoot) {
+  const raw = await gitOrNull(repoRoot, ["config", "--path", "core.hooksPath"]);
+  const hooksPathConfig = raw?.trim() || null;
+  if (!hooksPathConfig) return { dir: join4(repoRoot, ".git", "hooks"), hooksPathConfig: null };
+  const dir = isAbsolute(hooksPathConfig) ? hooksPathConfig : resolve2(repoRoot, hooksPathConfig);
+  return { dir, hooksPathConfig };
+}
+
+// src/hooks/git-hook-install.ts
+import { chmod, mkdir as mkdir3, readFile as readFile3, unlink, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2 } from "path";
 async function readHook(path) {
   try {
     return await readFile3(path, "utf8");
@@ -675,14 +918,14 @@ async function readHook(path) {
     return "";
   }
 }
-async function installGitHook(target, opts = {}) {
+async function installGitHookGeneric(target, kind, opts = {}) {
   const current = await readHook(target.hookPath);
-  const alreadyInstalled = isHookInstalled2(current);
-  const foreign = isForeignHook(current);
+  const alreadyInstalled = kind.isHookInstalled(current);
+  const foreign = kind.isForeignHook(current);
   if (foreign && !alreadyInstalled && !opts.force) {
-    throw new ForeignGitHookError(target.hookPath);
+    throw kind.createForeignError(target.hookPath);
   }
-  const next = upsertHookSnippet2(ensureShebang(current));
+  const next = kind.upsertHookSnippet(kind.ensureShebang(current));
   if (next === current) return { changed: false, alreadyInstalled, appendedToForeign: false };
   await mkdir3(dirname2(target.hookPath), { recursive: true });
   await writeFile3(target.hookPath, next, "utf8");
@@ -690,11 +933,11 @@ async function installGitHook(target, opts = {}) {
   });
   return { changed: true, alreadyInstalled, appendedToForeign: foreign && !alreadyInstalled };
 }
-async function removeGitHook(target) {
+async function removeGitHookGeneric(target, kind) {
   const current = await readHook(target.hookPath);
-  if (!isHookInstalled2(current)) return { changed: false };
-  const stripped = stripHookSnippet2(current).trim();
-  if (stripped === "" || stripped === SHEBANG) {
+  if (!kind.isHookInstalled(current)) return { changed: false };
+  const stripped = kind.stripHookSnippet(current).trim();
+  if (stripped === "" || stripped === kind.SHEBANG) {
     await unlink(target.hookPath).catch(() => {
     });
   } else {
@@ -703,9 +946,142 @@ async function removeGitHook(target) {
   }
   return { changed: true };
 }
-async function gitHookStatus(target) {
+async function gitHookStatusGeneric(target, kind) {
   const current = await readHook(target.hookPath);
-  return { installed: isHookInstalled2(current), foreign: isForeignHook(current) };
+  return { installed: kind.isHookInstalled(current), foreign: kind.isForeignHook(current) };
+}
+
+// src/hooks/install-git-precommit.ts
+var ForeignGitHookError = class extends Error {
+  constructor(hookPath) {
+    super(
+      `${hookPath} already has a pre-commit hook NexusMem did not install. Pass --force to append nexusmem's check to the end of it, or integrate manually.`
+    );
+    this.hookPath = hookPath;
+    this.name = "ForeignGitHookError";
+  }
+  hookPath;
+};
+var KIND = {
+  isHookInstalled: isHookInstalled5,
+  isForeignHook: isForeignHook2,
+  stripHookSnippet: stripHookSnippet5,
+  upsertHookSnippet: upsertHookSnippet5,
+  ensureShebang: ensureShebang2,
+  SHEBANG,
+  createForeignError: (hookPath) => new ForeignGitHookError(hookPath)
+};
+async function resolveGitHookTarget(repoRoot) {
+  const { dir, hooksPathConfig } = await resolveHooksDir(repoRoot);
+  return { hookPath: join5(dir, "pre-commit"), hooksPathConfig };
+}
+async function installGitHook(target, opts = {}) {
+  return installGitHookGeneric(target, KIND, opts);
+}
+async function removeGitHook(target) {
+  return removeGitHookGeneric(target, KIND);
+}
+async function gitHookStatus(target) {
+  return gitHookStatusGeneric(target, KIND);
+}
+
+// src/hooks/install-git-postcommit.ts
+import { join as join6 } from "path";
+
+// src/hooks/git-post-commit.ts
+var MARK_START5 = "# >>> nexusmem postcommit hook >>>";
+var MARK_END5 = "# <<< nexusmem postcommit hook <<<";
+var MARKERS2 = { markStart: MARK_START5, markEnd: MARK_END5 };
+var LOG_PATH = ".nexusmem/post-commit-sync.log";
+var LOG_TRUNCATE_THRESHOLD = 2e3;
+var STATE_PATH = ".nexusmem/post-commit-sync-state.json";
+function renderHookSnippet5() {
+  return [
+    MARK_START5,
+    "# Runs a full `nexusmem sync` (including embedding) in the background after",
+    "# each commit -- detached, so this never makes `git commit` itself wait.",
+    `# Output goes to ${LOG_PATH} (reset once it passes ${LOG_TRUNCATE_THRESHOLD} lines), not the terminal.`,
+    `# Last-run outcome is also written to ${STATE_PATH} (\`nexusmem status\` reads it).`,
+    "# Installed by: nexusmem hook git-post install",
+    "# Remove with:  nexusmem hook git-post remove",
+    "if command -v nexusmem >/dev/null 2>&1; then",
+    "  mkdir -p .nexusmem",
+    "  nohup sh -c '",
+    `    [ "$(wc -l <${LOG_PATH} 2>/dev/null || echo 0)" -gt ${LOG_TRUNCATE_THRESHOLD} ] && : >${LOG_PATH}`,
+    `    nexusmem sync --quiet --auto >>${LOG_PATH} 2>&1`,
+    "    ec=$?",
+    '    ok=$([ "$ec" -eq 0 ] && echo true || echo false)',
+    // Atomic rename, not truncate-in-place like the log above: this file is
+    // wholesale-replaced each run (no concurrent-appender fd to protect), so
+    // a rename avoids a reader ever seeing a half-written, unparseable JSON file.
+    // Double-quoted, not single: this whole block is already inside the
+    // outer nohup sh -c '...' single-quoted argument below, and single
+    // quotes cannot nest -- one here would close that argument early.
+    `    printf "{\\"ts\\":\\"%s\\",\\"ok\\":%s,\\"exitCode\\":%s}\\n" "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$ok" "$ec" >${STATE_PATH}.tmp && mv ${STATE_PATH}.tmp ${STATE_PATH}`,
+    "  ' >/dev/null 2>&1 &",
+    "fi",
+    MARK_END5,
+    ""
+  ].join("\n");
+}
+function parsePostCommitSyncState(raw) {
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof obj !== "object" || obj === null) return null;
+  const o = obj;
+  if (typeof o.ts !== "string" || typeof o.ok !== "boolean" || typeof o.exitCode !== "number") return null;
+  return { ts: o.ts, ok: o.ok, exitCode: o.exitCode };
+}
+function isHookInstalled6(content) {
+  return isHookInstalled4(content, MARKERS2);
+}
+function isForeignHook3(content) {
+  return isForeignHook(content, MARKERS2);
+}
+function stripHookSnippet6(content) {
+  return stripHookSnippet4(content, MARKERS2);
+}
+function upsertHookSnippet6(content) {
+  return upsertHookSnippet4(content, MARKERS2, renderHookSnippet5);
+}
+var ensureShebang3 = ensureShebang;
+
+// src/hooks/install-git-postcommit.ts
+var ForeignPostCommitHookError = class extends Error {
+  constructor(hookPath) {
+    super(
+      `${hookPath} already has a post-commit hook NexusMem did not install. Pass --force to append nexusmem's sync to the end of it, or integrate manually.`
+    );
+    this.hookPath = hookPath;
+    this.name = "ForeignPostCommitHookError";
+  }
+  hookPath;
+};
+var KIND2 = {
+  isHookInstalled: isHookInstalled6,
+  isForeignHook: isForeignHook3,
+  stripHookSnippet: stripHookSnippet6,
+  upsertHookSnippet: upsertHookSnippet6,
+  ensureShebang: ensureShebang3,
+  SHEBANG,
+  createForeignError: (hookPath) => new ForeignPostCommitHookError(hookPath)
+};
+async function resolvePostCommitHookTarget(repoRoot) {
+  const { dir, hooksPathConfig } = await resolveHooksDir(repoRoot);
+  return { hookPath: join6(dir, "post-commit"), hooksPathConfig };
+}
+async function installPostCommitGitHook(target, opts = {}) {
+  return installGitHookGeneric(target, KIND2, opts);
+}
+async function removePostCommitGitHook(target) {
+  return removeGitHookGeneric(target, KIND2);
+}
+async function postCommitGitHookStatus(target) {
+  return gitHookStatusGeneric(target, KIND2);
 }
 
 // src/store/deny-list.ts
@@ -1037,6 +1413,17 @@ var V12 = `
 ALTER TABLE nodes ADD COLUMN retrieved_count INTEGER NOT NULL DEFAULT 0;
 ALTER TABLE nodes ADD COLUMN last_retrieved_at INTEGER;
 `;
+var V13 = `
+ALTER TABLE nodes ADD COLUMN capture_mode TEXT NOT NULL DEFAULT 'unknown';
+ALTER TABLE nodes ADD COLUMN source_ts TEXT;
+
+UPDATE nodes
+SET source_ts = CASE
+  WHEN kind = 'doc_section' THEN NULL
+  WHEN kind = 'shell_command' AND json_extract(meta, '$.tsApprox') = 1 THEN NULL
+  ELSE ts
+END;
+`;
 var MIGRATIONS = [
   { version: 1, up: (db) => db.exec(V1) },
   { version: 2, up: (db) => db.exec(V2) },
@@ -1049,7 +1436,8 @@ var MIGRATIONS = [
   { version: 9, up: (db) => db.exec(V9) },
   { version: 10, up: (db) => db.exec(V10) },
   { version: 11, up: (db) => db.exec(V11) },
-  { version: 12, up: (db) => db.exec(V12) }
+  { version: 12, up: (db) => db.exec(V12) },
+  { version: 13, up: (db) => db.exec(V13) }
 ];
 var LATEST_SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
 function currentSchemaVersion(db) {
@@ -1159,15 +1547,16 @@ function epochOf(ts) {
   return Number.isNaN(parsed) ? Date.now() : parsed;
 }
 function upsertNodes(db, nodes) {
-  const exists = db.prepare("SELECT body, signal, title FROM nodes WHERE id = ?");
+  const exists = db.prepare("SELECT body, signal, title, capture_mode AS captureMode, source_ts AS sourceTs FROM nodes WHERE id = ?");
+  const projectCreatedAt = db.prepare("SELECT created_at AS createdAt FROM projects WHERE id = ?");
   const dropStaleEmbedding = db.prepare("DELETE FROM nodes_vec WHERE rowid = (SELECT rowid FROM nodes WHERE id = ?)");
   const insertNode = db.prepare(
-    `INSERT INTO nodes (id, kind, project_id, ts, ts_epoch, source, title, body, signal, meta, provenance, supersedes, created_at)
-     VALUES (@id, @kind, @projectId, @ts, @tsEpoch, @source, @title, @body, @signal, @meta, @provenance, @supersedes, @now)
+    `INSERT INTO nodes (id, kind, project_id, ts, ts_epoch, source, title, body, signal, meta, provenance, supersedes, created_at, capture_mode, source_ts)
+     VALUES (@id, @kind, @projectId, @ts, @tsEpoch, @source, @title, @body, @signal, @meta, @provenance, @supersedes, @now, @captureMode, @sourceTs)
      ON CONFLICT(id) DO UPDATE SET
        ts = excluded.ts, ts_epoch = excluded.ts_epoch, source = excluded.source,
        title = excluded.title, body = excluded.body, signal = excluded.signal, meta = excluded.meta,
-       provenance = excluded.provenance`
+       provenance = excluded.provenance, capture_mode = excluded.capture_mode, source_ts = excluded.source_ts`
   );
   const clearFiles = db.prepare("DELETE FROM node_files WHERE node_id = ?");
   const insertFile = db.prepare(
@@ -1179,6 +1568,7 @@ function upsertNodes(db, nodes) {
   );
   const stats2 = { inserted: 0, updated: 0, unchanged: 0, denied: 0 };
   const denyEntriesByProject = /* @__PURE__ */ new Map();
+  const createdAtByProject = /* @__PURE__ */ new Map();
   const run = db.transaction((batch) => {
     const now = Date.now();
     for (const node of batch) {
@@ -1191,14 +1581,28 @@ function upsertNodes(db, nodes) {
         stats2.denied += 1;
         continue;
       }
+      let initializedAt = createdAtByProject.get(node.projectId);
+      if (initializedAt === void 0) {
+        initializedAt = projectCreatedAt.get(node.projectId)?.createdAt ?? null;
+        createdAtByProject.set(node.projectId, initializedAt);
+      }
+      const sourceTs = node.sourceTs === void 0 ? node.ts : node.sourceTs;
+      const sourceEpoch = sourceTs === null ? Number.NaN : Date.parse(sourceTs);
+      let captureMode = "unknown";
+      if (sourceTs !== null && !Number.isNaN(sourceEpoch)) {
+        if (node.captureMode === "backfilled") captureMode = "backfilled";
+        else if (node.captureMode === "unknown") captureMode = "unknown";
+        else if (initializedAt !== null && sourceEpoch < initializedAt) captureMode = "backfilled";
+        else if (initializedAt !== null && sourceEpoch <= now) captureMode = "observed";
+      }
       const prior = exists.get(node.id);
       if (prior) {
-        if (prior.body === node.body && prior.signal === node.signal && prior.title === node.title) {
+        if (prior.body === node.body && prior.signal === node.signal && prior.title === node.title && prior.captureMode === captureMode && prior.sourceTs === sourceTs) {
           stats2.unchanged += 1;
           continue;
         }
         stats2.updated += 1;
-        dropStaleEmbedding.run(node.id);
+        if (prior.body !== node.body || prior.title !== node.title) dropStaleEmbedding.run(node.id);
       } else {
         stats2.inserted += 1;
       }
@@ -1214,6 +1618,8 @@ function upsertNodes(db, nodes) {
         signal: node.signal,
         meta: JSON.stringify(node.meta),
         provenance: node.provenance ?? defaultProvenanceForKind(node.kind),
+        captureMode,
+        sourceTs,
         supersedes: node.supersedes ?? null,
         now
       });
@@ -1251,13 +1657,14 @@ function clearProject(db, projectId) {
 function getNodesByIds(db, ids) {
   if (ids.length === 0) return [];
   return db.prepare(
-    `SELECT id, kind, project_id AS projectId, ts, title, body, signal, provenance, trust_state AS trustState
+    `SELECT id, kind, project_id AS projectId, ts, source_ts AS sourceTs, title, body, signal, provenance,
+              capture_mode AS captureMode, trust_state AS trustState
        FROM nodes WHERE id IN (SELECT value FROM json_each(?))`
   ).all(JSON.stringify(ids));
 }
 function listRecentNodes(db, projectId, limit = 20) {
   return db.prepare(
-    `SELECT id, kind, ts, source, title, signal, provenance
+    `SELECT id, kind, ts, source_ts AS sourceTs, source, title, signal, provenance, capture_mode AS captureMode
        FROM nodes
        WHERE project_id = ?
        ORDER BY ts_epoch DESC
@@ -1536,7 +1943,8 @@ function vectorSearch(db, projectId, embedding, limit = 20, opts = {}) {
   const asOfEpoch = opts.asOfEpoch ?? null;
   const k = asOfEpoch === null ? limit : Math.max(limit * 8, 50);
   return db.prepare(
-    `SELECT n.id, n.kind, n.ts, n.title, n.body, n.signal, n.provenance, n.trust_state AS trustState, v.distance AS distance
+    `SELECT n.id, n.kind, n.ts, n.source_ts AS sourceTs, n.title, n.body, n.signal, n.provenance,
+              n.capture_mode AS captureMode, n.trust_state AS trustState, v.distance AS distance
        FROM nodes_vec v
        JOIN nodes n ON n.rowid = v.rowid
        WHERE v.embedding MATCH ? AND k = ? AND v.project_id = ?
@@ -1567,7 +1975,8 @@ function search(db, projectId, query, limit = 20, opts = {}) {
   if (!match) return [];
   const asOfEpoch = opts.asOfEpoch ?? null;
   const rows = db.prepare(
-    `SELECT n.id, n.kind, n.ts, n.title, n.body, n.signal, n.provenance, n.trust_state AS trustState,
+    `SELECT n.id, n.kind, n.ts, n.source_ts AS sourceTs, n.title, n.body, n.signal, n.provenance,
+              n.capture_mode AS captureMode, n.trust_state AS trustState,
               bm25(nodes_fts, 10.0, 1.0) AS rank
        FROM nodes_fts
        JOIN nodes n ON n.rowid = nodes_fts.rowid
@@ -2071,14 +2480,18 @@ async function runForget(opts) {
 
 // src/cli/commands/hook-git.ts
 import pc2 from "picocolors";
+function hooksPathNote(hooksPathConfig) {
+  return `  ${pc2.dim(`core.hooksPath=${hooksPathConfig}`)}`;
+}
 async function runHookGitInstall(opts) {
   const repo = await readRepoInfo(opts.cwd);
-  const target = resolveGitHookTarget(repo.root);
+  const target = await resolveGitHookTarget(repo.root);
   const result = await installGitHook(target, { force: opts.force });
   const lines = [
     result.changed ? `${pc2.green(result.alreadyInstalled ? "updated" : "installed")} git pre-commit hook` : `${pc2.dim("already up to date")}`,
     `  hook ${target.hookPath}`
   ];
+  if (target.hooksPathConfig) lines.push(hooksPathNote(target.hooksPathConfig));
   if (result.appendedToForeign) {
     lines.push(`  ${pc2.yellow("appended after an existing pre-commit hook -- review")} ${target.hookPath}`);
   }
@@ -2093,7 +2506,7 @@ async function runHookGitInstall(opts) {
 }
 async function runHookGitRemove(opts) {
   const repo = await readRepoInfo(opts.cwd);
-  const target = resolveGitHookTarget(repo.root);
+  const target = await resolveGitHookTarget(repo.root);
   const result = await removeGitHook(target);
   process.stdout.write(
     result.changed ? `${pc2.green("removed")} nexusmem's block from ${target.hookPath}
@@ -2104,26 +2517,91 @@ async function runHookGitRemove(opts) {
 }
 async function runHookGitStatus(opts) {
   const repo = await readRepoInfo(opts.cwd);
-  const target = resolveGitHookTarget(repo.root);
+  const target = await resolveGitHookTarget(repo.root);
   const result = await gitHookStatus(target);
-  const statusLabel = result.installed ? pc2.green("installed") : result.foreign ? pc2.yellow("a foreign hook exists (not nexusmem) -- install --force to append") : pc2.yellow("not installed");
-  process.stdout.write([`${pc2.dim("hook  ")} ${target.hookPath}`, `${pc2.dim("status")} ${statusLabel}`, ""].join("\n"));
+  const statusLabel = result.installed ? pc2.green("installed") : result.foreign ? pc2.yellow("a foreign hook exists (not nexusmem) -- nexusmem hook git install --force to append") : pc2.yellow("not installed");
+  process.stdout.write(
+    [
+      `${pc2.dim("hook  ")} ${target.hookPath}`,
+      `${pc2.dim("status")} ${statusLabel}`,
+      target.hooksPathConfig ? hooksPathNote(target.hooksPathConfig) : "",
+      ""
+    ].filter((line) => line !== "").concat("").join("\n")
+  );
+  return 0;
+}
+async function runHookGitPostInstall(opts) {
+  const repo = await readRepoInfo(opts.cwd);
+  const target = await resolvePostCommitHookTarget(repo.root);
+  const result = await installPostCommitGitHook(target, { force: opts.force });
+  const lines = [
+    result.changed ? `${pc2.green(result.alreadyInstalled ? "updated" : "installed")} git post-commit hook` : `${pc2.dim("already up to date")}`,
+    `  hook ${target.hookPath}`
+  ];
+  if (target.hooksPathConfig) lines.push(hooksPathNote(target.hooksPathConfig));
+  if (result.appendedToForeign) {
+    lines.push(`  ${pc2.yellow("appended after an existing post-commit hook -- review")} ${target.hookPath}`);
+  }
+  lines.push(
+    "",
+    `Runs a full ${pc2.bold("nexusmem sync")} (including embedding) in the background after each commit --`,
+    `detached, so it never makes ${pc2.bold("git commit")} itself wait. Output goes to .nexusmem/post-commit-sync.log.`,
+    `Run ${pc2.bold("nexusmem hook git-post remove")} to undo this.`,
+    ""
+  );
+  process.stdout.write(lines.join("\n"));
+  return 0;
+}
+async function runHookGitPostRemove(opts) {
+  const repo = await readRepoInfo(opts.cwd);
+  const target = await resolvePostCommitHookTarget(repo.root);
+  const result = await removePostCommitGitHook(target);
+  process.stdout.write(
+    result.changed ? `${pc2.green("removed")} nexusmem's block from ${target.hookPath}
+` : `${pc2.dim("nothing to remove")} \u2014 no nexusmem block found in ${target.hookPath}
+`
+  );
+  return 0;
+}
+async function runHookGitPostStatus(opts) {
+  const repo = await readRepoInfo(opts.cwd);
+  const target = await resolvePostCommitHookTarget(repo.root);
+  const result = await postCommitGitHookStatus(target);
+  const statusLabel = result.installed ? pc2.green("installed") : result.foreign ? pc2.yellow("a foreign hook exists (not nexusmem) -- nexusmem hook git-post install --force to append") : pc2.yellow("not installed");
+  process.stdout.write(
+    [
+      `${pc2.dim("hook  ")} ${target.hookPath}`,
+      `${pc2.dim("status")} ${statusLabel}`,
+      target.hooksPathConfig ? hooksPathNote(target.hooksPathConfig) : "",
+      ""
+    ].filter((line) => line !== "").concat("").join("\n")
+  );
   return 0;
 }
 
 // src/cli/commands/hook.ts
 import pc3 from "picocolors";
+function shellCaveats(shell) {
+  if (shell !== "bash") return [];
+  return [
+    `Note: on macOS, Terminal.app opens login shells, which read ~/.bash_profile, not ~/.bashrc --`,
+    `if commands aren't being logged there, source this file from your .bash_profile.`,
+    `Note: if another tool already owns this shell's DEBUG trap, commands won't be logged at all`,
+    `(rather than logged with the wrong exit code) -- check \`nexusmem hook status\` after installing.`
+  ];
+}
 async function runHookInstall(opts) {
-  const target = await resolveHookTarget(opts.profile, opts.logPath);
+  const target = await resolveHookTarget(opts.shell, opts.profile, opts.logPath);
   const result = await installHook(target);
   process.stdout.write(
     [
-      result.changed ? `${pc3.green(result.alreadyInstalled ? "updated" : "installed")} shell hook` : `${pc3.dim("already up to date")}`,
+      result.changed ? `${pc3.green(result.alreadyInstalled ? "updated" : "installed")} shell hook (${target.shell})` : `${pc3.dim("already up to date")}`,
       `  profile ${target.profilePath}`,
       `  log     ${target.logPath}`,
       "",
-      `New commands in any PowerShell session using this profile will now log their timestamp, cwd and exit code.`,
-      `Open a new PowerShell window (or run \`. $PROFILE\`) for it to take effect.`,
+      `New commands in any ${target.shell} session using this profile will now log their timestamp, cwd and exit code.`,
+      target.shell === "pwsh" ? `Open a new PowerShell window (or run \`. $PROFILE\`) for it to take effect.` : `Open a new shell (or run \`. ${target.profilePath}\`) for it to take effect.`,
+      ...shellCaveats(target.shell),
       `Run ${pc3.bold("nexusmem hook remove")} to undo this.`,
       ""
     ].join("\n")
@@ -2131,7 +2609,7 @@ async function runHookInstall(opts) {
   return 0;
 }
 async function runHookRemove(opts) {
-  const target = await resolveHookTarget(opts.profile, opts.logPath);
+  const target = await resolveHookTarget(opts.shell, opts.profile, opts.logPath);
   const result = await removeHook(target);
   process.stdout.write(
     result.changed ? `${pc3.green("removed")} shell hook from ${target.profilePath}
@@ -2141,10 +2619,11 @@ async function runHookRemove(opts) {
   return 0;
 }
 async function runHookStatus(opts) {
-  const target = await resolveHookTarget(opts.profile, opts.logPath);
+  const target = await resolveHookTarget(opts.shell, opts.profile, opts.logPath);
   const result = await hookStatus(target);
   process.stdout.write(
     [
+      `${pc3.dim("shell  ")} ${target.shell}`,
       `${pc3.dim("profile")} ${target.profilePath}`,
       `${pc3.dim("log    ")} ${target.logPath}`,
       `${pc3.dim("status ")} ${result.installed ? pc3.green("installed") : pc3.yellow("not installed")}`,
@@ -2161,7 +2640,7 @@ import pc4 from "picocolors";
 // src/config/registry.ts
 import { existsSync as existsSync2 } from "fs";
 import { mkdir as mkdir4, readFile as readFile5, rename, writeFile as writeFile5 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 import { z as z3 } from "zod";
 var ENTRY_SCHEMA = z3.object({
   projectId: z3.string().min(1),
@@ -2176,7 +2655,7 @@ var REGISTRY_SCHEMA = z3.object({
   projects: z3.array(ENTRY_SCHEMA).default([])
 });
 function registryPath() {
-  return join5(globalWorkspaceDir(), "projects.json");
+  return join7(globalWorkspaceDir(), "projects.json");
 }
 async function readRegistry() {
   let raw;
@@ -2270,10 +2749,10 @@ async function runInit(opts) {
       const result = await installHook(target);
       lines.push(
         "",
-        `${pc4.green(result.changed ? "installed" : "already installed")} shell hook`,
+        `${pc4.green(result.changed ? "installed" : "already installed")} shell hook (${target.shell})`,
         `  profile ${target.profilePath}`,
         `  log     ${target.logPath}`,
-        `  open a new PowerShell window (or run \`. $PROFILE\`) for it to take effect`
+        target.shell === "pwsh" ? `  open a new PowerShell window (or run \`. $PROFILE\`) for it to take effect` : `  open a new shell (or run \`. ${target.profilePath}\`) for it to take effect`
       );
     } catch (err) {
       if (err instanceof ProfileNotFoundError) {
@@ -2401,6 +2880,13 @@ function approxTokens(text) {
 // src/retrieval/pack.ts
 var DEFAULT_SUMMARY_CHARS = 320;
 var NODE_OVERHEAD_TOKENS = 8;
+function renderedLabels(provenance, captureMode, trustState, project) {
+  const labels = [`[${provenance}]`];
+  if (captureMode !== "unknown") labels.push(`[capture:${captureMode}]`);
+  if (trustState !== "candidate") labels.push(`[${trustState}]`);
+  if (project) labels.push(`[${project}]`);
+  return labels.join(" ");
+}
 var CONVERSATION_ANSWER_MARKER = "\n\nA: ";
 var MAX_PER_FAMILY = 2;
 var CHUNKED_KINDS = /* @__PURE__ */ new Set(["conversation_turn", "doc_section", "code_diff"]);
@@ -2531,7 +3017,8 @@ function packContext(ranked, tokensBudget, opts = {}) {
       continue;
     }
     const summary = summarize(hit, summaryChars, query);
-    const tokens = approxTokens(hit.title) + approxTokens(summary) + NODE_OVERHEAD_TOKENS;
+    const captureMode = hit.captureMode ?? "unknown";
+    const tokens = approxTokens(hit.title) + approxTokens(summary) + approxTokens(renderedLabels(hit.provenance, captureMode, hit.trustState, hit.project)) + NODE_OVERHEAD_TOKENS;
     if (tokensUsed + tokens > tokensBudget) {
       droppedForBudget += 1;
       continue;
@@ -2540,12 +3027,14 @@ function packContext(ranked, tokensBudget, opts = {}) {
       id: hit.id,
       kind: hit.kind,
       ts: hit.ts,
+      sourceTs: hit.sourceTs === void 0 ? hit.ts : hit.sourceTs,
       title: hit.title,
       signal: hit.signal,
       score: hit.score,
       summary,
       tokens,
       provenance: hit.provenance,
+      captureMode,
       trustState: hit.trustState,
       ...hit.project ? { project: hit.project } : {}
     });
@@ -2558,10 +3047,9 @@ function renderContextBlock(query, result) {
   if (result.nodes.length === 0) return `No remembered context matched "${query}".`;
   const lines = [`Relevant history for: ${query}`, ""];
   for (const node of result.nodes) {
-    const project = node.project ? `[${node.project}] ` : "";
-    const provenance = `[${node.provenance}] `;
-    const trust = node.trustState !== "candidate" ? `[${node.trustState}] ` : "";
-    lines.push(`- ${node.ts.slice(0, 10)} ${provenance}${trust}${project}${node.title}`);
+    const labels = renderedLabels(node.provenance, node.captureMode, node.trustState, node.project);
+    const date = node.sourceTs === null ? "date unknown" : node.sourceTs.slice(0, 10);
+    lines.push(`- ${date} ${labels} ${node.title}`);
     if (node.summary && node.summary !== node.title) {
       if (node.kind === "code_diff") {
         for (const line of node.summary.split("\n")) lines.push(`  ${line}`);
@@ -2606,13 +3094,17 @@ function correlateFailures(store, projectId, opts = {}) {
     `SELECT id, ts_epoch, json_extract(meta, '$.command') AS command, json_extract(meta, '$.cwd') AS cwd
        FROM nodes
        WHERE project_id = ? AND kind = 'shell_command'
+         AND source_ts IS NOT NULL
          AND json_extract(meta, '$.exitCode') IS NOT NULL
-         AND json_extract(meta, '$.exitCode') != 0`
+         AND json_extract(meta, '$.exitCode') != 0
+         AND json_extract(meta, '$.cwd') IS NOT NULL`
   ).all(projectId);
   const findRetry = db.prepare(
     `SELECT id FROM nodes
      WHERE project_id = ? AND kind = 'shell_command'
+       AND source_ts IS NOT NULL
        AND json_extract(meta, '$.exitCode') = 0
+       AND json_extract(meta, '$.cwd') IS NOT NULL
        AND ts_epoch > ? AND ts_epoch <= ?
        AND lower(trim(json_extract(meta, '$.command'))) = ?
        AND (json_extract(meta, '$.cwd') IS ? OR json_extract(meta, '$.cwd') = ?)
@@ -2695,10 +3187,12 @@ function mergeSearchAndVectorHits(bm25Hits, vectorHits) {
       id: hit.id,
       kind: hit.kind,
       ts: hit.ts,
+      sourceTs: hit.sourceTs === void 0 ? hit.ts : hit.sourceTs,
       title: hit.title,
       body: hit.body,
       signal: hit.signal,
       provenance: hit.provenance,
+      captureMode: hit.captureMode ?? "unknown",
       trustState: hit.trustState,
       rank: 0
     });
@@ -2794,6 +3288,8 @@ function pullLinkedResolutions(resolveStore, ranked) {
           body: resolution.body,
           signal: resolution.signal,
           provenance: resolution.provenance,
+          captureMode: resolution.captureMode ?? "unknown",
+          sourceTs: resolution.sourceTs,
           trustState: resolution.trustState,
           rank: 0,
           // no bm25/vector rank of its own -- never read again past this point
@@ -3676,6 +4172,7 @@ function toMemoryNodes3(file, projectId, opts = {}) {
       kind: "doc_section",
       projectId,
       ts: file.ts,
+      sourceTs: null,
       source: "docs",
       title: sectionTitle(file.path, chunk2.heading, index, chunks.length),
       body: truncate(chunk2.text, maxBody),
@@ -4006,7 +4503,8 @@ function toMemoryNode3(entry, projectId, opts = {}) {
     id: makeNodeId(projectId, "shell_command", entry.naturalKey),
     kind: "shell_command",
     projectId,
-    ts: entry.ts,
+    ts: entry.ts ?? opts.recordedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    sourceTs: entry.ts,
     source: `shell:${entry.shell}`,
     title: truncate(titleLine, MAX_TITLE_CHARS7),
     body: renderBody2(entry, redactedCommand, maxBody),
@@ -4019,12 +4517,23 @@ function toMemoryNode3(entry, projectId, opts = {}) {
       exitCode: entry.exitCode,
       durationMs: entry.durationMs,
       tsApprox: entry.tsApprox,
+      sourceTimestamp: entry.ts,
       shell: entry.shell
     }
   };
 }
 function collectShellHistory(entries, projectId, opts = {}) {
-  return entries.map((entry) => toMemoryNode3(entry, projectId, opts));
+  const recordedAt = opts.recordedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const parsedBaseEpoch = Date.parse(recordedAt);
+  const baseEpoch = Number.isNaN(parsedBaseEpoch) ? Date.now() : parsedBaseEpoch;
+  return entries.map(
+    (entry, index) => toMemoryNode3(entry, projectId, {
+      ...opts,
+      // This is record-time ordering only. The source timestamp stays null,
+      // while increasing milliseconds preserve the history file's order.
+      recordedAt: new Date(baseEpoch + index).toISOString()
+    })
+  );
 }
 
 // src/conversation/claude-code-reader.ts
@@ -4035,18 +4544,18 @@ import { basename as basename2 } from "path";
 import { existsSync as existsSync3 } from "fs";
 import { readdir } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 function claudeProjectSlug(repoRoot) {
   return repoRoot.replace(/[\\/:]/g, "-");
 }
 function claudeProjectTranscriptDir(repoRoot) {
-  return join6(homedir3(), ".claude", "projects", claudeProjectSlug(repoRoot));
+  return join8(homedir3(), ".claude", "projects", claudeProjectSlug(repoRoot));
 }
 async function listTranscriptFiles(repoRoot) {
   const dir = claudeProjectTranscriptDir(repoRoot);
   if (!existsSync3(dir)) return [];
   const entries = await readdir(dir, { withFileTypes: true });
-  return entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join6(dir, e.name));
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join8(dir, e.name));
 }
 
 // src/conversation/claude-code-reader.ts
@@ -4129,7 +4638,7 @@ async function collectClaudeCodeTranscripts(repoRoot) {
 
 // src/docs/read.ts
 import { readFile as readFile7, stat } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 var DEFAULT_PATHSPECS = ["*.md"];
 async function listDocFiles(repoRoot, opts = {}) {
   const pathspecs = opts.include ?? DEFAULT_PATHSPECS;
@@ -4142,7 +4651,7 @@ async function readDocFiles(repoRoot, opts = {}) {
   const unreadable = [];
   for (const relPath of paths) {
     const path = relPath.replace(/\\/g, "/");
-    const absPath = join7(repoRoot, relPath);
+    const absPath = join9(repoRoot, relPath);
     let content;
     let mtime;
     try {
@@ -4360,6 +4869,7 @@ import { readFile as readFile9, stat as stat2 } from "fs/promises";
 // src/shell/hook-log.ts
 import { appendFile, mkdir as mkdir5, readFile as readFile8 } from "fs/promises";
 import { dirname as dirname4 } from "path";
+var HOOK_SHELL_KINDS = /* @__PURE__ */ new Set(["pwsh-hook", "bash-hook", "zsh-hook"]);
 function parseHookLogLine(line) {
   const trimmed = line.trim();
   if (!trimmed) return null;
@@ -4377,7 +4887,8 @@ function parseHookLogLine(line) {
     cwd: o.cwd,
     exitCode: typeof o.exitCode === "number" ? o.exitCode : null,
     durationMs: typeof o.durationMs === "number" ? o.durationMs : null,
-    command: o.command
+    command: o.command,
+    shell: typeof o.shell === "string" && HOOK_SHELL_KINDS.has(o.shell) ? o.shell : void 0
   };
 }
 async function readHookLog(path, fromLine) {
@@ -4385,17 +4896,20 @@ async function readHookLog(path, fromLine) {
   try {
     raw = await readFile8(path, "utf8");
   } catch {
-    return { entries: [], totalLines: fromLine };
+    return { entries: [], totalLines: fromLine, shellsSeen: /* @__PURE__ */ new Set() };
   }
   const lines = raw.split(/\r?\n/).filter((l) => l.length > 0);
-  const slice = fromLine > 0 && fromLine <= lines.length ? lines.slice(fromLine) : lines;
-  const entries = slice.map(parseHookLogLine).filter((e) => e !== null);
-  return { entries, totalLines: lines.length };
+  const allParsed = lines.map(parseHookLogLine);
+  const shellsSeen = /* @__PURE__ */ new Set();
+  for (const e of allParsed) if (e) shellsSeen.add(e.shell ?? "pwsh-hook");
+  const sliceStart = fromLine > 0 && fromLine <= lines.length ? fromLine : 0;
+  const entries = allParsed.slice(sliceStart).filter((e) => e !== null);
+  return { entries, totalLines: lines.length, shellsSeen };
 }
 
 // src/shell/parse-bash.ts
 var EPOCH_COMMENT = /^#(\d{9,10})$/;
-function parseBashHistory(raw, mtimeMs, opts = {}) {
+function parseBashHistory(raw, _mtimeMs, opts = {}) {
   const lines = raw.split(/\r?\n/);
   const prelim = [];
   let pendingEpoch = null;
@@ -4412,12 +4926,11 @@ function parseBashHistory(raw, mtimeMs, opts = {}) {
   const tail = opts.tailLines ? prelim.slice(-opts.tailLines) : prelim;
   const startIndex = prelim.length - tail.length;
   return tail.map((p, i) => {
-    const fromEnd = tail.length - 1 - i;
     const approx = p.ts === null;
     return {
       naturalKey: `bash:${startIndex + i}:${sha256Hex(p.command).slice(0, 12)}`,
       command: p.command,
-      ts: p.ts ?? new Date(mtimeMs - fromEnd * 1e3).toISOString(),
+      ts: p.ts,
       tsApprox: approx,
       exitCode: null,
       cwd: null,
@@ -4428,16 +4941,15 @@ function parseBashHistory(raw, mtimeMs, opts = {}) {
 }
 
 // src/shell/parse-psreadline.ts
-function parsePsReadLineHistory(raw, mtimeMs, opts = {}) {
+function parsePsReadLineHistory(raw, _mtimeMs, opts = {}) {
   const allLines = raw.split(/\r?\n/).filter((l) => l.trim().length > 0);
   const tail = opts.tailLines ? allLines.slice(-opts.tailLines) : allLines;
   const startIndex = allLines.length - tail.length;
   return tail.map((command, i) => {
-    const fromEnd = tail.length - 1 - i;
     return {
       naturalKey: `pwsh:${startIndex + i}:${sha256Hex(command).slice(0, 12)}`,
       command,
-      ts: new Date(mtimeMs - fromEnd * 1e3).toISOString(),
+      ts: null,
       tsApprox: true,
       exitCode: null,
       cwd: null,
@@ -4449,7 +4961,7 @@ function parsePsReadLineHistory(raw, mtimeMs, opts = {}) {
 
 // src/shell/parse-zsh.ts
 var EXTENDED_PREFIX = /^: (\d+):(\d+);(.*)$/;
-function parseZshHistory(raw, mtimeMs, opts = {}) {
+function parseZshHistory(raw, _mtimeMs, opts = {}) {
   const rawLines = raw.split(/\r?\n/);
   const prelim = [];
   let i = 0;
@@ -4481,12 +4993,11 @@ ${rawLines[i]}`;
   const tail = opts.tailLines ? prelim.slice(-opts.tailLines) : prelim;
   const startIndex = prelim.length - tail.length;
   return tail.map((p, idx) => {
-    const fromEnd = tail.length - 1 - idx;
     const approx = p.ts === null;
     return {
       naturalKey: `zsh:${startIndex + idx}:${sha256Hex(p.command).slice(0, 12)}`,
       command: p.command,
-      ts: p.ts ?? new Date(mtimeMs - fromEnd * 1e3).toISOString(),
+      ts: p.ts,
       tsApprox: approx,
       exitCode: null,
       cwd: null,
@@ -4504,15 +5015,16 @@ function isUnderRoot(cwd, root) {
   return c === r || c.startsWith(`${r}/`);
 }
 function hookEntryToRaw(e) {
+  const shell = e.shell ?? "pwsh-hook";
   return {
-    naturalKey: `pwsh-hook:${e.ts}:${sha256Hex(e.command).slice(0, 12)}`,
+    naturalKey: `${shell}:${e.ts}:${sha256Hex(e.command).slice(0, 12)}`,
     command: e.command,
     ts: e.ts,
     tsApprox: false,
     exitCode: e.exitCode,
     cwd: e.cwd,
     durationMs: e.durationMs,
-    shell: "pwsh-hook"
+    shell
   };
 }
 async function tryReadScrapeSource(path, parse, tailLines) {
@@ -4526,21 +5038,29 @@ async function collectAvailableShellHistory(opts = {}) {
   const preferHook = opts.preferHook ?? true;
   const hookPath = hookLogPath();
   const hookExists = existsSync4(hookPath);
+  let shellsSeen = /* @__PURE__ */ new Set();
   if (hookExists) {
     const fromLine = Number(opts.hookCursor ?? "0") || 0;
-    const { entries, totalLines } = await readHookLog(hookPath, fromLine);
+    const { entries, totalLines, shellsSeen: seen } = await readHookLog(hookPath, fromLine);
+    shellsSeen = seen;
     const scoped = opts.repoRoot ? entries.filter((e) => isUnderRoot(e.cwd, opts.repoRoot)) : entries;
     results.push({ name: "pwsh-hook", entries: scoped.map(hookEntryToRaw), cursorAfter: String(totalLines) });
   }
-  const skipPwshScrape = preferHook && hookExists;
+  const skipPwshScrape = preferHook && shellsSeen.has("pwsh-hook");
   if (!skipPwshScrape && process.platform === "win32") {
     const entries = await tryReadScrapeSource(psReadLineHistoryPath(), parsePsReadLineHistory, tailLines);
     if (entries) results.push({ name: "pwsh", entries });
   }
-  const bashEntries = await tryReadScrapeSource(bashHistoryPath(), parseBashHistory, tailLines);
-  if (bashEntries) results.push({ name: "bash", entries: bashEntries });
-  const zshEntries = await tryReadScrapeSource(zshHistoryPath(), parseZshHistory, tailLines);
-  if (zshEntries) results.push({ name: "zsh", entries: zshEntries });
+  const skipBashScrape = preferHook && shellsSeen.has("bash-hook");
+  if (!skipBashScrape) {
+    const bashEntries = await tryReadScrapeSource(bashHistoryPath(), parseBashHistory, tailLines);
+    if (bashEntries) results.push({ name: "bash", entries: bashEntries });
+  }
+  const skipZshScrape = preferHook && shellsSeen.has("zsh-hook");
+  if (!skipZshScrape) {
+    const zshEntries = await tryReadScrapeSource(zshHistoryPath(), parseZshHistory, tailLines);
+    if (zshEntries) results.push({ name: "zsh", entries: zshEntries });
+  }
   return results;
 }
 
@@ -4549,8 +5069,8 @@ function recomputeByNaturalKey(db, oldProjectId, newProjectId, kind, source, com
   const rows = source ? db.prepare("SELECT * FROM nodes WHERE project_id = ? AND kind = ? AND source = ?").all(oldProjectId, kind, source) : db.prepare("SELECT * FROM nodes WHERE project_id = ? AND kind = ?").all(oldProjectId, kind);
   const nodeExists = db.prepare("SELECT 1 FROM nodes WHERE id = ?");
   const insertNode = db.prepare(
-    `INSERT INTO nodes (id, kind, project_id, ts, ts_epoch, source, title, body, signal, meta, created_at)
-     VALUES (@id, @kind, @projectId, @ts, @tsEpoch, @source, @title, @body, @signal, @meta, @createdAt)`
+    `INSERT INTO nodes (id, kind, project_id, ts, ts_epoch, source, title, body, signal, meta, created_at, capture_mode, source_ts)
+     VALUES (@id, @kind, @projectId, @ts, @tsEpoch, @source, @title, @body, @signal, @meta, @createdAt, @captureMode, @sourceTs)`
   );
   const readFiles = db.prepare("SELECT path, previous_path, insertions, deletions, is_binary FROM node_files WHERE node_id = ?");
   const insertFile = db.prepare(
@@ -4597,7 +5117,9 @@ function recomputeByNaturalKey(db, oldProjectId, newProjectId, kind, source, com
         body: row.body,
         signal: row.signal,
         meta: row.meta,
-        createdAt: row.created_at
+        createdAt: row.created_at,
+        captureMode: row.capture_mode,
+        sourceTs: row.source_ts
       });
       for (const file of readFiles.all(row.id)) {
         insertFile.run({
@@ -4628,15 +5150,27 @@ function reconcileProjectId(db, oldProjectId, newProjectId) {
       (_row, meta) => typeof meta.sessionKey === "string" ? meta.sessionKey : null,
       denyEntries
     );
-    const hookShell = recomputeByNaturalKey(
-      db,
-      oldProjectId,
-      newProjectId,
-      "shell_command",
-      "shell:pwsh-hook",
-      (row, meta) => typeof meta.command === "string" ? `pwsh-hook:${row.ts}:${sha256Hex(meta.command).slice(0, 12)}` : null,
-      denyEntries
-    );
+    const HOOK_SHELL_SOURCES = [
+      { source: "shell:pwsh-hook", prefix: "pwsh-hook" },
+      { source: "shell:bash-hook", prefix: "bash-hook" },
+      { source: "shell:zsh-hook", prefix: "zsh-hook" }
+    ];
+    const hookShell = { migrated: 0, deduped: 0, skipped: 0, denied: 0 };
+    for (const { source, prefix } of HOOK_SHELL_SOURCES) {
+      const r = recomputeByNaturalKey(
+        db,
+        oldProjectId,
+        newProjectId,
+        "shell_command",
+        source,
+        (row, meta) => typeof meta.command === "string" ? `${prefix}:${row.ts}:${sha256Hex(meta.command).slice(0, 12)}` : null,
+        denyEntries
+      );
+      hookShell.migrated += r.migrated;
+      hookShell.deduped += r.deduped;
+      hookShell.skipped += r.skipped;
+      hookShell.denied += r.denied;
+    }
     let deniedConversationTurns = 0;
     if (denyEntries.length > 0) {
       const conversationTurns = db.prepare(`SELECT id, title, body, meta FROM nodes WHERE project_id = ? AND kind = 'conversation_turn'`).all(oldProjectId);
@@ -4672,7 +5206,7 @@ function reconcileProjectId(db, oldProjectId, newProjectId) {
 
 // src/structure/collect.ts
 import { readFile as readFile10 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 
 // src/structure/extract.ts
 var IMPORT_PATTERNS = [
@@ -5111,7 +5645,7 @@ async function collectFileEdges(repoRoot) {
   const trackedPaths = new Set(paths);
   let goModulePath = null;
   try {
-    goModulePath = parseGoModulePath(await readFile10(join8(repoRoot, "go.mod"), "utf8"));
+    goModulePath = parseGoModulePath(await readFile10(join10(repoRoot, "go.mod"), "utf8"));
   } catch {
     goModulePath = null;
   }
@@ -5121,7 +5655,7 @@ async function collectFileEdges(repoRoot) {
   for (const path of paths) {
     let content;
     try {
-      content = await readFile10(join8(repoRoot, path), "utf8");
+      content = await readFile10(join10(repoRoot, path), "utf8");
     } catch {
       unreadable.push(path);
       continue;
@@ -5210,6 +5744,52 @@ ${node.body}`)
   };
 }
 
+// src/cli/sync-lock.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { join as join11 } from "path";
+function lockPath(wsDir) {
+  return join11(wsDir, "sync.lock");
+}
+function readOwner(path) {
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    const pid = parsed?.pid;
+    return typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+function acquireSyncLock(wsDir) {
+  mkdirSync2(wsDir, { recursive: true });
+  const path = lockPath(wsDir);
+  for (; ; ) {
+    try {
+      writeFileSync(path, `${JSON.stringify({ pid: process.pid })}
+`, { flag: "wx" });
+      return { release: () => tryUnlink(path) };
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+    const owner = readOwner(path);
+    if (owner && isPidAlive(owner.pid)) return null;
+    tryUnlink(path);
+  }
+}
+function tryUnlink(path) {
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+}
+
 // src/cli/commands/sync.ts
 var BATCH_SIZE = 500;
 var PROGRESS_THRESHOLD = 200;
@@ -5526,6 +6106,15 @@ async function runSync(opts) {
 `);
   };
   const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
+  let lock = null;
+  if (opts.auto) {
+    lock = acquireSyncLock(ws.dir);
+    if (!lock) {
+      out(`${pc7.dim("auto-sync")} another sync is already running for this project -- skipping
+`);
+      return 0;
+    }
+  }
   const store = MemoryStore.open(ws.dbPath);
   const started = Date.now();
   try {
@@ -5635,6 +6224,7 @@ async function runSync(opts) {
     return 0;
   } finally {
     store.close();
+    lock?.release();
   }
 }
 
@@ -6529,10 +7119,11 @@ async function runScanShell(opts) {
   return 0;
 }
 function formatNode6(node) {
-  const approx = node.meta.tsApprox ? pc18.dim("~") : " ";
+  const sourceTimestamp = typeof node.meta.sourceTimestamp === "string" ? node.meta.sourceTimestamp : null;
+  const timestamp = sourceTimestamp ? sourceTimestamp.slice(0, 16).replace("T", " ") : pc18.dim("unknown");
   const exit = node.meta.exitCode;
   const exitLabel = typeof exit === "number" && exit !== 0 ? pc18.red(`exit ${exit}`) : "";
-  return [formatSignal(node.signal, SHELL_SIGNAL_BANDS), approx + node.ts.slice(0, 16).replace("T", " "), node.title, exitLabel].filter(Boolean).join(" ");
+  return [formatSignal(node.signal, SHELL_SIGNAL_BANDS), timestamp, node.title, exitLabel].filter(Boolean).join(" ");
 }
 
 // src/cli/commands/scan-structure.ts
@@ -6622,8 +7213,9 @@ async function runStale(opts) {
 }
 
 // src/cli/commands/status.ts
-import { basename as basename4 } from "path";
+import { basename as basename4, join as join12 } from "path";
 import { statSync } from "fs";
+import { readFile as readFile11 } from "fs/promises";
 import pc21 from "picocolors";
 function daySpan(oldest, newest) {
   const oldestDay = Date.parse(oldest.slice(0, 10));
@@ -6663,6 +7255,32 @@ function fileSize(path) {
     return 0;
   }
 }
+function relativeTime(fromMs, nowMs) {
+  const diffSec = Math.max(0, Math.round((nowMs - fromMs) / 1e3));
+  if (diffSec < 60) return `${diffSec} second${diffSec === 1 ? "" : "s"} ago`;
+  const diffMin = Math.round(diffSec / 60);
+  if (diffMin < 60) return `${diffMin} minute${diffMin === 1 ? "" : "s"} ago`;
+  const diffHour = Math.round(diffMin / 60);
+  if (diffHour < 24) return `${diffHour} hour${diffHour === 1 ? "" : "s"} ago`;
+  const diffDay = Math.round(diffHour / 24);
+  return `${diffDay} day${diffDay === 1 ? "" : "s"} ago`;
+}
+async function getShellHookStatus(injected) {
+  try {
+    const target = injected ?? await resolveHookTarget();
+    return { shell: target.shell, installed: (await hookStatus(target)).installed };
+  } catch {
+    return null;
+  }
+}
+async function readLastAutoSync(repoRoot) {
+  try {
+    const raw = await readFile11(join12(repoRoot, STATE_PATH), "utf8");
+    return parsePostCommitSyncState(raw);
+  } catch {
+    return null;
+  }
+}
 async function runStatus(opts) {
   const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
   const { repo, ws, projectId } = await loadContext(opts.cwd);
@@ -6682,6 +7300,27 @@ async function runStatus(opts) {
     const structure = store.fileEdgeStats(projectId);
     const staleCount = store.countStaleCandidates(projectId);
     const flaggedCount = store.countContradictionSuggestions(projectId);
+    const [shellHook, preCommitTarget, postCommitTarget, lastAutoSync] = await Promise.all([
+      getShellHookStatus(opts.shellHookTarget),
+      resolveGitHookTarget(repo.root),
+      resolvePostCommitHookTarget(repo.root),
+      readLastAutoSync(repo.root)
+    ]);
+    const [preCommitStatus, postCommitStatus] = await Promise.all([
+      gitHookStatus(preCommitTarget),
+      postCommitGitHookStatus(postCommitTarget)
+    ]);
+    const now = (opts.now ?? Date.now)();
+    const hooksPathNote2 = (target) => target.hooksPathConfig ? pc21.dim(` (core.hooksPath=${target.hooksPathConfig})`) : "";
+    const installedLabel = (installed) => installed ? pc21.green("installed") : pc21.yellow("not installed");
+    const lastAutoSyncLabel = lastAutoSync ? `${lastAutoSync.ok ? pc21.green("ok") : pc21.red(`FAILED (exit ${lastAutoSync.exitCode})`)} ${pc21.dim(relativeTime(Date.parse(lastAutoSync.ts), now))}` : postCommitStatus.installed ? pc21.dim("never (or hook predates this field -- reinstall with `nexusmem hook git-post install`)") : pc21.dim("n/a -- hook not installed");
+    const hooksLines = [
+      pc21.dim("hooks"),
+      `    ${pc21.dim(`shell (${shellHook?.shell ?? "?"})`.padEnd(23))} ${shellHook ? installedLabel(shellHook.installed) : pc21.dim("unknown -- could not detect this machine\u2019s shell profile")}`,
+      `    ${pc21.dim("git pre-commit".padEnd(23))} ${installedLabel(preCommitStatus.installed)}${hooksPathNote2(preCommitTarget)}`,
+      `    ${pc21.dim("git post-commit".padEnd(23))} ${installedLabel(postCommitStatus.installed)}${hooksPathNote2(postCommitTarget)}`,
+      `    ${pc21.dim("last auto-sync".padEnd(23))} ${lastAutoSyncLabel}`
+    ];
     const dbBytes = fileSize(ws.dbPath) + fileSize(`${ws.dbPath}-wal`);
     const kinds = Object.entries(stats2.byKind).sort((a, b) => b[1] - a[1]).map(([kind, n]) => `    ${String(n).padStart(6)}  ${kind}`);
     const staleProjectWarning = otherProjectIds.length ? `${pc21.yellow("stale   ")} ${otherProjectIds.length} prior project ${otherProjectIds.length === 1 ? "identity holds" : "identities hold"} ${otherProjectNodes} node(s) \u2014 run ${pc21.bold(
@@ -6711,7 +7350,9 @@ async function runStatus(opts) {
         chains.failuresTotal ? `${pc21.dim("chains  ")} ${pc21.bold(String(chains.resolvedTotal))}/${chains.failuresTotal} failure(s) resolved ${pc21.dim(`(${chains.resolvedByRetry} retry, ${chains.resolvedByDiscussion} discussion)`)}${chains.resolvedTotal < chains.failuresTotal ? ` \u2014 run ${pc21.bold("nexusmem sync --link-failures")} to link more` : ""}` : "",
         structure.edges ? `${pc21.dim("structure")} ${pc21.bold(String(structure.edges))} import edge(s) across ${structure.files} file(s)` : "",
         staleCount ? `${pc21.dim("aging   ")} ${pc21.bold(String(staleCount))} unconfirmed node(s) worth a look \u2014 run ${pc21.bold("nexusmem stale")}` : "",
-        flaggedCount ? `${pc21.dim("flagged ")} ${pc21.bold(String(flaggedCount))} likely-superseded node(s) awaiting review \u2014 run ${pc21.bold("nexusmem stale")} for detail` : ""
+        flaggedCount ? `${pc21.dim("flagged ")} ${pc21.bold(String(flaggedCount))} likely-superseded node(s) awaiting review \u2014 run ${pc21.bold("nexusmem stale")} for detail` : "",
+        "",
+        ...hooksLines
       ].filter((line) => line !== "").join("\n").concat("\n")
     );
     return 0;
@@ -6726,7 +7367,7 @@ function isExpected(err) {
   // the user fixes, not stack traces they debug.
   err instanceof GitSpawnError || // Survived every retry, so git is genuinely unstable on this machine
   // (antivirus, a bad install). Actionable, and not our stack to print.
-  err instanceof GitCrashError || err instanceof ConfigError || err instanceof ProfileNotFoundError || err instanceof ForeignGitHookError || err instanceof DenyListError || err instanceof MarkStaleError || err instanceof QueryError || err instanceof ReviewError;
+  err instanceof GitCrashError || err instanceof ConfigError || err instanceof ProfileNotFoundError || err instanceof ForeignGitHookError || err instanceof ForeignPostCommitHookError || err instanceof DenyListError || err instanceof MarkStaleError || err instanceof QueryError || err instanceof ReviewError;
 }
 function guard(run) {
   return async () => {
@@ -6762,7 +7403,11 @@ program.command("sync").description("Ingest new history into the local database"
   "--link-failures",
   "opt-in (experimental): after ingest, link failed shell commands to whatever later resolved them",
   false
-).option("-q, --quiet", "only print the final summary", false).action(
+).option("-q, --quiet", "only print the final summary", false).option(
+  "--auto",
+  "used by the post-commit hook: skip (instead of running) if another --auto sync already holds this project's lock -- a manually-run sync never checks it",
+  false
+).action(
   (options) => guard(
     () => runSync({
       cwd: options.cwd,
@@ -6778,16 +7423,21 @@ program.command("sync").description("Ingest new history into the local database"
       pruneStaleShell: options.pruneStaleShell,
       yes: options.yes,
       linkFailures: options.linkFailures,
-      quiet: options.quiet
+      quiet: options.quiet,
+      auto: options.auto
     })
   )()
 );
-program.command("hook").description("Manage the opt-in PowerShell hook that logs cwd + exit code + timestamp").addCommand(
-  new Command("install").description("Install (or update) the hook in your PowerShell profile").option("--profile <path>", "override the auto-detected $PROFILE path").action((options) => guard(() => runHookInstall({ profile: options.profile }))())
+var SHELL_CHOICES = ["pwsh", "bash", "zsh"];
+function shellOption() {
+  return new Option("--shell <kind>", "pwsh, bash, or zsh -- default: auto-detected from platform/$SHELL").choices(SHELL_CHOICES);
+}
+program.command("hook").description("Manage the opt-in shell hook that logs cwd + exit code + timestamp").addCommand(
+  new Command("install").description("Install (or update) the hook in your shell profile").addOption(shellOption()).option("--profile <path>", "override the auto-detected profile path").action((options) => guard(() => runHookInstall({ shell: options.shell, profile: options.profile }))())
 ).addCommand(
-  new Command("remove").description("Remove the hook block from your PowerShell profile").option("--profile <path>", "override the auto-detected $PROFILE path").action((options) => guard(() => runHookRemove({ profile: options.profile }))())
+  new Command("remove").description("Remove the hook block from your shell profile").addOption(shellOption()).option("--profile <path>", "override the auto-detected profile path").action((options) => guard(() => runHookRemove({ shell: options.shell, profile: options.profile }))())
 ).addCommand(
-  new Command("status").description("Show whether the hook is installed").option("--profile <path>", "override the auto-detected $PROFILE path").action((options) => guard(() => runHookStatus({ profile: options.profile }))())
+  new Command("status").description("Show whether the hook is installed").addOption(shellOption()).option("--profile <path>", "override the auto-detected profile path").action((options) => guard(() => runHookStatus({ shell: options.shell, profile: options.profile }))())
 ).addCommand(
   new Command("git").description("Manage the opt-in git pre-commit hook that runs `nexusmem precheck` before each commit").addCommand(
     new Command("install").description("Install (or update) the hook in .git/hooks/pre-commit").option("-C, --cwd <path>", "repository path", process.cwd()).option("--force", "append after an existing foreign pre-commit hook instead of refusing", false).action((options) => guard(() => runHookGitInstall({ cwd: options.cwd, force: options.force }))())
@@ -6796,6 +7446,14 @@ program.command("hook").description("Manage the opt-in PowerShell hook that logs
   ).addCommand(
     new Command("status").description("Show whether the git pre-commit hook is installed").option("-C, --cwd <path>", "repository path", process.cwd()).action((options) => guard(() => runHookGitStatus({ cwd: options.cwd }))())
   )
+).addCommand(
+  new Command("git-post").description("Manage the opt-in git post-commit hook that runs a full `nexusmem sync` (with embedding) after each commit").addCommand(
+    new Command("install").description("Install (or update) the hook in .git/hooks/post-commit").option("-C, --cwd <path>", "repository path", process.cwd()).option("--force", "append after an existing foreign post-commit hook instead of refusing", false).action((options) => guard(() => runHookGitPostInstall({ cwd: options.cwd, force: options.force }))())
+  ).addCommand(
+    new Command("remove").description("Remove nexusmem's block from .git/hooks/post-commit").option("-C, --cwd <path>", "repository path", process.cwd()).action((options) => guard(() => runHookGitPostRemove({ cwd: options.cwd }))())
+  ).addCommand(
+    new Command("status").description("Show whether the git post-commit hook is installed").option("-C, --cwd <path>", "repository path", process.cwd()).action((options) => guard(() => runHookGitPostStatus({ cwd: options.cwd }))())
+  )
 );
 program.command("status").description("Show what is currently remembered for this repository").option("-C, --cwd <path>", "repository path", process.cwd()).option("--share", "print a plain-text summary formatted for sharing, e.g. on X or Reddit").action((options) => guard(() => runStatus({ cwd: options.cwd, share: options.share }))());
 program.command("query").description("Search remembered history and print a token-budgeted context block").argument("<text>", "free-text query").option("-C, --cwd <path>", "repository path", process.cwd()).option("-b, --budget <tokens>", "max tokens in the packed context", (v) => Number.parseInt(v, 10), 2e3).option("-n, --candidates <count>", "how many search hits to rank before packing", (v) => Number.parseInt(v, 10), 30).option("--half-life <days>", "days for a node's recency weight to halve", (v) => Number.parseFloat(v)).option("--no-vector", "BM25 only -- skip embedding the query and vector search").option("-a, --all-projects", "search every registered repository, not just this one", false).option("--as-of <date>", 'bi-temporal read: only nodes recorded at or before this date -- "what did the store hold then", not "what happened then"').option("--json", "emit the packed result as JSON on stdout", false).action(