lens-engine 0.1.18 → 0.1.20

package/cli.js

@@ -3347,36 +3347,108 @@ var {
   Help
 } = import_index.default;
 
-// packages/cli/src/util/repo.ts
-import { readFile } from "fs/promises";
-import { existsSync } from "fs";
-import { resolve, dirname, basename } from "path";
-function findGitRoot(from) {
-  let dir = resolve(from);
-  while (true) {
-    if (existsSync(resolve(dir, ".git"))) return dir;
-    const parent = dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
+// packages/cli/src/util/config.ts
+import { randomUUID } from "crypto";
+import fsSync from "fs";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+var CONFIG_DIR = path.join(os.homedir(), ".lens");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var DEFAULTS = {
+  inject_behavior: "always",
+  show_progress: true
+};
+async function readConfig() {
+  try {
+    const raw = await fs.readFile(CONFIG_FILE, "utf-8");
+    return { ...DEFAULTS, ...JSON.parse(raw) };
+  } catch {
+    return DEFAULTS;
   }
 }
-async function parseRemoteUrl(gitRoot) {
+async function writeConfig(config) {
+  await fs.mkdir(CONFIG_DIR, { recursive: true });
+  await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+async function configGet(key) {
+  const config = await readConfig();
+  if (key in config) {
+    return JSON.stringify(config[key], null, 2);
+  }
+  return "null";
+}
+async function configSet(key, value) {
+  const config = await readConfig();
+  if (key === "inject_behavior" && ["always", "skip", "once"].includes(value)) {
+    config.inject_behavior = value;
+  } else if (key === "show_progress") {
+    config.show_progress = value === "true";
+  } else if (key === "cloud_url") {
+    config.cloud_url = value;
+  } else if (key === "telemetry") {
+    config.telemetry = value === "true";
+  } else {
+    throw new Error(`Invalid config: ${key}=${value}`);
+  }
+  await writeConfig(config);
+}
+function getCloudUrl() {
+  if (process.env.LENS_CLOUD_URL) return process.env.LENS_CLOUD_URL;
   try {
-    const config = await readFile(resolve(gitRoot, ".git/config"), "utf-8");
-    const match = config.match(/\[remote "origin"\][^[]*url\s*=\s*(.+)/m);
-    return match?.[1]?.trim();
+    const cfg2 = JSON.parse(fsSync.readFileSync(CONFIG_FILE, "utf-8"));
+    if (cfg2.cloud_url) return cfg2.cloud_url;
   } catch {
-    return void 0;
+  }
+  return "https://cloud.lens-engine.com";
+}
+function readConfigSync() {
+  try {
+    return { ...DEFAULTS, ...JSON.parse(fsSync.readFileSync(CONFIG_FILE, "utf-8")) };
+  } catch {
+    return DEFAULTS;
   }
 }
-async function detectRepo(cwd = process.cwd()) {
-  const root = findGitRoot(cwd);
-  if (!root) {
-    throw new Error("Not inside a git repository. Run from a git repo or use `git init`.");
+function isTelemetryEnabled() {
+  const config = readConfigSync();
+  return config.telemetry !== false;
+}
+
+// packages/cli/src/util/format.ts
+function output(data, json) {
+  if (json) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}
+`);
+  } else if (typeof data === "string") {
+    process.stdout.write(`${data}
+`);
+  } else {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}
+`);
+  }
+}
+function error(msg) {
+  process.stderr.write(`Error: ${msg}
+`);
+}
+
+// packages/cli/src/commands/config.ts
+async function configGetCommand(key) {
+  try {
+    const value = await configGet(key);
+    output(value, false);
+  } catch (err) {
+    output(err instanceof Error ? err.message : String(err), false);
+  }
+}
+async function configSetCommand(key, value) {
+  try {
+    await configSet(key, value);
+    output(`Config updated: ${key} = ${value}`, false);
+  } catch (err) {
+    output(err instanceof Error ? err.message : String(err), false);
+    process.exit(1);
   }
-  const remote_url = await parseRemoteUrl(root);
-  const name = basename(root);
-  return { root_path: root, name, remote_url };
 }
 
 // packages/cli/src/util/client.ts
@@ -3434,159 +3506,336 @@ async function request(method, path4, body, retries = 3) {
 var get = (path4) => request("GET", path4);
 var post = (path4, body) => request("POST", path4, body);
 
-// packages/cli/src/util/format.ts
-function output(data, json) {
-  if (json) {
-    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
-  } else if (typeof data === "string") {
-    process.stdout.write(data + "\n");
-  } else {
-    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+// packages/cli/src/util/repo.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { basename, dirname, resolve } from "path";
+function findGitRoot(from) {
+  let dir = resolve(from);
+  while (true) {
+    if (existsSync(resolve(dir, ".git"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
   }
 }
-function error(msg) {
-  process.stderr.write(`Error: ${msg}
-`);
-}
-
-// packages/cli/src/util/inject-claude-md.ts
-import fs2 from "fs/promises";
-import path2 from "path";
-
-// packages/cli/src/util/config.ts
-import fs from "fs/promises";
-import fsSync from "fs";
-import path from "path";
-import os from "os";
-import { randomUUID } from "crypto";
-var CONFIG_DIR = path.join(os.homedir(), ".lens");
-var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
-var DEFAULTS = {
-  inject_behavior: "always",
-  show_progress: true
-};
-async function readConfig() {
+async function parseRemoteUrl(gitRoot) {
   try {
-    const raw = await fs.readFile(CONFIG_FILE, "utf-8");
-    return { ...DEFAULTS, ...JSON.parse(raw) };
+    const config = await readFile(resolve(gitRoot, ".git/config"), "utf-8");
+    const match = config.match(/\[remote "origin"\][^[]*url\s*=\s*(.+)/m);
+    return match?.[1]?.trim();
   } catch {
-    return DEFAULTS;
+    return void 0;
   }
 }
-async function writeConfig(config) {
-  await fs.mkdir(CONFIG_DIR, { recursive: true });
-  await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
-}
-async function configGet(key) {
-  const config = await readConfig();
-  if (key in config) {
-    return JSON.stringify(config[key], null, 2);
+async function detectRepo(cwd = process.cwd()) {
+  const root = findGitRoot(cwd);
+  if (!root) {
+    throw new Error("Not inside a git repository. Run from a git repo or use `git init`.");
   }
-  return "null";
+  const remote_url = await parseRemoteUrl(root);
+  const name = basename(root);
+  return { root_path: root, name, remote_url };
 }
-async function configSet(key, value) {
-  const config = await readConfig();
-  if (key === "inject_behavior" && ["always", "skip", "once"].includes(value)) {
-    config.inject_behavior = value;
-  } else if (key === "show_progress") {
-    config.show_progress = value === "true";
-  } else if (key === "cloud_url") {
-    config.cloud_url = value;
-  } else if (key === "telemetry") {
-    config.telemetry = value === "true";
+
+// packages/cli/src/util/ensure-repo.ts
+async function ensureRepo() {
+  const info = await detectRepo();
+  const res = await post("/repo/register", {
+    root_path: info.root_path,
+    name: info.name,
+    remote_url: info.remote_url
+  });
+  return { repo_id: res.repo_id, name: res.name, root_path: info.root_path };
+}
+
+// packages/cli/src/commands/context.ts
+async function contextCommand(goal, opts) {
+  const { repo_id } = await ensureRepo();
+  const res = await post("/context", { repo_id, goal });
+  if (opts.json) {
+    output(res, true);
   } else {
-    throw new Error(`Invalid config: ${key}=${value}`);
+    output(res.context_pack, false);
   }
-  await writeConfig(config);
 }
-function getCloudUrl() {
-  if (process.env.LENS_CLOUD_URL) return process.env.LENS_CLOUD_URL;
+
+// packages/cli/src/commands/daemon-ctrl.ts
+import { execSync, spawn } from "child_process";
+import { existsSync as existsSync2, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { createRequire } from "module";
+import { homedir } from "os";
+import { dirname as dirname2, join } from "path";
+import { fileURLToPath } from "url";
+var LENS_DIR = join(homedir(), ".lens");
+var PID_FILE = join(LENS_DIR, "daemon.pid");
+var LOG_FILE = join(LENS_DIR, "daemon.log");
+var LAUNCH_AGENTS_DIR = join(homedir(), "Library", "LaunchAgents");
+var PLIST_PATH = join(LAUNCH_AGENTS_DIR, "com.lens.daemon.plist");
+var SYSTEMD_DIR = join(homedir(), ".config", "systemd", "user");
+var SERVICE_PATH = join(SYSTEMD_DIR, "lens-daemon.service");
+var WIN_REG_KEY = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
+var WIN_REG_NAME = "LensDaemon";
+function isDaemonRunning() {
+  if (!existsSync2(PID_FILE)) return { running: false };
+  const pid = Number(readFileSync(PID_FILE, "utf-8").trim());
   try {
-    const cfg2 = JSON.parse(fsSync.readFileSync(CONFIG_FILE, "utf-8"));
-    if (cfg2.cloud_url) return cfg2.cloud_url;
+    process.kill(pid, 0);
+    return { running: true, pid };
   } catch {
+    unlinkSync(PID_FILE);
+    return { running: false };
   }
-  return "https://cloud.lens-engine.com";
 }
-function readConfigSync() {
+function setupDarwin(daemonScript) {
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.lens.daemon</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${process.execPath}</string>
+        <string>${daemonScript}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <false/>
+    <key>StandardOutPath</key>
+    <string>${LOG_FILE}</string>
+    <key>StandardErrorPath</key>
+    <string>${LOG_FILE}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>LENS_DAEMON</key>
+        <string>1</string>
+    </dict>
+</dict>
+</plist>
+`;
+  const existing = existsSync2(PLIST_PATH) ? readFileSync(PLIST_PATH, "utf-8") : "";
+  if (existing === plist) return;
+  if (existing) {
+    try {
+      execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`);
+    } catch {
+    }
+  }
+  mkdirSync(LAUNCH_AGENTS_DIR, { recursive: true });
+  writeFileSync(PLIST_PATH, plist);
   try {
-    return { ...DEFAULTS, ...JSON.parse(fsSync.readFileSync(CONFIG_FILE, "utf-8")) };
+    execSync(`launchctl load "${PLIST_PATH}" 2>/dev/null`);
   } catch {
-    return DEFAULTS;
   }
 }
-function isTelemetryEnabled() {
-  const config = readConfigSync();
-  return config.telemetry !== false;
+function teardownDarwin() {
+  if (!existsSync2(PLIST_PATH)) return;
+  try {
+    execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`);
+  } catch {
+  }
 }
+function setupLinux(daemonScript) {
+  const unit = `[Unit]
+Description=LENS Daemon
 
-// packages/cli/src/util/inject-claude-md.ts
-var RLM_MARKER = "lens context";
-var CANDIDATE_PATHS = ["CLAUDE.md", "agents.md", "AGENTS.md", ".CLAUDE.md", ".agents.md", ".AGENTS.md"];
-async function findTargetFile(repoRoot) {
-  for (const relPath of CANDIDATE_PATHS) {
-    const fullPath = path2.join(repoRoot, relPath);
-    try {
-      await fs2.access(fullPath);
-      return fullPath;
-    } catch {
-      continue;
-    }
+[Service]
+ExecStart=${process.execPath} ${daemonScript}
+Restart=no
+Environment=LENS_DAEMON=1
+StandardOutput=append:${LOG_FILE}
+StandardError=append:${LOG_FILE}
+
+[Install]
+WantedBy=default.target
+`;
+  const existing = existsSync2(SERVICE_PATH) ? readFileSync(SERVICE_PATH, "utf-8") : "";
+  if (existing === unit) return;
+  mkdirSync(SYSTEMD_DIR, { recursive: true });
+  writeFileSync(SERVICE_PATH, unit);
+  try {
+    execSync("systemctl --user daemon-reload 2>/dev/null");
+  } catch {
   }
-  return null;
-}
-async function injectClaudeMd(repoRoot) {
-  const existingFile = await findTargetFile(repoRoot);
-  const targetFile = existingFile ?? path2.join(repoRoot, "CLAUDE.md");
-  let existingContent = "";
   try {
-    existingContent = await fs2.readFile(targetFile, "utf-8");
-    if (existingContent.toLowerCase().includes(RLM_MARKER)) {
-      return;
-    }
+    execSync("systemctl --user enable lens-daemon.service 2>/dev/null");
   } catch {
   }
-  const config = await readConfig();
-  if (existingFile && config.inject_behavior === "once") {
+}
+function teardownLinux() {
+  try {
+    execSync("systemctl --user disable lens-daemon.service 2>/dev/null");
+  } catch {
+  }
+}
+function setupWindows(daemonScript) {
+  const cmd = `"${process.execPath}" "${daemonScript}"`;
+  try {
+    const existing = execSync(`reg query "${WIN_REG_KEY}" /v ${WIN_REG_NAME} 2>nul`, { encoding: "utf-8" });
+    if (existing.includes(cmd)) return;
+  } catch {
+  }
+  try {
+    execSync(`reg add "${WIN_REG_KEY}" /v ${WIN_REG_NAME} /t REG_SZ /d "${cmd}" /f 2>nul`);
+  } catch {
+  }
+}
+function teardownWindows() {
+  try {
+    execSync(`reg delete "${WIN_REG_KEY}" /v ${WIN_REG_NAME} /f 2>nul`);
+  } catch {
+  }
+}
+function setupAutoStart(daemonScript) {
+  switch (process.platform) {
+    case "darwin":
+      setupDarwin(daemonScript);
+      break;
+    case "linux":
+      setupLinux(daemonScript);
+      break;
+    case "win32":
+      setupWindows(daemonScript);
+      break;
+  }
+}
+function removeAutoStart() {
+  switch (process.platform) {
+    case "darwin":
+      teardownDarwin();
+      break;
+    case "linux":
+      teardownLinux();
+      break;
+    case "win32":
+      teardownWindows();
+      break;
+  }
+}
+async function startCommand() {
+  const status = isDaemonRunning();
+  if (status.running) {
+    output(`LENS daemon already running (pid: ${status.pid})`, false);
     return;
   }
-  if (config.inject_behavior === "skip") {
+  const selfDir = dirname2(fileURLToPath(import.meta.url));
+  const sibling = join(selfDir, "daemon.js");
+  let daemonScript;
+  if (existsSync2(sibling)) {
+    daemonScript = sibling;
+  } else {
+    try {
+      const require2 = createRequire(import.meta.url);
+      daemonScript = require2.resolve("@lens/daemon");
+    } catch {
+      error("Could not find @lens/daemon. Run `pnpm build` first.");
+      return;
+    }
+  }
+  mkdirSync(LENS_DIR, { recursive: true });
+  setupAutoStart(daemonScript);
+  if (isDaemonRunning().running) {
+    const check2 = isDaemonRunning();
+    output(`LENS daemon started (pid: ${check2.pid})`, false);
     return;
   }
-  const { content } = await get("/repo/template");
-  if (existingContent) {
-    await fs2.writeFile(targetFile, `${content}
-
-${existingContent}`);
+  const logFd = openSync(LOG_FILE, "a");
+  const child = spawn(process.execPath, [daemonScript], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: { ...process.env, LENS_DAEMON: "1" }
+  });
+  child.unref();
+  for (let i = 0; i < 20; i++) {
+    await new Promise((r) => setTimeout(r, 250));
+    if (isDaemonRunning().running) break;
+  }
+  const check = isDaemonRunning();
+  if (check.running) {
+    output(`LENS daemon started (pid: ${check.pid})`, false);
   } else {
-    await fs2.writeFile(targetFile, content);
+    error(`LENS daemon failed to start. Check logs: ${LOG_FILE}`);
   }
 }
-
-// packages/cli/src/util/inject-mcp.ts
-import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-var MCP_ENTRY = {
-  command: "npx",
-  args: ["lens-daemon", "--stdio"]
-};
-function injectMcp(repoRoot) {
-  const mcpPath = join(repoRoot, ".mcp.json");
-  let existing = {};
-  if (existsSync2(mcpPath)) {
-    try {
-      existing = JSON.parse(readFileSync(mcpPath, "utf-8"));
-    } catch {
+async function stopCommand() {
+  const status = isDaemonRunning();
+  if (!status.running) {
+    output("LENS daemon is not running", false);
+    return;
+  }
+  removeAutoStart();
+  process.kill(status.pid, "SIGTERM");
+  for (let i = 0; i < 20; i++) {
+    await new Promise((r) => setTimeout(r, 250));
+    if (!isDaemonRunning().running) {
+      output(`LENS daemon stopped (pid: ${status.pid})`, false);
+      return;
     }
   }
-  if (!existing.mcpServers) existing.mcpServers = {};
-  const servers = existing.mcpServers;
-  if (servers.lens) return "exists";
-  const isNew = !existsSync2(mcpPath);
-  servers.lens = MCP_ENTRY;
-  writeFileSync(mcpPath, `${JSON.stringify(existing, null, 2)}
-`);
-  return isNew ? "created" : "updated";
+  error(`Daemon did not stop within 5s. Force kill with: kill -9 ${status.pid}`);
+}
+
+// packages/cli/src/commands/daemon-stats.ts
+async function daemonStatsCommand(opts) {
+  const s = await get("/daemon/stats");
+  if (opts.json) {
+    output(s, true);
+    return;
+  }
+  const embedPct = s.total_chunks > 0 ? Math.round(s.total_embeddings / s.total_chunks * 100) : 0;
+  const maintResult = s.last_maintenance_result ? `${s.last_maintenance_result.processed} processed, ${s.last_maintenance_result.errors} errors` : "\u2014";
+  const lines = [
+    "## LENS Daemon",
+    "",
+    `  Repos:      ${s.repos_count}`,
+    `  Chunks:     ${s.total_chunks.toLocaleString()}`,
+    `  Embeddings: ${s.total_embeddings.toLocaleString()} (${embedPct}%)`,
+    `  DB Size:    ${s.db_size_mb} MB`,
+    "",
+    "  ## Maintenance Cron",
+    `  Last maintenance: ${s.last_maintenance_at ?? "never"}`,
+    `  Next maintenance: ${s.next_maintenance_at ?? "\u2014"}`,
+    `  Last result:      ${maintResult}`
+  ];
+  output(lines.join("\n"), false);
+}
+
+// packages/cli/src/commands/dashboard.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+
+// packages/cli/src/util/browser.ts
+import { exec } from "child_process";
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} ${url}`);
+}
+
+// packages/cli/src/commands/dashboard.ts
+var PID_FILE2 = join2(homedir2(), ".lens", "daemon.pid");
+function isDaemonRunning2() {
+  if (!existsSync3(PID_FILE2)) return false;
+  const pid = Number(readFileSync2(PID_FILE2, "utf-8").trim());
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function dashboardCommand() {
+  if (!isDaemonRunning2()) {
+    error("LENS daemon is not running. Start with: lens daemon start");
+    return;
+  }
+  const port = process.env.LENS_PORT || "4111";
+  const host = process.env.LENS_HOST || `http://127.0.0.1:${port}`;
+  const url = `${host}/dashboard`;
+  output(`Opening ${url}`, false);
+  openBrowser(url);
 }
 
 // packages/cli/src/util/progress.ts
@@ -3618,7 +3867,7 @@ async function showProgress(repoId, name, timeoutMs = 18e5) {
         if (connFailures >= MAX_CONN_FAILURES) {
           process.stdout.write(
             `
-  ${red("\u2717")} ${bold("Daemon unavailable")} \u2014 ${dim("connection lost after " + connFailures + " retries")}
+  ${red("\u2717")} ${bold("Daemon unavailable")} \u2014 ${dim(`connection lost after ${connFailures} retries`)}
 `
           );
           process.stdout.write(`  ${dim("Restart with: lens start")}
@@ -3693,7 +3942,9 @@ async function showProgress(repoId, name, timeoutMs = 18e5) {
         if (embDone) {
           lines.push(`  ${green("\u2713")} Embeddings      ${dim(`${s.embedded_count}/${s.embeddable_count} code chunks`)}`);
         } else if (s.embedding_quota_exceeded) {
-          lines.push(`  ${yellow("\u26A0")} Embeddings      ${dim(`quota exceeded \u2014 ${s.embedded_count}/${s.embeddable_count}`)}`);
+          lines.push(
+            `  ${yellow("\u26A0")} Embeddings      ${dim(`quota exceeded \u2014 ${s.embedded_count}/${s.embeddable_count}`)}`
+          );
         } else if (s.embeddable_count === 0) {
           lines.push(`  ${dim("\u25CB")} Embeddings      ${dim("no code chunks")}`);
         } else {
@@ -3705,7 +3956,9 @@ async function showProgress(repoId, name, timeoutMs = 18e5) {
         if (sumDone) {
           lines.push(`  ${green("\u2713")} Summaries       ${dim(`${s.purpose_count}/${s.purpose_total} files`)}`);
         } else if (s.purpose_quota_exceeded) {
-          lines.push(`  ${yellow("\u26A0")} Summaries       ${dim(`quota exceeded \u2014 ${s.purpose_count}/${s.purpose_total}`)}`);
+          lines.push(
+            `  ${yellow("\u26A0")} Summaries       ${dim(`quota exceeded \u2014 ${s.purpose_count}/${s.purpose_total}`)}`
+          );
         } else if (s.purpose_total > 0) {
           lines.push(
             `  ${cyan(f)} Summaries       ${createBar(Math.round(s.purpose_count / s.purpose_total * 100), 20)} ${dim(`${s.purpose_count}/${s.purpose_total}`)}`
@@ -3754,7 +4007,8 @@ async function showProgress(repoId, name, timeoutMs = 18e5) {
     if (lastRendered) {
       process.stdout.write(`\x1B[${TOTAL_LINES}A\x1B[J`);
     }
-    process.stdout.write(output2 + "\n");
+    process.stdout.write(`${output2}
+`);
     lastRendered = output2;
     if (allDone) {
       done = true;
@@ -3774,65 +4028,6 @@ function sleep2(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
-// packages/cli/src/commands/register.ts
-async function registerCommand(opts) {
-  const info = await detectRepo();
-  const res = await post("/repo/register", {
-    root_path: info.root_path,
-    name: info.name,
-    remote_url: info.remote_url
-  });
-  if (opts.json) {
-    output(res, true);
-    return;
-  }
-  const mcpResult = injectMcp(info.root_path);
-  if (res.created) {
-    await injectClaudeMd(info.root_path);
-    output(`Registered ${res.name} (repo_id: ${res.repo_id})`, false);
-    if (mcpResult === "created" || mcpResult === "updated") {
-      output(`Wrote .mcp.json \u2192 Claude Code will auto-discover LENS`, false);
-    }
-    const config = await readConfig();
-    if (config.show_progress) {
-      await showProgress(res.repo_id, res.name);
-    } else {
-      output(`Indexing started. Run \`lens status\` to check progress.`, false);
-    }
-  } else {
-    output(`Already registered ${res.name} (repo_id: ${res.repo_id})`, false);
-    if (mcpResult === "created" || mcpResult === "updated") {
-      output(`Wrote .mcp.json \u2192 Claude Code will auto-discover LENS`, false);
-    }
-    if (opts.inject) {
-      await injectClaudeMd(info.root_path);
-      output(`Injected LENS instructions into CLAUDE.md`, false);
-    }
-  }
-}
-
-// packages/cli/src/util/ensure-repo.ts
-async function ensureRepo() {
-  const info = await detectRepo();
-  const res = await post("/repo/register", {
-    root_path: info.root_path,
-    name: info.name,
-    remote_url: info.remote_url
-  });
-  return { repo_id: res.repo_id, name: res.name, root_path: info.root_path };
-}
-
-// packages/cli/src/commands/context.ts
-async function contextCommand(goal, opts) {
-  const { repo_id } = await ensureRepo();
-  const res = await post("/context", { repo_id, goal });
-  if (opts.json) {
-    output(res, true);
-  } else {
-    output(res.context_pack, false);
-  }
-}
-
 // packages/cli/src/commands/index.ts
 async function indexCommand(opts) {
   const { repo_id, name } = await ensureRepo();
@@ -3866,56 +4061,6 @@ async function indexCommand(opts) {
   await showProgress(repo_id, name);
 }
 
-// packages/cli/src/commands/status.ts
-var dim2 = (s) => `\x1B[2m${s}\x1B[0m`;
-var green2 = (s) => `\x1B[32m${s}\x1B[0m`;
-var yellow2 = (s) => `\x1B[33m${s}\x1B[0m`;
-var bold2 = (s) => `\x1B[1m${s}\x1B[0m`;
-async function statusCommand(opts) {
-  const { repo_id, name } = await ensureRepo();
-  const s = await get(`/repo/${repo_id}/status`);
-  if (opts.json) {
-    output(s, true);
-    return;
-  }
-  const staleTag = s.is_stale ? yellow2(" STALE") : "";
-  const check = green2("\u2713");
-  const pending = dim2("\u25CB");
-  const hasCaps = s.has_capabilities !== false;
-  const lines = [
-    ``,
-    `  ${bold2(name)}${staleTag}`,
-    dim2(`  ${"\u2500".repeat(40)}`),
-    `  ${s.chunk_count > 0 ? check : pending} Chunks        ${dim2(s.chunk_count.toLocaleString())}`,
-    `  ${s.metadata_count > 0 ? check : pending} Metadata      ${dim2(`${s.metadata_count.toLocaleString()} files`)}`,
-    `  ${s.git_commits_analyzed > 0 ? check : pending} Git history   ${dim2(`${s.git_commits_analyzed.toLocaleString()} files`)}`,
-    `  ${s.import_edge_count > 0 ? check : pending} Import graph  ${dim2(`${s.import_edge_count.toLocaleString()} edges`)}`,
-    `  ${s.cochange_pairs > 0 ? check : pending} Co-changes    ${dim2(`${s.cochange_pairs.toLocaleString()} pairs`)}`
-  ];
-  if (hasCaps) {
-    const warn = yellow2("\u26A0");
-    const embDone = s.embedded_pct >= 100 || s.embedded_count >= s.embeddable_count && s.embeddable_count > 0;
-    const embLabel = s.embedding_quota_exceeded ? `quota exceeded \u2014 ${s.embedded_count}/${s.embeddable_count}` : s.embeddable_count > 0 ? `${s.embedded_count}/${s.embeddable_count} code chunks (${s.embedded_pct}%)` : "no code chunks";
-    const embIcon = s.embedding_quota_exceeded ? warn : embDone ? check : pending;
-    const vocabLabel = s.vocab_cluster_count > 0 ? `${s.vocab_cluster_count} clusters` : "...";
-    const vocabIcon = s.vocab_cluster_count > 0 ? check : pending;
-    const purDone = s.purpose_count > 0 && s.purpose_count >= s.purpose_total;
-    const purposeLabel = s.purpose_quota_exceeded ? `quota exceeded \u2014 ${s.purpose_count}/${s.purpose_total}` : s.purpose_total > 0 ? `${s.purpose_count}/${s.purpose_total} files` : "no files";
-    const purposeIcon = s.purpose_quota_exceeded ? warn : purDone ? check : pending;
-    lines.push(`  ${vocabIcon} Vocab clust.  ${dim2(vocabLabel)}`);
-    lines.push(`  ${embIcon} Embeddings    ${dim2(embLabel)}`);
-    lines.push(`  ${purposeIcon} Summaries     ${dim2(purposeLabel)}`);
-  } else {
-    lines.push(``);
-    lines.push(`  ${yellow2("\u26A1")} ${bold2("Pro")}`);
-    lines.push(`    ${dim2("\xB7 Vocab clusters")}`);
-    lines.push(`    ${dim2("\xB7 Embeddings")}`);
-    lines.push(`    ${dim2("\xB7 Summaries")}`);
-    lines.push(`    ${dim2("lens login \u2192 upgrade to enable")}`);
-  }
-  output(lines.join("\n"), false);
-}
-
 // packages/cli/src/commands/list.ts
 async function listCommand(opts) {
   const res = await get("/repo/list/detailed");
@@ -3932,280 +4077,43 @@ async function listCommand(opts) {
   const lines = [header, sep];
   for (const r of res.repos) {
     const id = r.id.slice(0, 8);
-    const indexed = r.last_indexed_at ? timeAgo(r.last_indexed_at) : "never";
-    lines.push(
-      pad(id, 10) + pad(r.name, 20) + pad(r.index_status, 10) + pad(String(r.files_indexed), 8) + pad(r.chunk_count.toLocaleString(), 10) + pad(`${r.embedded_pct}%`, 8) + indexed
-    );
-  }
-  output(lines.join("\n"), false);
-}
-function pad(s, width) {
-  return s.length >= width ? s.slice(0, width - 1) + " " : s + " ".repeat(width - s.length);
-}
-function timeAgo(iso) {
-  const diff = Date.now() - new Date(iso).getTime();
-  const mins = Math.floor(diff / 6e4);
-  if (mins < 1) return "just now";
-  if (mins < 60) return `${mins}m ago`;
-  const hours = Math.floor(mins / 60);
-  if (hours < 24) return `${hours}h ago`;
-  const days = Math.floor(hours / 24);
-  return `${days}d ago`;
-}
-
-// packages/cli/src/commands/remove.ts
-async function removeCommand(opts) {
-  const { repo_id, name } = await ensureRepo();
-  if (!opts.yes) {
-    process.stderr.write(`Remove "${name}" (${repo_id})? All index data will be deleted.
-`);
-    process.stderr.write(`Re-run with --yes to confirm.
-`);
-    process.exit(1);
-  }
-  const spinner = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-  let i = 0;
-  let phase = "Stopping watcher";
-  const interval = setInterval(() => {
-    const frame = spinner[i % spinner.length];
-    process.stdout.write(`\r${frame} ${phase}...`);
-    i++;
-  }, 80);
-  await new Promise((r) => setTimeout(r, 200));
-  phase = `Removing ${name}`;
-  const res = await request("DELETE", `/repo/${repo_id}`);
-  clearInterval(interval);
-  if (opts.json) {
-    output(res, true);
-  } else {
-    process.stdout.write(`\r\u2713 Removed ${name}: ${res.chunks_removed} chunks deleted
-`);
-  }
-}
-
-// packages/cli/src/commands/daemon-stats.ts
-async function daemonStatsCommand(opts) {
-  const s = await get("/daemon/stats");
-  if (opts.json) {
-    output(s, true);
-    return;
-  }
-  const embedPct = s.total_chunks > 0 ? Math.round(s.total_embeddings / s.total_chunks * 100) : 0;
-  const maintResult = s.last_maintenance_result ? `${s.last_maintenance_result.processed} processed, ${s.last_maintenance_result.errors} errors` : "\u2014";
-  const lines = [
-    "## LENS Daemon",
-    "",
-    `  Repos:      ${s.repos_count}`,
-    `  Chunks:     ${s.total_chunks.toLocaleString()}`,
-    `  Embeddings: ${s.total_embeddings.toLocaleString()} (${embedPct}%)`,
-    `  DB Size:    ${s.db_size_mb} MB`,
-    "",
-    "  ## Maintenance Cron",
-    `  Last maintenance: ${s.last_maintenance_at ?? "never"}`,
-    `  Next maintenance: ${s.next_maintenance_at ?? "\u2014"}`,
-    `  Last result:      ${maintResult}`
-  ];
-  output(lines.join("\n"), false);
-}
-
-// packages/cli/src/commands/watch.ts
-async function watchCommand(opts) {
-  const { repo_id, name } = await ensureRepo();
-  const res = await post("/index/watch", { repo_id });
-  if (opts.json) {
-    output(res, true);
-  } else if (res.already_watching) {
-    output(`${name} is already being watched`, false);
-  } else {
-    output(`File watcher started for ${name}`, false);
-  }
-}
-async function unwatchCommand(opts) {
-  const { repo_id, name } = await ensureRepo();
-  const res = await post("/index/unwatch", { repo_id });
-  if (opts.json) {
-    output(res, true);
-  } else if (res.stopped) {
-    output(`File watcher stopped for ${name}`, false);
-  } else {
-    output(`${name} was not being watched`, false);
-  }
-}
-async function watchStatusCommand(opts) {
-  const { repo_id, name } = await ensureRepo();
-  const res = await get(`/index/watch-status/${repo_id}`);
-  if (opts.json) {
-    output(res, true);
-  } else if (res.watching) {
-    output(
-      `${name}: watching since ${res.started_at}
-  Changed: ${res.changed_files} files | Deleted: ${res.deleted_files} files`,
-      false
-    );
-  } else {
-    output(`${name}: not watching. Run \`lens repo watch\` to start.`, false);
-  }
-}
-
-// packages/cli/src/commands/mcp.ts
-async function mcpCommand() {
-  const { root_path } = await detectRepo();
-  const result = injectMcp(root_path);
-  if (result === "exists") {
-    output("LENS MCP entry already present in .mcp.json", false);
-  } else {
-    output("Wrote .mcp.json \u2014 agents will auto-discover LENS", false);
-  }
-}
-
-// packages/cli/src/commands/config.ts
-async function configGetCommand(key) {
-  try {
-    const value = await configGet(key);
-    output(value, false);
-  } catch (err) {
-    output(err instanceof Error ? err.message : String(err), false);
-  }
-}
-async function configSetCommand(key, value) {
-  try {
-    await configSet(key, value);
-    output(`Config updated: ${key} = ${value}`, false);
-  } catch (err) {
-    output(err instanceof Error ? err.message : String(err), false);
-    process.exit(1);
-  }
-}
-
-// packages/cli/src/commands/daemon-ctrl.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, unlinkSync, openSync, mkdirSync } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
-import { homedir } from "os";
-import { spawn } from "child_process";
-import { fileURLToPath } from "url";
-import { createRequire } from "module";
-var LENS_DIR = join2(homedir(), ".lens");
-var PID_FILE = join2(LENS_DIR, "daemon.pid");
-var LOG_FILE = join2(LENS_DIR, "daemon.log");
-function isDaemonRunning() {
-  if (!existsSync3(PID_FILE)) return { running: false };
-  const pid = Number(readFileSync2(PID_FILE, "utf-8").trim());
-  try {
-    process.kill(pid, 0);
-    return { running: true, pid };
-  } catch {
-    unlinkSync(PID_FILE);
-    return { running: false };
-  }
-}
-async function startCommand() {
-  const status = isDaemonRunning();
-  if (status.running) {
-    output(`LENS daemon already running (pid: ${status.pid})`, false);
-    return;
-  }
-  const selfDir = dirname2(fileURLToPath(import.meta.url));
-  const sibling = join2(selfDir, "daemon.js");
-  let daemonScript;
-  if (existsSync3(sibling)) {
-    daemonScript = sibling;
-  } else {
-    try {
-      const require2 = createRequire(import.meta.url);
-      daemonScript = require2.resolve("@lens/daemon");
-    } catch {
-      error("Could not find @lens/daemon. Run `pnpm build` first.");
-      return;
-    }
-  }
-  mkdirSync(LENS_DIR, { recursive: true });
-  const logFd = openSync(LOG_FILE, "a");
-  const child = spawn(process.execPath, [daemonScript], {
-    detached: true,
-    stdio: ["ignore", logFd, logFd],
-    env: { ...process.env, LENS_DAEMON: "1" }
-  });
-  child.unref();
-  for (let i = 0; i < 20; i++) {
-    await new Promise((r) => setTimeout(r, 250));
-    if (isDaemonRunning().running) break;
-  }
-  const check = isDaemonRunning();
-  if (check.running) {
-    output(`LENS daemon started (pid: ${check.pid})`, false);
-  } else {
-    error(`LENS daemon failed to start. Check logs: ${LOG_FILE}`);
-  }
-}
-async function stopCommand() {
-  const status = isDaemonRunning();
-  if (!status.running) {
-    output("LENS daemon is not running", false);
-    return;
-  }
-  process.kill(status.pid, "SIGTERM");
-  for (let i = 0; i < 20; i++) {
-    await new Promise((r) => setTimeout(r, 250));
-    if (!isDaemonRunning().running) {
-      output(`LENS daemon stopped (pid: ${status.pid})`, false);
-      return;
-    }
-  }
-  error("Daemon did not stop within 5s. Force kill with: kill -9 " + status.pid);
-}
-
-// packages/cli/src/commands/dashboard.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir2 } from "os";
-
-// packages/cli/src/util/browser.ts
-import { exec } from "child_process";
-function openBrowser(url) {
-  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-  exec(`${cmd} ${url}`);
-}
-
-// packages/cli/src/commands/dashboard.ts
-var PID_FILE2 = join3(homedir2(), ".lens", "daemon.pid");
-function isDaemonRunning2() {
-  if (!existsSync4(PID_FILE2)) return false;
-  const pid = Number(readFileSync3(PID_FILE2, "utf-8").trim());
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
+    const indexed = r.last_indexed_at ? timeAgo(r.last_indexed_at) : "never";
+    lines.push(
+      pad(id, 10) + pad(r.name, 20) + pad(r.index_status, 10) + pad(String(r.files_indexed), 8) + pad(r.chunk_count.toLocaleString(), 10) + pad(`${r.embedded_pct}%`, 8) + indexed
+    );
   }
+  output(lines.join("\n"), false);
 }
-async function dashboardCommand() {
-  if (!isDaemonRunning2()) {
-    error("LENS daemon is not running. Start with: lens daemon start");
-    return;
-  }
-  const port = process.env.LENS_PORT || "4111";
-  const host = process.env.LENS_HOST || `http://127.0.0.1:${port}`;
-  const url = `${host}/dashboard`;
-  output(`Opening ${url}`, false);
-  openBrowser(url);
+function pad(s, width) {
+  return s.length >= width ? `${s.slice(0, width - 1)} ` : s + " ".repeat(width - s.length);
+}
+function timeAgo(iso) {
+  const diff = Date.now() - new Date(iso).getTime();
+  const mins = Math.floor(diff / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
 }
 
 // packages/cli/src/commands/login.ts
 import http from "http";
 
 // packages/cli/src/util/auth.ts
-import fs3 from "fs/promises";
-import path3 from "path";
+import fs2 from "fs/promises";
 import os2 from "os";
-var CONFIG_DIR2 = path3.join(os2.homedir(), ".lens");
-var AUTH_FILE = path3.join(CONFIG_DIR2, "auth.json");
+import path2 from "path";
+var CONFIG_DIR2 = path2.join(os2.homedir(), ".lens");
+var AUTH_FILE = path2.join(CONFIG_DIR2, "auth.json");
 async function writeAuth(tokens) {
-  await fs3.mkdir(CONFIG_DIR2, { recursive: true });
-  await fs3.writeFile(AUTH_FILE, JSON.stringify(tokens, null, 2), { mode: 384 });
+  await fs2.mkdir(CONFIG_DIR2, { recursive: true });
+  await fs2.writeFile(AUTH_FILE, JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 async function clearAuth() {
   try {
-    await fs3.unlink(AUTH_FILE);
+    await fs2.unlink(AUTH_FILE);
   } catch {
   }
 }
@@ -4560,12 +4468,19 @@ async function loginCommand(opts) {
       }
       if (req.method === "POST" && url.pathname === "/token") {
         let body = "";
-        req.on("data", (c) => body += c);
+        req.on("data", (c) => {
+          body += c;
+        });
         req.on("end", async () => {
           try {
             const { access_token, refresh_token, expires_in, user_email } = JSON.parse(body);
             const expires_at = Math.floor(Date.now() / 1e3) + Number(expires_in || 3600);
-            const tokens = { access_token, refresh_token, user_email, expires_at };
+            const tokens = {
+              access_token,
+              refresh_token,
+              user_email,
+              expires_at
+            };
             try {
               const keyRes = await fetch(`${CLOUD_API_URL}/auth/key`, {
                 headers: { Authorization: `Bearer ${access_token}` }
@@ -4591,7 +4506,7 @@ async function loginCommand(opts) {
             cleanup();
             resolve2();
             setTimeout(() => process.exit(0), 100);
-          } catch (err) {
+          } catch (_err) {
             res.writeHead(400);
             res.end("Bad request");
           }
@@ -4638,8 +4553,245 @@ async function logoutCommand() {
   output("Logged out of LENS cloud.", false);
 }
 
+// packages/cli/src/util/inject-mcp.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+var MCP_ENTRY = {
+  command: "npx",
+  args: ["lens-daemon", "--stdio"]
+};
+function injectMcp(repoRoot) {
+  const mcpPath = join3(repoRoot, ".mcp.json");
+  let existing = {};
+  if (existsSync4(mcpPath)) {
+    try {
+      existing = JSON.parse(readFileSync3(mcpPath, "utf-8"));
+    } catch {
+    }
+  }
+  if (!existing.mcpServers) existing.mcpServers = {};
+  const servers = existing.mcpServers;
+  if (servers.lens) return "exists";
+  const isNew = !existsSync4(mcpPath);
+  servers.lens = MCP_ENTRY;
+  writeFileSync2(mcpPath, `${JSON.stringify(existing, null, 2)}
+`);
+  return isNew ? "created" : "updated";
+}
+
+// packages/cli/src/commands/mcp.ts
+async function mcpCommand() {
+  const { root_path } = await detectRepo();
+  const result = injectMcp(root_path);
+  if (result === "exists") {
+    output("LENS MCP entry already present in .mcp.json", false);
+  } else {
+    output("Wrote .mcp.json \u2014 agents will auto-discover LENS", false);
+  }
+}
+
+// packages/cli/src/util/inject-claude-md.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+var RLM_MARKER = "lens context";
+var CANDIDATE_PATHS = ["CLAUDE.md", "agents.md", "AGENTS.md", ".CLAUDE.md", ".agents.md", ".AGENTS.md"];
+async function findTargetFile(repoRoot) {
+  for (const relPath of CANDIDATE_PATHS) {
+    const fullPath = path3.join(repoRoot, relPath);
+    try {
+      await fs3.access(fullPath);
+      return fullPath;
+    } catch {
+    }
+  }
+  return null;
+}
+async function injectClaudeMd(repoRoot) {
+  const existingFile = await findTargetFile(repoRoot);
+  const targetFile = existingFile ?? path3.join(repoRoot, "CLAUDE.md");
+  let existingContent = "";
+  try {
+    existingContent = await fs3.readFile(targetFile, "utf-8");
+    if (existingContent.toLowerCase().includes(RLM_MARKER)) {
+      return;
+    }
+  } catch {
+  }
+  const config = await readConfig();
+  if (existingFile && config.inject_behavior === "once") {
+    return;
+  }
+  if (config.inject_behavior === "skip") {
+    return;
+  }
+  const { content } = await get("/repo/template");
+  if (existingContent) {
+    await fs3.writeFile(targetFile, `${content}
+
+${existingContent}`);
+  } else {
+    await fs3.writeFile(targetFile, content);
+  }
+}
+
+// packages/cli/src/commands/register.ts
+async function registerCommand(opts) {
+  const info = await detectRepo();
+  const res = await post("/repo/register", {
+    root_path: info.root_path,
+    name: info.name,
+    remote_url: info.remote_url
+  });
+  if (opts.json) {
+    output(res, true);
+    return;
+  }
+  const mcpResult = injectMcp(info.root_path);
+  if (res.created) {
+    await injectClaudeMd(info.root_path);
+    output(`Registered ${res.name} (repo_id: ${res.repo_id})`, false);
+    if (mcpResult === "created" || mcpResult === "updated") {
+      output(`Wrote .mcp.json \u2192 Claude Code will auto-discover LENS`, false);
+    }
+    const config = await readConfig();
+    if (config.show_progress) {
+      await showProgress(res.repo_id, res.name);
+    } else {
+      output(`Indexing started. Run \`lens status\` to check progress.`, false);
+    }
+  } else {
+    output(`Already registered ${res.name} (repo_id: ${res.repo_id})`, false);
+    if (mcpResult === "created" || mcpResult === "updated") {
+      output(`Wrote .mcp.json \u2192 Claude Code will auto-discover LENS`, false);
+    }
+    if (opts.inject) {
+      await injectClaudeMd(info.root_path);
+      output(`Injected LENS instructions into CLAUDE.md`, false);
+    }
+  }
+}
+
+// packages/cli/src/commands/remove.ts
+async function removeCommand(opts) {
+  const { repo_id, name } = await ensureRepo();
+  if (!opts.yes) {
+    process.stderr.write(`Remove "${name}" (${repo_id})? All index data will be deleted.
+`);
+    process.stderr.write(`Re-run with --yes to confirm.
+`);
+    process.exit(1);
+  }
+  const spinner = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let i = 0;
+  let phase = "Stopping watcher";
+  const interval = setInterval(() => {
+    const frame = spinner[i % spinner.length];
+    process.stdout.write(`\r${frame} ${phase}...`);
+    i++;
+  }, 80);
+  await new Promise((r) => setTimeout(r, 200));
+  phase = `Removing ${name}`;
+  const res = await request("DELETE", `/repo/${repo_id}`);
+  clearInterval(interval);
+  if (opts.json) {
+    output(res, true);
+  } else {
+    process.stdout.write(`\r\u2713 Removed ${name}: ${res.chunks_removed} chunks deleted
+`);
+  }
+}
+
+// packages/cli/src/commands/status.ts
+var dim2 = (s) => `\x1B[2m${s}\x1B[0m`;
+var green2 = (s) => `\x1B[32m${s}\x1B[0m`;
+var yellow2 = (s) => `\x1B[33m${s}\x1B[0m`;
+var bold2 = (s) => `\x1B[1m${s}\x1B[0m`;
+async function statusCommand(opts) {
+  const { repo_id, name } = await ensureRepo();
+  const s = await get(`/repo/${repo_id}/status`);
+  if (opts.json) {
+    output(s, true);
+    return;
+  }
+  const staleTag = s.is_stale ? yellow2(" STALE") : "";
+  const check = green2("\u2713");
+  const pending = dim2("\u25CB");
+  const hasCaps = s.has_capabilities !== false;
+  const lines = [
+    ``,
+    `  ${bold2(name)}${staleTag}`,
+    dim2(`  ${"\u2500".repeat(40)}`),
+    `  ${s.chunk_count > 0 ? check : pending} Chunks        ${dim2(s.chunk_count.toLocaleString())}`,
+    `  ${s.metadata_count > 0 ? check : pending} Metadata      ${dim2(`${s.metadata_count.toLocaleString()} files`)}`,
+    `  ${s.git_commits_analyzed > 0 ? check : pending} Git history   ${dim2(`${s.git_commits_analyzed.toLocaleString()} files`)}`,
+    `  ${s.import_edge_count > 0 ? check : pending} Import graph  ${dim2(`${s.import_edge_count.toLocaleString()} edges`)}`,
+    `  ${s.cochange_pairs > 0 ? check : pending} Co-changes    ${dim2(`${s.cochange_pairs.toLocaleString()} pairs`)}`
+  ];
+  if (hasCaps) {
+    const warn = yellow2("\u26A0");
+    const embDone = s.embedded_pct >= 100 || s.embedded_count >= s.embeddable_count && s.embeddable_count > 0;
+    const embLabel = s.embedding_quota_exceeded ? `quota exceeded \u2014 ${s.embedded_count}/${s.embeddable_count}` : s.embeddable_count > 0 ? `${s.embedded_count}/${s.embeddable_count} code chunks (${s.embedded_pct}%)` : "no code chunks";
+    const embIcon = s.embedding_quota_exceeded ? warn : embDone ? check : pending;
+    const vocabLabel = s.vocab_cluster_count > 0 ? `${s.vocab_cluster_count} clusters` : "...";
+    const vocabIcon = s.vocab_cluster_count > 0 ? check : pending;
+    const purDone = s.purpose_count > 0 && s.purpose_count >= s.purpose_total;
+    const purposeLabel = s.purpose_quota_exceeded ? `quota exceeded \u2014 ${s.purpose_count}/${s.purpose_total}` : s.purpose_total > 0 ? `${s.purpose_count}/${s.purpose_total} files` : "no files";
+    const purposeIcon = s.purpose_quota_exceeded ? warn : purDone ? check : pending;
+    lines.push(`  ${vocabIcon} Vocab clust.  ${dim2(vocabLabel)}`);
+    lines.push(`  ${embIcon} Embeddings    ${dim2(embLabel)}`);
+    lines.push(`  ${purposeIcon} Summaries     ${dim2(purposeLabel)}`);
+  } else {
+    lines.push(``);
+    lines.push(`  ${yellow2("\u26A1")} ${bold2("Pro")}`);
+    lines.push(`    ${dim2("\xB7 Vocab clusters")}`);
+    lines.push(`    ${dim2("\xB7 Embeddings")}`);
+    lines.push(`    ${dim2("\xB7 Summaries")}`);
+    lines.push(`    ${dim2("lens login \u2192 upgrade to enable")}`);
+  }
+  output(lines.join("\n"), false);
+}
+
+// packages/cli/src/commands/watch.ts
+async function watchCommand(opts) {
+  const { repo_id, name } = await ensureRepo();
+  const res = await post("/index/watch", { repo_id });
+  if (opts.json) {
+    output(res, true);
+  } else if (res.already_watching) {
+    output(`${name} is already being watched`, false);
+  } else {
+    output(`File watcher started for ${name}`, false);
+  }
+}
+async function unwatchCommand(opts) {
+  const { repo_id, name } = await ensureRepo();
+  const res = await post("/index/unwatch", { repo_id });
+  if (opts.json) {
+    output(res, true);
+  } else if (res.stopped) {
+    output(`File watcher stopped for ${name}`, false);
+  } else {
+    output(`${name} was not being watched`, false);
+  }
+}
+async function watchStatusCommand(opts) {
+  const { repo_id, name } = await ensureRepo();
+  const res = await get(`/index/watch-status/${repo_id}`);
+  if (opts.json) {
+    output(res, true);
+  } else if (res.watching) {
+    output(
+      `${name}: watching since ${res.started_at}
+  Changed: ${res.changed_files} files | Deleted: ${res.deleted_files} files`,
+      false
+    );
+  } else {
+    output(`${name}: not watching. Run \`lens repo watch\` to start.`, false);
+  }
+}
+
 // packages/cli/src/index.ts
-var program2 = new Command().name("lens").description("LENS \u2014 Local-first repo context engine").version("0.1.18");
+var program2 = new Command().name("lens").description("LENS \u2014 Local-first repo context engine").version("0.1.20");
 function trackCommand(name) {
   if (!isTelemetryEnabled()) return;
   const BASE_URL2 = process.env.LENS_HOST ?? "http://127.0.0.1:4111";