nexusmem 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,2686 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import pc11 from "picocolors";
+
+// src/config/workspace.ts
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { z } from "zod";
+var WORKSPACE_DIR = ".nexusmem";
+function resolveWorkspace(repoRoot) {
+  const dir = join(repoRoot, WORKSPACE_DIR);
+  return {
+    root: repoRoot,
+    dir,
+    dbPath: join(dir, "memory.db"),
+    configPath: join(dir, "config.json")
+  };
+}
+function isInitialized(ws) {
+  return existsSync(ws.configPath);
+}
+var ConfigSchema = z.object({
+  version: z.literal(1),
+  projectId: z.string().min(1),
+  sources: z.object({
+    git: z.object({
+      enabled: z.boolean().default(true),
+      /** Git date expression bounding how far back to ingest; null = all history. */
+      since: z.string().nullable().default(null),
+      includeMerges: z.boolean().default(true)
+    }).default({ enabled: true, since: null, includeMerges: true }),
+    shell: z.object({
+      enabled: z.boolean().default(true),
+      /** Lines kept from scrape-based (no-hook) history files each sync. */
+      tailLines: z.number().int().positive().default(300)
+    }).default({ enabled: true, tailLines: 300 }),
+    /**
+     * Opt-in, unlike git/shell: conversation transcripts are the source
+     * most likely to contain something sensitive (a pasted credential,
+     * confidential discussion), so this must be a deliberate choice, not
+     * an automatic default. See docs/phase-2-spec.md.
+     */
+    conversation: z.object({
+      enabled: z.boolean().default(false)
+    }).default({ enabled: false }),
+    /** Tracked `.md` files -- README, architecture docs. On by default like git/shell: no secrets risk, just project prose. */
+    docs: z.object({
+      enabled: z.boolean().default(true),
+      /** git pathspecs passed to `git ls-files`. */
+      include: z.array(z.string()).default(["*.md"])
+    }).default({ enabled: true, include: ["*.md"] })
+  }).default({
+    git: { enabled: true, since: null, includeMerges: true },
+    shell: { enabled: true, tailLines: 300 },
+    conversation: { enabled: false },
+    docs: { enabled: true, include: ["*.md"] }
+  }),
+  limits: z.object({
+    maxFilesPerNode: z.number().int().positive().default(40),
+    maxBodyChars: z.number().int().positive().default(4e3)
+  }).default({ maxFilesPerNode: 40, maxBodyChars: 4e3 })
+});
+function defaultConfig(projectId) {
+  return ConfigSchema.parse({ version: 1, projectId });
+}
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+async function readConfig(ws) {
+  let raw;
+  try {
+    raw = await readFile(ws.configPath, "utf8");
+  } catch {
+    throw new ConfigError(`Not initialized: ${ws.configPath} not found. Run \`nexusmem init\` first.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new ConfigError(`${ws.configPath} is not valid JSON: ${err.message}`);
+  }
+  const result = ConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
+    throw new ConfigError(`${ws.configPath} is invalid:
+${issues}`);
+  }
+  return result.data;
+}
+async function writeConfig(ws, config) {
+  await mkdir(ws.dir, { recursive: true });
+  await writeFile(ws.configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+async function writeWorkspaceGitignore(ws) {
+  await mkdir(ws.dir, { recursive: true });
+  await writeFile(join(ws.dir, ".gitignore"), "# Machine-local derived data.\n*\n", "utf8");
+}
+
+// src/git/exec.ts
+import { spawn } from "child_process";
+var GitError = class extends Error {
+  constructor(message, args, exitCode, stderr) {
+    super(message);
+    this.args = args;
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+    this.name = "GitError";
+  }
+  args;
+  exitCode;
+  stderr;
+};
+var GitSpawnError = class extends Error {
+  constructor(message, args, code, transient, cause) {
+    super(message);
+    this.args = args;
+    this.code = code;
+    this.transient = transient;
+    this.cause = cause;
+    this.name = "GitSpawnError";
+  }
+  args;
+  code;
+  transient;
+  cause;
+};
+var GitCrashError = class extends Error {
+  constructor(message, args, status, exitCode, signal) {
+    super(message);
+    this.args = args;
+    this.status = status;
+    this.exitCode = exitCode;
+    this.signal = signal;
+    this.name = "GitCrashError";
+  }
+  args;
+  status;
+  exitCode;
+  signal;
+};
+var NTSTATUS_FAILURE_BASE = 3221225472;
+var STATUS_CONTROL_C_EXIT = 3221225786;
+var FATAL_SIGNALS = /* @__PURE__ */ new Set(["SIGSEGV", "SIGBUS", "SIGABRT", "SIGILL", "SIGFPE"]);
+function crashStatus(code, signal) {
+  if (signal) return FATAL_SIGNALS.has(signal) ? signal : null;
+  if (code >= NTSTATUS_FAILURE_BASE && code !== STATUS_CONTROL_C_EXIT) {
+    return `0x${code.toString(16).toUpperCase()}`;
+  }
+  return null;
+}
+var TRANSIENT_SPAWN_CODES = /* @__PURE__ */ new Set(["EAGAIN", "EPERM", "EACCES", "EMFILE", "ENFILE", "ENOMEM", "EBUSY", "ETXTBSY"]);
+function toSpawnError(err, cwd, args) {
+  const code = err?.code;
+  if (code === "ENOENT") {
+    return new GitSpawnError(
+      `Could not run git: either git is not on PATH, or the directory does not exist: ${cwd}`,
+      args,
+      code,
+      false,
+      err
+    );
+  }
+  const transient = code !== void 0 && TRANSIENT_SPAWN_CODES.has(code);
+  const suffix = transient ? " This is usually transient on Windows -- retrying the same command often succeeds." : "";
+  return new GitSpawnError(
+    `Could not start git (${code ?? "unknown spawn failure"}) in ${cwd}.${suffix}`,
+    args,
+    code,
+    transient,
+    err
+  );
+}
+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));
+async function* gitStream(cwd, args, opts = {}) {
+  const sleep = opts.sleep ?? realSleep;
+  for (let attempt = 0; ; attempt += 1) {
+    let produced = false;
+    try {
+      for await (const chunk of runGitOnce(cwd, args, opts)) {
+        produced = true;
+        yield chunk;
+      }
+      return;
+    } catch (err) {
+      const retryable = err instanceof GitSpawnError && err.transient || err instanceof GitCrashError;
+      if (produced || !retryable || attempt >= RETRY_DELAYS_MS.length) throw err;
+      await sleep(RETRY_DELAYS_MS[attempt]);
+    }
+  }
+}
+async function* runGitOnce(cwd, args, opts) {
+  const fullArgs = [...BASE_ARGS, ...args];
+  const child = (opts.spawn ?? spawn)("git", fullArgs, { cwd, windowsHide: true });
+  child.stdout.setEncoding("utf8");
+  child.stderr.setEncoding("utf8");
+  let stderr = "";
+  child.stderr.on("data", (chunk) => {
+    if (stderr.length < 64 * 1024) stderr += chunk;
+  });
+  const exited = new Promise((resolve2, reject) => {
+    child.once("error", (err) => reject(toSpawnError(err, cwd, fullArgs)));
+    child.once("close", (code2, signal2) => resolve2({ code: code2 ?? 0, signal: signal2 ?? null }));
+  });
+  exited.catch(() => {
+  });
+  try {
+    for await (const chunk of child.stdout) {
+      yield chunk;
+    }
+  } finally {
+    if (child.exitCode === null) child.kill();
+  }
+  const { code, signal } = await exited;
+  const crash = crashStatus(code, signal);
+  if (crash) {
+    throw new GitCrashError(
+      `git ${args.join(" ")} was killed before it could answer (${crash}) in ${cwd}. This is an environment fault, not a problem with the repository.`,
+      fullArgs,
+      crash,
+      code,
+      signal
+    );
+  }
+  if (code !== 0) {
+    const trimmed = stderr.trim();
+    const detail = trimmed.split("\n")[0];
+    throw new GitError(
+      `git ${args.join(" ")} exited with code ${code}${detail ? `: ${detail}` : ""}`,
+      fullArgs,
+      code,
+      trimmed
+    );
+  }
+}
+async function git(cwd, args, opts = {}) {
+  let out = "";
+  for await (const chunk of gitStream(cwd, args, opts)) out += chunk;
+  return out;
+}
+async function gitOrNull(cwd, args, opts = {}) {
+  try {
+    return await git(cwd, args, opts);
+  } catch (err) {
+    if (err instanceof GitError) return null;
+    throw err;
+  }
+}
+
+// src/git/repo.ts
+import { resolve } from "path";
+var NotAGitRepositoryError = class extends Error {
+  constructor(cwd) {
+    super(`Not a git repository: ${cwd}`);
+    this.cwd = cwd;
+    this.name = "NotAGitRepositoryError";
+  }
+  cwd;
+};
+var NOT_A_REPO = /not a git repository/i;
+async function isAncestor(cwd, ancestor, descendant) {
+  try {
+    await git(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]);
+    return true;
+  } catch (err) {
+    if (err instanceof GitError) return false;
+    throw err;
+  }
+}
+async function readRepoInfo(cwd) {
+  let rootRaw;
+  try {
+    rootRaw = await git(cwd, ["rev-parse", "--show-toplevel"]);
+  } catch (err) {
+    if (err instanceof GitError && NOT_A_REPO.test(err.stderr)) {
+      throw new NotAGitRepositoryError(cwd);
+    }
+    throw err;
+  }
+  const root = resolve(rootRaw.trim());
+  const [branchRaw, headRaw, originRaw] = await Promise.all([
+    gitOrNull(root, ["rev-parse", "--abbrev-ref", "HEAD"]),
+    gitOrNull(root, ["rev-parse", "HEAD"]),
+    gitOrNull(root, ["remote", "get-url", "origin"])
+  ]);
+  const branch = branchRaw?.trim() ?? null;
+  return {
+    root,
+    branch: branch && branch !== "HEAD" ? branch : null,
+    head: headRaw?.trim() || null,
+    originUrl: originRaw?.trim() || null
+  };
+}
+
+// src/hooks/install.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname } from "path";
+
+// src/shell/paths.ts
+import { execFile } from "child_process";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function psReadLineHistoryPath() {
+  const appData = process.env.APPDATA ?? join2(homedir(), "AppData", "Roaming");
+  return join2(appData, "Microsoft", "Windows", "PowerShell", "PSReadLine", "ConsoleHost_history.txt");
+}
+function bashHistoryPath() {
+  return process.env.HISTFILE_BASH ?? join2(homedir(), ".bash_history");
+}
+function zshHistoryPath() {
+  return process.env.HISTFILE ?? join2(homedir(), ".zsh_history");
+}
+function globalWorkspaceDir() {
+  return join2(homedir(), ".nexusmem");
+}
+function hookLogPath() {
+  return join2(globalWorkspaceDir(), "shell-history.jsonl");
+}
+async function resolvePowerShellProfilePath(exe = "powershell") {
+  try {
+    const { stdout } = await execFileAsync(exe, ["-NoLogo", "-NoProfile", "-Command", "$PROFILE"], {
+      windowsHide: true
+    });
+    const path = stdout.trim();
+    return path.length > 0 ? path : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/hooks/powershell.ts
+var MARK_START = "# >>> nexusmem shell hook >>>";
+var MARK_END = "# <<< nexusmem shell hook <<<";
+function toPowerShellLiteral(s) {
+  return `'${s.replace(/'/g, "''")}'`;
+}
+function renderHookSnippet(logPath) {
+  return [
+    MARK_START,
+    "if (Test-Path Function:\\prompt) { $function:__ssd_original_prompt = $function:prompt }",
+    "$global:__ssd_last_history_id = -1",
+    `$global:__ssd_log_path = ${toPowerShellLiteral(logPath)}`,
+    "function global:prompt {",
+    "  $__ssd_h = Get-History -Count 1 -ErrorAction SilentlyContinue",
+    "  if ($__ssd_h -and $__ssd_h.Id -ne $global:__ssd_last_history_id) {",
+    "    $global:__ssd_last_history_id = $__ssd_h.Id",
+    "    try {",
+    "      $__ssd_entry = [ordered]@{",
+    '        ts = (Get-Date).ToString("o")',
+    "        cwd = (Get-Location).Path",
+    "        exitCode = $LASTEXITCODE",
+    "        durationMs = [int](($__ssd_h.EndExecutionTime - $__ssd_h.StartExecutionTime).TotalMilliseconds)",
+    "        command = $__ssd_h.CommandLine",
+    "      }",
+    "      $__ssd_dir = Split-Path -Parent $global:__ssd_log_path",
+    "      if (-not (Test-Path $__ssd_dir)) { New-Item -ItemType Directory -Force -Path $__ssd_dir | Out-Null }",
+    "      Add-Content -LiteralPath $global:__ssd_log_path -Value ($__ssd_entry | ConvertTo-Json -Compress) -Encoding utf8",
+    "    } catch {}",
+    "  }",
+    "  if (Test-Path Function:\\__ssd_original_prompt) { & $function:__ssd_original_prompt }",
+    `  else { "PS $($executionContext.SessionState.Path.CurrentLocation)$('>' * ($nestedPromptLevel + 1)) " }`,
+    "}",
+    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/install.ts
+var ProfileNotFoundError = class extends Error {
+  constructor() {
+    super("Could not resolve a PowerShell profile path (tried `powershell -Command $PROFILE`). Pass --profile explicitly.");
+    this.name = "ProfileNotFoundError";
+  }
+};
+async function resolveHookTarget(profileOverride, logPathOverride) {
+  const profilePath = profileOverride ?? await resolvePowerShellProfilePath();
+  if (!profilePath) throw new ProfileNotFoundError();
+  return { profilePath, logPath: logPathOverride ?? hookLogPath() };
+}
+async function readProfile(path) {
+  try {
+    return await readFile2(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+async function installHook(target) {
+  const current = await readProfile(target.profilePath);
+  const alreadyInstalled = isHookInstalled(current);
+  const next = 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 current = await readProfile(target.profilePath);
+  if (!isHookInstalled(current)) return { changed: false };
+  await writeFile2(target.profilePath, stripHookSnippet(current), "utf8");
+  return { changed: true };
+}
+async function hookStatus(target) {
+  const current = await readProfile(target.profilePath);
+  return { installed: isHookInstalled(current) };
+}
+
+// src/cli/commands/hook.ts
+import pc from "picocolors";
+async function runHookInstall(opts) {
+  const target = await resolveHookTarget(opts.profile, opts.logPath);
+  const result = await installHook(target);
+  process.stdout.write(
+    [
+      result.changed ? `${pc.green(result.alreadyInstalled ? "updated" : "installed")} shell hook` : `${pc.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.`,
+      `Run ${pc.bold("nexusmem hook remove")} to undo this.`,
+      ""
+    ].join("\n")
+  );
+  return 0;
+}
+async function runHookRemove(opts) {
+  const target = await resolveHookTarget(opts.profile, opts.logPath);
+  const result = await removeHook(target);
+  process.stdout.write(
+    result.changed ? `${pc.green("removed")} shell hook from ${target.profilePath}
+` : `${pc.dim("nothing to remove")} \u2014 no hook block found in ${target.profilePath}
+`
+  );
+  return 0;
+}
+async function runHookStatus(opts) {
+  const target = await resolveHookTarget(opts.profile, opts.logPath);
+  const result = await hookStatus(target);
+  process.stdout.write(
+    [
+      `${pc.dim("profile")} ${target.profilePath}`,
+      `${pc.dim("log    ")} ${target.logPath}`,
+      `${pc.dim("status ")} ${result.installed ? pc.green("installed") : pc.yellow("not installed")}`,
+      ""
+    ].join("\n")
+  );
+  return 0;
+}
+
+// src/cli/commands/init.ts
+import { relative } from "path";
+import pc2 from "picocolors";
+
+// src/core/ids.ts
+import { createHash } from "crypto";
+var KEY_SEP = "\0";
+function sha256Hex(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex");
+}
+function makeNodeId(projectId, kind, naturalKey) {
+  return sha256Hex([projectId, kind, naturalKey].join(KEY_SEP)).slice(0, 24);
+}
+
+// src/core/project.ts
+function normalizeGitUrl(url) {
+  let s = url.trim();
+  const scp = /^(?:[^@/]+@)?([^/:]+):(.+)$/.exec(s);
+  if (scp && !s.includes("://")) {
+    s = `${scp[1]}/${scp[2]}`;
+  } else {
+    s = s.replace(/^[a-z+]+:\/\//i, "").replace(/^[^@/]+@/, "");
+  }
+  return s.replace(/\/+$/, "").replace(/\.git$/i, "").replace(/\/+$/, "").replace(/\/{2,}/g, "/").toLowerCase();
+}
+function makeProjectId({ root, originUrl }) {
+  const basis = originUrl ? `remote:${normalizeGitUrl(originUrl)}` : `path:${root.replace(/\\/g, "/").toLowerCase()}`;
+  return sha256Hex(basis).slice(0, 16);
+}
+
+// src/store/store.ts
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { dirname as dirname2 } from "path";
+import * as sqliteVec from "sqlite-vec";
+
+// src/store/fts.ts
+var FTS_SYNTAX = /["'()*:^{}[\]-]/g;
+function toMatchQuery(input) {
+  const tokens = input.replace(FTS_SYNTAX, " ").split(/\s+/).map((t) => t.trim()).filter((t) => t.length > 0);
+  if (tokens.length === 0) return null;
+  return tokens.map((t) => `"${t}"*`).join(" OR ");
+}
+
+// src/store/schema.ts
+var V1 = `
+CREATE TABLE meta (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE projects (
+  id             TEXT PRIMARY KEY,
+  root           TEXT NOT NULL,
+  origin_url     TEXT,
+  created_at     INTEGER NOT NULL,
+  last_synced_at INTEGER
+);
+
+CREATE TABLE nodes (
+  id         TEXT PRIMARY KEY,
+  kind       TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  -- Human-readable ISO-8601 with offset, kept verbatim from the source event.
+  ts         TEXT NOT NULL,
+  -- Same instant as epoch ms, so range scans and ordering never parse strings.
+  ts_epoch   INTEGER NOT NULL,
+  source     TEXT NOT NULL,
+  title      TEXT NOT NULL,
+  body       TEXT NOT NULL,
+  signal     REAL NOT NULL,
+  meta       TEXT NOT NULL DEFAULT '{}',
+  created_at INTEGER NOT NULL
+);
+
+CREATE INDEX idx_nodes_project_ts   ON nodes (project_id, ts_epoch DESC);
+CREATE INDEX idx_nodes_project_kind ON nodes (project_id, kind, ts_epoch DESC);
+
+CREATE TABLE node_files (
+  node_id       TEXT NOT NULL REFERENCES nodes (id) ON DELETE CASCADE,
+  path          TEXT NOT NULL,
+  previous_path TEXT,
+  insertions    INTEGER,
+  deletions     INTEGER,
+  is_binary     INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (node_id, path)
+);
+
+-- Path-scoped recall ("what happened to src/store/db.ts?") is a first-class
+-- query, so it gets its own index rather than a scan over node_files.
+CREATE INDEX idx_node_files_path ON node_files (path);
+
+-- External-content FTS: the index stores no copy of the text, it points back
+-- at nodes.rowid. Halves the on-disk footprint of the searchable corpus.
+CREATE VIRTUAL TABLE nodes_fts USING fts5 (
+  title,
+  body,
+  content = 'nodes',
+  content_rowid = 'rowid',
+  tokenize = 'unicode61 remove_diacritics 2'
+);
+
+CREATE TRIGGER nodes_fts_ai AFTER INSERT ON nodes BEGIN
+  INSERT INTO nodes_fts (rowid, title, body) VALUES (new.rowid, new.title, new.body);
+END;
+
+CREATE TRIGGER nodes_fts_ad AFTER DELETE ON nodes BEGIN
+  INSERT INTO nodes_fts (nodes_fts, rowid, title, body) VALUES ('delete', old.rowid, old.title, old.body);
+END;
+
+CREATE TRIGGER nodes_fts_au AFTER UPDATE ON nodes BEGIN
+  INSERT INTO nodes_fts (nodes_fts, rowid, title, body) VALUES ('delete', old.rowid, old.title, old.body);
+  INSERT INTO nodes_fts (rowid, title, body) VALUES (new.rowid, new.title, new.body);
+END;
+
+CREATE TABLE sync_state (
+  project_id  TEXT NOT NULL,
+  -- Collector identity, e.g. 'git' or 'shell:pwsh'.
+  source      TEXT NOT NULL,
+  -- Opaque to the store; for git this is the HEAD sha at last successful sync.
+  cursor      TEXT,
+  last_run_at INTEGER,
+  PRIMARY KEY (project_id, source)
+);
+`;
+var EMBEDDING_DIM = 768;
+var V2 = `
+-- Unlike nodes_fts, this is NOT trigger-populated: computing an embedding
+-- means an async call to an external model, which a synchronous SQL trigger
+-- cannot make. Rows are written explicitly by the embedding pass in
+-- vector/embed.ts, keyed by the same rowid nodes_fts already uses.
+CREATE VIRTUAL TABLE nodes_vec USING vec0 (
+  embedding float[${EMBEDDING_DIM}]
+);
+`;
+var MIGRATIONS = [
+  { version: 1, up: (db) => db.exec(V1) },
+  { version: 2, up: (db) => db.exec(V2) }
+];
+var LATEST_SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
+function currentSchemaVersion(db) {
+  return Number(db.pragma("user_version", { simple: true }) ?? 0);
+}
+function migrate(db) {
+  const from = currentSchemaVersion(db);
+  for (const migration of MIGRATIONS) {
+    if (migration.version <= from) continue;
+    db.transaction(() => {
+      migration.up(db);
+      db.pragma(`user_version = ${migration.version}`);
+    })();
+  }
+  return { from, to: currentSchemaVersion(db) };
+}
+
+// src/store/store.ts
+function epochOf(ts) {
+  const parsed = Date.parse(ts);
+  return Number.isNaN(parsed) ? Date.now() : parsed;
+}
+var MemoryStore = class _MemoryStore {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  static open(dbPath) {
+    mkdirSync(dirname2(dbPath), { recursive: true });
+    const db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
+    db.pragma("foreign_keys = ON");
+    sqliteVec.load(db);
+    migrate(db);
+    return new _MemoryStore(db);
+  }
+  close() {
+    this.db.close();
+  }
+  upsertProject(project) {
+    this.db.prepare(
+      `INSERT INTO projects (id, root, origin_url, created_at)
+         VALUES (@id, @root, @originUrl, @now)
+         ON CONFLICT(id) DO UPDATE SET root = excluded.root, origin_url = excluded.origin_url`
+    ).run({ ...project, now: Date.now() });
+  }
+  markSynced(projectId) {
+    this.db.prepare("UPDATE projects SET last_synced_at = ? WHERE id = ?").run(Date.now(), projectId);
+  }
+  /**
+   * Write a batch of nodes in one transaction.
+   *
+   * Ids are content-addressed, so re-ingesting the same event is a no-op --
+   * a node is only rewritten when the derived content actually changed (which
+   * happens when scoring or body composition is improved between releases).
+   */
+  upsertNodes(nodes) {
+    const exists = this.db.prepare("SELECT body, signal, title FROM nodes WHERE id = ?");
+    const dropStaleEmbedding = this.db.prepare(
+      "DELETE FROM nodes_vec WHERE rowid = (SELECT rowid FROM nodes WHERE id = ?)"
+    );
+    const insertNode = this.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, @now)
+       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`
+    );
+    const clearFiles = this.db.prepare("DELETE FROM node_files WHERE node_id = ?");
+    const insertFile = this.db.prepare(
+      `INSERT INTO node_files (node_id, path, previous_path, insertions, deletions, is_binary)
+       VALUES (@nodeId, @path, @previousPath, @insertions, @deletions, @isBinary)
+       ON CONFLICT(node_id, path) DO UPDATE SET
+         previous_path = excluded.previous_path, insertions = excluded.insertions,
+         deletions = excluded.deletions, is_binary = excluded.is_binary`
+    );
+    const stats = { inserted: 0, updated: 0, unchanged: 0 };
+    const run = this.db.transaction((batch) => {
+      const now = Date.now();
+      for (const node of batch) {
+        const prior = exists.get(node.id);
+        if (prior) {
+          if (prior.body === node.body && prior.signal === node.signal && prior.title === node.title) {
+            stats.unchanged += 1;
+            continue;
+          }
+          stats.updated += 1;
+          dropStaleEmbedding.run(node.id);
+        } else {
+          stats.inserted += 1;
+        }
+        insertNode.run({
+          id: node.id,
+          kind: node.kind,
+          projectId: node.projectId,
+          ts: node.ts,
+          tsEpoch: epochOf(node.ts),
+          source: node.source,
+          title: node.title,
+          body: node.body,
+          signal: node.signal,
+          meta: JSON.stringify(node.meta),
+          now
+        });
+        clearFiles.run(node.id);
+        for (const file of node.files) {
+          insertFile.run({
+            nodeId: node.id,
+            path: file.path,
+            previousPath: file.previousPath ?? null,
+            insertions: file.insertions,
+            deletions: file.deletions,
+            isBinary: file.binary ? 1 : 0
+          });
+        }
+      }
+    });
+    run(nodes);
+    return stats;
+  }
+  getSyncCursor(projectId, source) {
+    const row = this.db.prepare("SELECT cursor FROM sync_state WHERE project_id = ? AND source = ?").get(projectId, source);
+    return row?.cursor ?? null;
+  }
+  setSyncCursor(projectId, source, cursor) {
+    this.db.prepare(
+      `INSERT INTO sync_state (project_id, source, cursor, last_run_at)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT(project_id, source) DO UPDATE SET cursor = excluded.cursor, last_run_at = excluded.last_run_at`
+    ).run(projectId, source, cursor, Date.now());
+  }
+  /** Every source that has ever synced for this project, most recently run first. */
+  listSyncState(projectId) {
+    return this.db.prepare("SELECT source, cursor, last_run_at AS lastRunAt FROM sync_state WHERE project_id = ? ORDER BY last_run_at DESC").all(projectId);
+  }
+  /** Drop every node for a project. Used by `sync --rebuild`. */
+  clearProject(projectId) {
+    this.db.prepare("DELETE FROM nodes_vec WHERE rowid IN (SELECT rowid FROM nodes WHERE project_id = ?)").run(projectId);
+    const info = this.db.prepare("DELETE FROM nodes WHERE project_id = ?").run(projectId);
+    this.db.prepare("DELETE FROM sync_state WHERE project_id = ?").run(projectId);
+    return info.changes;
+  }
+  /**
+   * Delete the nodes of one source that its latest full scan did not produce.
+   *
+   * Needed by any source whose node ids are derived from content that can be
+   * *edited in place* rather than only appended to. A `doc_section` id comes
+   * from `path + heading slug`, so renaming a markdown heading mints a new node
+   * and strands the old one: `sync` reports `+1 new`, and the corpus then holds
+   * two contradictory versions of the same section, both of which come back for
+   * the same query. Git and shell nodes describe events that already happened
+   * and are never restated, so they have nothing to prune.
+   *
+   * Scoping is the whole safety story here, and it is deliberately narrow:
+   *
+   * - `project_id` -- never reaches another repository's memory.
+   * - `source` -- an exact match on the collector's own key, so pruning `docs`
+   *   cannot touch `conversation:claude-code`, `shell:pwsh` or `git` nodes even
+   *   though they share the table.
+   * - `keepIds` -- everything this scan produced.
+   * - `keepPaths` -- files the scan could not read. Their nodes are kept
+   *   because an unreadable file is not evidence that its sections are gone.
+   *
+   * Callers must pass the ids from a *complete* scan of the source. A partial
+   * or filtered scan would read as "these nodes no longer exist" and delete
+   * real history.
+   */
+  pruneSourceNodes(projectId, source, keepIds, opts = {}) {
+    const scope = `project_id = @projectId AND source = @source
+        AND id NOT IN (SELECT value FROM json_each(@keepIds))
+        AND id NOT IN (SELECT node_id FROM node_files WHERE path IN (SELECT value FROM json_each(@keepPaths)))`;
+    const params = {
+      projectId,
+      source,
+      keepIds: JSON.stringify(keepIds),
+      keepPaths: JSON.stringify(opts.keepPaths ?? [])
+    };
+    return this.db.transaction(() => {
+      this.db.prepare(`DELETE FROM nodes_vec WHERE rowid IN (SELECT rowid FROM nodes WHERE ${scope})`).run(params);
+      return this.db.prepare(`DELETE FROM nodes WHERE ${scope}`).run(params).changes;
+    })();
+  }
+  /** Nodes for this project that have no embedding yet (new, or invalidated by a content change). */
+  findNodesNeedingEmbedding(projectId, limit = 200) {
+    return this.db.prepare(
+      `SELECT n.rowid AS rowid, n.id AS id, n.title AS title, n.body AS body
+         FROM nodes n
+         LEFT JOIN nodes_vec v ON v.rowid = n.rowid
+         WHERE n.project_id = ? AND v.rowid IS NULL
+         LIMIT ?`
+    ).all(projectId, limit);
+  }
+  upsertEmbedding(rowid, embedding) {
+    this.db.prepare("INSERT OR REPLACE INTO nodes_vec (rowid, embedding) VALUES (?, ?)").run(BigInt(rowid), embedding);
+  }
+  /**
+   * Nearest-neighbour search over the corpus.
+   *
+   * `nodes_vec` has no `project_id` column of its own (embeddings are
+   * generic; project scoping lives on `nodes`), so this over-fetches `k`
+   * before joining and filtering, then caps to `limit`. Simple and correct;
+   * not the efficient way to do this at a scale this project isn't at yet.
+   */
+  vectorSearch(projectId, embedding, limit = 20) {
+    const overfetch = Math.max(limit * 8, 50);
+    return this.db.prepare(
+      `SELECT n.id, n.kind, n.ts, n.title, n.body, n.signal, v.distance AS distance
+         FROM nodes_vec v
+         JOIN nodes n ON n.rowid = v.rowid
+         WHERE v.embedding MATCH ? AND k = ? AND n.project_id = ?
+         ORDER BY v.distance
+         LIMIT ?`
+    ).all(embedding, overfetch, projectId, limit);
+  }
+  stats(projectId) {
+    const kinds = this.db.prepare("SELECT kind, COUNT(*) AS n FROM nodes WHERE project_id = ? GROUP BY kind").all(projectId);
+    const range = this.db.prepare("SELECT MIN(ts) AS oldest, MAX(ts) AS newest FROM nodes WHERE project_id = ?").get(projectId);
+    const files = this.db.prepare(
+      `SELECT COUNT(DISTINCT f.path) AS n
+         FROM node_files f JOIN nodes n ON n.id = f.node_id
+         WHERE n.project_id = ?`
+    ).get(projectId);
+    return {
+      total: kinds.reduce((sum, k) => sum + k.n, 0),
+      byKind: Object.fromEntries(kinds.map((k) => [k.kind, k.n])),
+      oldest: range.oldest,
+      newest: range.newest,
+      distinctFiles: files.n
+    };
+  }
+  /**
+   * Lexical search over the corpus.
+   *
+   * Title is weighted 10x body: a commit subject that names the thing you asked
+   * about is far stronger evidence than the same word buried in a file list.
+   * Ranking by `relevance x signal` happens a layer up, in retrieval.
+   */
+  search(projectId, query, limit = 20) {
+    const match = toMatchQuery(query);
+    if (!match) return [];
+    const rows = this.db.prepare(
+      `SELECT n.id, n.kind, n.ts, n.title, n.body, n.signal,
+                bm25(nodes_fts, 10.0, 1.0) AS rank
+         FROM nodes_fts
+         JOIN nodes n ON n.rowid = nodes_fts.rowid
+         WHERE nodes_fts MATCH ? AND n.project_id = ?
+         ORDER BY rank
+         LIMIT ?`
+    ).all(match, projectId, limit);
+    return rows;
+  }
+  /** Escape hatch for tests and future modules. */
+  get raw() {
+    return this.db;
+  }
+};
+
+// src/cli/commands/init.ts
+async function runInit(opts) {
+  const out = opts.out ?? ((chunk) => void process.stdout.write(chunk));
+  const repo = await readRepoInfo(opts.cwd);
+  const ws = resolveWorkspace(repo.root);
+  const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
+  const already = isInitialized(ws);
+  if (already && !opts.force) {
+    const existing = await readConfig(ws);
+    process.stderr.write(
+      `${pc2.yellow("already initialized")} ${relative(process.cwd(), ws.configPath) || ws.configPath}
+  project ${pc2.cyan(existing.projectId)}
+  use ${pc2.bold("--force")} to reset the config (the database is kept)
+`
+    );
+    return 0;
+  }
+  await writeWorkspaceGitignore(ws);
+  const config = defaultConfig(projectId);
+  if (opts.enableConversation) config.sources.conversation.enabled = true;
+  await writeConfig(ws, config);
+  const store = MemoryStore.open(ws.dbPath);
+  try {
+    store.upsertProject({ id: projectId, root: repo.root, originUrl: repo.originUrl });
+  } finally {
+    store.close();
+  }
+  const lines = [
+    `${pc2.green("initialized")} ${ws.dir}`,
+    `  project  ${pc2.cyan(projectId)}`,
+    `  repo     ${repo.root}`,
+    `  branch   ${repo.branch ?? pc2.yellow("(detached)")}`,
+    `  schema   v${LATEST_SCHEMA_VERSION}`
+  ];
+  if (opts.enableConversation) {
+    lines.push(`  ${pc2.yellow("conversation source enabled")} -- transcripts will be redacted-but-indexed on sync`);
+  }
+  if (opts.hook) {
+    try {
+      const target = await resolveHookTarget();
+      const result = await installHook(target);
+      lines.push(
+        "",
+        `${pc2.green(result.changed ? "installed" : "already installed")} shell hook`,
+        `  profile ${target.profilePath}`,
+        `  log     ${target.logPath}`,
+        `  open a new PowerShell window (or run \`. $PROFILE\`) for it to take effect`
+      );
+    } catch (err) {
+      if (err instanceof ProfileNotFoundError) {
+        lines.push("", `${pc2.yellow("hook not installed")} ${err.message}`);
+      } else {
+        throw err;
+      }
+    }
+  }
+  lines.push("", `Next: ${pc2.bold("nexusmem sync")}`, "");
+  out(lines.join("\n"));
+  return 0;
+}
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z2 } from "zod";
+
+// src/core/text.ts
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max - 1).trimEnd()}\u2026`;
+}
+function approxTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
+// src/retrieval/pack.ts
+var DEFAULT_SUMMARY_CHARS = 320;
+var NODE_OVERHEAD_TOKENS = 8;
+var CONVERSATION_ANSWER_MARKER = "\n\nA: ";
+function summarize(hit, maxChars) {
+  const answerIdx = hit.body.indexOf(CONVERSATION_ANSWER_MARKER);
+  if (answerIdx !== -1) {
+    const answer = hit.body.slice(answerIdx + CONVERSATION_ANSWER_MARKER.length).trim();
+    if (answer) return truncate(answer, maxChars);
+  }
+  const rest = hit.body.startsWith(hit.title) ? hit.body.slice(hit.title.length).trim() : hit.body;
+  return truncate(rest || hit.title, maxChars);
+}
+function packContext(ranked, tokensBudget, opts = {}) {
+  const summaryChars = opts.summaryChars ?? DEFAULT_SUMMARY_CHARS;
+  const nodes = [];
+  let tokensUsed = 0;
+  let droppedForBudget = 0;
+  for (const hit of ranked) {
+    const summary = summarize(hit, summaryChars);
+    const tokens = approxTokens(hit.title) + approxTokens(summary) + NODE_OVERHEAD_TOKENS;
+    if (tokensUsed + tokens > tokensBudget) {
+      droppedForBudget += 1;
+      continue;
+    }
+    nodes.push({
+      id: hit.id,
+      kind: hit.kind,
+      ts: hit.ts,
+      title: hit.title,
+      signal: hit.signal,
+      score: hit.score,
+      summary,
+      tokens
+    });
+    tokensUsed += tokens;
+  }
+  return { nodes, tokensUsed, tokensBudget, consideredNodes: ranked.length, droppedForBudget };
+}
+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) {
+    lines.push(`- ${node.ts.slice(0, 10)} ${node.title}`);
+    if (node.summary && node.summary !== node.title) {
+      lines.push(`  ${node.summary.replace(/\n+/g, " ")}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/retrieval/fuse.ts
+var RRF_K = 60;
+function reciprocalRankFusion(lists) {
+  const scores = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    list.forEach((item, index) => {
+      const contribution = 1 / (RRF_K + index + 1);
+      scores.set(item.id, (scores.get(item.id) ?? 0) + contribution);
+    });
+  }
+  return scores;
+}
+function mergeSearchAndVectorHits(bm25Hits, vectorHits) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const hit of bm25Hits) byId.set(hit.id, hit);
+  for (const hit of vectorHits) {
+    if (byId.has(hit.id)) continue;
+    byId.set(hit.id, { id: hit.id, kind: hit.kind, ts: hit.ts, title: hit.title, body: hit.body, signal: hit.signal, rank: 0 });
+  }
+  return [...byId.values()];
+}
+
+// src/retrieval/rank.ts
+var RELEVANCE_FLOOR = 0.15;
+var SIGNAL_FLOOR = 0.2;
+var RECENCY_FLOOR = 0.3;
+var DEFAULT_HALF_LIFE_DAYS = 30;
+var MS_PER_DAY = 864e5;
+var MAX_PRIOR_OVERTURN = 2;
+var SIGNAL_EXPONENT = Math.log(MAX_PRIOR_OVERTURN) / Math.log(1 / SIGNAL_FLOOR);
+var RECENCY_EXPONENT = Math.log(MAX_PRIOR_OVERTURN) / Math.log(1 / RECENCY_FLOOR);
+function normalizeRelevance(hits) {
+  const costs = hits.map((h) => h.rank);
+  const min = Math.min(...costs);
+  const max = Math.max(...costs);
+  if (min === max) return hits.map(() => 1);
+  return costs.map((cost) => {
+    const normalized = (max - cost) / (max - min);
+    return RELEVANCE_FLOOR + (1 - RELEVANCE_FLOOR) * normalized;
+  });
+}
+function normalizeExternalRelevance(hits, scores) {
+  const values = hits.map((h) => scores.get(h.id) ?? 0);
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  if (min === max) return hits.map(() => 1);
+  return values.map((v) => {
+    const normalized = (v - min) / (max - min);
+    return RELEVANCE_FLOOR + (1 - RELEVANCE_FLOOR) * normalized;
+  });
+}
+function ageDaysOf(ts, now) {
+  const parsed = Date.parse(ts);
+  if (Number.isNaN(parsed)) return 0;
+  return Math.max(0, (now.getTime() - parsed) / MS_PER_DAY);
+}
+function rankHits(hits, opts = {}) {
+  if (hits.length === 0) return [];
+  const halfLife = opts.halfLifeDays ?? DEFAULT_HALF_LIFE_DAYS;
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const relevances = opts.relevanceScores ? normalizeExternalRelevance(hits, opts.relevanceScores) : normalizeRelevance(hits);
+  const ranked = hits.map((hit, i) => {
+    const relevance = relevances[i] ?? RELEVANCE_FLOOR;
+    const signalWeight = SIGNAL_FLOOR + (1 - SIGNAL_FLOOR) * hit.signal;
+    const ageDays = ageDaysOf(hit.ts, now);
+    const recencyFactor = RECENCY_FLOOR + (1 - RECENCY_FLOOR) * 2 ** (-ageDays / halfLife);
+    const score = relevance * signalWeight ** SIGNAL_EXPONENT * recencyFactor ** RECENCY_EXPONENT;
+    return { ...hit, relevance, signalWeight, ageDays, recencyFactor, score };
+  });
+  return ranked.sort((a, b) => b.score - a.score);
+}
+
+// src/retrieval/query-pipeline.ts
+async function runHybridQuery(store, projectId, query, opts) {
+  const bm25Hits = store.search(projectId, query, opts.candidates);
+  let vectorHits = [];
+  if (opts.embeddingProvider) {
+    const queryVector = await opts.embeddingProvider.embed(query);
+    if (queryVector) vectorHits = store.vectorSearch(projectId, queryVector, opts.candidates);
+  }
+  const hits = vectorHits.length > 0 ? mergeSearchAndVectorHits(bm25Hits, vectorHits) : bm25Hits;
+  const relevanceScores = vectorHits.length > 0 ? reciprocalRankFusion([bm25Hits, vectorHits]) : void 0;
+  const ranked = rankHits(hits, { halfLifeDays: opts.halfLifeDays, relevanceScores });
+  const packed = packContext(ranked, opts.budget);
+  return { bm25Count: bm25Hits.length, vectorCount: vectorHits.length, hits, packed };
+}
+
+// src/vector/embed.ts
+var DEFAULT_BASE_URL = "http://127.0.0.1:11434";
+var DEFAULT_MODEL = "nomic-embed-text";
+var DEFAULT_DIMENSION = 768;
+var DEFAULT_TIMEOUT_MS = 1e4;
+var OllamaEmbeddingProvider = class {
+  dimension;
+  baseUrl;
+  model;
+  timeoutMs;
+  constructor(opts = {}) {
+    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
+    this.model = opts.model ?? DEFAULT_MODEL;
+    this.dimension = opts.dimension ?? DEFAULT_DIMENSION;
+    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  async embed(text) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(`${this.baseUrl}/api/embeddings`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ model: this.model, prompt: text }),
+        signal: controller.signal
+      });
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (!Array.isArray(data.embedding) || data.embedding.length !== this.dimension) return null;
+      return new Float32Array(data.embedding);
+    } catch {
+      return null;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/cli/commands/sync.ts
+import pc3 from "picocolors";
+
+// src/conversation/chunk.ts
+var HEADING_LINE = /^#{1,6}\s+(.+)$/;
+var BOLD_LEAD = /^\*\*([^*]+?)\*\*/;
+function sectionStart(paragraph) {
+  const firstLine = paragraph.split("\n")[0] ?? "";
+  const heading = HEADING_LINE.exec(firstLine);
+  if (heading) return (heading[1] ?? "").trim();
+  const bold = BOLD_LEAD.exec(paragraph);
+  if (bold) return (bold[1] ?? "").trim();
+  return null;
+}
+function chunkAssistantText(text, maxChars) {
+  const paragraphs = text.replace(/\r\n?/g, "\n").split(/\n{2,}/).map((p) => p.trim()).filter(Boolean);
+  if (paragraphs.length === 0) return [];
+  const chunks = [];
+  let buffer = [];
+  let bufferHeading = null;
+  const bufferChars = () => buffer.reduce((n, p) => n + p.length, 0) + Math.max(0, buffer.length - 1) * 2;
+  const flush = () => {
+    if (buffer.length === 0) return;
+    chunks.push({ heading: bufferHeading, text: truncate(buffer.join("\n\n"), maxChars) });
+    buffer = [];
+    bufferHeading = null;
+  };
+  for (const paragraph of paragraphs) {
+    const heading = sectionStart(paragraph);
+    const startsNewSection = heading !== null && buffer.length > 0;
+    const wouldOverflow = buffer.length > 0 && bufferChars() + 2 + paragraph.length > maxChars;
+    if (startsNewSection || wouldOverflow) flush();
+    if (heading !== null) bufferHeading = heading;
+    buffer.push(paragraph);
+  }
+  flush();
+  return chunks;
+}
+
+// src/conversation/redact.ts
+var RULES = [
+  { name: "private-key-block", pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g },
+  { name: "aws-access-key", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
+  { name: "github-token", pattern: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g },
+  { name: "slack-token", pattern: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g },
+  { name: "jwt", pattern: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g },
+  // key/token/secret/password = "value" or : value, in code, JSON, env-file or prose form.
+  {
+    name: "key-value-secret",
+    pattern: /\b((?:api[_-]?key|secret|password|passwd|token|access[_-]?key)s?)\s*[:=]\s*['"]?[A-Za-z0-9_\-./+=]{8,}['"]?/gi
+  }
+];
+function redact(text) {
+  let redactedCount = 0;
+  let out = text;
+  for (const rule of RULES) {
+    out = out.replace(rule.pattern, (_match, ...rest) => {
+      redactedCount += 1;
+      const key = typeof rest[0] === "string" ? rest[0] : null;
+      return key ? `${key}: [redacted]` : "[redacted]";
+    });
+  }
+  return { text: out, redactedCount };
+}
+
+// src/collectors/conversation.ts
+var DEFAULT_MAX_BODY_CHARS = 2500;
+var DEFAULT_MAX_CHUNK_CHARS = 900;
+var MAX_TITLE_CHARS = 200;
+var MAX_FILES_PER_NODE = 20;
+var EXPLANATION_MARKERS = /\b(because|the reason|design decision|trade-?off|instead of|rationale|so that)\b|เพราะ|ทำไม|เหตุผล/i;
+var TRIVIAL_ACK = /^(ok|okay|thanks?|ขอบคุณ|ครับ|ค่ะ|got it|sounds good|👍|done)\.?!?$/i;
+function scoreConversationTurn(userText, replyText) {
+  const text = `${userText}
+${replyText}`;
+  let score = 0.3;
+  if (EXPLANATION_MARKERS.test(text)) score += 0.25;
+  if (replyText.length > 400) score += 0.15;
+  else if (replyText.length < 80) score -= 0.1;
+  if (TRIVIAL_ACK.test(userText.trim())) score -= 0.2;
+  if (userText.trim().endsWith("?")) score += 0.05;
+  return Number(Math.min(1, Math.max(0.05, score)).toFixed(3));
+}
+var FILE_PATH = /\b(?:[\w.-]+\/)*[\w-]+\.(?:ts|tsx|js|jsx|json|md|py|rs|go|java|c|cpp|h|hpp|css|html|ya?ml|toml|sql|sh|ps1)\b/g;
+function extractMentionedFiles(text) {
+  const seen = /* @__PURE__ */ new Set();
+  const files = [];
+  for (const match of text.matchAll(FILE_PATH)) {
+    const path = match[0];
+    if (seen.has(path)) continue;
+    seen.add(path);
+    files.push({ path, insertions: null, deletions: null, binary: false });
+    if (files.length >= MAX_FILES_PER_NODE) break;
+  }
+  return files;
+}
+function withSuffix(base, suffix) {
+  const budget = Math.max(20, MAX_TITLE_CHARS - suffix.length);
+  return `${truncate(base, budget)}${suffix}`;
+}
+function chunkTitle(userFirstLine, heading, index, count) {
+  if (heading) return withSuffix(userFirstLine, ` \u2014 ${heading}`);
+  if (count > 1) return withSuffix(userFirstLine, ` (part ${index + 1}/${count})`);
+  return truncate(userFirstLine, MAX_TITLE_CHARS);
+}
+function toMemoryNodes(turn, projectId, opts = {}) {
+  const maxBody = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS;
+  const maxChunk = opts.maxChunkChars ?? DEFAULT_MAX_CHUNK_CHARS;
+  const userRedacted = redact(turn.userText);
+  const userFirstLine = userRedacted.text.split(/\r?\n/)[0] ?? userRedacted.text;
+  const assistantRedacted = redact(turn.assistantText);
+  const chunks = chunkAssistantText(assistantRedacted.text, maxChunk);
+  if (chunks.length === 0) return [];
+  return chunks.map((chunk, index) => {
+    const body = [`Q: ${userRedacted.text}`, "", `A: ${chunk.text}`].join("\n");
+    return {
+      id: makeNodeId(projectId, "conversation_turn", `${turn.naturalKey}:${index}`),
+      kind: "conversation_turn",
+      projectId,
+      ts: turn.ts,
+      source: `conversation:${turn.source}`,
+      title: chunkTitle(userFirstLine, chunk.heading, index, chunks.length),
+      body: truncate(body, maxBody),
+      files: extractMentionedFiles(`${userRedacted.text}
+${chunk.text}`),
+      signal: scoreConversationTurn(userRedacted.text, chunk.text),
+      meta: {
+        cwd: turn.cwd,
+        source: turn.source,
+        chunkIndex: index,
+        chunkCount: chunks.length,
+        heading: chunk.heading,
+        // Redaction runs once over the whole reply before chunking (so a
+        // secret can never straddle a chunk boundary and slip through) --
+        // this is the turn's total, repeated on every chunk it produced,
+        // not a per-chunk count.
+        redactedCount: userRedacted.redactedCount + assistantRedacted.redactedCount
+      }
+    };
+  });
+}
+function collectConversationTurns(turns, projectId, opts = {}) {
+  return turns.filter((t) => t.assistantText.length > 0).flatMap((turn) => toMemoryNodes(turn, projectId, opts));
+}
+
+// src/collectors/docs.ts
+var DEFAULT_MAX_BODY_CHARS2 = 2e3;
+var DEFAULT_MAX_CHUNK_CHARS2 = 1200;
+var MAX_TITLE_CHARS2 = 200;
+var EXPLANATION_MARKERS2 = /\b(because|the reason|design decision|trade-?off|instead of|rationale|why)\b/i;
+function scoreDocSection(path, heading, text) {
+  let score = 0.45;
+  if (EXPLANATION_MARKERS2.test(text)) score += 0.25;
+  if (/(^|\/)readme\.md$/i.test(path)) score += 0.1;
+  if (heading === null) score -= 0.1;
+  if (text.length < 80) score -= 0.15;
+  return Number(Math.min(1, Math.max(0.05, score)).toFixed(3));
+}
+function slugify(heading, index) {
+  if (heading === null) return `_preamble-${index}`;
+  const slug = heading.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || `_section-${index}`;
+}
+function sectionTitle(path, heading, index, count) {
+  if (heading) return truncate(`${path} \u2014 ${heading}`, MAX_TITLE_CHARS2);
+  if (count > 1) return truncate(`${path} (part ${index + 1}/${count})`, MAX_TITLE_CHARS2);
+  return truncate(path, MAX_TITLE_CHARS2);
+}
+function toMemoryNodes2(file, projectId, opts = {}) {
+  const maxBody = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS2;
+  const maxChunk = opts.maxChunkChars ?? DEFAULT_MAX_CHUNK_CHARS2;
+  const chunks = chunkAssistantText(file.content, maxChunk);
+  if (chunks.length === 0) return [];
+  const seenSlugs = /* @__PURE__ */ new Map();
+  return chunks.map((chunk, index) => {
+    const baseSlug = slugify(chunk.heading, index);
+    const occurrence = seenSlugs.get(baseSlug) ?? 0;
+    seenSlugs.set(baseSlug, occurrence + 1);
+    const naturalKey = occurrence === 0 ? `${file.path}#${baseSlug}` : `${file.path}#${baseSlug}:${occurrence}`;
+    return {
+      id: makeNodeId(projectId, "doc_section", naturalKey),
+      kind: "doc_section",
+      projectId,
+      ts: file.ts,
+      source: "docs",
+      title: sectionTitle(file.path, chunk.heading, index, chunks.length),
+      body: truncate(chunk.text, maxBody),
+      files: [{ path: file.path, insertions: null, deletions: null, binary: false }],
+      signal: scoreDocSection(file.path, chunk.heading, chunk.text),
+      meta: {
+        path: file.path,
+        heading: chunk.heading,
+        chunkIndex: index,
+        chunkCount: chunks.length
+      }
+    };
+  });
+}
+function collectDocFiles(files, projectId, opts = {}) {
+  return files.flatMap((file) => toMemoryNodes2(file, projectId, opts));
+}
+
+// src/git/parse.ts
+var RECORD_SEP = "";
+var UNIT_SEP = "";
+var GIT_LOG_FORMAT = "%x1e%H%x1f%h%x1f%P%x1f%an%x1f%ae%x1f%aI%x1f%cI%x1f%s%x1f%B%x1f";
+var FIELD_COUNT = 10;
+function splitRecords(buffer, flush = false) {
+  const parts = buffer.split(RECORD_SEP);
+  const rest = flush ? "" : parts.pop() ?? "";
+  const records = parts.filter((p) => p.trim().length > 0);
+  if (flush && rest.trim().length > 0) records.push(rest);
+  return { records, rest };
+}
+function parseCommitRecord(record) {
+  let payload = record;
+  while (payload.startsWith(RECORD_SEP)) payload = payload.slice(RECORD_SEP.length);
+  const parts = payload.split(UNIT_SEP);
+  if (parts.length < FIELD_COUNT) return null;
+  const sha = parts[0] ?? "";
+  if (!/^[0-9a-f]{7,64}$/i.test(sha)) return null;
+  const numstatBlock = parts[parts.length - 1] ?? "";
+  const message = parts.slice(8, parts.length - 1).join(UNIT_SEP).trim();
+  const subject = (parts[7] ?? "").trim();
+  const parents = (parts[2] ?? "").trim().split(/\s+/).filter(Boolean);
+  return {
+    sha,
+    shortSha: parts[1] ?? "",
+    parents,
+    authorName: parts[3] ?? "",
+    authorEmail: parts[4] ?? "",
+    authoredAt: parts[5] ?? "",
+    committedAt: parts[6] ?? "",
+    subject,
+    message,
+    messageBody: stripSubject(message, subject),
+    files: parseNumstat(numstatBlock),
+    isMerge: parents.length > 1
+  };
+}
+function stripSubject(message, subject) {
+  if (!subject || !message.startsWith(subject)) return message;
+  return message.slice(subject.length).trim();
+}
+var NUMSTAT_LINE = /^(\d+|-)\t(\d+|-)\t(.*)$/;
+function parseNumstat(block) {
+  const files = [];
+  for (const line of block.split("\n")) {
+    const m = NUMSTAT_LINE.exec(line.trimEnd());
+    if (!m) continue;
+    const [, addRaw = "", delRaw = "", pathRaw = ""] = m;
+    const binary = addRaw === "-" || delRaw === "-";
+    const { path, previousPath } = resolveRenamePath(unquoteGitPath(pathRaw));
+    const touch = {
+      path,
+      insertions: binary ? null : Number(addRaw),
+      deletions: binary ? null : Number(delRaw),
+      binary
+    };
+    if (previousPath) touch.previousPath = previousPath;
+    files.push(touch);
+  }
+  return files;
+}
+function resolveRenamePath(raw) {
+  const braced = /^(.*)\{(.*?) => (.*?)\}(.*)$/.exec(raw);
+  if (braced) {
+    const [, prefix = "", from = "", to = "", suffix = ""] = braced;
+    return {
+      path: collapseSlashes(prefix + to + suffix),
+      previousPath: collapseSlashes(prefix + from + suffix)
+    };
+  }
+  const plain = raw.split(" => ");
+  if (plain.length === 2) {
+    return { path: (plain[1] ?? "").trim(), previousPath: (plain[0] ?? "").trim() };
+  }
+  return { path: raw };
+}
+function collapseSlashes(p) {
+  return p.replace(/\/{2,}/g, "/").replace(/^\//, "");
+}
+function unquoteGitPath(p) {
+  if (p.length < 2 || !p.startsWith('"') || !p.endsWith('"')) return p;
+  const inner = p.slice(1, -1);
+  const bytes = [];
+  for (let i = 0; i < inner.length; i += 1) {
+    const ch = inner[i] ?? "";
+    if (ch !== "\\") {
+      for (const b of Buffer.from(ch, "utf8")) bytes.push(b);
+      continue;
+    }
+    const esc = inner[i + 1] ?? "";
+    const simple = { n: 10, t: 9, r: 13, a: 7, b: 8, f: 12, v: 11 };
+    if (esc in simple) {
+      bytes.push(simple[esc]);
+      i += 1;
+    } else if (esc === '"' || esc === "\\") {
+      bytes.push(esc.charCodeAt(0));
+      i += 1;
+    } else if (/[0-7]/.test(esc)) {
+      const octal = inner.slice(i + 1, i + 4);
+      bytes.push(parseInt(octal, 8) & 255);
+      i += 3;
+    } else {
+      bytes.push(92);
+    }
+  }
+  return Buffer.from(bytes).toString("utf8");
+}
+
+// src/git/log.ts
+var EMPTY_HISTORY = /does not have any commits yet|unknown revision|bad revision|ambiguous argument/i;
+function buildLogArgs(opts = {}) {
+  const { rev = "HEAD", afterCommit, since, maxCount, includeMerges = true, paths } = opts;
+  const args = ["log", `--format=${GIT_LOG_FORMAT}`, "--numstat", "--no-color"];
+  if (!includeMerges) args.push("--no-merges");
+  if (maxCount && maxCount > 0) args.push(`--max-count=${maxCount}`);
+  if (since) args.push(`--since=${since}`);
+  args.push(afterCommit ? `${afterCommit}..${rev}` : rev);
+  if (paths?.length) args.push("--", ...paths);
+  return args;
+}
+async function* readCommits(cwd, opts = {}) {
+  const args = buildLogArgs(opts);
+  let buffer = "";
+  try {
+    for await (const chunk of gitStream(cwd, args)) {
+      buffer += chunk;
+      const { records, rest } = splitRecords(buffer);
+      buffer = rest;
+      for (const record of records) {
+        const commit = parseCommitRecord(record);
+        if (commit) yield commit;
+      }
+    }
+  } catch (err) {
+    if (err instanceof GitError && EMPTY_HISTORY.test(err.stderr)) return;
+    throw err;
+  }
+  for (const record of splitRecords(buffer, true).records) {
+    const commit = parseCommitRecord(record);
+    if (commit) yield commit;
+  }
+}
+
+// src/collectors/git-commits.ts
+var DEFAULTS = { maxFilesPerNode: 40, maxBodyChars: 4e3 };
+var MAX_TITLE_CHARS3 = 200;
+var CONVENTIONAL = /^([a-z]+)(?:\(([^)]*)\))?(!)?:\s*(.+)$/i;
+function parseConventionalHeader(subject) {
+  const m = CONVENTIONAL.exec(subject.trim());
+  if (!m) return { type: null, scope: null, breaking: false, description: subject.trim() };
+  return {
+    type: (m[1] ?? "").toLowerCase(),
+    scope: m[2] ?? null,
+    breaking: Boolean(m[3]),
+    description: (m[4] ?? "").trim()
+  };
+}
+var TYPE_WEIGHTS = {
+  fix: 0.8,
+  feat: 0.8,
+  revert: 0.78,
+  perf: 0.7,
+  refactor: 0.68,
+  security: 0.85,
+  test: 0.45,
+  docs: 0.35,
+  build: 0.32,
+  ci: 0.28,
+  chore: 0.25,
+  style: 0.2
+};
+var AUTOMATED = /^(merge (branch|pull request|remote)|bump |update dependenc|\[bot\]|revert "merge)/i;
+function scoreCommit(commit) {
+  const header = parseConventionalHeader(commit.subject);
+  let score = header.type ? TYPE_WEIGHTS[header.type] ?? 0.5 : 0.5;
+  if (header.breaking) score += 0.12;
+  if (commit.messageBody.length > 120) score += 0.1;
+  if (commit.isMerge) score = Math.min(score, 0.3);
+  if (AUTOMATED.test(commit.subject)) score -= 0.15;
+  const churn = commit.files.reduce((n, f) => n + (f.insertions ?? 0) + (f.deletions ?? 0), 0);
+  if (commit.files.length > 100 || churn > 5e3) score *= 0.75;
+  if (commit.files.length <= 1 && churn <= 3) score -= 0.05;
+  return Number(Math.min(1, Math.max(0.05, score)).toFixed(3));
+}
+function byChurnDesc(a, b) {
+  const ca = (a.insertions ?? 0) + (a.deletions ?? 0);
+  const cb = (b.insertions ?? 0) + (b.deletions ?? 0);
+  return cb - ca;
+}
+function renderFileLine(f) {
+  const churn = f.binary ? "binary" : `+${f.insertions ?? 0}/-${f.deletions ?? 0}`;
+  return f.previousPath ? `  ${f.path} (${churn}, renamed from ${f.previousPath})` : `  ${f.path} (${churn})`;
+}
+function toMemoryNode(commit, projectId, opts = {}) {
+  const maxFiles = opts.maxFilesPerNode ?? DEFAULTS.maxFilesPerNode;
+  const maxBody = opts.maxBodyChars ?? DEFAULTS.maxBodyChars;
+  const header = parseConventionalHeader(commit.subject);
+  const keptFiles = [...commit.files].sort(byChurnDesc).slice(0, maxFiles);
+  const insertions = commit.files.reduce((n, f) => n + (f.insertions ?? 0), 0);
+  const deletions = commit.files.reduce((n, f) => n + (f.deletions ?? 0), 0);
+  const bodyParts = [commit.subject];
+  if (commit.messageBody) bodyParts.push("", commit.messageBody);
+  if (keptFiles.length) {
+    bodyParts.push("", "Files changed:", ...keptFiles.map(renderFileLine));
+    if (commit.files.length > keptFiles.length) {
+      bodyParts.push(`  ...and ${commit.files.length - keptFiles.length} more file(s)`);
+    }
+  }
+  return {
+    id: makeNodeId(projectId, "git_commit", commit.sha),
+    kind: "git_commit",
+    projectId,
+    ts: commit.authoredAt,
+    source: "git",
+    title: truncate(commit.subject || `(no subject) ${commit.shortSha}`, MAX_TITLE_CHARS3),
+    body: truncate(bodyParts.join("\n"), maxBody),
+    files: keptFiles,
+    signal: scoreCommit(commit),
+    meta: {
+      sha: commit.sha,
+      shortSha: commit.shortSha,
+      parents: commit.parents,
+      authorName: commit.authorName,
+      authorEmail: commit.authorEmail,
+      committedAt: commit.committedAt,
+      isMerge: commit.isMerge,
+      filesChanged: commit.files.length,
+      insertions,
+      deletions,
+      conventionalType: header.type,
+      conventionalScope: header.scope,
+      breaking: header.breaking
+    }
+  };
+}
+async function* collectGitCommits(cwd, projectId, opts = {}) {
+  for await (const commit of readCommits(cwd, opts)) {
+    yield toMemoryNode(commit, projectId, opts);
+  }
+}
+
+// src/collectors/shell-history.ts
+var DEFAULT_MAX_BODY_CHARS3 = 1e3;
+var MAX_TITLE_CHARS4 = 200;
+var NOISE = /^(cd|ls|dir|pwd|clear|cls|exit|history|whoami|date|type|cat|more|less|ll|la)\b/i;
+var BUILD_TEST = /^(npm|pnpm|yarn)\s+(run\s+)?(test|build|lint|typecheck|tsc)\b|^(pytest|go\s+test|cargo\s+(test|build)|mvn\s+test|gradle\s+test|dotnet\s+(test|build))\b/i;
+var INSTALL = /^(npm|pnpm|yarn)\s+(install|add|remove|uninstall|ci)\b|^pip\s+install\b|^(cargo\s+add|go\s+get|composer\s+require)\b/i;
+var GIT_CMD = /^git\s+/i;
+var GIT_DESTRUCTIVE = /^git\s+(push\s+.*--force|reset\s+--hard|clean\s+-[a-z]*f|branch\s+-d)\b/i;
+var RISKY = /(rm\s+-rf|remove-item\s+.*-recurse|del\s+\/s|drop\s+(table|database)|--force\b|truncate\s+table)/i;
+function scoreShellCommand(entry) {
+  const cmd = entry.command.trim();
+  let score;
+  if (NOISE.test(cmd)) score = 0.1;
+  else if (RISKY.test(cmd) || GIT_DESTRUCTIVE.test(cmd)) score = 0.75;
+  else if (INSTALL.test(cmd)) score = 0.6;
+  else if (BUILD_TEST.test(cmd)) score = 0.55;
+  else if (GIT_CMD.test(cmd)) score = 0.2;
+  else score = 0.35;
+  if (entry.exitCode !== null) {
+    score += entry.exitCode !== 0 ? 0.25 : 0.05;
+  }
+  if (cmd.length > 60) score += 0.05;
+  else if (cmd.length <= 3) score -= 0.05;
+  return Number(Math.min(1, Math.max(0.05, score)).toFixed(3));
+}
+function renderBody(entry, maxChars) {
+  const parts = [`$ ${entry.command}`];
+  const metaLine = [];
+  if (entry.cwd) metaLine.push(`cwd: ${entry.cwd}`);
+  if (entry.exitCode !== null) metaLine.push(`exit: ${entry.exitCode}`);
+  if (entry.durationMs !== null) metaLine.push(`duration: ${entry.durationMs}ms`);
+  if (metaLine.length) parts.push("", metaLine.join("  "));
+  return truncate(parts.join("\n"), maxChars);
+}
+function toMemoryNode2(entry, projectId, opts = {}) {
+  const maxBody = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS3;
+  const titleLine = entry.command.split(/\r?\n/)[0] ?? entry.command;
+  return {
+    id: makeNodeId(projectId, "shell_command", entry.naturalKey),
+    kind: "shell_command",
+    projectId,
+    ts: entry.ts,
+    source: `shell:${entry.shell}`,
+    title: truncate(titleLine, MAX_TITLE_CHARS4),
+    body: renderBody(entry, maxBody),
+    files: [],
+    signal: scoreShellCommand(entry),
+    meta: {
+      command: entry.command,
+      cwd: entry.cwd,
+      exitCode: entry.exitCode,
+      durationMs: entry.durationMs,
+      tsApprox: entry.tsApprox,
+      shell: entry.shell
+    }
+  };
+}
+function collectShellHistory(entries, projectId, opts = {}) {
+  return entries.map((entry) => toMemoryNode2(entry, projectId, opts));
+}
+
+// src/conversation/claude-code-reader.ts
+import { readFile as readFile3 } from "fs/promises";
+
+// src/conversation/paths.ts
+import { existsSync as existsSync2 } from "fs";
+import { readdir } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+function claudeProjectSlug(repoRoot) {
+  return repoRoot.replace(/[\\/:]/g, "-");
+}
+function claudeProjectTranscriptDir(repoRoot) {
+  return join3(homedir2(), ".claude", "projects", claudeProjectSlug(repoRoot));
+}
+async function listTranscriptFiles(repoRoot) {
+  const dir = claudeProjectTranscriptDir(repoRoot);
+  if (!existsSync2(dir)) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join3(dir, e.name));
+}
+
+// src/conversation/claude-code-reader.ts
+function parseLine(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function extractUserText(line) {
+  const content = line.message?.content;
+  if (typeof content === "string") return content.trim() || null;
+  if (Array.isArray(content)) {
+    if (content.some((b) => b.type === "tool_result")) return null;
+    const text = content.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n").trim();
+    return text || null;
+  }
+  return null;
+}
+function extractAssistantText(line) {
+  const content = line.message?.content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n").trim();
+}
+function parseClaudeCodeTranscript(raw, opts = {}) {
+  const source = opts.source ?? "claude-code";
+  const turns = [];
+  let current = null;
+  const flush = () => {
+    if (!current) return;
+    const assistantText = current.assistantParts.join("\n\n").trim();
+    turns.push({
+      naturalKey: `claude-code:${current.uuid}`,
+      userText: current.userText,
+      assistantText,
+      ts: current.ts,
+      cwd: current.cwd,
+      source
+    });
+    current = null;
+  };
+  for (const rawLine of raw.split(/\r?\n/)) {
+    const line = parseLine(rawLine);
+    if (!line || line.isSidechain) continue;
+    if (line.type === "user") {
+      const userText = extractUserText(line);
+      if (userText === null) continue;
+      flush();
+      current = {
+        uuid: line.uuid ?? `noid-${turns.length}`,
+        userText,
+        ts: line.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+        cwd: line.cwd ?? null,
+        assistantParts: []
+      };
+      continue;
+    }
+    if (line.type === "assistant" && current) {
+      const text = extractAssistantText(line);
+      if (text) current.assistantParts.push(text);
+    }
+  }
+  flush();
+  return turns;
+}
+async function collectClaudeCodeTranscripts(repoRoot) {
+  const files = await listTranscriptFiles(repoRoot);
+  const turns = [];
+  for (const file of files) {
+    const raw = await readFile3(file, "utf8");
+    turns.push(...parseClaudeCodeTranscript(raw));
+  }
+  return turns;
+}
+
+// src/docs/read.ts
+import { readFile as readFile4, stat } from "fs/promises";
+import { join as join4 } from "path";
+var DEFAULT_PATHSPECS = ["*.md"];
+async function listDocFiles(repoRoot, opts = {}) {
+  const pathspecs = opts.include ?? DEFAULT_PATHSPECS;
+  const out = await git(repoRoot, ["ls-files", "--", ...pathspecs]);
+  return out.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+async function readDocFiles(repoRoot, opts = {}) {
+  const paths = await listDocFiles(repoRoot, opts);
+  const files = [];
+  const unreadable = [];
+  for (const relPath of paths) {
+    const path = relPath.replace(/\\/g, "/");
+    const absPath = join4(repoRoot, relPath);
+    let content;
+    let mtime;
+    try {
+      [content, { mtime }] = await Promise.all([readFile4(absPath, "utf8"), stat(absPath)]);
+    } catch {
+      unreadable.push(path);
+      continue;
+    }
+    files.push({ path, content, ts: mtime.toISOString() });
+  }
+  return { files, unreadable };
+}
+
+// src/shell/detect.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile6, stat as stat2 } from "fs/promises";
+
+// src/shell/hook-log.ts
+import { appendFile, mkdir as mkdir3, readFile as readFile5 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+function parseHookLogLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  let obj;
+  try {
+    obj = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (typeof obj !== "object" || obj === null) return null;
+  const o = obj;
+  if (typeof o.ts !== "string" || typeof o.cwd !== "string" || typeof o.command !== "string") return null;
+  return {
+    ts: o.ts,
+    cwd: o.cwd,
+    exitCode: typeof o.exitCode === "number" ? o.exitCode : null,
+    durationMs: typeof o.durationMs === "number" ? o.durationMs : null,
+    command: o.command
+  };
+}
+async function readHookLog(path, fromLine) {
+  let raw;
+  try {
+    raw = await readFile5(path, "utf8");
+  } catch {
+    return { entries: [], totalLines: fromLine };
+  }
+  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 };
+}
+
+// src/shell/parse-bash.ts
+var EPOCH_COMMENT = /^#(\d{9,10})$/;
+function parseBashHistory(raw, mtimeMs, opts = {}) {
+  const lines = raw.split(/\r?\n/);
+  const prelim = [];
+  let pendingEpoch = null;
+  for (const line of lines) {
+    if (line.trim().length === 0) continue;
+    const m = EPOCH_COMMENT.exec(line.trim());
+    if (m) {
+      pendingEpoch = Number(m[1]);
+      continue;
+    }
+    prelim.push({ command: line, ts: pendingEpoch !== null ? new Date(pendingEpoch * 1e3).toISOString() : null });
+    pendingEpoch = null;
+  }
+  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(),
+      tsApprox: approx,
+      exitCode: null,
+      cwd: null,
+      durationMs: null,
+      shell: "bash"
+    };
+  });
+}
+
+// src/shell/parse-psreadline.ts
+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(),
+      tsApprox: true,
+      exitCode: null,
+      cwd: null,
+      durationMs: null,
+      shell: "pwsh"
+    };
+  });
+}
+
+// src/shell/parse-zsh.ts
+var EXTENDED_PREFIX = /^: (\d+):(\d+);(.*)$/;
+function parseZshHistory(raw, mtimeMs, opts = {}) {
+  const rawLines = raw.split(/\r?\n/);
+  const prelim = [];
+  let i = 0;
+  while (i < rawLines.length) {
+    const line = rawLines[i] ?? "";
+    if (line.trim().length === 0) {
+      i += 1;
+      continue;
+    }
+    const m = EXTENDED_PREFIX.exec(line);
+    let epoch = null;
+    let duration = null;
+    let cmd;
+    if (m) {
+      epoch = Number(m[1]);
+      duration = Number(m[2]);
+      cmd = m[3] ?? "";
+    } else {
+      cmd = line;
+    }
+    while (cmd.endsWith("\\") && i + 1 < rawLines.length) {
+      i += 1;
+      cmd = `${cmd.slice(0, -1)}
+${rawLines[i]}`;
+    }
+    prelim.push({ command: cmd, ts: epoch !== null ? new Date(epoch * 1e3).toISOString() : null, durationMs: duration });
+    i += 1;
+  }
+  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(),
+      tsApprox: approx,
+      exitCode: null,
+      cwd: null,
+      durationMs: p.durationMs,
+      shell: "zsh"
+    };
+  });
+}
+
+// src/shell/detect.ts
+function isUnderRoot(cwd, root) {
+  const norm = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+  const c = norm(cwd);
+  const r = norm(root);
+  return c === r || c.startsWith(`${r}/`);
+}
+function hookEntryToRaw(e) {
+  return {
+    naturalKey: `pwsh-hook:${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"
+  };
+}
+async function tryReadScrapeSource(path, parse, tailLines) {
+  if (!existsSync3(path)) return null;
+  const [raw, stats] = await Promise.all([readFile6(path, "utf8"), stat2(path)]);
+  return parse(raw, stats.mtimeMs, { tailLines });
+}
+async function collectAvailableShellHistory(opts = {}) {
+  const results = [];
+  const tailLines = opts.tailLines ?? 300;
+  const preferHook = opts.preferHook ?? true;
+  const hookPath = hookLogPath();
+  const hookExists = existsSync3(hookPath);
+  if (hookExists) {
+    const fromLine = Number(opts.hookCursor ?? "0") || 0;
+    const { entries, totalLines } = await readHookLog(hookPath, fromLine);
+    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;
+  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 });
+  return results;
+}
+
+// src/vector/sync.ts
+async function embedPendingNodes(store, provider, projectId, opts = {}) {
+  const pending = store.findNodesNeedingEmbedding(projectId, opts.batchLimit ?? 200);
+  let embedded = 0;
+  let skipped = 0;
+  for (const node of pending) {
+    const vector = await provider.embed(`${node.title}
+${node.body}`);
+    if (vector && vector.length === provider.dimension) {
+      store.upsertEmbedding(node.rowid, vector);
+      embedded += 1;
+    } else {
+      skipped += 1;
+    }
+  }
+  return { embedded, skipped, providerUnavailable: pending.length > 0 && embedded === 0 };
+}
+
+// src/cli/context.ts
+async function loadContext(cwd) {
+  const repo = await readRepoInfo(cwd);
+  const ws = resolveWorkspace(repo.root);
+  const config = await readConfig(ws);
+  return { repo, ws, projectId: makeProjectId({ root: repo.root, originUrl: repo.originUrl }), config };
+}
+
+// src/cli/commands/sync.ts
+var BATCH_SIZE = 500;
+var GIT_SOURCE = "git";
+function addStats(into, from) {
+  into.inserted += from.inserted;
+  into.updated += from.updated;
+  into.unchanged += from.unchanged;
+}
+async function syncGit(store, projectId, opts, repo, config, log) {
+  const totals = { inserted: 0, updated: 0, unchanged: 0 };
+  if (!repo.head) {
+    log(`${pc3.yellow("git")} skipped -- repository has no commits yet`);
+    return { totals, seen: 0 };
+  }
+  if (!config.sources.git.enabled) {
+    log(`${pc3.dim("git")} disabled in config`);
+    return { totals, seen: 0 };
+  }
+  let cursor = opts.full || opts.rebuild ? null : store.getSyncCursor(projectId, GIT_SOURCE);
+  if (cursor && !await isAncestor(repo.root, cursor, repo.head)) {
+    log(`${pc3.yellow("git cursor stale")} ${cursor.slice(0, 7)} is not an ancestor of HEAD \u2014 falling back to a full walk`);
+    cursor = null;
+  }
+  if (cursor === repo.head) {
+    log(`${pc3.green("git up to date")} at ${repo.head.slice(0, 7)}`);
+    store.setSyncCursor(projectId, GIT_SOURCE, repo.head);
+    return { totals, seen: 0 };
+  }
+  log(
+    `${pc3.dim("git syncing")} ${repo.branch ?? "HEAD"} ${cursor ? `${cursor.slice(0, 7)}..${repo.head.slice(0, 7)}` : "(full history)"}`
+  );
+  let batch = [];
+  let seen = 0;
+  const flush = () => {
+    if (batch.length === 0) return;
+    addStats(totals, store.upsertNodes(batch));
+    batch = [];
+    log(`  ${pc3.dim(`${seen} commits read, ${totals.inserted} new`)}`);
+  };
+  const nodes = collectGitCommits(repo.root, projectId, {
+    afterCommit: cursor,
+    since: opts.since ?? config.sources.git.since,
+    includeMerges: config.sources.git.includeMerges,
+    maxFilesPerNode: config.limits.maxFilesPerNode,
+    maxBodyChars: config.limits.maxBodyChars
+  });
+  for await (const node of nodes) {
+    batch.push(node);
+    seen += 1;
+    if (batch.length >= BATCH_SIZE) flush();
+  }
+  flush();
+  store.setSyncCursor(projectId, GIT_SOURCE, repo.head);
+  return { totals, seen };
+}
+async function syncShell(store, projectId, opts, repoRoot, config, log) {
+  const totals = { inserted: 0, updated: 0, unchanged: 0 };
+  if (!config.sources.shell.enabled) {
+    log(`${pc3.dim("shell")} disabled in config`);
+    return { totals, seen: 0 };
+  }
+  const results = await collectAvailableShellHistory({
+    tailLines: opts.shellTailLines ?? config.sources.shell.tailLines,
+    repoRoot,
+    hookCursor: store.getSyncCursor(projectId, "shell:pwsh-hook")
+  });
+  if (results.length === 0) {
+    log(`${pc3.dim("shell")} no history source found on this machine`);
+    return { totals, seen: 0 };
+  }
+  let seen = 0;
+  for (const result of results) {
+    const sourceKey = `shell:${result.name}`;
+    const nodes = collectShellHistory(result.entries, projectId, { maxBodyChars: config.limits.maxBodyChars });
+    seen += nodes.length;
+    if (nodes.length > 0) {
+      addStats(totals, store.upsertNodes(nodes));
+    }
+    store.setSyncCursor(projectId, sourceKey, result.cursorAfter ?? `scanned:${result.entries.length}`);
+    log(`  ${pc3.dim(`${sourceKey}: ${nodes.length} entr${nodes.length === 1 ? "y" : "ies"} read`)}`);
+  }
+  return { totals, seen };
+}
+var CONVERSATION_SOURCE = "conversation:claude-code";
+async function syncConversation(store, projectId, repoRoot, config, log, forceEnabled) {
+  const totals = { inserted: 0, updated: 0, unchanged: 0 };
+  const enabled = forceEnabled ?? config.sources.conversation.enabled;
+  if (!enabled) {
+    return { totals, seen: 0 };
+  }
+  const turns = await collectClaudeCodeTranscripts(repoRoot);
+  if (turns.length === 0) {
+    log(`${pc3.dim("conversation")} no transcripts found`);
+    return { totals, seen: 0 };
+  }
+  const nodes = collectConversationTurns(turns, projectId, { maxBodyChars: config.limits.maxBodyChars });
+  if (nodes.length > 0) addStats(totals, store.upsertNodes(nodes));
+  store.setSyncCursor(projectId, CONVERSATION_SOURCE, `scanned:${nodes.length}`);
+  log(`  ${pc3.dim(`${CONVERSATION_SOURCE}: ${nodes.length} of ${turns.length} exchange(s) kept`)}`);
+  return { totals, seen: nodes.length };
+}
+var DOCS_SOURCE = "docs";
+async function syncDocs(store, projectId, repoRoot, config, log) {
+  const totals = { inserted: 0, updated: 0, unchanged: 0 };
+  if (!config.sources.docs.enabled) {
+    log(`${pc3.dim("docs")} disabled in config`);
+    return { totals, seen: 0 };
+  }
+  const { files, unreadable } = await readDocFiles(repoRoot, { include: config.sources.docs.include });
+  const nodes = collectDocFiles(files, projectId, { maxBodyChars: config.limits.maxBodyChars });
+  if (nodes.length > 0) addStats(totals, store.upsertNodes(nodes));
+  const pruned = store.pruneSourceNodes(
+    projectId,
+    DOCS_SOURCE,
+    nodes.map((node) => node.id),
+    { keepPaths: unreadable }
+  );
+  store.setSyncCursor(projectId, DOCS_SOURCE, `scanned:${nodes.length}`);
+  if (files.length === 0 && unreadable.length === 0) {
+    log(`${pc3.dim("docs")} no tracked .md files found`);
+  } else {
+    const prunedPart = pruned > 0 ? `, ${pc3.yellow(`${pruned} stale removed`)}` : "";
+    const skippedPart = unreadable.length > 0 ? `, ${unreadable.length} unreadable (kept)` : "";
+    log(`  ${pc3.dim(`${DOCS_SOURCE}: ${nodes.length} section(s) from ${files.length} file(s)`)}${prunedPart}${pc3.dim(skippedPart)}`);
+  }
+  return { totals, seen: nodes.length };
+}
+async function runSync(opts) {
+  const { repo, ws, projectId, config } = await loadContext(opts.cwd);
+  const log = (line) => {
+    if (!opts.quiet) process.stderr.write(`${line}
+`);
+  };
+  const out = opts.out ?? ((chunk) => void process.stdout.write(chunk));
+  const store = MemoryStore.open(ws.dbPath);
+  const started = Date.now();
+  try {
+    store.upsertProject({ id: projectId, root: repo.root, originUrl: repo.originUrl });
+    if (opts.rebuild) {
+      const removed = store.clearProject(projectId);
+      log(`${pc3.dim("rebuild")} dropped ${removed} existing node(s)`);
+    }
+    const git2 = await syncGit(store, projectId, opts, repo, config, log);
+    const shell = await syncShell(store, projectId, opts, repo.root, config, log);
+    const conversation = await syncConversation(store, projectId, repo.root, config, log, opts.conversationOverride);
+    const docs = await syncDocs(store, projectId, repo.root, config, log);
+    let embedLine = "";
+    if (!opts.noEmbed) {
+      const result = await embedPendingNodes(store, new OllamaEmbeddingProvider(), projectId);
+      if (result.embedded > 0) {
+        embedLine = `  ${pc3.dim(`vector: ${result.embedded} node(s) embedded`)}${result.skipped > 0 ? pc3.dim(`, ${result.skipped} skipped`) : ""}
+`;
+      } else if (result.providerUnavailable) {
+        log(`${pc3.dim("vector")} embedding provider unavailable (is Ollama running with nomic-embed-text pulled?) -- BM25-only for now`);
+      }
+    }
+    store.markSynced(projectId);
+    const totals = { inserted: 0, updated: 0, unchanged: 0 };
+    addStats(totals, git2.totals);
+    addStats(totals, shell.totals);
+    addStats(totals, conversation.totals);
+    addStats(totals, docs.totals);
+    const stats = store.stats(projectId);
+    const elapsed = ((Date.now() - started) / 1e3).toFixed(2);
+    const conversationEnabled = opts.conversationOverride ?? config.sources.conversation.enabled;
+    const conversationPart = conversationEnabled ? `, ${conversation.seen} conversation exchange(s)` : "";
+    const docsPart = config.sources.docs.enabled ? `, ${docs.seen} doc section(s)` : "";
+    out(
+      [
+        `${pc3.green("synced")} ${git2.seen} commit(s), ${shell.seen} shell entr${shell.seen === 1 ? "y" : "ies"}${conversationPart}${docsPart} in ${elapsed}s`,
+        `  ${pc3.green(`+${totals.inserted} new`)}  ${pc3.yellow(`~${totals.updated} updated`)}  ${pc3.dim(`=${totals.unchanged} unchanged`)}`,
+        `  ${pc3.dim(`${stats.total} node(s) total across ${stats.distinctFiles} file path(s)`)}`,
+        ""
+      ].join("\n") + embedLine
+    );
+    return 0;
+  } finally {
+    store.close();
+  }
+}
+
+// src/mcp/tools.ts
+async function searchMemory(input) {
+  const repo = await readRepoInfo(input.projectRoot);
+  const ws = resolveWorkspace(repo.root);
+  const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
+  const budget = input.budget ?? 2e3;
+  const candidates = input.candidates ?? 30;
+  const store = MemoryStore.open(ws.dbPath);
+  try {
+    const { bm25Count, vectorCount, hits, packed } = await runHybridQuery(store, projectId, input.query, {
+      budget,
+      candidates,
+      embeddingProvider: input.noVector ? null : new OllamaEmbeddingProvider()
+    });
+    return {
+      text: renderContextBlock(input.query, packed),
+      matched: hits.length,
+      bm25Matched: bm25Count,
+      vectorMatched: vectorCount,
+      tokensUsed: packed.tokensUsed,
+      tokensBudget: packed.tokensBudget
+    };
+  } finally {
+    store.close();
+  }
+}
+async function syncProject(input) {
+  const chunks = [];
+  const out = (chunk) => {
+    chunks.push(chunk);
+  };
+  await runInit({ cwd: input.projectRoot, force: false, hook: false, enableConversation: false, out });
+  const opts = {
+    cwd: input.projectRoot,
+    full: false,
+    rebuild: false,
+    quiet: true,
+    noEmbed: input.noEmbed,
+    out
+  };
+  await runSync(opts);
+  return { summary: chunks.join("").trim() };
+}
+async function getStatus(input) {
+  const repo = await readRepoInfo(input.projectRoot);
+  const ws = resolveWorkspace(repo.root);
+  const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
+  const store = MemoryStore.open(ws.dbPath);
+  try {
+    const stats = store.stats(projectId);
+    return { total: stats.total, byKind: stats.byKind, sources: store.listSyncState(projectId) };
+  } finally {
+    store.close();
+  }
+}
+
+// src/mcp/server.ts
+function createServer() {
+  const server = new McpServer({ name: "nexusmem", version: "0.1.0" });
+  server.registerTool(
+    "search_memory",
+    {
+      title: "Search remembered project history",
+      description: "Search a NexusMem-tracked repository's remembered history: git commits, shell commands, tracked markdown docs, and (if enabled) conversation transcripts. Returns a token-budgeted, ranked context block -- not raw search results.",
+      inputSchema: {
+        projectRoot: z2.string().describe("Absolute path to the repository root"),
+        query: z2.string().describe("Free-text question or search terms"),
+        budget: z2.number().int().positive().optional().describe("Max tokens in the returned context block. Default 2000.")
+      }
+    },
+    async ({ projectRoot, query, budget }) => {
+      const result = await searchMemory({ projectRoot, query, budget });
+      return {
+        content: [{ type: "text", text: result.text }],
+        structuredContent: {
+          text: result.text,
+          matched: result.matched,
+          bm25Matched: result.bm25Matched,
+          vectorMatched: result.vectorMatched,
+          tokensUsed: result.tokensUsed,
+          tokensBudget: result.tokensBudget
+        }
+      };
+    }
+  );
+  server.registerTool(
+    "sync_project",
+    {
+      title: "Sync remembered history",
+      description: "Ingest new git, shell, docs and (if enabled) conversation history for a NexusMem-tracked repository into its local database.",
+      inputSchema: {
+        projectRoot: z2.string().describe("Absolute path to the repository root")
+      }
+    },
+    async ({ projectRoot }) => {
+      const result = await syncProject({ projectRoot });
+      return { content: [{ type: "text", text: result.summary }] };
+    }
+  );
+  server.registerTool(
+    "get_status",
+    {
+      title: "Show what is remembered",
+      description: "Report how many nodes NexusMem currently remembers for a repository, broken down by kind and source.",
+      inputSchema: {
+        projectRoot: z2.string().describe("Absolute path to the repository root")
+      }
+    },
+    async ({ projectRoot }) => {
+      const result = await getStatus({ projectRoot });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        structuredContent: result
+      };
+    }
+  );
+  return server;
+}
+async function runMcpServer() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/cli/commands/query.ts
+import pc4 from "picocolors";
+async function runQuery(opts) {
+  const { ws, projectId } = await loadContext(opts.cwd);
+  const store = MemoryStore.open(ws.dbPath);
+  try {
+    const { bm25Count, vectorCount, hits, packed } = await runHybridQuery(store, projectId, opts.query, {
+      budget: opts.budget,
+      candidates: opts.candidates,
+      halfLifeDays: opts.halfLifeDays,
+      embeddingProvider: opts.noVector ? null : new OllamaEmbeddingProvider()
+    });
+    const matched = hits.length;
+    const rawTokens = hits.reduce((n, h) => n + approxTokens(h.body), 0);
+    const packerEfficiency = rawTokens > 0 ? 1 - packed.tokensUsed / rawTokens : 0;
+    if (opts.json) {
+      process.stdout.write(
+        `${JSON.stringify(
+          {
+            query: opts.query,
+            matched,
+            bm25Matched: bm25Count,
+            vectorMatched: vectorCount,
+            packed: packed.nodes,
+            tokensUsed: packed.tokensUsed,
+            tokensBudget: packed.tokensBudget,
+            droppedForBudget: packed.droppedForBudget
+          },
+          null,
+          2
+        )}
+`
+      );
+      return 0;
+    }
+    if (matched === 0) {
+      process.stderr.write(`${pc4.yellow("no matches")} for "${opts.query}"
+`);
+      return 0;
+    }
+    process.stderr.write(
+      [
+        `${pc4.dim("matched")} ${bm25Count} bm25${vectorCount > 0 ? ` + ${vectorCount} vector` : ""}, packed ${pc4.bold(String(packed.nodes.length))} into budget`,
+        `${pc4.dim("tokens ")} ${packed.tokensUsed}/${packed.tokensBudget}` + (packed.droppedForBudget ? pc4.dim(`  (${packed.droppedForBudget} dropped for budget)`) : ""),
+        rawTokens > 0 ? `${pc4.dim("vs raw ")} ${rawTokens} tokens if these same matches were sent unpacked  ${packerEfficiency >= 0 ? pc4.green(`(${(packerEfficiency * 100).toFixed(0)}% packer efficiency)`) : pc4.yellow(`(${(-packerEfficiency * 100).toFixed(0)}% larger -- overhead dominates on small result sets)`)}` : "",
+        ""
+      ].filter(Boolean).join("\n")
+    );
+    process.stdout.write(`${renderContextBlock(opts.query, packed)}
+`);
+    return 0;
+  } finally {
+    store.close();
+  }
+}
+
+// src/cli/commands/scan-conversation.ts
+import pc6 from "picocolors";
+
+// src/cli/format.ts
+import pc5 from "picocolors";
+var GIT_SIGNAL_BANDS = { high: 0.7, medium: 0.45 };
+var SHELL_SIGNAL_BANDS = { high: 0.6, medium: 0.4 };
+var CONVERSATION_SIGNAL_BANDS = { high: 0.55, medium: 0.35 };
+var DOCS_SIGNAL_BANDS = { high: 0.55, medium: 0.35 };
+function signalBand(signal, bands) {
+  if (signal >= bands.high) return "high";
+  if (signal >= bands.medium) return "medium";
+  return "low";
+}
+var BAND_COLOR = {
+  high: pc5.green,
+  medium: pc5.yellow,
+  low: pc5.dim
+};
+function formatSignal(signal, bands) {
+  return BAND_COLOR[signalBand(signal, bands)](signal.toFixed(2));
+}
+
+// src/cli/commands/scan-conversation.ts
+async function runScanConversation(opts) {
+  const repo = await readRepoInfo(opts.cwd);
+  const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
+  const files = await listTranscriptFiles(repo.root);
+  if (!opts.json) {
+    process.stderr.write(
+      files.length ? `${pc6.dim("transcripts")} ${files.length} file(s) in ${claudeProjectTranscriptDir(repo.root)}
+
+` : `${pc6.yellow("no transcripts found")} at ${claudeProjectTranscriptDir(repo.root)}
+`
+    );
+  }
+  const turns = await collectClaudeCodeTranscripts(repo.root);
+  const nodes = collectConversationTurns(turns, projectId).filter((n) => n.signal >= opts.minSignal);
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(nodes, null, 2)}
+`);
+    return 0;
+  }
+  for (const node of nodes) process.stdout.write(`${formatNode(node)}
+`);
+  const redactedTotal = nodes.reduce((n, x) => n + (Number(x.meta.redactedCount) || 0), 0);
+  const approxTotal = nodes.reduce((n, x) => n + approxTokens(x.body), 0);
+  process.stderr.write(
+    `
+${pc6.bold(String(nodes.length))} of ${turns.length} exchange(s) above threshold  ${pc6.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}` + (redactedTotal > 0 ? `  ${pc6.yellow(`${redactedTotal} secret-like value(s) redacted`)}` : "") + "\n"
+  );
+  return 0;
+}
+function formatNode(node) {
+  return [formatSignal(node.signal, CONVERSATION_SIGNAL_BANDS), node.ts.slice(0, 16).replace("T", " "), node.title].join(" ");
+}
+
+// src/cli/commands/scan-docs.ts
+import pc7 from "picocolors";
+async function runScanDocs(opts) {
+  const repo = await readRepoInfo(opts.cwd);
+  const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
+  const { files, unreadable } = await readDocFiles(repo.root);
+  if (!opts.json) {
+    process.stderr.write(
+      files.length ? `${pc7.dim("tracked .md files")} ${files.map((f) => f.path).join(", ")}
+
+` : `${pc7.yellow("no tracked .md files found")}
+`
+    );
+    if (unreadable.length > 0) {
+      process.stderr.write(`${pc7.yellow("unreadable")} ${unreadable.join(", ")}
+
+`);
+    }
+  }
+  const nodes = collectDocFiles(files, projectId).filter((n) => n.signal >= opts.minSignal);
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(nodes, null, 2)}
+`);
+    return 0;
+  }
+  for (const node of nodes) process.stdout.write(`${formatNode2(node)}
+`);
+  const approxTotal = nodes.reduce((n, x) => n + approxTokens(x.body), 0);
+  process.stderr.write(
+    `
+${pc7.bold(String(nodes.length))} section(s) from ${files.length} file(s) above threshold  ${pc7.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
+`
+  );
+  return 0;
+}
+function formatNode2(node) {
+  return [formatSignal(node.signal, DOCS_SIGNAL_BANDS), node.title].join(" ");
+}
+
+// src/cli/commands/scan-git.ts
+import pc8 from "picocolors";
+async function runScanGit(opts) {
+  const repo = await readRepoInfo(opts.cwd);
+  const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
+  if (!opts.json) {
+    process.stderr.write(
+      [
+        `${pc8.dim("repo   ")} ${repo.root}`,
+        `${pc8.dim("branch ")} ${repo.branch ?? pc8.yellow("(detached)")}`,
+        `${pc8.dim("origin ")} ${repo.originUrl ?? pc8.dim("(none)")}`,
+        `${pc8.dim("project")} ${pc8.cyan(projectId)}`,
+        ""
+      ].join("\n")
+    );
+  }
+  const nodes = [];
+  const collectOpts = {
+    since: opts.since ?? null,
+    maxCount: opts.limit ?? null,
+    includeMerges: opts.merges
+  };
+  for await (const node of collectGitCommits(repo.root, projectId, collectOpts)) {
+    if (node.signal < opts.minSignal) continue;
+    nodes.push(node);
+    if (!opts.json) process.stdout.write(`${formatNode3(node)}
+`);
+  }
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(nodes, null, 2)}
+`);
+    return 0;
+  }
+  process.stderr.write(`
+${summarize2(nodes)}
+`);
+  return 0;
+}
+function formatNode3(node) {
+  const sha = String(node.meta.shortSha ?? "").padEnd(9);
+  const date = node.ts.slice(0, 10);
+  const files = Number(node.meta.filesChanged ?? 0);
+  const churn = `+${node.meta.insertions ?? 0}/-${node.meta.deletions ?? 0}`;
+  return [
+    formatSignal(node.signal, GIT_SIGNAL_BANDS),
+    pc8.dim(date),
+    pc8.magenta(sha),
+    node.title,
+    pc8.dim(`(${files} file${files === 1 ? "" : "s"}, ${churn})`)
+  ].join(" ");
+}
+function summarize2(nodes) {
+  if (nodes.length === 0) return pc8.yellow("no commits matched");
+  const timestamps = nodes.map((n) => n.ts).sort();
+  const avgSignal = nodes.reduce((n, x) => n + x.signal, 0) / nodes.length;
+  const totalTokens = nodes.reduce((n, x) => n + approxTokens(x.body), 0);
+  const fileHits = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    for (const f of node.files) fileHits.set(f.path, (fileHits.get(f.path) ?? 0) + 1);
+  }
+  const hottest = [...fileHits.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([path, count]) => `    ${String(count).padStart(3)}x ${path}`);
+  return [
+    `${pc8.bold(String(nodes.length))} nodes  ${pc8.dim(`${timestamps[0]?.slice(0, 10)} .. ${timestamps.at(-1)?.slice(0, 10)}`)}`,
+    `  avg signal ${avgSignal.toFixed(3)}   ~${totalTokens.toLocaleString()} tokens if sent raw`,
+    hottest.length ? `  hottest files:
+${hottest.join("\n")}` : ""
+  ].filter(Boolean).join("\n");
+}
+
+// src/cli/commands/scan-shell.ts
+import pc9 from "picocolors";
+async function runScanShell(opts) {
+  const repo = await readRepoInfo(opts.cwd);
+  const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
+  const results = await collectAvailableShellHistory({ tailLines: opts.tailLines, repoRoot: repo.root });
+  if (!opts.json) {
+    process.stderr.write(
+      results.length ? `${pc9.dim("sources found")} ${results.map((r) => r.name).join(", ")}
+
+` : `${pc9.yellow("no shell history source found on this machine")}
+`
+    );
+  }
+  const allNodes = [];
+  for (const result of results) {
+    const nodes = collectShellHistory(result.entries, projectId).filter((n) => n.signal >= opts.minSignal);
+    allNodes.push(...nodes);
+    if (!opts.json) {
+      process.stdout.write(`${pc9.bold(`shell:${result.name}`)} ${pc9.dim(`(${nodes.length} of ${result.entries.length} above threshold)`)}
+`);
+      for (const node of nodes) process.stdout.write(`${formatNode4(node)}
+`);
+      process.stdout.write("\n");
+    }
+  }
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(allNodes, null, 2)}
+`);
+    return 0;
+  }
+  const approxTotal = allNodes.reduce((n, x) => n + approxTokens(x.body), 0);
+  process.stderr.write(`${pc9.bold(String(allNodes.length))} node(s) total  ${pc9.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
+`);
+  return 0;
+}
+function formatNode4(node) {
+  const approx = node.meta.tsApprox ? pc9.dim("~") : " ";
+  const exit = node.meta.exitCode;
+  const exitLabel = typeof exit === "number" && exit !== 0 ? pc9.red(`exit ${exit}`) : "";
+  return [formatSignal(node.signal, SHELL_SIGNAL_BANDS), approx + node.ts.slice(0, 16).replace("T", " "), node.title, exitLabel].filter(Boolean).join(" ");
+}
+
+// src/cli/commands/status.ts
+import { statSync } from "fs";
+import pc10 from "picocolors";
+function humanBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+function fileSize(path) {
+  try {
+    return statSync(path).size;
+  } catch {
+    return 0;
+  }
+}
+async function runStatus(opts) {
+  const { repo, ws, projectId } = await loadContext(opts.cwd);
+  const store = MemoryStore.open(ws.dbPath);
+  try {
+    const stats = store.stats(projectId);
+    const sources = store.listSyncState(projectId);
+    const gitCursor = sources.find((s) => s.source === "git")?.cursor ?? null;
+    const schema = currentSchemaVersion(store.raw);
+    const dbBytes = fileSize(ws.dbPath) + fileSize(`${ws.dbPath}-wal`);
+    const kinds = Object.entries(stats.byKind).sort((a, b) => b[1] - a[1]).map(([kind, n]) => `    ${String(n).padStart(6)}  ${kind}`);
+    process.stdout.write(
+      [
+        `${pc10.dim("repo    ")} ${repo.root}`,
+        `${pc10.dim("branch  ")} ${repo.branch ?? pc10.yellow("(detached)")}`,
+        `${pc10.dim("project ")} ${pc10.cyan(projectId)}`,
+        `${pc10.dim("schema  ")} v${schema}${schema === LATEST_SCHEMA_VERSION ? "" : pc10.yellow(` (latest is v${LATEST_SCHEMA_VERSION})`)}`,
+        `${pc10.dim("database")} ${ws.dbPath} ${pc10.dim(`(${humanBytes(dbBytes)})`)}`,
+        "",
+        `${pc10.bold(String(stats.total))} node(s)${stats.total ? ` ${pc10.dim(`${stats.oldest?.slice(0, 10)} .. ${stats.newest?.slice(0, 10)}`)}` : ""}`,
+        ...kinds,
+        stats.total ? `    ${pc10.dim(`${stats.distinctFiles} distinct file path(s)`)}` : "",
+        "",
+        sources.length ? pc10.dim("sources") : pc10.yellow("no sources synced yet"),
+        ...sources.map((s) => {
+          const when = s.lastRunAt ? new Date(s.lastRunAt).toISOString().slice(0, 16).replace("T", " ") : "never";
+          const cursorLabel = s.source === "git" ? s.cursor?.slice(0, 7) ?? "-" : s.cursor ?? "-";
+          return `    ${s.source.padEnd(14)} ${pc10.dim(`last run ${when}`)}  ${pc10.dim(`cursor ${cursorLabel}`)}`;
+        }),
+        gitCursor && gitCursor !== repo.head ? `${pc10.yellow("git behind HEAD")} \u2014 run ${pc10.bold("nexusmem sync")}` : "",
+        ""
+      ].filter((line) => line !== "").join("\n").concat("\n")
+    );
+    return 0;
+  } finally {
+    store.close();
+  }
+}
+
+// src/cli/index.ts
+function isExpected(err) {
+  return err instanceof NotAGitRepositoryError || // "git isn't installed" and "the spawn failed, try again" are both things
+  // 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;
+}
+function guard(run) {
+  return async () => {
+    try {
+      process.exitCode = await run();
+    } catch (err) {
+      if (isExpected(err)) {
+        process.stderr.write(`${pc11.red("error")} ${err.message}
+`);
+        process.exitCode = 1;
+        return;
+      }
+      throw err;
+    }
+  };
+}
+var program = new Command();
+program.name("nexusmem").description("NexusMem \u2014 local-first persistent memory for AI coding agents").version("0.1.0");
+program.command("init").description("Create the .nexusmem workspace and database for this repository").option("-C, --cwd <path>", "repository path", process.cwd()).option("--force", "overwrite an existing config (the database is kept)", false).option("--hook", "also install the opt-in PowerShell hook (cwd + exit code + timestamp)", false).option("--enable-conversation", "opt in to the conversation-transcript source (off by default -- see docs/phase-2-spec.md)", false).action(
+  (options) => guard(
+    () => runInit({ cwd: options.cwd, force: options.force, hook: options.hook, enableConversation: options.enableConversation })
+  )()
+);
+program.command("sync").description("Ingest new history into the local database").option("-C, --cwd <path>", "repository path", process.cwd()).option("--full", "ignore the stored cursor and re-walk all history", false).option("--rebuild", "drop this project's nodes and re-ingest from scratch", false).option("--since <date>", "override the configured git cutoff, e.g. 1.year.ago").option("--shell-lines <count>", "override the configured shell tail-window size", (v) => Number.parseInt(v, 10)).option("--conversation", "force the conversation source on for this run, without persisting it to config", false).option("--no-embed", "skip the vector-embedding pass for this run").option("-q, --quiet", "only print the final summary", false).action(
+  (options) => guard(
+    () => runSync({
+      cwd: options.cwd,
+      full: options.full,
+      rebuild: options.rebuild,
+      since: options.since,
+      shellTailLines: options.shellLines,
+      conversationOverride: options.conversation ? true : void 0,
+      noEmbed: !options.embed,
+      quiet: options.quiet
+    })
+  )()
+);
+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 }))())
+).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 }))())
+).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 }))())
+);
+program.command("status").description("Show what is currently remembered for this repository").option("-C, --cwd <path>", "repository path", process.cwd()).action((options) => guard(() => runStatus({ cwd: options.cwd }))());
+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("--json", "emit the packed result as JSON on stdout", false).action(
+  (text, options) => guard(
+    () => runQuery({
+      cwd: options.cwd,
+      query: text,
+      budget: options.budget,
+      candidates: options.candidates,
+      halfLifeDays: options.halfLife,
+      noVector: !options.vector,
+      json: options.json
+    })
+  )()
+);
+program.command("scan-git").description("Preview the MemoryNodes git history would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--since <date>", "only commits newer than this git date expression, e.g. 90.days.ago").option("-n, --limit <count>", "stop after N commits", (v) => Number.parseInt(v, 10)).option("--no-merges", "skip merge commits").option("--min-signal <score>", "drop nodes below this signal", (v) => Number.parseFloat(v), 0).option("--json", "emit MemoryNodes as JSON on stdout", false).action(
+  (options) => guard(
+    () => runScanGit({
+      cwd: options.cwd,
+      since: options.since,
+      limit: options.limit,
+      merges: options.merges,
+      json: options.json,
+      minSignal: options.minSignal
+    })
+  )()
+);
+program.command("scan-shell").description("Preview the MemoryNodes shell history would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("-n, --tail-lines <count>", "lines kept from each scrape-based source", (v) => Number.parseInt(v, 10), 300).option("--min-signal <score>", "drop nodes below this signal", (v) => Number.parseFloat(v), 0).option("--json", "emit MemoryNodes as JSON on stdout", false).action(
+  (options) => guard(
+    () => runScanShell({ cwd: options.cwd, tailLines: options.tailLines, minSignal: options.minSignal, json: options.json })
+  )()
+);
+program.command("scan-conversation").description("Preview the MemoryNodes the conversation transcript would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--min-signal <score>", "drop nodes below this signal", (v) => Number.parseFloat(v), 0).option("--json", "emit MemoryNodes as JSON on stdout", false).action(
+  (options) => guard(() => runScanConversation({ cwd: options.cwd, minSignal: options.minSignal, json: options.json }))()
+);
+program.command("scan-docs").description("Preview the MemoryNodes tracked .md files would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--min-signal <score>", "drop nodes below this signal", (v) => Number.parseFloat(v), 0).option("--json", "emit MemoryNodes as JSON on stdout", false).action((options) => guard(() => runScanDocs({ cwd: options.cwd, minSignal: options.minSignal, json: options.json }))());
+program.command("mcp").description("Start the MCP server (stdio transport) for Claude Desktop, Cursor, Windsurf, etc.").action(() => guard(() => runMcpServer().then(() => 0))());
+program.parseAsync(process.argv).catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`${pc11.red("error")} ${message}
+`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=index.js.map