memdex 0.1.2 → 0.1.4

package/dist/cli.js

@@ -0,0 +1,1975 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/common.ts
+var exports_common = {};
+__export(exports_common, {
+  yymmddhhmm: () => yymmddhhmm,
+  writeJson: () => writeJson,
+  which: () => which,
+  uninitializedStatus: () => uninitializedStatus,
+  slugify: () => slugify,
+  sleep: () => sleep,
+  shellSplit: () => shellSplit,
+  shellQuote: () => shellQuote,
+  sha256Text: () => sha256Text,
+  sha256File: () => sha256File,
+  sha256Bytes: () => sha256Bytes,
+  setTestHooks: () => setTestHooks,
+  secondsSince: () => secondsSince,
+  scriptCmd: () => scriptCmd,
+  runCommand: () => runCommand,
+  resetTestHooks: () => resetTestHooks,
+  repomixCmd: () => repomixCmd,
+  repoLock: () => repoLock,
+  removeFileQuiet: () => removeFileQuiet,
+  readJson: () => readJson,
+  posixPath: () => posixPath,
+  positiveInt: () => positiveInt,
+  pathMatchesSpec: () => pathMatchesSpec,
+  pathIsIncluded: () => pathIsIncluded,
+  pathIsIgnored: () => pathIsIgnored,
+  parseSizeBytes: () => parseSizeBytes,
+  parseIso: () => parseIso,
+  packageRoot: () => packageRoot,
+  output: () => output,
+  nowUtc: () => nowUtc,
+  notebooklmCmd: () => notebooklmCmd,
+  neverUploadSpecs: () => neverUploadSpecs,
+  missingConfigMessage: () => missingConfigMessage,
+  loadState: () => loadState,
+  loadConfig: () => loadConfig,
+  iso: () => iso,
+  includeSpecs: () => includeSpecs,
+  groupSpecs: () => groupSpecs,
+  fileSize: () => fileSize,
+  fileExists: () => fileExists,
+  die: () => die,
+  defaultShortSourceTitlePrefix: () => defaultShortSourceTitlePrefix,
+  defaultNotebookTitle: () => defaultNotebookTitle,
+  defaultInclude: () => defaultInclude,
+  defaultGroups: () => defaultGroups,
+  defaultConfig: () => defaultConfig,
+  configPath: () => configPath,
+  commandLine: () => commandLine,
+  bundleMode: () => bundleMode,
+  STATE_JSON: () => STATE_JSON,
+  SCRIPT_CMD_ENV: () => SCRIPT_CMD_ENV,
+  PENDING_UPLOAD_JSON: () => PENDING_UPLOAD_JSON,
+  NOTEBOOKLM_PACKAGE: () => NOTEBOOKLM_PACKAGE,
+  NOTEBOOKLM_BIN_ENV: () => NOTEBOOKLM_BIN_ENV,
+  MemdexError: () => MemdexError,
+  LEGACY_SCRIPT_CMD_ENV: () => LEGACY_SCRIPT_CMD_ENV,
+  DEFAULT_NOTEBOOK_TITLE_PREFIX: () => DEFAULT_NOTEBOOK_TITLE_PREFIX,
+  CONFIG_JSON: () => CONFIG_JSON,
+  CONFIG_DIR: () => CONFIG_DIR2
+});
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import YAML from "yaml";
+function setTestHooks(next) {
+  hooks.run = next.run;
+  hooks.notebooklmCmd = next.notebooklmCmd;
+  hooks.repomixCmd = next.repomixCmd;
+}
+function resetTestHooks() {
+  hooks.run = undefined;
+  hooks.notebooklmCmd = undefined;
+  hooks.repomixCmd = undefined;
+}
+function nowUtc() {
+  return new Date;
+}
+function iso(ts = nowUtc()) {
+  return ts.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function parseIso(value) {
+  if (!value)
+    return null;
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function yymmddhhmm(ts = nowUtc()) {
+  const yy = String(ts.getUTCFullYear()).slice(-2);
+  const mm = String(ts.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(ts.getUTCDate()).padStart(2, "0");
+  const hh = String(ts.getUTCHours()).padStart(2, "0");
+  const mi = String(ts.getUTCMinutes()).padStart(2, "0");
+  return `${yy}${mm}${dd}${hh}${mi}`;
+}
+function die(message, code = 2) {
+  throw new MemdexError(message, code);
+}
+function sleep(ms) {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+function shellSplit(value) {
+  const parts = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let match;
+  while (match = re.exec(value))
+    parts.push(match[1] ?? match[2] ?? match[3]);
+  return parts;
+}
+function shellQuote(value) {
+  if (/^[A-Za-z0-9_./:=+-]+$/.test(value))
+    return value;
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function scriptCmd() {
+  const override = (process.env[SCRIPT_CMD_ENV] || process.env[LEGACY_SCRIPT_CMD_ENV] || "").trim();
+  return override ? shellSplit(override) : ["memdex"];
+}
+function commandLine(repo, command, ...parts) {
+  return [...scriptCmd(), command, "--repo", repo, ...parts].map(shellQuote).join(" ");
+}
+function missingConfigMessage(repo, configFile, command = "") {
+  const lines = [
+    `project is not initialized for project retrieval: ${configFile}`,
+    "",
+    "Initialize this repo first:",
+    `  ${commandLine(repo, "init", "--create-notebook")}`,
+    "",
+    "Or reuse an existing NotebookLM notebook with the expected title:",
+    `  ${commandLine(repo, "init", "--reuse-existing-notebook")}`,
+    "",
+    "Then ask or locate directly; both commands run freshness preflight:",
+    `  ${commandLine(repo, "ask", "your question")}`,
+    `  ${commandLine(repo, "locate", "thing to find")}`,
+    "",
+    "If this is the first broad upload and you already approve it:",
+    `  ${commandLine(repo, "ask", "--yes", "your question")}`
+  ];
+  if (command)
+    lines.splice(1, 0, `Command \`${command}\` needs \`.memdex/config.json\` before it can run.`);
+  return lines.join(`
+`);
+}
+function uninitializedStatus(repo, configFile) {
+  return {
+    status: "not-initialized",
+    initialized: false,
+    config: configFile,
+    message: "project is not initialized for project retrieval",
+    next: {
+      createNotebook: commandLine(repo, "init", "--create-notebook"),
+      reuseExistingNotebook: commandLine(repo, "init", "--reuse-existing-notebook"),
+      ask: commandLine(repo, "ask", "your question"),
+      locate: commandLine(repo, "locate", "thing to find"),
+      askWithFirstUploadApproval: commandLine(repo, "ask", "--yes", "your question")
+    }
+  };
+}
+async function repoLock(repo, fn, timeoutSeconds = 300) {
+  const lockPath = join(repo, CONFIG_DIR2, ".lock");
+  mkdirSync(dirname(lockPath), { recursive: true });
+  const started = Date.now();
+  let fd;
+  while (fd === undefined) {
+    try {
+      fd = openSync(lockPath, "wx");
+      writeFileSync(fd, `pid=${process.pid}
+createdAt=${iso()}
+`);
+    } catch (error) {
+      if (error?.code !== "EEXIST")
+        throw error;
+      if ((Date.now() - started) / 1000 > timeoutSeconds)
+        die(`timed out waiting for lock: ${lockPath}`);
+      await sleep(200);
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    try {
+      if (fd !== undefined)
+        closeSync(fd);
+    } catch {}
+    removeFileQuiet(lockPath);
+  }
+}
+async function runCommand(argv, cwd, opts = {}) {
+  if (hooks.run)
+    return hooks.run(argv, cwd, opts);
+  return new Promise((resolveRun) => {
+    const child = spawn(argv[0], argv.slice(1), { cwd, stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let finished = false;
+    const timer = opts.timeout ? setTimeout(() => {
+      if (!finished)
+        child.kill("SIGTERM");
+    }, opts.timeout * 1000) : undefined;
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("close", (code) => {
+      finished = true;
+      if (timer)
+        clearTimeout(timer);
+      resolveRun({ argv, returncode: code ?? 1, stdout, stderr });
+    });
+    child.on("error", (error) => {
+      finished = true;
+      if (timer)
+        clearTimeout(timer);
+      resolveRun({ argv, returncode: 1, stdout, stderr: `${stderr}${error.message}` });
+    });
+    if (opts.inputText !== undefined)
+      child.stdin.end(opts.inputText);
+    else
+      child.stdin.end();
+  });
+}
+function which(name) {
+  const paths = (process.env.PATH || "").split(":");
+  const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+  for (const dir of paths) {
+    for (const ext of exts) {
+      const candidate = join(dir, name + ext);
+      if (existsSync(candidate))
+        return candidate;
+    }
+  }
+  return null;
+}
+function notebooklmCmd() {
+  if (hooks.notebooklmCmd)
+    return hooks.notebooklmCmd();
+  const override = (process.env[NOTEBOOKLM_BIN_ENV] || "").trim();
+  if (override)
+    return shellSplit(override);
+  const found = which("notebooklm");
+  if (found)
+    return [found];
+  die(`required tool not found on PATH: notebooklm
+` + `Install persistently: uv tool install ${NOTEBOOKLM_PACKAGE}
+` + `Or set ${NOTEBOOKLM_BIN_ENV}='uvx --from ${NOTEBOOKLM_PACKAGE} notebooklm'`);
+}
+function repomixCmd() {
+  if (hooks.repomixCmd)
+    return hooks.repomixCmd();
+  const found = which("repomix");
+  if (found)
+    return [found];
+  if (which("npx"))
+    return ["npx", "repomix"];
+  die("required tool not found on PATH: repomix or npx");
+}
+function sha256Bytes(data) {
+  return `sha256:${createHash("sha256").update(data).digest("hex")}`;
+}
+function sha256Text(data) {
+  return sha256Bytes(Buffer.from(data, "utf8"));
+}
+function sha256File(path) {
+  return sha256Bytes(readFileSync(path));
+}
+function removeFileQuiet(path) {
+  try {
+    unlinkSync(path);
+  } catch (error) {
+    if (error?.code !== "ENOENT")
+      throw error;
+  }
+}
+function writeJson(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+function readJson(path) {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function defaultInclude() {
+  return ["src", "crates", "packages", "apps", "bins", "docs", "scripts", "tests", "xtask", "AGENTS.md", "CLAUDE.md", "README.md", "Cargo.toml", "package.json", "justfile"];
+}
+function defaultGroups() {
+  return [
+    { id: "docs", include: ["AGENTS.md", "CLAUDE.md", "README.md", "docs/**"] },
+    { id: "apps", include: ["apps/**"] },
+    { id: "packages", include: ["packages/**"] },
+    { id: "src", include: ["src/**", "crates/**", "bins/**", "xtask/**"] },
+    { id: "tests", include: ["tests/**", "testdata/**"] },
+    { id: "scripts", include: ["scripts/**"] }
+  ];
+}
+function slugify(value) {
+  const slug = value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return slug || "repo";
+}
+function defaultNotebookTitle(projectName, titlePrefix = DEFAULT_NOTEBOOK_TITLE_PREFIX) {
+  return `${titlePrefix}:${projectName}`;
+}
+function defaultShortSourceTitlePrefix() {
+  return "memdex";
+}
+function defaultConfig(repo, notebookId = "", opts = {}) {
+  const project = opts.projectName || basename(repo);
+  const prefix = opts.notebookTitlePrefix || DEFAULT_NOTEBOOK_TITLE_PREFIX;
+  return {
+    version: 1,
+    project: { name: project },
+    provider: "notebooklm",
+    notebooklm: {
+      notebook_id: notebookId,
+      notebook_title_prefix: prefix,
+      notebook_title: opts.notebookTitle || defaultNotebookTitle(project, prefix),
+      source_title_prefix: defaultShortSourceTitlePrefix(),
+      wait_after_upload: true,
+      upload_parallelism: 4,
+      wait_parallelism: 8,
+      delete_parallelism: 4
+    },
+    bundle: {
+      tool: "repomix",
+      mode: "chunked",
+      include: defaultInclude(),
+      output: `${CONFIG_DIR2}/cache/{prefix}-{timestamp}.txt`,
+      style: "",
+      compress: false,
+      target_chunk_bytes: 524288,
+      max_chunk_bytes: 900000,
+      source_title_template: "{prefix}--{set}--{group}--{chunk}--{hash}.md",
+      groups: defaultGroups(),
+      default_group: { enabled: true, id: "misc" }
+    },
+    refresh: {
+      auto: true,
+      mode: "replace",
+      check_ttl_seconds: 300,
+      min_upload_interval_seconds: 900,
+      max_staleness_seconds: 86400,
+      keep_previous_sources: 0,
+      delete_previous_after_success: true
+    },
+    safety: {
+      require_user_approval_first_upload: true,
+      never_upload: [
+        ".env*",
+        "**/.env*",
+        ".git/**",
+        "**/.git/**",
+        "node_modules/**",
+        "**/node_modules/**",
+        "target/**",
+        "**/target/**",
+        "dist/**",
+        "**/dist/**",
+        "build/**",
+        "**/build/**",
+        "coverage/**",
+        "**/coverage/**",
+        ".next/**",
+        "**/.next/**",
+        ".generated/**",
+        "**/.generated/**",
+        "public/**",
+        "**/public/**",
+        "*.png",
+        "**/*.png",
+        "*.jpg",
+        "**/*.jpg",
+        "*.jpeg",
+        "**/*.jpeg",
+        "*.gif",
+        "**/*.gif",
+        "*.webp",
+        "**/*.webp",
+        "*.svg",
+        "**/*.svg",
+        "*.ico",
+        "**/*.ico",
+        "*.otf",
+        "**/*.otf",
+        "*.ttf",
+        "**/*.ttf",
+        "*.woff",
+        "**/*.woff",
+        "*.woff2",
+        "**/*.woff2",
+        "*.mp4",
+        "**/*.mp4",
+        "*.mov",
+        "**/*.mov",
+        "*.zip",
+        "**/*.zip",
+        "*.tar",
+        "**/*.tar",
+        "*.gz",
+        "**/*.gz"
+      ]
+    },
+    retrieval: { line_numbers_require_local_verify: true, max_local_matches: 80 }
+  };
+}
+function configPath(repo) {
+  const candidates = [
+    join(repo, CONFIG_DIR2, CONFIG_JSON),
+    join(repo, CONFIG_DIR2, "config.yaml"),
+    join(repo, CONFIG_DIR2, "config.yml"),
+    join(repo, ".notebooklm", CONFIG_JSON),
+    join(repo, ".notebooklm", "config.yaml"),
+    join(repo, ".notebooklm", "config.yml")
+  ];
+  return candidates.find((path) => existsSync(path)) || join(repo, CONFIG_DIR2, CONFIG_JSON);
+}
+function loadConfig(repo, command = "") {
+  const path = configPath(repo);
+  if (!existsSync(path))
+    die(missingConfigMessage(repo, path, command));
+  const text = readFileSync(path, "utf8");
+  const data = path.endsWith(".json") ? JSON.parse(text) : YAML.parse(text);
+  return [data || {}, path];
+}
+function loadState(configFile) {
+  const statePath = join(dirname(configFile), STATE_JSON);
+  if (existsSync(statePath))
+    return [readJson(statePath), statePath];
+  return [{ sources: [] }, statePath];
+}
+function includeSpecs(config) {
+  const include = config.bundle?.include || defaultInclude();
+  return include.map((item) => String(item).trim().replace(/^\/|\/$/g, "")).filter(Boolean);
+}
+function groupSpecs(group) {
+  return (group.include || []).map((item) => String(item).trim().replace(/^\/|\/$/g, "")).filter(Boolean);
+}
+function neverUploadSpecs(config) {
+  const builtIn = defaultConfig(process.cwd()).safety.never_upload;
+  return [...builtIn, ...config.safety?.never_upload || []].map((item) => String(item).trim()).filter(Boolean);
+}
+function globRegex(spec) {
+  let pattern = spec.trim().replace(/^\.\//, "");
+  let out = "";
+  for (let i = 0;i < pattern.length; i += 1) {
+    const ch = pattern[i];
+    const next = pattern[i + 1];
+    if (ch === "*" && next === "*") {
+      out += ".*";
+      i += 1;
+    } else if (ch === "*") {
+      out += "[^/]*";
+    } else if (ch === "?") {
+      out += "[^/]";
+    } else {
+      out += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${out}$`);
+}
+function pathMatchesSpec(path, spec) {
+  const clean = path.trim().replace(/^\.\//, "");
+  const pattern = spec.trim().replace(/^\.\//, "");
+  if (!pattern)
+    return false;
+  if (pattern === "." || pattern === "*")
+    return true;
+  if (clean === pattern || clean.startsWith(`${pattern.replace(/\/$/, "")}/`))
+    return true;
+  return globRegex(pattern).test(clean) || globRegex(pattern).test(`./${clean}`);
+}
+function pathIsIncluded(path, includes) {
+  return includes.some((spec) => pathMatchesSpec(path, spec));
+}
+function pathIsIgnored(path, ignores) {
+  return ignores.some((spec) => pathMatchesSpec(path, spec));
+}
+function bundleMode(config) {
+  return String(config.bundle?.mode || "chunked");
+}
+function parseSizeBytes(value, fallback) {
+  if (Number.isInteger(value))
+    return value;
+  const match = String(value || "").trim().toLowerCase().match(/^(\d+)(?:\s*(b|kb|kib|mb|mib))?$/);
+  if (!match)
+    return fallback;
+  const amount = Number(match[1]);
+  const unit = match[2] || "b";
+  if (unit === "kb" || unit === "kib")
+    return amount * 1024;
+  if (unit === "mb" || unit === "mib")
+    return amount * 1024 * 1024;
+  return amount;
+}
+function positiveInt(value, fallback, minimum = 1, maximum = 32) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  const valueOrFallback = Number.isFinite(parsed) ? parsed : fallback;
+  return Math.max(minimum, Math.min(maximum, valueOrFallback));
+}
+function secondsSince(value) {
+  const parsed = parseIso(value);
+  return parsed ? (Date.now() - parsed.getTime()) / 1000 : null;
+}
+function posixPath(path) {
+  return sep === "/" ? path : path.split(sep).join("/");
+}
+function output(data, asJson) {
+  if (asJson) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+    for (const [key, value] of Object.entries(data)) {
+      console.log(`${key}: ${typeof value === "object" ? JSON.stringify(value) : value}`);
+    }
+    return;
+  }
+  console.log(data);
+}
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function fileSize(path) {
+  return statSync(path).size;
+}
+var MemdexError, CONFIG_DIR2 = ".memdex", CONFIG_JSON = "config.json", STATE_JSON = "state.local.json", PENDING_UPLOAD_JSON = "pending-upload.local.json", DEFAULT_NOTEBOOK_TITLE_PREFIX = "memdex", SCRIPT_CMD_ENV = "MEMDEX_CMD", LEGACY_SCRIPT_CMD_ENV = "CODEBASE_RETRIEVE_CMD", NOTEBOOKLM_PACKAGE = "git+https://github.com/teng-lin/notebooklm-py.git", NOTEBOOKLM_BIN_ENV = "NOTEBOOKLM_BIN", packageRoot, hooks;
+var init_common = __esm(() => {
+  MemdexError = class MemdexError extends Error {
+    code;
+    constructor(message, code = 2) {
+      super(message);
+      this.name = "MemdexError";
+      this.code = code;
+    }
+  };
+  packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+  hooks = {};
+});
+
+// src/cli.ts
+init_common();
+import { Command } from "commander";
+
+// src/commands.ts
+init_common();
+import { existsSync as existsSync6, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename as basename2, isAbsolute, join as join5, resolve as resolve2 } from "node:path";
+
+// src/chunking.ts
+init_common();
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync, statSync as statSync2 } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import { dirname as dirname3, join as join3, relative } from "node:path";
+
+// src/notebooklm.ts
+init_common();
+import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2 } from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import { dirname as dirname2, join as join2 } from "node:path";
+function notebookId(config) {
+  const value = config.notebooklm?.notebook_id || "";
+  if (!value)
+    die("notebooklm.notebook_id missing in config");
+  return String(value);
+}
+function notebookTitle(config) {
+  const project = String(config.project?.name || "repo");
+  const prefix = String(config.notebooklm?.notebook_title_prefix || "memdex");
+  return String(config.notebooklm?.notebook_title || defaultNotebookTitle(project, prefix));
+}
+function parseNotebookJson(stdout, fallbackTitle) {
+  let data;
+  try {
+    data = JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+  const candidates = [data, data?.notebook, data?.data, data?.result];
+  for (const item of candidates) {
+    if (!item || typeof item !== "object")
+      continue;
+    const id = item.id || item.notebook_id || item.notebookId;
+    const title = item.title || item.name || fallbackTitle;
+    if (id)
+      return { id: String(id), title: String(title) };
+  }
+  return null;
+}
+async function listNotebooks(repo) {
+  const result = await runCommand([...notebooklmCmd(), "list", "--json"], repo, { timeout: 120 });
+  if (result.returncode !== 0)
+    die(`notebooklm list failed:
+${result.stdout}
+${result.stderr}`);
+  try {
+    const data = JSON.parse(result.stdout);
+    const notebooks = data.notebooks || (Array.isArray(data) ? data : []);
+    return notebooks.filter((item) => item && typeof item === "object");
+  } catch (error) {
+    die(`notebooklm list returned invalid JSON: ${error.message}`);
+  }
+}
+async function findNotebookByTitle(repo, title) {
+  const matches = (await listNotebooks(repo)).filter((item) => String(item.title || "") === title);
+  if (matches.length > 1)
+    die(`multiple notebooks found with title ${JSON.stringify(title)}: ${matches.map((item) => item.id || "").join(", ")}`);
+  if (!matches.length)
+    return null;
+  return { id: String(matches[0].id || ""), title: String(matches[0].title || title) };
+}
+async function createNotebook(repo, title) {
+  const result = await runCommand([...notebooklmCmd(), "create", title, "--json"], repo, { timeout: 180 });
+  if (result.returncode !== 0)
+    die(`notebooklm create failed:
+${result.stdout}
+${result.stderr}`);
+  const parsed = parseNotebookJson(result.stdout, title);
+  if (parsed)
+    return parsed;
+  const found = await findNotebookByTitle(repo, title);
+  if (found)
+    return found;
+  die(`created notebook but could not resolve notebook id for title ${JSON.stringify(title)}`);
+}
+async function listSources(repo, nbid) {
+  const result = await runCommand([...notebooklmCmd(), "source", "list", "-n", nbid, "--json"], repo, { timeout: 120 });
+  if (result.returncode !== 0)
+    return [];
+  try {
+    const data = JSON.parse(result.stdout);
+    const sources = data.sources || (Array.isArray(data) ? data : []);
+    return sources.filter((item) => item && typeof item === "object");
+  } catch {
+    return [];
+  }
+}
+async function findSourceByTitle(repo, nbid, title) {
+  for (const src of await listSources(repo, nbid)) {
+    if (String(src.title || "") === title && src.id)
+      return { id: String(src.id), title };
+  }
+  return null;
+}
+function sourceFromAddJson(stdout, title) {
+  let data;
+  try {
+    data = JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+  for (const item of [data, data?.source, data?.data, data?.result]) {
+    if (!item || typeof item !== "object")
+      continue;
+    const id = item.id || item.source_id || item.sourceId;
+    if (id)
+      return { id: String(id), title: String(item.title || item.name || title) };
+  }
+  return null;
+}
+async function uploadTextSourceFromFile(repo, config, path, title) {
+  const nbid = notebookId(config);
+  let content = "";
+  try {
+    content = readFileSync2(path, "utf8");
+  } catch (error) {
+    die(`source is not valid UTF-8 text for ${title}: ${error.message}`);
+  }
+  const result = await runCommand([...notebooklmCmd(), "source", "add", "-", "-n", nbid, "--type", "text", "--title", title, "--json"], repo, { inputText: content, timeout: 600 });
+  if (result.returncode !== 0)
+    die(`notebooklm source add failed for ${title}:
+${result.stdout}
+${result.stderr}`);
+  const source = sourceFromAddJson(result.stdout, title) || await findSourceByTitle(repo, nbid, title);
+  if (!source?.id)
+    die(`uploaded source but could not resolve source id for ${title}`);
+  return source;
+}
+async function waitSourceReady(repo, nbid, sourceId) {
+  const wait = await runCommand([...notebooklmCmd(), "source", "wait", sourceId, "-n", nbid], repo, { timeout: 600 });
+  return wait.returncode === 0;
+}
+function sourceContentSha(value) {
+  return String(value.contentSha256 || value.chunkSha256 || value.bundleSha256 || "");
+}
+function sourceFileListSha(value) {
+  return String(value.fileListSha256 || value.sha256 || "");
+}
+function chunkKey(value) {
+  return `${value.group}/${value.chunk}`;
+}
+function sourceWithChunkMetadata(source, bundle, opts) {
+  const item = {
+    ...source,
+    group: bundle.group,
+    chunk: bundle.chunk,
+    chunkKey: chunkKey(bundle),
+    chunkSha256: bundle.bundleSha256,
+    contentSha256: bundle.contentSha256 || bundle.bundleSha256,
+    fileListSha256: bundle.fileListSha256 || bundle.sha256,
+    fileCount: bundle.fileCount,
+    files: [...bundle.files || []],
+    status: opts.status
+  };
+  if (opts.reused)
+    Object.assign(item, { reused: true, reusedAt: iso() });
+  else
+    Object.assign(item, { uploadedAt: iso() });
+  return item;
+}
+function activeSources(state) {
+  if (state.activeSourceSet && typeof state.activeSourceSet === "object" && Array.isArray(state.activeSourceSet.sources)) {
+    return state.activeSourceSet.sources.filter((item) => item && typeof item === "object");
+  }
+  return Array.isArray(state.sources) ? state.sources.filter((item) => item && typeof item === "object") : [];
+}
+function activeReadySourceIds(state) {
+  return activeSources(state).filter((src) => src.id && String(src.status || "ready") === "ready").map((src) => String(src.id));
+}
+function cleanupPendingSourceIds(state) {
+  return Array.isArray(state.cleanupPendingSourceIds) ? [...new Set(state.cleanupPendingSourceIds.map(String).filter(Boolean))] : [];
+}
+function queueCleanupSourceIds(state, sourceIds) {
+  const active = new Set(activeSources(state).map((src) => String(src.id || "")).filter(Boolean));
+  const merged = [...new Set([...cleanupPendingSourceIds(state), ...sourceIds])].filter((sid) => sid && !active.has(sid));
+  if (merged.length)
+    state.cleanupPendingSourceIds = merged;
+  else
+    delete state.cleanupPendingSourceIds;
+  return merged;
+}
+function pendingUploadPath(repo) {
+  return join2(repo, CONFIG_DIR2, PENDING_UPLOAD_JSON);
+}
+function clearPendingUpload(repo) {
+  removeFileQuiet(pendingUploadPath(repo));
+}
+function readPendingUpload(repo) {
+  const path = pendingUploadPath(repo);
+  if (!existsSync2(path))
+    return null;
+  try {
+    const data = JSON.parse(readFileSync2(path, "utf8"));
+    return data && typeof data === "object" ? data : { sources: [] };
+  } catch {
+    return { sources: [] };
+  }
+}
+function writePendingUpload(repo, value) {
+  writeJson(pendingUploadPath(repo), value);
+}
+async function runPool(items, workers, fn, progress) {
+  const results = [];
+  let index = 0;
+  let done = 0;
+  const worker = async () => {
+    while (index < items.length) {
+      const current = items[index++];
+      const result = await fn(current);
+      results.push(result);
+      done += 1;
+      progress?.(done, items.length);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(workers, items.length) }, worker));
+  return results;
+}
+async function deleteSourceIdsParallel(repo, nbid, sourceIds, opts) {
+  const ids = [...new Set(sourceIds.filter(Boolean))];
+  if (!ids.length)
+    return [];
+  const deleted = await runPool(ids, Math.min(ids.length, Math.max(1, opts.parallelism)), async (sid) => {
+    const result = await runCommand([...notebooklmCmd(), "source", "delete", sid, "-n", nbid, "--yes"], repo, { timeout: 120 });
+    if (result.returncode !== 0) {
+      console.error(`warning: failed to delete source ${sid}`);
+      return "";
+    }
+    return sid;
+  }, (count, total) => console.error(`cleanup ${count}/${total}`));
+  return deleted.filter(Boolean);
+}
+async function recoverPendingCleanup(repo, config, state, statePath) {
+  const pending = cleanupPendingSourceIds(state);
+  if (!pending.length)
+    return [];
+  const active = new Set(activeSources(state).map((src) => String(src.id || "")).filter(Boolean));
+  const deleteIds = pending.filter((sid) => !active.has(sid));
+  if (!deleteIds.length) {
+    delete state.cleanupPendingSourceIds;
+    writeJson(statePath, state);
+    return [];
+  }
+  const deleted = await deleteSourceIdsParallel(repo, notebookId(config), deleteIds, { parallelism: positiveInt(config.notebooklm?.delete_parallelism, 4) });
+  const deletedSet = new Set(deleted);
+  const remaining = pending.filter((sid) => !deletedSet.has(sid) && !active.has(sid));
+  if (remaining.length)
+    state.cleanupPendingSourceIds = remaining;
+  else
+    delete state.cleanupPendingSourceIds;
+  writeJson(statePath, state);
+  return deleted;
+}
+async function recoverPendingUpload(repo, config, state = {}) {
+  const pending = readPendingUpload(repo);
+  if (!pending)
+    return [];
+  const sources = Array.isArray(pending.sources) ? pending.sources : [];
+  if (!Array.isArray(pending.sources)) {
+    clearPendingUpload(repo);
+    return [];
+  }
+  const active = new Set(activeSources(state).map((src) => String(src.id || "")).filter(Boolean));
+  const ids = sources.filter((src) => src?.id).map((src) => String(src.id));
+  if (ids.length && active.size && ids.every((sid) => active.has(sid))) {
+    clearPendingUpload(repo);
+    return [];
+  }
+  const deleted = await deleteSourceIdsParallel(repo, String(pending.notebookId || notebookId(config)), ids.filter((sid) => !active.has(sid)), { parallelism: positiveInt(config.notebooklm?.delete_parallelism, 4) });
+  const deletedSet = new Set(deleted);
+  const remaining = sources.filter((src) => src?.id && !deletedSet.has(String(src.id)));
+  if (remaining.length)
+    writePendingUpload(repo, { ...pending, sources: remaining });
+  else
+    clearPendingUpload(repo);
+  return deleted;
+}
+function appendPendingSource(repo, journal, source) {
+  journal.sources = Array.isArray(journal.sources) ? journal.sources : [];
+  journal.sources.push({ id: source.id, title: source.title });
+  writePendingUpload(repo, journal);
+}
+function findReusableSource(bundle, previous, used) {
+  const wanted = sourceContentSha(bundle);
+  if (!wanted)
+    return null;
+  for (const source of previous) {
+    const sid = String(source.id || "");
+    if (!sid || used.has(sid) || String(source.status || "ready") !== "ready")
+      continue;
+    if (sourceContentSha(source) === wanted) {
+      used.add(sid);
+      return source;
+    }
+  }
+  return null;
+}
+async function uploadOneChunk(repo, config, bundle) {
+  const source = await uploadTextSourceFromFile(repo, config, String(bundle.path), String(bundle.title));
+  return sourceWithChunkMetadata(source, bundle, { status: "uploaded" });
+}
+async function uploadChunksParallel(repo, config, bundles, opts) {
+  if (!bundles.length)
+    return [];
+  const nbid = notebookId(config);
+  const journal = { version: 1, setId: opts.setId, notebookId: nbid, startedAt: iso(), sources: [] };
+  writePendingUpload(repo, journal);
+  const uploaded = [];
+  try {
+    const results = await runPool(bundles, Math.min(bundles.length, positiveInt(config.notebooklm?.upload_parallelism, 4)), async ([index, bundle]) => {
+      const source = await uploadOneChunk(repo, config, bundle);
+      appendPendingSource(repo, journal, source);
+      return [index, source];
+    }, (count, total) => console.error(`upload ${count}/${total}`));
+    uploaded.push(...results);
+    return uploaded.sort((a, b) => a[0] - b[0]);
+  } catch (error) {
+    await deleteSourceIdsParallel(repo, nbid, uploaded.map(([, source]) => String(source.id || "")), { parallelism: positiveInt(config.notebooklm?.delete_parallelism, 4) });
+    clearPendingUpload(repo);
+    throw error;
+  }
+}
+async function waitUploadedSourcesParallel(repo, config, sources) {
+  if (!sources.length || config.notebooklm?.wait_after_upload === false)
+    return sources;
+  const nbid = notebookId(config);
+  const ready = await runPool(sources, Math.min(sources.length, positiveInt(config.notebooklm?.wait_parallelism, 8)), async ([index, source]) => {
+    const sid = String(source.id || "");
+    if (!sid)
+      throw new Error(`missing source id for ${source.title}`);
+    if (!await waitSourceReady(repo, nbid, sid))
+      throw new Error(`source processing failed for chunk ${source.title}: ${sid}`);
+    return [index, { ...source, status: "ready" }];
+  }, (count, total) => console.error(`wait ${count}/${total}`));
+  return ready.sort((a, b) => a[0] - b[0]);
+}
+async function uploadBundleSet(repo, config, state, bundles, opts) {
+  const nbid = notebookId(config);
+  await recoverPendingUpload(repo, config, state);
+  const previous = activeSources(state);
+  const used = new Set;
+  const sourcesByIndex = Array(bundles.length).fill(null);
+  const uploadPairs = [];
+  bundles.forEach((bundle, index) => {
+    const reusable = findReusableSource(bundle, previous, used);
+    if (reusable)
+      sourcesByIndex[index] = sourceWithChunkMetadata(reusable, bundle, { status: "ready", reused: true });
+    else
+      uploadPairs.push([index, bundle]);
+  });
+  const uploaded = await uploadChunksParallel(repo, config, uploadPairs, opts);
+  let ready;
+  try {
+    ready = await waitUploadedSourcesParallel(repo, config, uploaded);
+  } catch (error) {
+    await deleteSourceIdsParallel(repo, nbid, uploaded.map(([, source]) => String(source.id || "")), { parallelism: positiveInt(config.notebooklm?.delete_parallelism, 4) });
+    clearPendingUpload(repo);
+    throw error;
+  }
+  for (const [index, source] of ready)
+    sourcesByIndex[index] = source;
+  const sources = sourcesByIndex.filter(Boolean);
+  const activeIds = new Set(sources.map((src) => String(src.id || "")).filter(Boolean));
+  const previousIds = previous.map((src) => String(src.id || "")).filter(Boolean);
+  const keepPrevious = Number(config.refresh?.keep_previous_sources || 0);
+  const keepIds = keepPrevious > 0 ? new Set(previousIds.slice(-keepPrevious)) : new Set;
+  const retiredIds = previousIds.filter((sid) => !activeIds.has(sid) && !keepIds.has(sid));
+  const sourceSet = {
+    id: opts.setId,
+    prefix: String(config.notebooklm?.source_title_prefix || defaultShortSourceTitlePrefix()),
+    bundleSetSha256: sourceSetHash(bundles),
+    uploadedAt: iso(),
+    sources
+  };
+  if ((config.refresh?.mode || "replace") === "replace" && config.refresh?.delete_previous_after_success !== false)
+    sourceSet._retiredSourceIds = retiredIds;
+  return sourceSet;
+}
+function sourceSetHash(bundles) {
+  return createHash2("sha256").update(bundles.map((bundle) => `${bundle.group} ${bundle.chunk} ${sourceContentSha(bundle)} ${sourceFileListSha(bundle)}`).join(`
+`)).digest("hex").replace(/^/, "sha256:");
+}
+function tempSourcePrefix(config) {
+  const prefix = String(config.notebooklm?.temporary_source_title_prefix || "").trim();
+  return prefix ? slugify(prefix) : `${String(config.notebooklm?.source_title_prefix || defaultShortSourceTitlePrefix()).trim()}tmp`;
+}
+function tempSourceTitle(config, opts) {
+  const digest = opts.contentSha.split(":", 2).at(-1) || opts.contentSha;
+  return `${tempSourcePrefix(config)}--${opts.setId}--${slugify(opts.kind)}--${slugify(opts.title)}--${digest.slice(0, 8)}.md`;
+}
+function stageTempSourceFile(repo, title, sourcePath) {
+  const staged = join2(repo, CONFIG_DIR2, "cache", title);
+  mkdirSync2(dirname2(staged), { recursive: true });
+  copyFileSync(sourcePath, staged);
+  return staged;
+}
+function tempSourceSets(state) {
+  return Array.isArray(state.temporarySourceSets) ? state.temporarySourceSets.filter((item) => item && typeof item === "object") : [];
+}
+function tempSourceExpiresAt(ttlSeconds) {
+  return ttlSeconds > 0 ? iso(new Date(Date.now() + ttlSeconds * 1000)) : null;
+}
+function sourceIsExpired(sourceSet) {
+  return sourceSet.expiresAt ? new Date(String(sourceSet.expiresAt)).getTime() <= Date.now() : false;
+}
+async function withRepoLock(repo, fn) {
+  return repoLock(repo, fn);
+}
+
+// src/chunking.ts
+async function listGitFiles(repo) {
+  const result = await runCommand(["git", "ls-files", "-co", "--exclude-standard"], repo);
+  if (result.returncode === 0)
+    return result.stdout.split(`
+`).map((line) => line.trim()).filter(Boolean).sort();
+  const files = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join3(dir, entry.name);
+      const rel = posixPath(relative(repo, full));
+      if (rel === ".git" || rel.startsWith(".git/"))
+        continue;
+      if (entry.isDirectory())
+        walk(full);
+      else if (entry.isFile())
+        files.push(rel);
+    }
+  };
+  walk(repo);
+  return files.sort();
+}
+async function collectBundleFiles(repo, config) {
+  const includes = includeSpecs(config);
+  const ignores = neverUploadSpecs(config);
+  const files = [];
+  for (const path of await listGitFiles(repo)) {
+    if (!pathIsIncluded(path, includes) || pathIsIgnored(path, ignores))
+      continue;
+    const full = join3(repo, path);
+    if (!existsSync3(full))
+      continue;
+    const stat = statSync2(full);
+    if (!stat.isFile() || stat.isSymbolicLink())
+      continue;
+    files.push(path);
+  }
+  return [...new Set(files)].sort();
+}
+function chunkFileSize(repo, path) {
+  return statSync2(join3(repo, path)).size + Buffer.byteLength(path, "utf8") + 64;
+}
+function fileBucket(path) {
+  const parts = path.split("/");
+  if (parts.length >= 3 && ["apps", "packages", "crates"].includes(parts[0]))
+    return parts.slice(0, 3).join("/");
+  if (parts.length >= 2)
+    return parts.slice(0, 2).join("/");
+  return parts[0];
+}
+function sourceTitleForChunk(config, opts) {
+  const configured = String(config.notebooklm?.source_title_prefix || "").trim();
+  const prefix = !configured || configured.startsWith("codebase-retrieve-") ? defaultShortSourceTitlePrefix() : configured;
+  const template = String(config.bundle?.source_title_template || "{prefix}--{set}--{group}--{chunk}--{hash}.md");
+  return template.replaceAll("{prefix}", slugify(prefix)).replaceAll("{set}", opts.setId).replaceAll("{set_id}", opts.setId).replaceAll("{group}", slugify(opts.group)).replaceAll("{chunk}", String(opts.index).padStart(3, "0")).replaceAll("{idx}", String(opts.index).padStart(3, "0")).replaceAll("{hash}", opts.chunkHash.slice(0, 8));
+}
+function chunkHashForFiles(repo, files) {
+  const digest = createHash3("sha256");
+  for (const file of files) {
+    digest.update(file);
+    digest.update("\x00");
+    const full = join3(repo, file);
+    if (existsSync3(full) && statSync2(full).isFile())
+      digest.update(readFileSync3(full));
+    digest.update("\x00");
+  }
+  return digest.digest("hex");
+}
+function assignFilesToGroups(files, config) {
+  const bundle = config.bundle || {};
+  const groups = "groups" in bundle ? bundle.groups || [] : defaultGroups();
+  const assigned = [];
+  const seen = new Set;
+  for (const group of groups) {
+    const gid = slugify(String(group.id || "group"));
+    const specs = groupSpecs(group);
+    for (const path of files) {
+      if (seen.has(path))
+        continue;
+      if (specs.length && pathIsIncluded(path, specs)) {
+        assigned.push([gid, path]);
+        seen.add(path);
+      }
+    }
+  }
+  const defaultGroup = "default_group" in bundle ? bundle.default_group || {} : { enabled: true, id: "misc" };
+  if (defaultGroup.enabled) {
+    const gid = slugify(String(defaultGroup.id || "misc"));
+    for (const path of files)
+      if (!seen.has(path))
+        assigned.push([gid, path]);
+  } else if (!groups.length) {
+    for (const path of files)
+      assigned.push(["repo", path]);
+  }
+  return assigned;
+}
+function flushChunk(chunks, repo, config, setId, group, index, files, total) {
+  if (!files.length)
+    return;
+  const digest = chunkHashForFiles(repo, files);
+  chunks.push({
+    group,
+    chunk: String(index).padStart(3, "0"),
+    index,
+    files: [...files],
+    estimatedBytes: total,
+    sha256: `sha256:${digest}`,
+    title: sourceTitleForChunk(config, { setId, group, index, chunkHash: digest })
+  });
+}
+function activeChunkFileMembers(state, group) {
+  if (!state)
+    return [];
+  return activeSources(state).filter((source) => String(source.group || "") === group && Array.isArray(source.files) && source.files.length).map((source) => [Number.parseInt(String(source.chunk || "0"), 10) || 0, source.files.map(String).filter(Boolean)]).sort((a, b) => a[0] - b[0]).map(([, files]) => files);
+}
+function appendGreedyChunks(chunks, repo, config, opts) {
+  let current = [];
+  let currentSize = 0;
+  let index = opts.startIndex;
+  for (const path of opts.files) {
+    const size = chunkFileSize(repo, path);
+    if (size > opts.maxBytes)
+      die(`file exceeds max chunk size (${opts.maxBytes} bytes): ${path} (${size} bytes)`);
+    if (current.length && currentSize + size > opts.target) {
+      flushChunk(chunks, repo, config, opts.setId, opts.group, index, current, currentSize);
+      current = [];
+      currentSize = 0;
+      index += 1;
+    }
+    current.push(path);
+    currentSize += size;
+  }
+  if (current.length)
+    flushChunk(chunks, repo, config, opts.setId, opts.group, index, current, currentSize);
+}
+function planGroupChunks(chunks, repo, config, opts) {
+  const ordered = [...opts.files].sort((a, b) => `${fileBucket(a)}\x00${a}`.localeCompare(`${fileBucket(b)}\x00${b}`));
+  const available = new Set(ordered);
+  const kept = [];
+  for (const previousFiles of activeChunkFileMembers(opts.state, opts.group)) {
+    const retained = previousFiles.filter((path) => available.has(path));
+    if (!retained.length)
+      continue;
+    const sizes = retained.map((path) => [path, chunkFileSize(repo, path)]);
+    for (const [path, size] of sizes)
+      if (size > opts.maxBytes)
+        die(`file exceeds max chunk size (${opts.maxBytes} bytes): ${path} (${size} bytes)`);
+    const total = sizes.reduce((sum, [, size]) => sum + size, 0);
+    if (total <= opts.target || retained.length === 1) {
+      kept.push(retained);
+      for (const path of retained)
+        available.delete(path);
+    }
+  }
+  let index = 1;
+  for (const files of kept) {
+    flushChunk(chunks, repo, config, opts.setId, opts.group, index, files, files.reduce((sum, path) => sum + chunkFileSize(repo, path), 0));
+    index += 1;
+  }
+  appendGreedyChunks(chunks, repo, config, { ...opts, startIndex: index, files: ordered.filter((path) => available.has(path)) });
+}
+async function planBundleChunks(repo, config, opts) {
+  const bundle = config.bundle || {};
+  let target = parseSizeBytes(bundle.target_chunk_bytes, 524288);
+  const maxBytes = parseSizeBytes(bundle.max_chunk_bytes, 900000);
+  if (target > maxBytes)
+    target = maxBytes;
+  const assigned = assignFilesToGroups(await collectBundleFiles(repo, config), config);
+  const byGroup = new Map;
+  for (const [group, path] of assigned)
+    byGroup.set(group, [...byGroup.get(group) || [], path]);
+  const chunks = [];
+  for (const group of [...byGroup.keys()].sort()) {
+    planGroupChunks(chunks, repo, config, { setId: opts.setId, group, files: byGroup.get(group) || [], target, maxBytes, state: opts.state });
+  }
+  return chunks;
+}
+async function gitHead(repo) {
+  const result = await runCommand(["git", "rev-parse", "HEAD"], repo);
+  return result.returncode === 0 ? result.stdout.trim() : "no-git-head";
+}
+async function gitStatusRecords(repo) {
+  const result = await runCommand(["git", "status", "--porcelain=v1", "-z", "--untracked-files=all"], repo);
+  if (result.returncode !== 0)
+    return [];
+  const raw = result.stdout.split("\x00").filter(Boolean);
+  const records = [];
+  let skip = false;
+  for (const item of raw) {
+    if (skip) {
+      skip = false;
+      continue;
+    }
+    const status = item.slice(0, 2);
+    const path = item.slice(3);
+    if (status.startsWith("R") || status.startsWith("C"))
+      skip = true;
+    records.push([status, path]);
+  }
+  return records;
+}
+async function fastFingerprint(repo, config, configFile) {
+  const includes = includeSpecs(config);
+  const ignores = neverUploadSpecs(config);
+  const parts = [`head=${await gitHead(repo)}`, `config=${sha256File(configFile)}`];
+  const relevant = [];
+  for (const [status, path] of await gitStatusRecords(repo)) {
+    if (!pathIsIncluded(path, includes) || pathIsIgnored(path, ignores))
+      continue;
+    relevant.push(path);
+    const full = join3(repo, path);
+    let content = "missing";
+    if (existsSync3(full) && statSync2(full).isFile())
+      content = sha256File(full);
+    else if (existsSync3(full))
+      content = "dir";
+    parts.push(`${status} ${path} ${content}`);
+  }
+  return [sha256Text(parts.join(`
+`)), relevant];
+}
+function expandBundlePath(repo, config) {
+  const prefix = config.notebooklm?.source_title_prefix || `${repo}-repo`;
+  const timestamp = iso().replaceAll("-", "").replaceAll(":", "").replace("Z", "Z");
+  const template = config.bundle?.output || `${CONFIG_DIR}/cache/{prefix}-{timestamp}.txt`;
+  return join3(repo, template.replaceAll("{prefix}", prefix).replaceAll("{timestamp}", timestamp));
+}
+function expandChunkPath(repo, config, title) {
+  const template = config.bundle?.output || `${CONFIG_DIR}/cache/{title}`;
+  if (template.includes("{title}")) {
+    return join3(repo, template.replaceAll("{title}", title).replaceAll("{prefix}", config.notebooklm?.source_title_prefix || defaultShortSourceTitlePrefix()).replaceAll("{timestamp}", yymmddhhmm()));
+  }
+  return join3(dirname3(join3(repo, template)), title);
+}
+function repomixBaseArgv(config) {
+  const argv = repomixCmd();
+  const bundle = config.bundle || {};
+  if (String(bundle.style || "").trim())
+    argv.push("--style", String(bundle.style).trim());
+  if (bundle.compress)
+    argv.push("--compress");
+  const ignore = neverUploadSpecs(config).join(",");
+  if (ignore)
+    argv.push("--ignore", ignore);
+  return argv;
+}
+async function buildBundle(repo, config) {
+  const out = expandBundlePath(repo, config);
+  mkdirSync3(dirname3(out), { recursive: true });
+  const result = await runCommand([...repomixBaseArgv(config), "--include", includeSpecs(config).join(","), "--output", out], repo, { timeout: 600 });
+  if (result.returncode !== 0)
+    die(`repomix failed:
+${result.stdout}
+${result.stderr}`);
+  return out;
+}
+async function buildBundleSet(repo, config, opts) {
+  const maxBytes = parseSizeBytes(config.bundle?.max_chunk_bytes, 900000);
+  const chunks = await planBundleChunks(repo, config, opts);
+  const bundles = [];
+  try {
+    for (const chunk of chunks) {
+      const title = String(chunk.title);
+      const out = expandChunkPath(repo, config, title);
+      mkdirSync3(dirname3(out), { recursive: true });
+      const inputText = `${chunk.files.map(String).join(`
+`)}
+`;
+      const result = await runCommand([...repomixBaseArgv(config), "--stdin", "--output", out], repo, { inputText, timeout: 600 });
+      if (result.returncode !== 0)
+        die(`repomix failed for chunk ${title}:
+${result.stdout}
+${result.stderr}`);
+      const actualBytes = statSync2(out).size;
+      if (actualBytes > maxBytes)
+        die(`rendered chunk exceeds max size (${maxBytes} bytes): ${title} (${actualBytes} bytes)`);
+      bundles.push({ ...chunk, path: out, bundleSha256: sha256File(out), contentSha256: sha256File(out), fileListSha256: chunk.sha256, actualBytes, fileCount: chunk.files.length });
+    }
+  } catch (error) {
+    for (const bundle of bundles)
+      if (bundle.path)
+        removeFileQuiet(String(bundle.path));
+    throw error;
+  }
+  return bundles;
+}
+
+// src/ensure.ts
+init_common();
+import { existsSync as existsSync4 } from "node:fs";
+function stateUploadedFingerprint(state) {
+  return state.lastUploadedFastFingerprint || null;
+}
+async function ensureIndex(repo, opts = {}) {
+  const cfg = configPath(repo);
+  if (!existsSync4(cfg)) {
+    if (opts.jsonOutput || opts.returnUninitialized)
+      return uninitializedStatus(repo, cfg);
+    die(missingConfigMessage(repo, cfg, opts.command || "ensure"));
+  }
+  return repoLock(repo, () => ensureIndexLocked(repo, opts));
+}
+async function ensureIndexLocked(repo, opts = {}) {
+  const [config, cfgPath] = loadConfig(repo, opts.command || "ensure");
+  const [state, statePath] = loadState(cfgPath);
+  await recoverPendingUpload(repo, config, state);
+  await recoverPendingCleanup(repo, config, state, statePath);
+  const [fastHash, relevantPaths] = await fastFingerprint(repo, config, cfgPath);
+  const refresh = config.refresh || {};
+  const checkedAge = secondsSince(state.lastCheckedAt);
+  const uploadedAge = secondsSince(state.lastUploadedAt);
+  const uploadedFingerprint = stateUploadedFingerprint(state);
+  const result = {
+    status: "unknown",
+    config: cfgPath,
+    state: statePath,
+    relevant_changed_paths: relevantPaths,
+    fast_fingerprint: fastHash
+  };
+  if (!opts.force && checkedAge !== null && checkedAge < Number(refresh.check_ttl_seconds ?? 300) && uploadedFingerprint === fastHash) {
+    Object.assign(state, { lastCheckedAt: iso(), lastCheckedFastFingerprint: fastHash, lastBundlePath: null });
+    writeJson(statePath, state);
+    return { ...result, status: "fresh-ttl", checked_age_seconds: checkedAge };
+  }
+  if (!opts.force && uploadedFingerprint === fastHash && state.lastUploadedAt) {
+    Object.assign(state, { lastCheckedAt: iso(), lastCheckedFastFingerprint: fastHash, lastBundlePath: null });
+    writeJson(statePath, state);
+    return { ...result, status: "fresh-fingerprint" };
+  }
+  const firstUpload = activeSources(state).length === 0;
+  if (firstUpload && config.safety?.require_user_approval_first_upload !== false && !opts.yes && !opts.force) {
+    return { ...result, status: "needs-first-upload-approval" };
+  }
+  const minInterval = Number(refresh.min_upload_interval_seconds ?? 900);
+  const maxStaleness = Number(refresh.max_staleness_seconds ?? 86400);
+  if (!opts.force && uploadedAge !== null && uploadedAge < minInterval && uploadedAge < maxStaleness) {
+    Object.assign(state, { lastCheckedAt: iso(), lastCheckedFastFingerprint: fastHash, lastBundlePath: null });
+    writeJson(statePath, state);
+    return { ...result, status: "stale-throttled", uploaded_age_seconds: uploadedAge };
+  }
+  if (!opts.force && refresh.auto === false) {
+    Object.assign(state, { lastCheckedAt: iso(), lastCheckedFastFingerprint: fastHash, lastBundlePath: null });
+    writeJson(statePath, state);
+    return { ...result, status: "auto-refresh-disabled" };
+  }
+  if (bundleMode(config) === "chunked") {
+    const setId = yymmddhhmm();
+    const bundles = await buildBundleSet(repo, config, { setId, state });
+    try {
+      const bundleSetSha = sourceSetHash(bundles);
+      if (!opts.force && state.lastBundleSetSha256 === bundleSetSha) {
+        Object.assign(state, { lastCheckedAt: iso(), lastCheckedFastFingerprint: fastHash, lastBundlePath: null });
+        writeJson(statePath, state);
+        return { ...result, status: "fresh-bundle-hash", bundleSetSha256: bundleSetSha, bundleDeleted: true };
+      }
+      const sourceSet = await uploadBundleSet(repo, config, state, bundles, { setId });
+      const retiredIds = (sourceSet._retiredSourceIds || []).map(String).filter(Boolean);
+      delete sourceSet._retiredSourceIds;
+      Object.assign(state, {
+        lastCheckedAt: iso(),
+        lastUploadedAt: iso(),
+        lastConfigSha256: sha256File(cfgPath),
+        lastCheckedFastFingerprint: fastHash,
+        lastUploadedFastFingerprint: fastHash,
+        lastFastFingerprint: fastHash,
+        lastBundleSetSha256: bundleSetSha,
+        lastBundleSha256: bundleSetSha,
+        lastBundlePath: null,
+        activeSourceSet: sourceSet,
+        sources: (sourceSet.sources || []).filter((src) => src && typeof src === "object")
+      });
+      const cleanupPendingSourceIds2 = queueCleanupSourceIds(state, retiredIds);
+      writeJson(statePath, state);
+      clearPendingUpload(repo);
+      return { ...result, status: "uploaded", bundleSetSha256: bundleSetSha, bundleDeleted: true, sourceSet, cleanupPendingSourceIds: cleanupPendingSourceIds2 };
+    } finally {
+      for (const bundle2 of bundles)
+        if (bundle2.path)
+          removeFileQuiet(String(bundle2.path));
+    }
+  }
+  const bundle = await buildBundle(repo, config);
+  try {
+    const bundleSha = sha256File(bundle);
+    if (!opts.force && state.lastBundleSha256 === bundleSha) {
+      Object.assign(state, { lastCheckedAt: iso(), lastCheckedFastFingerprint: fastHash, lastBundlePath: null });
+      writeJson(statePath, state);
+      return { ...result, status: "fresh-bundle-hash", bundleSha256: bundleSha, bundleDeleted: true };
+    }
+    const source = await uploadTextSourceFromFile(repo, config, bundle, bundle.split("/").at(-1) || "bundle.txt");
+    source.bundleSha256 = bundleSha;
+    source.uploadedAt = iso();
+    if (config.notebooklm?.wait_after_upload && source.id) {
+      if (!await waitSourceReady(repo, notebookId(config), String(source.id)))
+        console.error(`warning: source wait failed for ${source.id}`);
+    }
+    state.sources = [...state.sources || [], source];
+    Object.assign(state, {
+      lastCheckedAt: iso(),
+      lastUploadedAt: iso(),
+      lastConfigSha256: sha256File(cfgPath),
+      lastCheckedFastFingerprint: fastHash,
+      lastUploadedFastFingerprint: fastHash,
+      lastFastFingerprint: fastHash,
+      lastBundleSha256: bundleSha,
+      lastBundlePath: null
+    });
+    writeJson(statePath, state);
+    return { ...result, status: "uploaded", bundleSha256: bundleSha, bundleDeleted: true, source };
+  } finally {
+    removeFileQuiet(bundle);
+  }
+}
+
+// src/retrieval.ts
+init_common();
+import { existsSync as existsSync5, readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+var PATH_RE = /(?:(?:[\w.-]+\/)+[\w.@+-]+\.(?:rs|ts|tsx|js|jsx|py|go|java|kt|md|toml|yaml|yml|json|sh|sql|css|scss|html))/g;
+var TERM_RE = /[A-Za-z_][A-Za-z0-9_]{3,}|[A-Za-z0-9][A-Za-z0-9_-]{4,}/g;
+var STOP_TERMS = new Set([
+  "agent",
+  "authority",
+  "btreemap",
+  "bundle",
+  "codex",
+  "command",
+  "docs",
+  "fixture",
+  "gate",
+  "justfile",
+  "keywords",
+  "local",
+  "names",
+  "paths",
+  "postgres",
+  "postgresql",
+  "real",
+  "refs",
+  "repo",
+  "shell",
+  "test",
+  "trigger",
+  "where",
+  "which",
+  "what",
+  "when",
+  "implemented",
+  "implementation",
+  "function",
+  "tests",
+  "files",
+  "return",
+  "likely",
+  "line",
+  "numbers",
+  "source",
+  "notebooklm"
+]);
+async function askProvider(repo, question) {
+  const [config, cfgPath] = loadConfig(repo, "ask");
+  const [state] = loadState(cfgPath);
+  const argv = ["notebooklm", "ask", question, "-n", notebookId(config)];
+  const { notebooklmCmd: notebooklmCmd2 } = await Promise.resolve().then(() => (init_common(), exports_common));
+  argv.splice(0, 1, ...notebooklmCmd2());
+  for (const sourceId of activeReadySourceIds(state))
+    argv.push("-s", sourceId);
+  argv.push("--json");
+  const result = await runCommand(argv, repo, { timeout: 180 });
+  if (result.returncode !== 0)
+    return { error: true, stdout: result.stdout, stderr: result.stderr };
+  try {
+    return JSON.parse(result.stdout);
+  } catch {
+    return { answer: result.stdout };
+  }
+}
+function answerText(data) {
+  return typeof data.answer === "string" ? data.answer : JSON.stringify(data);
+}
+function activeSourcesById(repo) {
+  const [, cfg] = loadConfig(repo, "ask");
+  const [state] = loadState(cfg);
+  const byId = new Map;
+  for (const source of activeSources(state))
+    if (source.id)
+      byId.set(String(source.id), source);
+  return byId;
+}
+function referencePathCandidates(repo, source, text) {
+  const files = Array.isArray(source.files) ? source.files.map(String).filter(Boolean) : [];
+  const fileSet = new Set(files);
+  const matches = [];
+  for (const raw of text.matchAll(PATH_RE)) {
+    const path = raw[0].replace(/[`'".,;:()[\]{}<>]+$/g, "");
+    if (fileSet.has(path) && existsSync5(join4(repo, path)))
+      matches.push([path, null]);
+  }
+  if (matches.length)
+    return [...new Map(matches.map((item) => [item.join(":"), item])).values()].slice(0, 5);
+  const snippet = text.split(/\s+/).join(" ");
+  if (snippet.length < 4 || snippet.length > 240 || text.includes("<directory_structure>"))
+    return [];
+  for (const path of files) {
+    const full = join4(repo, path);
+    if (!existsSync5(full) || statSync3(full).size > 2000000)
+      continue;
+    const content = readFileSync4(full, "utf8");
+    const index = content.indexOf(text);
+    if (index >= 0)
+      matches.push([path, content.slice(0, index).split(`
+`).length]);
+    else if (content.split(/\s+/).join(" ").includes(snippet))
+      matches.push([path, null]);
+    if (matches.length >= 5)
+      break;
+  }
+  return matches;
+}
+function formatReferencePaths(paths) {
+  const rendered = paths.slice(0, 3).map(([path, line]) => line ? `${path}:${line}` : path);
+  return `${rendered.join(", ")}${paths.length <= 3 ? "" : `, ...(+${paths.length - 3})`}`;
+}
+function printCompactReferences(repo, answer) {
+  if (!Array.isArray(answer.references) || !answer.references.length)
+    return;
+  const sources = activeSourcesById(repo);
+  const rows = [];
+  const seen = new Set;
+  for (const ref of answer.references) {
+    if (!ref || typeof ref !== "object")
+      continue;
+    const num = String(ref.citation_number || "").trim();
+    if (!num || seen.has(num))
+      continue;
+    seen.add(num);
+    const source = sources.get(String(ref.source_id || ""));
+    const paths = source ? referencePathCandidates(repo, source, String(ref.cited_text || "")) : [];
+    if (paths.length)
+      rows.push(`[${num}] ${formatReferencePaths(paths)}`);
+  }
+  if (rows.length)
+    console.log(`
+references:
+${rows.join(`
+`)}`);
+}
+function extractCandidates(text, query) {
+  const paths = [...new Set([...text.matchAll(PATH_RE)].map((match) => match[0]))].sort();
+  const terms = new Set;
+  for (const raw of `${text}
+${query}`.matchAll(TERM_RE)) {
+    const term = raw[0].replace(/^[`'"]|[`'"]$/g, "");
+    if (term.length < 4 || STOP_TERMS.has(term.toLowerCase()) || term.includes("/") || term.includes("."))
+      continue;
+    terms.add(term);
+  }
+  return [paths, [...terms].sort().slice(0, 24)];
+}
+function highSignalTerms(terms) {
+  const selected = terms.filter((term) => !STOP_TERMS.has(term.toLowerCase()) && (term.includes("_") || term.includes("-") || /[A-Z]/.test(term.slice(1)) || term.length >= 14));
+  return selected.length ? selected : terms.filter((term) => !STOP_TERMS.has(term.toLowerCase())).slice(0, 8);
+}
+function rgRoots(repo, config, candidates) {
+  const candidateRoots = candidates.filter((path) => existsSync5(join4(repo, path)));
+  const roots = includeSpecs(config).filter((spec) => existsSync5(join4(repo, spec)));
+  return [...candidateRoots.length ? [candidateRoots] : [], roots.length ? roots : ["."]];
+}
+function parseRgMatches(stdout, seen, remaining) {
+  const matches = [];
+  for (const line of stdout.split(`
+`)) {
+    if (matches.length >= remaining)
+      break;
+    const parts = line.split(":", 3);
+    if (parts.length !== 3)
+      continue;
+    const [path, lineNo, text] = parts;
+    const key = `${path}\x00${lineNo}\x00${text.trim()}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    matches.push({ path, line: /^\d+$/.test(lineNo) ? Number(lineNo) : lineNo, text: text.trim() });
+  }
+  return matches;
+}
+async function localRg(repo, config, terms, candidatePaths = []) {
+  if (!terms.length || !which("rg"))
+    return [];
+  const signal = highSignalTerms(terms);
+  const pattern = signal.slice(0, 16).map((term) => term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  const maxMatches = Number(config.retrieval?.max_local_matches || 80);
+  const matches = [];
+  const seen = new Set;
+  for (const roots of rgRoots(repo, config, candidatePaths)) {
+    const remaining = maxMatches - matches.length;
+    if (remaining <= 0)
+      break;
+    const result = await runCommand(["rg", "-n", "-S", "-e", pattern, "--", ...roots], repo, { timeout: 120 });
+    if (![0, 1].includes(result.returncode))
+      return [{ error: result.stderr.trim() }];
+    matches.push(...parseRgMatches(result.stdout, seen, remaining));
+  }
+  return matches;
+}
+function freshnessWarning(freshness) {
+  const status = String(freshness.status || "");
+  if (status === "stale-throttled") {
+    const changed = Array.isArray(freshness.relevant_changed_paths) ? freshness.relevant_changed_paths : [];
+    const preview = changed.length ? `; changed=${changed.slice(0, 5).join(", ")}${changed.length <= 5 ? "" : `, ...(+${changed.length - 5})`}` : "";
+    const age = freshness.uploaded_age_seconds !== undefined ? `; uploaded_age_seconds=${freshness.uploaded_age_seconds}` : "";
+    return `warning: index is stale-throttled${age}${preview}; provider answer may lag local changes. Use --force-refresh or refresh --force if needed.`;
+  }
+  if (status === "needs-first-upload-approval")
+    return "warning: first broad upload requires approval; rerun with --yes or run refresh explicitly.";
+  if (status === "auto-refresh-disabled")
+    return "warning: auto refresh is disabled; provider answer may lag local changes.";
+  return null;
+}
+function providerBlockMessage(freshness) {
+  if (freshness.status === "not-initialized")
+    return "skipped; project is not initialized for project retrieval.";
+  if (freshness.status === "needs-first-upload-approval")
+    return "skipped; first broad upload requires approval. Rerun ask/locate with --yes or run refresh explicitly.";
+  return null;
+}
+function firstUploadNext(repo, command, query) {
+  return {
+    [`${command}WithFirstUploadApproval`]: commandLine(repo, command, "--yes", query),
+    refresh: commandLine(repo, "refresh", "--force")
+  };
+}
+function providerBlockPayload(freshness, nextSteps) {
+  const next = freshness.next || nextSteps;
+  return { error: true, message: providerBlockMessage(freshness) || "skipped", ...next ? { next } : {} };
+}
+async function locate(repo, query, opts) {
+  const freshness = await ensureIndex(repo, { force: opts.forceRefresh, yes: opts.yes, jsonOutput: opts.json, command: "locate", returnUninitialized: true });
+  const blocked = providerBlockMessage(freshness);
+  if (blocked) {
+    const next = freshness.next || (freshness.status === "needs-first-upload-approval" ? firstUploadNext(repo, "locate", query) : undefined);
+    return {
+      freshness,
+      notebooklm_candidates: { paths: [], existing_paths: [], terms: [] },
+      local_line_refs: [],
+      provider_misses_or_stale_paths: [],
+      provider_answer: `(${blocked})`,
+      claim_boundary: "Semantic provider was not called because retrieval preflight is blocked.",
+      ...next ? { next } : {}
+    };
+  }
+  const prompt = `Find the code location for this repository question. Return likely repo paths, function names, test names, command names, and keywords for rg. If exact line numbers are unavailable, say so. Question: ${query}`;
+  const provider = await askProvider(repo, prompt);
+  const [paths, terms] = extractCandidates(answerText(provider), query);
+  const [config] = loadConfig(repo, "locate");
+  const existing = paths.filter((path) => existsSync5(join4(repo, path)));
+  return {
+    freshness,
+    notebooklm_candidates: { paths, existing_paths: existing, terms },
+    local_line_refs: await localRg(repo, config, terms, existing),
+    provider_misses_or_stale_paths: paths.filter((path) => !existsSync5(join4(repo, path))),
+    provider_answer: opts.includeProviderAnswer ? provider : "(hidden; pass --include-provider-answer)",
+    claim_boundary: "Line refs come from local rg results, not NotebookLM."
+  };
+}
+
+// src/commands.ts
+async function cmdInit(opts) {
+  const repo = resolve2(String(opts.repo || "."));
+  const cfgDir = join5(repo, CONFIG_DIR2);
+  const cfg = join5(cfgDir, CONFIG_JSON);
+  if (existsSync6(cfg) && !opts.force)
+    die(`config already exists: ${cfg}`);
+  const projectName = opts.projectName || basename2(repo);
+  const titlePrefix = opts.notebookTitlePrefix || "memdex";
+  const title = opts.notebookTitle || defaultNotebookTitle(projectName, titlePrefix);
+  let notebookIdValue = opts.notebookId || "";
+  let resolvedNotebook = null;
+  if (!notebookIdValue && (opts.reuseExistingNotebook || opts.createNotebook)) {
+    resolvedNotebook = await findNotebookByTitle(repo, title);
+    if (!resolvedNotebook && opts.createNotebook)
+      resolvedNotebook = await createNotebook(repo, title);
+    if (!resolvedNotebook)
+      die(`no NotebookLM notebook found with title ${JSON.stringify(title)}; pass --create-notebook or --notebook-id`);
+    notebookIdValue = String(resolvedNotebook.id || "");
+  }
+  const config = defaultConfig(repo, notebookIdValue, { projectName, notebookTitlePrefix: titlePrefix, notebookTitle: title });
+  if (opts.include)
+    config.bundle.include = String(opts.include).split(",").map((part) => part.trim()).filter(Boolean);
+  if (opts.sourceTitlePrefix)
+    config.notebooklm.source_title_prefix = opts.sourceTitlePrefix;
+  writeJson(cfg, config);
+  writeFileSync2(join5(cfgDir, ".gitignore"), `state.local.json
+state.local.*.json
+pending-upload.local.json
+cache/
+*.lock
+`);
+  console.log(`created: ${cfg}`);
+  console.log(`created: ${join5(cfgDir, ".gitignore")}`);
+  console.log(`notebook_title: ${title}`);
+  if (resolvedNotebook)
+    console.log(`notebook_id: ${notebookIdValue}`);
+  console.log("next:");
+  if (notebookIdValue) {
+    console.log(`  ${commandLine(repo, "ensure", "--yes")}`);
+    console.log(`  ${commandLine(repo, "ask", "your question")}`);
+  } else {
+    console.log("  set notebooklm.notebook_id in the config, or rerun init with --create-notebook / --reuse-existing-notebook / --notebook-id");
+  }
+}
+async function cmdStatus(opts) {
+  const repo = resolve2(String(opts.repo || "."));
+  const cfgCandidate = configPath(repo);
+  if (!existsSync6(cfgCandidate)) {
+    output(uninitializedStatus(repo, cfgCandidate), opts.json);
+    return;
+  }
+  const [config, cfgPath] = loadConfig(repo, "status");
+  const [state, statePath] = loadState(cfgPath);
+  const [fastHash, changed] = await fastFingerprint(repo, config, cfgPath);
+  output({
+    initialized: true,
+    config: cfgPath,
+    state: statePath,
+    provider: config.provider,
+    projectName: config.project?.name,
+    notebook_id: config.notebooklm?.notebook_id,
+    notebookTitle: notebookTitle(config),
+    sourceTitlePrefix: config.notebooklm?.source_title_prefix,
+    lastCheckedAt: state.lastCheckedAt,
+    lastUploadedAt: state.lastUploadedAt,
+    lastBundleSha256: state.lastBundleSha256,
+    fastFingerprint: fastHash,
+    stateCheckedFastFingerprint: state.lastCheckedFastFingerprint,
+    stateUploadedFastFingerprint: stateUploadedFingerprint(state),
+    stateFastFingerprint: state.lastFastFingerprint,
+    relevantChangedPaths: changed,
+    sources: state.sources || []
+  }, opts.json);
+}
+async function cmdPack(opts) {
+  const repo = resolve2(String(opts.repo || "."));
+  const [config, cfgPath] = loadConfig(repo, "pack");
+  const [state] = loadState(cfgPath);
+  const setId = opts.setId || yymmddhhmm();
+  const chunks = await planBundleChunks(repo, config, { setId, state });
+  if (opts.dryRun) {
+    output({
+      setId,
+      mode: "chunked",
+      chunkCount: chunks.length,
+      chunks: chunks.map((chunk) => ({
+        group: chunk.group,
+        chunk: chunk.chunk,
+        title: chunk.title,
+        estimatedBytes: chunk.estimatedBytes,
+        fileCount: (chunk.files || []).length,
+        ...opts.includeFiles ? { files: chunk.files || [] } : {}
+      }))
+    }, opts.json);
+    return;
+  }
+  const bundles = await buildBundleSet(repo, config, { setId, state });
+  output({
+    setId,
+    bundleCount: bundles.length,
+    bundles: bundles.map((bundle) => ({
+      group: bundle.group,
+      chunk: bundle.chunk,
+      title: bundle.title,
+      path: bundle.path,
+      fileCount: bundle.fileCount,
+      bundleSha256: bundle.bundleSha256,
+      contentSha256: bundle.contentSha256
+    }))
+  }, opts.json);
+}
+async function cmdEnsure(opts) {
+  output(await ensureIndex(resolve2(String(opts.repo || ".")), { force: opts.force, yes: opts.yes, jsonOutput: opts.json, command: "ensure" }), opts.json);
+}
+async function cmdRefresh(opts) {
+  output(await ensureIndex(resolve2(String(opts.repo || ".")), { force: true, yes: true, jsonOutput: opts.json, command: "refresh" }), opts.json);
+}
+function printAskResult(repo, freshness, answer, opts) {
+  if (opts.json) {
+    output({ freshness, provider_answer: answer }, true);
+    return;
+  }
+  const warning = freshnessWarning(freshness);
+  if (warning)
+    console.log(warning);
+  if (opts.verbose) {
+    console.log(`freshness: ${JSON.stringify(freshness)}`);
+    const metadata = {};
+    for (const key of ["conversation_id", "turn_number", "is_follow_up"])
+      if (key in answer)
+        metadata[key] = answer[key];
+    if (Array.isArray(answer.references))
+      metadata.references_count = answer.references.length;
+    if (Object.keys(metadata).length)
+      console.log(`provider: ${JSON.stringify(metadata)}`);
+  }
+  console.log(answerText(answer));
+  printCompactReferences(repo, answer);
+}
+async function cmdAsk(question, opts) {
+  const repo = resolve2(String(opts.repo || "."));
+  const freshness = await ensureIndex(repo, { force: opts.forceRefresh, yes: opts.yes, jsonOutput: opts.json, command: "ask", returnUninitialized: true });
+  const blocked = providerBlockMessage(freshness);
+  if (blocked) {
+    const next = freshness.status === "needs-first-upload-approval" ? firstUploadNext(repo, "ask", question) : undefined;
+    printAskResult(repo, freshness, providerBlockPayload(freshness, next), opts);
+    return;
+  }
+  printAskResult(repo, freshness, await askProvider(repo, question), opts);
+}
+function printLocateResult(result, opts) {
+  if (opts.json) {
+    output(result, true);
+    return;
+  }
+  const warning = freshnessWarning(result.freshness || {});
+  if (warning)
+    console.log(warning);
+  if (opts.verbose)
+    console.log(`freshness: ${JSON.stringify(result.freshness || {})}`);
+  const visible = { ...result };
+  delete visible.freshness;
+  output(visible, false);
+}
+async function cmdLocate(query, opts) {
+  printLocateResult(await locate(resolve2(String(opts.repo || ".")), query, { forceRefresh: opts.forceRefresh, yes: opts.yes, json: opts.json, includeProviderAnswer: opts.includeProviderAnswer }), opts);
+}
+async function cmdTempSourceUpload(opts) {
+  const repo = resolve2(String(opts.repo || "."));
+  const [config, cfgPath] = loadConfig(repo, "temp-source upload");
+  let sourcePath = String(opts.file || "");
+  sourcePath = isAbsolute(sourcePath) ? sourcePath : resolve2(repo, sourcePath);
+  if (!existsSync6(sourcePath))
+    die(`temp source file not found: ${sourcePath}`);
+  const setId = yymmddhhmm();
+  const contentSha = sha256File(sourcePath);
+  const title = tempSourceTitle(config, { setId, kind: opts.kind, title: opts.title, contentSha });
+  const staged = stageTempSourceFile(repo, title, sourcePath);
+  let sourceSet = {};
+  let item = {};
+  await withRepoLock(repo, async () => {
+    try {
+      const [state, statePath] = loadState(cfgPath);
+      const source = await uploadTextSourceFromFile(repo, config, staged, title);
+      let status = "uploaded";
+      if (config.notebooklm?.wait_after_upload !== false && source.id) {
+        status = await waitSourceReady(repo, notebookId(config), String(source.id)) ? "ready" : "error";
+        if (status !== "ready") {
+          await deleteSourceIdsParallel(repo, notebookId(config), [String(source.id || "")], { parallelism: Number(config.notebooklm?.delete_parallelism || 4) });
+          die(`source processing failed for temp source ${title}: ${source.id}`);
+        }
+      }
+      const active = state.activeSourceSet && typeof state.activeSourceSet === "object" ? state.activeSourceSet : {};
+      item = {
+        id: source.id,
+        title: source.title || title,
+        contentSha256: contentSha,
+        uploadedAt: iso(),
+        status,
+        origin: { activeSourceSetId: active.id, chunkKeys: opts.originChunk || [], filePaths: opts.originFile || [] }
+      };
+      sourceSet = { id: setId, kind: slugify(opts.kind), purpose: opts.title, createdAt: iso(), expiresAt: tempSourceExpiresAt(Number(opts.ttlSeconds || 0)), sources: [item] };
+      state.temporarySourceSets = [...tempSourceSets(state), sourceSet];
+      writeJson(statePath, state);
+    } finally {
+      removeFileQuiet(staged);
+    }
+  });
+  output({ sourceSet, source: item }, opts.json);
+}
+async function cmdTempSourceList(opts) {
+  const repo = resolve2(String(opts.repo || "."));
+  const [config, cfgPath] = loadConfig(repo, "temp-source list");
+  const [state] = loadState(cfgPath);
+  let sets = tempSourceSets(state);
+  if (opts.kind)
+    sets = sets.filter((item) => String(item.kind || "") === slugify(opts.kind));
+  const prefix = tempSourcePrefix(config);
+  const provider = (await listSources(repo, notebookId(config))).filter((src) => String(src.title || "").startsWith(`${prefix}--`));
+  const tracked = new Set(tempSourceSets(state).flatMap((set) => (set.sources || []).map((src) => String(src.id || "")).filter(Boolean)));
+  output({ temporarySourceSets: sets, untrackedPrefixMatches: provider.filter((src) => !tracked.has(String(src.id || ""))) }, opts.json);
+}
+async function cmdTempSourceCleanup(opts) {
+  const repo = resolve2(String(opts.repo || "."));
+  const [config, cfgPath] = loadConfig(repo, "temp-source cleanup");
+  let deleted = [];
+  let untracked = [];
+  await withRepoLock(repo, async () => {
+    const [state, statePath] = loadState(cfgPath);
+    const wantedKind = opts.kind ? slugify(opts.kind) : "";
+    const selected = [];
+    const kept = [];
+    for (const sourceSet of tempSourceSets(state)) {
+      let matches = true;
+      if (opts.setId && String(sourceSet.id || "") !== String(opts.setId))
+        matches = false;
+      if (wantedKind && String(sourceSet.kind || "") !== wantedKind)
+        matches = false;
+      if (opts.expired && !sourceIsExpired(sourceSet))
+        matches = false;
+      (matches ? selected : kept).push(sourceSet);
+    }
+    if (!opts.yes)
+      die("cleanup requires --yes");
+    const sourceIds = selected.flatMap((set) => (set.sources || []).map((src) => String(src.id || "")).filter(Boolean));
+    deleted = await deleteSourceIdsParallel(repo, notebookId(config), sourceIds, { parallelism: Number(config.notebooklm?.delete_parallelism || 4) });
+    const deletedSet = new Set(deleted);
+    const remainingSelected = selected.map((set) => ({ ...set, sources: (set.sources || []).filter((src) => !deletedSet.has(String(src.id || ""))) })).filter((set) => set.sources.length);
+    state.temporarySourceSets = [...kept, ...remainingSelected];
+    writeJson(statePath, state);
+    const prefix = tempSourcePrefix(config);
+    const providerMatches = (await listSources(repo, notebookId(config))).filter((src) => String(src.title || "").startsWith(`${prefix}--`));
+    const tracked = new Set(tempSourceSets(state).flatMap((set) => (set.sources || []).map((src) => String(src.id || "")).filter(Boolean)));
+    untracked = providerMatches.filter((src) => !tracked.has(String(src.id || "")) && !deletedSet.has(String(src.id || "")));
+    if (opts.includeUntrackedPrefix) {
+      const extra = await deleteSourceIdsParallel(repo, notebookId(config), untracked.map((src) => String(src.id || "")).filter(Boolean), { parallelism: Number(config.notebooklm?.delete_parallelism || 4) });
+      deleted.push(...extra);
+      const extraSet = new Set(extra);
+      untracked = untracked.filter((src) => !extraSet.has(String(src.id || "")));
+    }
+  });
+  output({ deletedSourceIds: deleted, untrackedPrefixMatches: untracked }, opts.json);
+}
+
+// src/cli.ts
+function buildProgram() {
+  const program = new Command;
+  program.name("memdex").description([
+    "Agent-facing semantic retrieval for projects and source sets.",
+    "",
+    "Memdex uses NotebookLM as a semantic locator, then treats local files,",
+    "command output, and project docs as authority for exact evidence."
+  ].join(`
+`)).showHelpAfterError().addHelpText("after", `
+
+Common agent paths:
+  memdex init --repo . --create-notebook
+  memdex ask --repo . "Where is retry/backfill documented?"
+  memdex locate --repo . "invoice export retry command"
+  memdex ask --repo . --yes "question"
+
+Command routing:
+  ask      answer architecture/docs/status questions over the source set
+  locate   find likely files or symbols and return local line refs
+  init     create .memdex/config.json and bind a NotebookLM notebook
+  status   inspect local config, freshness, and recorded source state
+  ensure   prewarm or refresh the index when policy allows
+  refresh  force a source replacement
+  pack     preview deterministic repomix chunks without provider Q&A
+`);
+  program.command("ask").description("answer semantic project questions with freshness preflight").argument("<question>", "natural-language question to ask over the source set").option("--repo <repo>", "project root", ".").option("--yes", "approve first broad upload if setup is otherwise ready").option("--force-refresh", "refresh managed sources before asking").option("--json", "print machine-readable JSON").option("--verbose", "include freshness and provider metadata").action((question, opts) => cmdAsk(question, opts));
+  program.command("locate").description("find likely files or symbols and verify local line refs").argument("<query>", "natural-language thing to find").option("--repo <repo>", "project root", ".").option("--yes", "approve first broad upload if setup is otherwise ready").option("--force-refresh", "refresh managed sources before locating").option("--include-provider-answer", "include the raw provider answer in output").option("--json", "print machine-readable JSON").option("--verbose", "include freshness metadata").action((query, opts) => cmdLocate(query, opts));
+  program.command("init").description("create .memdex/config.json and bind a NotebookLM notebook").option("--repo <repo>", "project, repo, vault, or source-set root", ".").option("--notebook-id <id>", "bind an existing NotebookLM notebook by ID", "").option("--project-name <name>", "stable project key for notebook and source titles", "").option("--notebook-title-prefix <prefix>", "NotebookLM title prefix", "memdex").option("--notebook-title <title>", "exact NotebookLM title to create or reuse", "").option("--reuse-existing-notebook", "reuse an exact title match; do not create cloud state").option("--create-notebook", "create the NotebookLM notebook when no exact title match exists").option("--source-title-prefix <prefix>", "prefix for managed NotebookLM source titles", "").option("--include <specs>", "comma-separated include roots or files for the source set", "").option("--force", "overwrite existing .memdex/config.json").action((opts) => cmdInit(opts));
+  program.command("status").description("inspect config, freshness, and recorded source state").option("--repo <repo>", "project root", ".").option("--json", "print machine-readable JSON").action((opts) => cmdStatus(opts));
+  program.command("pack").description("preview deterministic repomix chunks").option("--repo <repo>", "project root", ".").option("--set-id <id>", "stable source-set ID for rendered chunk titles", "").option("--dry-run", "show planned chunks without running repomix").option("--include-files", "include per-chunk file lists in output").option("--json", "print machine-readable JSON").action((opts) => cmdPack(opts));
+  program.command("ensure").description("prewarm or refresh the index when policy allows").option("--repo <repo>", "project root", ".").option("--force", "bypass freshness TTL and rebuild source state").option("--yes", "approve the first broad upload for this run").option("--json", "print machine-readable JSON").action((opts) => cmdEnsure(opts));
+  program.command("refresh").description("force source replacement").option("--repo <repo>", "project root", ".").option("--force", "force refresh even when freshness checks would skip it").option("--json", "print machine-readable JSON").action((opts) => cmdRefresh(opts));
+  const temp = program.command("temp-source").description("manage temporary derived NotebookLM sources");
+  temp.command("upload").description("upload a temporary source file").option("--repo <repo>", "project root", ".").requiredOption("--kind <kind>", "temporary source kind").requiredOption("--title <title>", "human-readable title slug").requiredOption("--file <file>", "local markdown/text file to upload").option("--origin-chunk <chunk>", "origin active chunk key; repeatable", collect, []).option("--origin-file <file>", "origin local file path; repeatable", collect, []).option("--ttl-seconds <seconds>", "optional expiry TTL in seconds", "0").option("--json", "print machine-readable JSON").action((opts) => cmdTempSourceUpload({ ...opts, ttlSeconds: Number(opts.ttlSeconds || 0) }));
+  temp.command("list").description("list recorded temporary sources").option("--repo <repo>", "project root", ".").option("--kind <kind>", "filter by temporary source kind", "").option("--json", "print machine-readable JSON").action((opts) => cmdTempSourceList(opts));
+  temp.command("cleanup").description("delete recorded temporary sources").option("--repo <repo>", "project root", ".").option("--kind <kind>", "filter by temporary source kind", "").option("--set-id <id>", "filter by temporary source-set ID", "").option("--expired", "clean only expired temporary sources").option("--include-untracked-prefix", "also delete untracked prefix matches; requires --yes").option("--yes", "confirm deletion").option("--json", "print machine-readable JSON").action((opts) => cmdTempSourceCleanup(opts));
+  return program;
+}
+function collect(value, previous) {
+  previous.push(value);
+  return previous;
+}
+async function main(argv = process.argv) {
+  try {
+    await buildProgram().parseAsync(argv);
+  } catch (error) {
+    if (error instanceof MemdexError) {
+      console.error(`error: ${error.message}`);
+      process.exitCode = error.code;
+      return;
+    }
+    throw error;
+  }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  await main();
+}
+export {
+  main,
+  buildProgram
+};