@orquentra/codebuddy 2.7.0 → 2.9.0

package/dist/{main-AHNGHC4L.js → main-YJKSYFPT.js}

@@ -1,6 +1,48 @@
+import {
+  renderLeanBlock,
+  runLeanHookCommand
+} from "./chunk-UK6XTS2Y.js";
 import {
   runPreToolHookCommand
-} from "./chunk-AQHPEJR6.js";
+} from "./chunk-ENKDFLOO.js";
+import {
+  failSoft,
+  readHookInput,
+  writeStdout
+} from "./chunk-FJOTP632.js";
+import {
+  WORKFLOW_CLIENTS,
+  clientDisplayName,
+  clientHooksInstalled,
+  defaultRulesMode,
+  detectClient,
+  hermesConfigPath,
+  hermesPluginInstalled,
+  installClaudeEntry,
+  installClient,
+  installCodexEntry,
+  installWorkflowRules,
+  listClaudeEntries,
+  listCodexEntries,
+  readHermesConfig,
+  removeClaudeEntry,
+  removeCodexEntry,
+  renderManagedBlock,
+  renderWorkflowTemplate,
+  setHooks,
+  uninstallClient,
+  writeProjectMcpConfig
+} from "./chunk-J4T6HHI4.js";
+import {
+  AUTOMATION_MODES,
+  CLIENT_ADAPTERS,
+  CLIENT_IDS,
+  LIFECYCLE_EVENTS,
+  MODE_LABELS,
+  parseClient,
+  parseMode,
+  supportedModes
+} from "./chunk-W7GAXL6C.js";
 import {
   isDockerDaemonRunning,
   tryStartDockerDesktop,
@@ -12,26 +54,26 @@ import {
   postgresUp
 } from "./chunk-CSRD5OQA.js";
 import {
-  renderLeanBlock,
-  runLeanHookCommand
-} from "./chunk-LCSBL5TT.js";
-import {
-  failSoft,
-  readHookInput,
-  writeStdout
-} from "./chunk-FJOTP632.js";
-import {
+  TELEMETRY_NOTICE,
+  flushTelemetry,
   generateSuggestions,
   migrateMemoryToFiles,
+  readTelemetryState,
   registerCodeBuddyTools,
+  showTelemetryNoticeOnce,
   startMcpServer,
-  watchRepository
-} from "./chunk-EEUFU7KV.js";
+  telemetryBlocked,
+  telemetryStatePath,
+  telemetryUrl,
+  traceCliCommand,
+  watchRepository,
+  writeTelemetryState
+} from "./chunk-2WH2Q4TA.js";
 import {
   DEFAULT_ZVEC_MODEL,
   buildZvecIndex,
   zvecStatus
-} from "./chunk-MSUAVR3R.js";
+} from "./chunk-GXOML4UZ.js";
 import {
   PlanFileStore,
   PlanLifecycle,
@@ -49,21 +91,21 @@ import {
   runResetHook,
   runStageHook,
   runSyncHook
-} from "./chunk-YJIA2MFL.js";
-import {
-  parseTraceLines,
-  readTraces,
-  tracePath
-} from "./chunk-TUR6YKEE.js";
-import "./chunk-DFV2SK6C.js";
+} from "./chunk-F4BJ3DXW.js";
 import {
   SessionCapsuleLedger,
   detectTestCommand,
   estimateTokens
 } from "./chunk-GKNYMNFM.js";
+import {
+  parseTraceLines,
+  readTraces,
+  tracePath
+} from "./chunk-YN7TEIUH.js";
 import {
   hookRoot
 } from "./chunk-TGFTKWOR.js";
+import "./chunk-DFV2SK6C.js";
 import {
   bootstrapDatabase,
   buildProviderFromConfig,
@@ -75,11 +117,11 @@ import {
   pingDatabase,
   runDoctor,
   runMigrations
-} from "./chunk-AK2UAE32.js";
+} from "./chunk-QN76UJP7.js";
 import {
   MemoryFileStore,
   VERSION
-} from "./chunk-JUAFCLRB.js";
+} from "./chunk-SRA4MDVG.js";
 import {
   computeFactHash,
   generateEntityId
@@ -92,23 +134,25 @@ import {
 import {
   loadLlmSummaries,
   summarizeRepository
-} from "./chunk-BQM7FJ7D.js";
+} from "./chunk-6NZEZJYD.js";
 import {
   chatJson,
   coolingDown,
   usageToday
 } from "./chunk-ESZXCZIN.js";
 import {
-  buildArchitectureMap,
   generateGraphifyGraph,
-  indexRepository,
-  loadFreshIndex,
   loadGraphifyMap,
-  neighbours,
-  queryMap,
   setupGraphify,
   syncFileVectors
-} from "./chunk-5EDGAZQN.js";
+} from "./chunk-TLWGZVPC.js";
+import {
+  buildArchitectureMap,
+  indexRepository,
+  loadFreshIndex,
+  neighbours,
+  queryMap
+} from "./chunk-ITQO632W.js";
 import {
   extractSymbolTable,
   supportsSymbols
@@ -143,14 +187,12 @@ import {
   setZvecEnabled,
   writeConfigFile
 } from "./chunk-KNR2P2UY.js";
-import {
-  writeAtomic
-} from "./chunk-CG5B3LYG.js";
+import "./chunk-CG5B3LYG.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/cli/main.ts
 import { Command } from "commander";
-import pc22 from "picocolors";
+import pc23 from "picocolors";
 
 // src/integrations/github.ts
 import { constants } from "fs";
@@ -337,7 +379,7 @@ function runTestCommand(command, source, repositoryRoot, timeoutMs) {
   if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
     throw new Error("--timeout must be a positive number of milliseconds.");
   }
-  return new Promise((resolve13) => {
+  return new Promise((resolve6) => {
     const startedAt = Date.now();
     const child = spawn(command, {
       cwd: repositoryRoot,
@@ -362,7 +404,7 @@ ${output.slice(-MAX_TEST_OUTPUT_CHARS)}`;
     }, timeoutMs);
     child.on("close", (exitCode, signal) => {
       clearTimeout(timer);
-      resolve13({
+      resolve6({
         status: timedOut ? "timed_out" : exitCode === 0 ? "passed" : "failed",
         command,
         source,
@@ -374,7 +416,7 @@ ${output.slice(-MAX_TEST_OUTPUT_CHARS)}`;
     });
     child.on("error", (error) => {
       clearTimeout(timer);
-      resolve13({
+      resolve6({
         status: "failed",
         command,
         source,
@@ -585,1016 +627,17 @@ function testBadge(status) {
   return pc.yellow("[not run]");
 }
 
-// src/cli/commands/claude-desktop.ts
-import { existsSync } from "fs";
-import { mkdir as mkdir2, readFile } from "fs/promises";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
-import { fileURLToPath } from "url";
-function claudeDesktopConfigPath(home = process.env.HOME ?? "") {
-  if (process.platform === "darwin") {
-    return join2(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
-  }
-  if (process.platform === "win32") {
-    return join2(process.env.APPDATA ?? home, "Claude", "claude_desktop_config.json");
-  }
-  return join2(home, ".config", "Claude", "claude_desktop_config.json");
-}
-async function readClaudeConfig(path) {
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(await readFile(path, "utf8"));
-  } catch (error) {
-    throw new Error(
-      `Failed to parse Claude Desktop config at ${path}: ${error.message}`
-    );
-  }
-}
-async function writeClaudeConfig(path, config) {
-  await mkdir2(dirname2(path), { recursive: true });
-  await writeAtomic(path, `${JSON.stringify(config, null, 2)}
-`, { mode: 384 });
-}
-function resolveCliEntrypoint() {
-  const fromArgv = process.argv[1];
-  if (fromArgv && existsSync(fromArgv)) return fromArgv;
-  const here = dirname2(fileURLToPath(import.meta.url));
-  const candidates = [
-    resolve2(here, "index.js"),
-    // bundled: here = dist/cli/
-    resolve2(here, "..", "cli", "index.js"),
-    // source: here = src/cli/commands/
-    resolve2(here, "..", "index.js")
-  ];
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) return candidate;
-  }
-  return fromArgv ?? candidates[0] ?? "";
-}
-function buildEntry(options) {
-  const env = {
-    CODEBUDDY_NAMESPACE: options.namespace,
-    CODEBUDDY_PROJECT_ROOT: resolve2(options.projectRoot ?? process.cwd())
-  };
-  if (options.hfToken) env.HF_TOKEN = options.hfToken;
-  if (options.groqApiKey) env.GROQ_API_KEY = options.groqApiKey;
-  if (options.databaseUrl) env.DATABASE_URL = options.databaseUrl;
-  return {
-    // Absolute: Claude Desktop is a GUI app and does not inherit the shell's
-    // PATH (nvm, Homebrew), so a bare "node" may not resolve or may be another
-    // version. Re-run `codebuddy claude install` after switching Node.
-    command: process.execPath,
-    args: [resolveCliEntrypoint(), "serve"],
-    env
-  };
-}
-async function installClaudeEntry(options) {
-  const path = claudeDesktopConfigPath();
-  const config = await readClaudeConfig(path);
-  config.mcpServers ??= {};
-  const serverKey = options.serverName ?? `codebuddy-${options.namespace}`;
-  const existed = config.mcpServers[serverKey] !== void 0;
-  config.mcpServers[serverKey] = buildEntry(options);
-  await writeClaudeConfig(path, config);
-  return { path, serverKey, created: !existed };
-}
-async function removeClaudeEntry(serverKey) {
-  const path = claudeDesktopConfigPath();
-  const config = await readClaudeConfig(path);
-  if (!config.mcpServers || !(serverKey in config.mcpServers)) {
-    return { removed: false, path };
-  }
-  delete config.mcpServers[serverKey];
-  await writeClaudeConfig(path, config);
-  return { removed: true, path };
-}
-async function listClaudeEntries() {
-  const path = claudeDesktopConfigPath();
-  const config = await readClaudeConfig(path);
-  const entries = Object.entries(config.mcpServers ?? {}).filter(([key]) => key === "codebuddy" || key.startsWith("codebuddy-")).map(([key, entry]) => ({
-    key,
-    namespace: entry.env?.CODEBUDDY_NAMESPACE ?? null,
-    databaseUrl: entry.env?.DATABASE_URL ?? null
-  }));
-  return { path, entries };
-}
-
 // src/cli/commands/clients.ts
 import { relative } from "path";
 import pc2 from "picocolors";
 
-// src/clients/adapters.ts
-var AUTOMATION_MODES = ["agent", "hooks", "mcp-only", "lean"];
-var MODE_LABELS = {
-  agent: "agent-driven",
-  hooks: "hook-driven",
-  "mcp-only": "MCP-only",
-  lean: "Lean (token reduction)"
-};
-var LIFECYCLE_EVENTS = ["prompt", "edit", "turn-end", "compaction"];
-var CLIENT_IDS = ["claude", "codex", "opencode", "freebuff", "hermes"];
-var CLIENT_ADAPTERS = {
-  claude: {
-    name: "Claude Code",
-    host: { bin: "claude", verified: "2.1.287" },
-    rulesFile: "CLAUDE.md",
-    mcp: { file: ".mcp.json", format: "mcpServers" },
-    hookEvents: LIFECYCLE_EVENTS,
-    hooks: "claude-settings",
-    framing: "UserPromptSubmit stdout is added to the prompt as hook context (wrapper is host-defined); unchanged lines are not resent; MCP schemas may be deferred by tool search",
-    defersMcpSchemas: true
-  },
-  codex: {
-    name: "Codex",
-    host: { bin: "codex", verified: "0.163.0" },
-    rulesFile: "AGENTS.md",
-    mcp: { global: "codex", manual: "codebuddy codex install (global ~/.codex/config.toml)" },
-    hookEvents: [],
-    gap: "no CodeBuddy hook adapter for Codex yet",
-    framing: "agent mode only; AGENTS.md is part of the instructions every request"
-  },
-  opencode: {
-    name: "OpenCode",
-    host: { bin: "opencode", verified: "1.18.32" },
-    rulesFile: "AGENTS.md",
-    // opencode.jsonc is used instead when it is the only one present.
-    mcp: { file: "opencode.json", format: "opencode" },
-    // Plugin bridge: chat.message (prompt), tool.execute.after (edit),
-    // session.idle (turn-end), session.compacted.
-    hookEvents: LIFECYCLE_EVENTS,
-    hooks: "opencode-plugin",
-    framing: "block appended verbatim as a synthetic text part that stays in history; unchanged lines are not resent"
-  },
-  freebuff: {
-    name: "Freebuff",
-    // Not installed; checked against source CodebuffAI/freebuff@f9ae64dd.
-    host: { bin: "freebuff", verified: "source f9ae64dd" },
-    rulesFile: "AGENTS.md",
-    mcp: { file: ".agents/mcp.json", format: "mcpServers" },
-    hookEvents: [],
-    gap: "no lifecycle surface at CodebuffAI/freebuff@f9ae64dd: no user hook config, and the SDK run_file_change_hooks tool is a no-op (sdk/src/tools/run-file-change-hooks.ts)",
-    note: "reads AGENTS.md, and CLAUDE.md only in a directory without one (common/src/constants/knowledge.ts)",
-    framing: "agent mode only; AGENTS.md is sent as a fenced block under a fixed project-instructions header"
-  },
-  hermes: {
-    name: "Hermes Agent",
-    host: { bin: "hermes", verified: "0.17.0" },
-    rulesFile: "AGENTS.md",
-    mcp: {
-      global: "hermes",
-      manual: "add a codebuddy entry under mcp_servers in ~/.hermes/config.yaml"
-    },
-    // Project Python plugin: pre_llm_call (prompt), post_tool_call (edit),
-    // on_session_end (turn-end). Compaction has no plugin hook; the context is
-    // resent in full every turn and the session ledger reset with it.
-    hookEvents: LIFECYCLE_EVENTS,
-    hooks: "hermes-plugin",
-    ephemeralContext: true,
-    framing: "block appended to this turn's user message only and never persisted, so it is resent in full every turn",
-    note: "hooks load only with HERMES_ENABLE_PROJECT_PLUGINS=1 and codebuddy in plugins.enabled of ~/.hermes/config.yaml; .hermes.md takes precedence over AGENTS.md"
-  }
-};
-function parseClient(value) {
-  const client = value ?? "claude";
-  if (!CLIENT_IDS.includes(client)) {
-    throw new Error(`Unknown client "${client}". Use one of: ${CLIENT_IDS.join(", ")}.`);
-  }
-  return client;
-}
-function parseMode(value) {
-  if (!AUTOMATION_MODES.includes(value)) {
-    throw new Error(`Unknown mode "${value}". Use one of: ${AUTOMATION_MODES.join(", ")}.`);
-  }
-  return value;
-}
-function supportedModes(adapter) {
-  return adapter.hookEvents.length === LIFECYCLE_EVENTS.length ? [...AUTOMATION_MODES] : ["agent", "mcp-only"];
-}
-function sharedRulesReaders(client) {
-  const file = CLIENT_ADAPTERS[client].rulesFile;
-  return CLIENT_IDS.filter((id) => id !== client && CLIENT_ADAPTERS[id].rulesFile === file);
-}
-
 // src/clients/cost.ts
-import { mkdtemp, rm as rm3 } from "fs/promises";
+import { mkdtemp, rm } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join7, resolve as resolve7 } from "path";
+import { join as join2, resolve as resolve2 } from "path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-
-// src/templates/install.ts
-import { readFile as readFile6, rm as rm2 } from "fs/promises";
-import { join as join6, resolve as resolve6 } from "path";
-
-// src/hooks/hermes-plugin.ts
-import { readFile as readFile3 } from "fs/promises";
-import { dirname as dirname4, join as join3, resolve as resolve3 } from "path";
-
-// src/hooks/managed-plugin.ts
-import { mkdir as mkdir3, readFile as readFile2, rm, rmdir } from "fs/promises";
-import { dirname as dirname3 } from "path";
-async function read(path) {
-  try {
-    return await readFile2(path, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
-}
-async function managedPluginInstalled(plugin3) {
-  for (const file of plugin3.files) {
-    if (!(await read(file.path))?.startsWith(plugin3.marker)) return false;
-  }
-  return true;
-}
-async function setManagedPlugin(plugin3, enabled) {
-  const current = await Promise.all(plugin3.files.map((file) => read(file.path)));
-  const foreign = plugin3.files.find((_, i) => {
-    const text3 = current[i];
-    return text3 != null && !text3.startsWith(plugin3.marker);
-  });
-  if (foreign) {
-    if (!enabled) return false;
-    throw new Error(
-      `${foreign.path} exists and is not managed by CodeBuddy; move it aside and re-run.`
-    );
-  }
-  let changed = false;
-  for (const [i, file] of plugin3.files.entries()) {
-    if (enabled && current[i] !== file.content) {
-      await mkdir3(dirname3(file.path), { recursive: true });
-      await writeAtomic(file.path, file.content, { mode: 420 });
-      changed = true;
-    } else if (!enabled && current[i] != null) {
-      await rm(file.path, { force: true });
-      changed = true;
-    }
-  }
-  if (!enabled && changed) {
-    for (const dir of plugin3.dirs) await rmdir(dir).catch(() => {
-    });
-  }
-  return changed;
-}
-
-// src/hooks/hermes-plugin.ts
-var HERMES_PLUGIN_MARKER = "# codebuddy-managed: hermes-plugin";
-var HERMES_PLUGIN_MANIFEST = `${HERMES_PLUGIN_MARKER} v1
-name: codebuddy
-version: 1.0.0
-kind: standalone
-description: CodeBuddy recall and capture bridge (codebuddy clients install hermes --mode hooks).
-provides_hooks:
-  - pre_llm_call
-  - post_tool_call
-  - post_llm_call
-  - on_session_end
-`;
-var HERMES_LEAN_MANIFEST = `${HERMES_PLUGIN_MARKER} v1 lean
-name: codebuddy
-version: 1.0.0
-kind: standalone
-description: CodeBuddy lean bridge (codebuddy clients install hermes --mode lean).
-provides_hooks:
-  - pre_llm_call
-`;
-var HERMES_HOOK_FN = `def _hook(command, payload):
-    """Run one fail-soft CodeBuddy hook; its stdout, or "" on any failure."""
-    try:
-        done = subprocess.run(
-            ["codebuddy", "hooks", command],
-            input=json.dumps({"cwd": ROOT, **payload}),
-            capture_output=True,
-            text=True,
-            timeout=TIMEOUT_S[command],
-            cwd=ROOT,
-        )
-    except Exception:
-        return ""
-    return done.stdout if done.returncode == 0 else ""
-
-
-`;
-function renderHermesPlugin(variant) {
-  return variant === "lean" ? `${HERMES_PLUGIN_MARKER} v1 lean
-# Generated by "codebuddy clients install hermes --mode lean"; removed by
-# "codebuddy clients uninstall hermes". Local edits are overwritten.
-"""CodeBuddy lean bridge: forwards each prompt to "codebuddy hooks lean"."""
-
-import json
-import subprocess
-from pathlib import Path
-
-# <root>/.hermes/plugins/codebuddy/__init__.py
-ROOT = str(Path(__file__).absolute().parents[3])
-TIMEOUT_S = {"lean": 2}
-
-
-${HERMES_HOOK_FN}def _pre_llm_call(session_id="", user_message="", **_):
-    if not isinstance(user_message, str) or not user_message.strip():
-        return None
-    payload = {
-        "session_id": session_id,
-        "hook_event_name": "pre_llm_call",
-        "ephemeral_context": True,
-        "prompt": user_message,
-    }
-    block = _hook("lean", payload).strip()
-    return {"context": block} if block else None
-
-
-def register(ctx):
-    ctx.register_hook("pre_llm_call", _pre_llm_call)
-` : `${HERMES_PLUGIN_MARKER} v1
-# Generated by "codebuddy clients install hermes --mode hooks"; removed by
-# "codebuddy clients uninstall hermes". Local edits are overwritten.
-"""CodeBuddy lifecycle bridge: forwards Hermes hooks to "codebuddy hooks <command>"."""
-
-import json
-import subprocess
-import threading
-from pathlib import Path
-
-# <root>/.hermes/plugins/codebuddy/__init__.py
-ROOT = str(Path(__file__).absolute().parents[3])
-EDIT_TOOLS = {"write_file", "patch"}
-TIMEOUT_S = {"context": 20, "stage": 10, "capture": 60}
-_lock = threading.Lock()
-_turns = {}
-
-
-${HERMES_HOOK_FN}def _turn(turn_id, session_id):
-    # Compression can rotate the session id mid-turn; a turn keeps its first id.
-    with _lock:
-        return _turns.setdefault(
-            turn_id or session_id, {"session": session_id, "text": "", "commands": []}
-        )
-
-
-def _pre_llm_call(session_id="", turn_id="", user_message="", **_):
-    _turn(turn_id, session_id)
-    payload = {"session_id": session_id, "hook_event_name": "pre_llm_call", "ephemeral_context": True}
-    if isinstance(user_message, str) and user_message.strip():
-        payload["prompt"] = user_message
-    block = _hook("context", payload).strip()
-    return {"context": block} if block else None
-
-
-def _post_tool_call(tool_name="", args=None, result=None, session_id="", turn_id="", **_):
-    turn = _turn(turn_id, session_id)
-    args = args if isinstance(args, dict) else {}
-    if tool_name in EDIT_TOOLS:
-        # Paths only: write_file content never needs to cross the pipe.
-        tool_input = {k: args[k] for k in ("path", "mode", "patch") if k in args}
-        _hook("stage", {
-            "session_id": turn["session"],
-            "hook_event_name": "post_tool_call",
-            "tool_name": tool_name,
-            "tool_input": tool_input,
-        })
-    elif tool_name == "terminal" and isinstance(args.get("command"), str):
-        exit_code = None
-        if not args.get("background"):  # a background process has not finished
-            try:
-                exit_code = json.loads(result).get("exit_code")
-            except Exception:
-                pass
-        turn["commands"].append({
-            "command": args["command"],
-            "exit_code": exit_code if type(exit_code) is int else None,
-        })
-
-
-def _post_llm_call(session_id="", turn_id="", assistant_response="", **_):
-    if isinstance(assistant_response, str) and assistant_response.strip():
-        _turn(turn_id, session_id)["text"] = assistant_response
-
-
-def _on_session_end(session_id="", turn_id="", **_):
-    with _lock:
-        turn = _turns.pop(turn_id or session_id, None)
-    turn = turn or {"session": session_id, "text": "", "commands": []}
-    payload = {"session_id": turn["session"], "hook_event_name": "on_session_end"}
-    if turn["text"]:
-        payload["last_assistant_message"] = turn["text"]
-    if turn["commands"]:
-        payload["shell_commands"] = turn["commands"][-20:]
-    _hook("capture", payload)
-
-
-def register(ctx):
-    ctx.register_hook("pre_llm_call", _pre_llm_call)
-    ctx.register_hook("post_tool_call", _post_tool_call)
-    ctx.register_hook("post_llm_call", _post_llm_call)
-    ctx.register_hook("on_session_end", _on_session_end)
-`;
-}
-var HERMES_PLUGIN_SOURCE = renderHermesPlugin("full");
-function hermesPluginDir(repositoryRoot) {
-  return join3(resolve3(repositoryRoot), ".hermes", "plugins", "codebuddy");
-}
-function plugin(repositoryRoot, variant = "full") {
-  const dir = hermesPluginDir(repositoryRoot);
-  return {
-    marker: HERMES_PLUGIN_MARKER,
-    files: [
-      {
-        path: join3(dir, "plugin.yaml"),
-        content: variant === "lean" ? HERMES_LEAN_MANIFEST : HERMES_PLUGIN_MANIFEST
-      },
-      { path: join3(dir, "__init__.py"), content: renderHermesPlugin(variant) }
-    ],
-    dirs: [dir, dirname4(dir), dirname4(dirname4(dir))]
-  };
-}
-function hermesPluginInstalled(repositoryRoot) {
-  return managedPluginInstalled(plugin(repositoryRoot));
-}
-function setHermesPlugin(repositoryRoot, enabled, variant = "full") {
-  return setManagedPlugin(plugin(repositoryRoot, variant), enabled);
-}
-async function hermesPluginVariant(repositoryRoot) {
-  if (!await hermesPluginInstalled(repositoryRoot)) return null;
-  const source = await readFile3(join3(hermesPluginDir(repositoryRoot), "__init__.py"), "utf8");
-  return source.startsWith(`${HERMES_PLUGIN_MARKER} v1 lean`) ? "lean" : "full";
-}
-
-// src/hooks/opencode-plugin.ts
-import { readFile as readFile4 } from "fs/promises";
-import { dirname as dirname5, join as join4, resolve as resolve4 } from "path";
-var OPENCODE_PLUGIN_MARKER = "// codebuddy-managed: opencode-plugin";
-var OPENCODE_RUNTIME = `const ID_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-let lastMs = 0;
-let counter = 0;
-
-/** Run one fail-soft CodeBuddy hook; resolves to its stdout, "" on any failure. */
-function hook(command, payload) {
-  return new Promise((done) => {
-    let out = "";
-    let child;
-    try {
-      child = spawn("codebuddy", ["hooks", command], {
-        cwd: payload.cwd,
-        stdio: ["pipe", "pipe", "ignore"],
-        // npm installs a codebuddy.cmd shim on Windows, which spawn only runs through a shell.
-        shell: process.platform === "win32",
-      });
-    } catch {
-      done("");
-      return;
-    }
-    const timer = setTimeout(() => child.kill(), TIMEOUT_MS[command]);
-    child.stdout.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      out += chunk;
-    });
-    child.on("error", () => {
-      clearTimeout(timer);
-      done("");
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      done(code === 0 ? out : "");
-    });
-    child.stdin.on("error", () => {});
-    child.stdin.end(JSON.stringify(payload));
-  });
-}
-
-/** An ascending OpenCode part id (prt_ + 48-bit time/counter hex + 14 base62). */
-function partId() {
-  const now = Date.now();
-  if (now !== lastMs) {
-    lastMs = now;
-    counter = 0;
-  }
-  counter += 1;
-  const time = (BigInt(now) * 4096n + BigInt(counter)) & 0xffffffffffffn;
-  let random = "";
-  for (const byte of crypto.getRandomValues(new Uint8Array(14))) random += ID_CHARS[byte % 62];
-  return "prt_" + time.toString(16).padStart(12, "0") + random;
-}
-
-`;
-function renderOpencodePlugin(variant) {
-  return variant === "lean" ? `${OPENCODE_PLUGIN_MARKER} v1 lean
-// Generated by \`codebuddy clients install opencode --mode lean\`; removed by
-// \`codebuddy clients uninstall opencode\`. Local edits are overwritten.
-import { spawn } from "node:child_process";
-
-const TIMEOUT_MS = { lean: 2000, reset: 10000 };
-${OPENCODE_RUNTIME}/** @type {import("@opencode-ai/plugin").Plugin} */
-export const CodeBuddyPlugin = async ({ directory }) => {
-  const base = (sessionID, event) => ({ session_id: sessionID, cwd: directory, hook_event_name: event });
-
-  return {
-    "chat.message": async (input, output) => {
-      const prompt = output.parts
-        .flatMap((part) => (part.type === "text" && !part.synthetic ? [part.text] : []))
-        .join("\\n")
-        .trim();
-      if (!prompt) return;
-      const block = (await hook("lean", { ...base(input.sessionID, "chat.message"), prompt })).trim();
-      if (!block) return;
-      output.parts.push({
-        id: partId(),
-        sessionID: input.sessionID,
-        messageID: output.message.id,
-        type: "text",
-        text: block,
-        synthetic: true,
-      });
-    },
-    event: async ({ event }) => {
-      if (event.type === "session.compacted") {
-        await hook("reset", { ...base(event.properties.sessionID, "session.compacted"), source: "compact" });
-      }
-    },
-  };
-};
-` : `${OPENCODE_PLUGIN_MARKER} v1
-// Generated by \`codebuddy clients install opencode --mode hooks\`; removed by
-// \`codebuddy clients uninstall opencode\`. Local edits are overwritten.
-import { spawn } from "node:child_process";
-
-const EDIT_TOOLS = new Set(["edit", "write", "patch", "apply_patch"]);
-const TIMEOUT_MS = { context: 20000, stage: 10000, capture: 60000, reset: 10000 };
-${OPENCODE_RUNTIME}/** @type {import("@opencode-ai/plugin").Plugin} */
-export const CodeBuddyPlugin = async ({ directory }) => {
-  /** @type {Map<string, { text: string, commands: Array<{ command: string, exit_code: number | null }> }>} */
-  const turns = new Map();
-  const turn = (sessionID) => {
-    if (!turns.has(sessionID)) turns.set(sessionID, { text: "", commands: [] });
-    return turns.get(sessionID);
-  };
-  const base = (sessionID, event) => ({ session_id: sessionID, cwd: directory, hook_event_name: event });
-
-  return {
-    "chat.message": async (input, output) => {
-      turns.delete(input.sessionID);
-      const prompt = output.parts
-        .flatMap((part) => (part.type === "text" && !part.synthetic ? [part.text] : []))
-        .join("\\n")
-        .trim();
-      const block = (
-        await hook("context", { ...base(input.sessionID, "chat.message"), ...(prompt ? { prompt } : {}) })
-      ).trim();
-      if (!block) return;
-      output.parts.push({
-        id: partId(),
-        sessionID: input.sessionID,
-        messageID: output.message.id,
-        type: "text",
-        text: block,
-        synthetic: true,
-      });
-    },
-    "tool.execute.after": async (input, output) => {
-      if (EDIT_TOOLS.has(input.tool)) {
-        await hook("stage", {
-          ...base(input.sessionID, "tool.execute.after"),
-          tool_name: input.tool,
-          tool_input: input.args,
-        });
-      } else if (input.tool === "bash" && typeof input.args?.command === "string") {
-        const exit = output.metadata?.exit;
-        turn(input.sessionID).commands.push({
-          command: input.args.command,
-          exit_code: typeof exit === "number" ? exit : null,
-        });
-      }
-    },
-    "experimental.text.complete": async (input, output) => {
-      if (output.text.trim()) turn(input.sessionID).text = output.text;
-    },
-    event: async ({ event }) => {
-      if (event.type === "session.idle") {
-        const sessionID = event.properties.sessionID;
-        const current = turns.get(sessionID);
-        turns.delete(sessionID);
-        await hook("capture", {
-          ...base(sessionID, "session.idle"),
-          ...(current?.text ? { last_assistant_message: current.text } : {}),
-          ...(current?.commands.length ? { shell_commands: current.commands.slice(-20) } : {}),
-        });
-      } else if (event.type === "session.compacted") {
-        await hook("reset", { ...base(event.properties.sessionID, "session.compacted"), source: "compact" });
-      }
-    },
-  };
-};
-`;
-}
-var OPENCODE_PLUGIN_SOURCE = renderOpencodePlugin("full");
-function opencodePluginPath(repositoryRoot) {
-  return join4(resolve4(repositoryRoot), ".opencode", "plugins", "codebuddy.js");
-}
-function plugin2(repositoryRoot, variant = "full") {
-  const path = opencodePluginPath(repositoryRoot);
-  return {
-    marker: OPENCODE_PLUGIN_MARKER,
-    files: [{ path, content: renderOpencodePlugin(variant) }],
-    dirs: [dirname5(path), dirname5(dirname5(path))]
-  };
-}
-function opencodePluginInstalled(repositoryRoot) {
-  return managedPluginInstalled(plugin2(repositoryRoot));
-}
-function setOpencodePlugin(repositoryRoot, enabled, variant = "full") {
-  return setManagedPlugin(plugin2(repositoryRoot, variant), enabled);
-}
-async function opencodePluginVariant(repositoryRoot) {
-  if (!await opencodePluginInstalled(repositoryRoot)) return null;
-  const source = await readFile4(opencodePluginPath(repositoryRoot), "utf8");
-  return source.startsWith(`${OPENCODE_PLUGIN_MARKER} v1 lean`) ? "lean" : "full";
-}
-
-// src/hooks/settings.ts
-import { mkdir as mkdir4, readFile as readFile5 } from "fs/promises";
-import { dirname as dirname6, join as join5, resolve as resolve5 } from "path";
-var HOOK_COMMAND_PREFIX = "codebuddy hooks";
-var TOOL_GUARD_DEF = {
-  event: "PreToolUse",
-  matcher: "Read|Grep|Bash",
-  command: `${HOOK_COMMAND_PREFIX} pretool`
-};
-var HOOK_DEFS = [
-  { event: "UserPromptSubmit", command: `${HOOK_COMMAND_PREFIX} context` },
-  {
-    event: "PostToolUse",
-    matcher: "Edit|Write|MultiEdit",
-    command: `${HOOK_COMMAND_PREFIX} stage`
-  },
-  { event: "Stop", command: `${HOOK_COMMAND_PREFIX} capture` },
-  // After compaction or /clear the model no longer holds earlier context, so
-  // capsules the session ledger marked as sent must be sent again.
-  { event: "SessionStart", matcher: "compact|clear", command: `${HOOK_COMMAND_PREFIX} reset` },
-  TOOL_GUARD_DEF
-];
-var LEAN_HOOK_DEFS = [
-  { event: "UserPromptSubmit", command: `${HOOK_COMMAND_PREFIX} lean` },
-  { event: "SessionStart", matcher: "compact|clear", command: `${HOOK_COMMAND_PREFIX} reset` },
-  TOOL_GUARD_DEF
-];
-function claudeSettingsPath(repositoryRoot = process.cwd()) {
-  return join5(resolve5(repositoryRoot), ".claude", "settings.json");
-}
-function upsertHooks(settings, variant = "full") {
-  const defs = variant === "lean" ? LEAN_HOOK_DEFS : HOOK_DEFS;
-  const wanted = new Set(defs.map((def) => def.command));
-  const next = { ...settings, hooks: { ...settings.hooks ?? {} } };
-  const hooks = next.hooks;
-  let changed = false;
-  for (const event of Object.keys(hooks)) {
-    const groups = [];
-    for (const group of hooks[event] ?? []) {
-      const kept = (group.hooks ?? []).filter(
-        (hook) => !hook.command?.startsWith(HOOK_COMMAND_PREFIX) || wanted.has(hook.command)
-      );
-      if (kept.length !== (group.hooks ?? []).length) changed = true;
-      if (kept.length > 0) groups.push({ ...group, hooks: kept });
-    }
-    if (groups.length > 0) hooks[event] = groups;
-    else delete hooks[event];
-  }
-  for (const def of defs) {
-    const groups = [...hooks[def.event] ?? []];
-    const existingIndex = groups.findIndex(
-      (group) => group.hooks?.some((hook) => hook.command === def.command)
-    );
-    if (existingIndex === -1) {
-      groups.push({
-        ...def.matcher ? { matcher: def.matcher } : {},
-        hooks: [{ type: "command", command: def.command }]
-      });
-      changed = true;
-    } else {
-      const existing = groups[existingIndex];
-      if (existing && (def.matcher ?? void 0) !== (existing.matcher ?? void 0)) {
-        const { matcher: _oldMatcher, ...rest } = existing;
-        groups[existingIndex] = def.matcher ? { ...rest, matcher: def.matcher } : rest;
-        changed = true;
-      }
-    }
-    hooks[def.event] = groups;
-  }
-  return { settings: next, changed };
-}
-function removeHooks(settings) {
-  if (!settings.hooks) return { settings, changed: false };
-  const next = { ...settings, hooks: { ...settings.hooks } };
-  const hooks = next.hooks;
-  let changed = false;
-  for (const event of Object.keys(hooks)) {
-    const keptGroups = [];
-    for (const group of hooks[event] ?? []) {
-      const keptHooks = (group.hooks ?? []).filter(
-        (hook) => !hook.command?.startsWith(HOOK_COMMAND_PREFIX)
-      );
-      if (keptHooks.length !== (group.hooks ?? []).length) changed = true;
-      if (keptHooks.length === 0) continue;
-      keptGroups.push({ ...group, hooks: keptHooks });
-    }
-    if (keptGroups.length === 0) delete hooks[event];
-    else hooks[event] = keptGroups;
-  }
-  return { settings: next, changed };
-}
-function hooksInstalled(settings) {
-  const hooks = settings.hooks ?? {};
-  return Object.values(hooks).some(
-    (groups) => groups.some((group) => group.hooks?.some((h) => h.command?.startsWith(HOOK_COMMAND_PREFIX)))
-  );
-}
-function hooksVariant(settings) {
-  if (!hooksInstalled(settings)) return null;
-  const leanCommand = `${HOOK_COMMAND_PREFIX} lean`;
-  const lean = Object.values(settings.hooks ?? {}).some(
-    (groups) => groups.some((group) => group.hooks?.some((hook) => hook.command === leanCommand))
-  );
-  return lean ? "lean" : "full";
-}
-async function readSettings(path) {
-  try {
-    return JSON.parse(await readFile5(path, "utf8"));
-  } catch (error) {
-    if (error.code === "ENOENT") return {};
-    throw error;
-  }
-}
-async function writeSettings(path, settings) {
-  await mkdir4(dirname6(path), { recursive: true });
-  await writeAtomic(path, `${JSON.stringify(settings, null, 2)}
-`, { mode: 420 });
-}
-
-// src/hooks/install.ts
-var SURFACES = {
-  "claude-settings": {
-    path: claudeSettingsPath,
-    installed: async (root) => hooksInstalled(await readSettings(claudeSettingsPath(root))),
-    variant: async (root) => hooksVariant(await readSettings(claudeSettingsPath(root))),
-    set: async (root, enabled, variant) => {
-      const path = claudeSettingsPath(root);
-      const current = await readSettings(path);
-      const { settings, changed } = enabled ? upsertHooks(current, variant) : removeHooks(current);
-      if (changed) await writeSettings(path, settings);
-      return changed;
-    }
-  },
-  "opencode-plugin": {
-    path: opencodePluginPath,
-    installed: opencodePluginInstalled,
-    variant: opencodePluginVariant,
-    set: setOpencodePlugin
-  },
-  "hermes-plugin": {
-    path: hermesPluginDir,
-    installed: hermesPluginInstalled,
-    variant: hermesPluginVariant,
-    set: setHermesPlugin
-  }
-};
-async function setClientHooks(root, client, enabled, variant = "full") {
-  const surface = CLIENT_ADAPTERS[client].hooks;
-  if (!surface) return null;
-  const { path, set } = SURFACES[surface];
-  return { target: path(root), changed: await set(root, enabled, variant) };
-}
-async function clientHooksVariant(root, client) {
-  const surface = CLIENT_ADAPTERS[client].hooks;
-  if (!surface) return void 0;
-  return SURFACES[surface].variant(root);
-}
-async function clientHooksInstalled(root, client) {
-  const surface = CLIENT_ADAPTERS[client].hooks;
-  return surface ? SURFACES[surface].installed(root) : null;
-}
-async function hookedRulesSiblings(root, client) {
-  const file = CLIENT_ADAPTERS[client].rulesFile;
-  const hooked = [];
-  for (const id of CLIENT_IDS) {
-    if (id !== client && CLIENT_ADAPTERS[id].rulesFile === file && await clientHooksInstalled(root, id))
-      hooked.push(id);
-  }
-  return hooked;
-}
-async function rulesFileHooked(root, client) {
-  return await clientHooksInstalled(root, client) === true || (await hookedRulesSiblings(root, client)).length > 0;
-}
-
-// src/templates/workflow.ts
-var WORKFLOW_CLIENTS = CLIENT_IDS;
-var INTRO = [
-  "You have CodeBuddy available as a local, MCP-backed project-context engine.",
-  "Use it to work like a careful senior engineer, not to dump broad context.",
-  ""
-];
-var START_AGENT = [
-  "## At the start of a substantive coding turn",
-  "",
-  "1. When project context is needed, call `context_pack` with the user's task and a token budget (start",
-  "   with 4000). It automatically finds relevant files and returns bounded symbols,",
-  "   plan, policy, incidents, risks, architecture neighbours, and team facts.",
-  "   Reuse evidence already present. For a clearly identified small edit, read the",
-  "   needed source directly; fetch context for unknown dependencies or project constraints.",
-  "   Read missing function bodies before editing. If safety evidence was omitted,",
-  "   narrow the targets or increase the budget before proceeding.",
-  "2. Use `context_bootstrap` only when you need broad project orientation beyond",
-  "   the task pack. Use `context_before_edit` when you already have exact paths",
-  "   or a plan and need a narrower follow-up.",
-  "3. Prior work from earlier chats arrives as `handoffs` with freshness",
-  "   (`changedSince`, `missing`); re-check those files before relying on it.",
-  "4. On repeated context calls in one conversation, pass a stable `sessionId` and",
-  "   the previous response's `delivery.deliveryId` as `ack`. Unchanged sections",
-  "   are then omitted and listed in `delivery.unchanged`. If earlier output is no",
-  "   longer in your context (e.g. after compaction), pass `full: true`.",
-  ""
-];
-var START_HOOKS = [
-  "## At the start of a substantive coding turn",
-  "",
-  "CodeBuddy hooks inject a `CodeBuddy project context (auto-recalled)` block into",
-  "each prompt: project, plan, policies, facts, incidents, handoffs, current",
-  "changes, and risk. Agents without CodeBuddy hooks (no such block in the prompt)",
-  "follow the agent-driven flow: `context_pack` first, `context_after_turn` last.",
-  "",
-  "1. Start from the injected block; do not call `context_bootstrap` for orientation",
-  "   it already covers. Its `task files` are CodeBuddy's best match; when it names",
-  "   none, call `context_pack` with the task before searching the repository yourself.",
-  "2. Read ranges, not whole files: `Read` with offset/limit, or `sed -n 'A,Bp'`.",
-  "   Large files read whole (`Read` without a range, `cat`, `less`) are denied with an",
-  "   outline of their symbols and line ranges; read the range you need from it.",
-  "3. Call `context_pack` (or `context_before_edit` with exact paths) when the",
-  "   task needs symbols, neighbours, or file-level evidence the block lacks. Pass the",
-  "   block's `session` value as `sessionId` and the previous `delivery.deliveryId`",
-  "   as `ack` so unchanged sections are not resent.",
-  "4. Prior work from earlier chats arrives as handoffs with freshness; re-check",
-  "   those files before relying on it.",
-  ""
-];
-var MIDDLE = [
-  "## While implementing",
-  "",
-  "- Prefer the smallest sufficient set of edits; preserve existing behavior.",
-  "- Honor risk warnings and policy rules for the files you touch; call out risk",
-  "  before editing sensitive areas.",
-  "- Do not re-request broad context if the task pack already suffices.",
-  "",
-  "## Before finalizing",
-  "",
-  "- Consider calling `code_suggestions` (with `paths`, `planId`, or `useGit`) for",
-  "  read-only, evidence-backed quality findings; resolve high-severity ones.",
-  "- Run the smallest relevant verification (tests, lint, typecheck) and fix",
-  "  failures before presenting completion.",
-  ""
-];
-var AFTER_AGENT = [
-  "## After a meaningful turn",
-  "",
-  "- Call `context_after_turn` with a concise `summary`, the `changedFiles`, and a",
-  "  `planId` if one is active, plus `verification` (commands run and results)",
-  "  so the turn's worklog handoff records it. CodeBuddy auto-saves confident facts, decisions,",
-  "  and incidents, queues uncertain or sensitive items for review, and drops",
-  "  chatter. Never paste secrets, tokens, or credentials into the summary.",
-  ""
-];
-var AFTER_HOOKS = [
-  "## After a meaningful turn",
-  "",
-  "- Do not call `context_after_turn`: the turn-end hook captures the turn once, from",
-  "  the real change set and the verification commands you ran. A second capture",
-  "  would record a divergent worklog entry.",
-  "- Never paste secrets, tokens, or credentials into your final message; it is the",
-  "  capture summary.",
-  ""
-];
-var TAIL = [
-  "## If a tool or service is unavailable (degraded mode)",
-  "",
-  "- A CodeBuddy MCP tool errors or is missing: proceed using the repository",
-  "  itself as the source of truth; do not block on it.",
-  "- Postgres is unreachable: the file-based tools (context, plan, risk, map,",
-  "  suggest) still work; recall and embeddings may be degraded \u2014 say so instead",
-  "  of inventing remembered facts.",
-  "- Retrieval returns no context: read the relevant files directly rather than",
-  "  guessing; the working tree is authoritative.",
-  "",
-  "## Never",
-  "",
-  "- Invent behavior the codebase does not support.",
-  "- Ignore failing tests or lint.",
-  "- Make speculative, wide changes without evidence.",
-  "- Save low-confidence project memory as a durable fact."
-];
-function renderBody(mode) {
-  return [
-    ...INTRO,
-    ...mode === "hooks" ? START_HOOKS : START_AGENT,
-    ...MIDDLE,
-    ...mode === "hooks" ? AFTER_HOOKS : AFTER_AGENT,
-    ...TAIL
-  ].join("\n");
-}
-function rulesReaders(file) {
-  return CLIENT_IDS.filter((id) => CLIENT_ADAPTERS[id].rulesFile === file).map((id) => CLIENT_ADAPTERS[id].name).join(", ");
-}
-function renderWorkflowTemplate(client, mode = "agent") {
-  const file = CLIENT_ADAPTERS[client].rulesFile;
-  return [
-    `# CodeBuddy workflow (${rulesReaders(file)})`,
-    "",
-    "This section is managed by CodeBuddy (`codebuddy clients install <client> --mode <mode>`)",
-    `and lives in \`${file}\`. Edit outside the managed markers to customize.`,
-    `Automation mode: \`${mode}\` (${MODE_LABELS[mode]}).`,
-    "",
-    renderBody(mode)
-  ].join("\n");
-}
-function parseWorkflowMode(block) {
-  return block.match(/Automation mode: `(hooks|agent)`/)?.[1] === "hooks" ? "hooks" : "agent";
-}
-function defaultRulesFile(client) {
-  return CLIENT_ADAPTERS[client].rulesFile;
-}
-function clientDisplayName(client) {
-  return CLIENT_ADAPTERS[client].name;
-}
-
-// src/templates/install.ts
-var START_MARKER = "<!-- codebuddy:workflow:start -->";
-var END_MARKER = "<!-- codebuddy:workflow:end -->";
-function renderManagedBlock(client, mode = "agent") {
-  return `${START_MARKER}
-${renderWorkflowTemplate(client, mode)}
-${END_MARKER}
-`;
-}
-async function installWorkflowRules(options) {
-  const projectRoot = resolve6(options.projectRoot ?? process.cwd());
-  const path = options.targetPath ?? join6(projectRoot, defaultRulesFile(options.client));
-  const existing = await readIfPresent(path);
-  const mode = options.mode ?? await defaultRulesMode(options.client, projectRoot);
-  if (options.onlyIfManaged && (existing === null || !hasManagedBlock(existing))) {
-    return { path, client: options.client, action: "unchanged" };
-  }
-  if (mode === "mcp-only") {
-    const content2 = existing === null ? null : removeBlock(existing);
-    if (content2 === null || content2 === existing) {
-      return { path, client: options.client, action: "unchanged" };
-    }
-    if (content2.trim() === "") await rm2(path, { force: true });
-    else await writeAtomic(path, content2, { mode: 420 });
-    return { path, client: options.client, action: "removed" };
-  }
-  const { content, action } = upsertBlock(existing, renderManagedBlock(options.client, mode));
-  if (action === "unchanged") return { path, client: options.client, action };
-  await writeAtomic(path, content, { mode: 420 });
-  return { path, client: options.client, action };
-}
-function upsertBlock(existing, block) {
-  if (existing === null) return { content: block, action: "created" };
-  const start = existing.indexOf(START_MARKER);
-  const end = existing.indexOf(END_MARKER);
-  if (start !== -1 && end !== -1 && end > start) {
-    const before = existing.slice(0, start);
-    const after = existing.slice(end + END_MARKER.length).replace(/^\n/, "");
-    const replaced = `${before}${block}${after}`;
-    return { content: replaced, action: replaced === existing ? "unchanged" : "updated" };
-  }
-  const separator = existing.length === 0 || existing.endsWith("\n\n") ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
-  return { content: `${existing}${separator}${block}`, action: "added" };
-}
-async function defaultRulesMode(client, projectRoot = process.cwd()) {
-  return await rulesFileHooked(projectRoot, client) ? "hooks" : "agent";
-}
-async function readManagedMode(path) {
-  const existing = await readIfPresent(path);
-  if (existing === null || !hasManagedBlock(existing)) return null;
-  return parseWorkflowMode(existing.slice(existing.indexOf(START_MARKER)));
-}
-function hasManagedBlock(content) {
-  const start = content.indexOf(START_MARKER);
-  return start !== -1 && content.indexOf(END_MARKER) > start;
-}
-function removeBlock(existing) {
-  if (!hasManagedBlock(existing)) return existing;
-  const start = existing.indexOf(START_MARKER);
-  const end = existing.indexOf(END_MARKER) + END_MARKER.length;
-  const before = existing.slice(0, start).replace(/\n\n$/, "\n");
-  const after = existing.slice(end).replace(/^\n/, "");
-  return `${before}${after}`;
-}
-async function readIfPresent(path) {
-  try {
-    return await readFile6(path, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
-}
-
-// src/clients/cost.ts
 async function mcpSchemaTokens(root, namespace) {
   const server = new McpServer({ name: "codebuddy", version: VERSION });
   registerCodeBuddyTools(server, {
@@ -1624,7 +667,7 @@ async function hookBlockTokens(root, namespace) {
     namespace,
     useGit: true
   }).catch(() => null);
-  const scratch = await mkdtemp(join7(tmpdir(), "codebuddy-cost-"));
+  const scratch = await mkdtemp(join2(tmpdir(), "codebuddy-cost-"));
   try {
     const ledger = new SessionCapsuleLedger(scratch);
     const render = () => renderContextBlock(bootstrap, beforeEdit, ledger, "cost", true);
@@ -1642,11 +685,11 @@ async function hookBlockTokens(root, namespace) {
       lean: { first: estimateTokens(leanFirst.text), later: estimateTokens(leanLater.text) }
     };
   } finally {
-    await rm3(scratch, { recursive: true, force: true });
+    await rm(scratch, { recursive: true, force: true });
   }
 }
 async function measureClientCosts(projectRoot = process.cwd(), namespace) {
-  const root = resolve7(projectRoot);
+  const root = resolve2(projectRoot);
   const ns = namespace ?? await resolveNamespaceFrom(root);
   const mcpSchema = await mcpSchemaTokens(root, ns);
   const block = await hookBlockTokens(root, ns);
@@ -1676,506 +719,10 @@ async function measureClientCosts(projectRoot = process.cwd(), namespace) {
   });
 }
 
-// src/clients/install.ts
-import { access as access3 } from "fs/promises";
-import { join as join11, resolve as resolve9 } from "path";
-
-// src/integrations/project-mcp.ts
-import { access as access2, mkdir as mkdir5, readFile as readFile7, rm as rm4 } from "fs/promises";
-import { dirname as dirname7, join as join8, resolve as resolve8 } from "path";
-async function writeProjectMcpConfig(options) {
-  const path = join8(options.repositoryRoot, ".mcp.json");
-  const current = await readProjectMcpConfig(path);
-  current.mcpServers ??= {};
-  current.mcpServers[`codebuddy-${options.namespace}`] = codebuddyMcpServer(
-    options.repositoryRoot,
-    options.namespace
-  );
-  if (options.graphify) {
-    current.mcpServers.graphify = {
-      command: "python",
-      args: [
-        "-m",
-        "graphify.serve",
-        resolve8(options.repositoryRoot, options.graphPath ?? "graphify-out/graph.json")
-      ],
-      env: { CODEBUDDY_PROJECT_ROOT: options.repositoryRoot }
-    };
-  } else if (current.mcpServers.graphify) {
-    delete current.mcpServers.graphify;
-  }
-  await writeAtomic(path, `${JSON.stringify(current, null, 2)}
-`, { mode: 420 });
-  return { path, servers: Object.keys(current.mcpServers).sort() };
-}
-var OPENCODE_SCHEMA = "https://opencode.ai/config.json";
-function codebuddyMcpServer(repositoryRoot, namespace) {
-  return {
-    command: "codebuddy",
-    args: ["serve"],
-    env: {
-      CODEBUDDY_PROJECT_ROOT: repositoryRoot,
-      CODEBUDDY_NAMESPACE: namespace,
-      CODEBUDDY_TOOL_PROFILE: "core"
-    }
-  };
-}
-async function projectMcpPath(root, file, format) {
-  const path = join8(root, file);
-  if (format !== "opencode" || await exists(path)) return path;
-  return await exists(`${path}c`) ? `${path}c` : path;
-}
-async function exists(path) {
-  return access2(path).then(
-    () => true,
-    () => false
-  );
-}
-function formatEntry(format, server) {
-  if (format === "mcpServers") return server;
-  return {
-    type: "local",
-    command: [server.command, ...server.args],
-    ...server.env ? { environment: server.env } : {},
-    enabled: true
-  };
-}
-function serversKey(format) {
-  return format === "opencode" ? "mcp" : "mcpServers";
-}
-async function upsertMcpServer(path, format, name, server) {
-  const existed = await exists(path);
-  const { config, comments } = await readConfig(path);
-  const key = serversKey(format);
-  const servers2 = { ...config[key] ?? {} };
-  const entry = formatEntry(format, server);
-  if (JSON.stringify(servers2[name]) === JSON.stringify(entry)) return "unchanged";
-  if (comments) return "manual";
-  servers2[name] = entry;
-  const next = format === "opencode" && !existed ? { $schema: OPENCODE_SCHEMA, ...config, [key]: servers2 } : { ...config, [key]: servers2 };
-  await mkdir5(dirname7(path), { recursive: true });
-  await writeAtomic(path, `${JSON.stringify(next, null, 2)}
-`, { mode: 420 });
-  return existed ? "updated" : "created";
-}
-async function removeMcpServer(path, format, name) {
-  const { config, comments } = await readConfig(path);
-  const key = serversKey(format);
-  const servers2 = { ...config[key] ?? {} };
-  if (!(name in servers2)) return "unchanged";
-  if (comments) return "manual";
-  delete servers2[name];
-  const next = { ...config, [key]: servers2 };
-  const leftover = Object.keys(next).filter((k) => k !== key && k !== "$schema");
-  if (Object.keys(servers2).length === 0 && leftover.length === 0) await rm4(path, { force: true });
-  else await writeAtomic(path, `${JSON.stringify(next, null, 2)}
-`, { mode: 420 });
-  return "removed";
-}
-async function hasMcpServer(path, format, name) {
-  const { config } = await readConfig(path);
-  return name in (config[serversKey(format)] ?? {});
-}
-function parseJsonc(raw) {
-  let comments = false;
-  const json2 = raw.replace(/"(?:[^"\\]|\\.)*"|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (match) => {
-    if (match.startsWith('"')) return match;
-    comments = true;
-    return " ";
-  }).replace(/"(?:[^"\\]|\\.)*"|,(\s*[}\]])/g, (match, tail) => tail ?? match);
-  return { value: JSON.parse(json2), comments };
-}
-async function readConfig(path) {
-  try {
-    const { value, comments } = parseJsonc(await readFile7(path, "utf8"));
-    const config = value && typeof value === "object" ? value : {};
-    return { config, comments };
-  } catch (error) {
-    if (error.code === "ENOENT") return { config: {}, comments: false };
-    throw new Error(`Could not read ${path}: ${error.message}`);
-  }
-}
-async function readProjectMcpConfig(path) {
-  return (await readConfig(path)).config;
-}
-
-// src/cli/commands/codex.ts
-import { existsSync as existsSync2 } from "fs";
-import { mkdir as mkdir6, readFile as readFile8 } from "fs/promises";
-import { homedir } from "os";
-import { dirname as dirname8, join as join9 } from "path";
-function codexConfigPath(home = homedir()) {
-  return join9(home, ".codex", "config.toml");
-}
-async function readCodexConfig(path) {
-  if (!existsSync2(path)) return "";
-  return readFile8(path, "utf8");
-}
-async function writeCodexConfig(path, content) {
-  await mkdir6(dirname8(path), { recursive: true });
-  await writeAtomic(path, content, { mode: 384 });
-}
-async function installCodexEntry(options) {
-  const path = codexConfigPath();
-  const serverKey = options.serverName ?? `codebuddy-${options.namespace}`;
-  const current = await readCodexConfig(path);
-  const existed = hasServerBlock(current, serverKey);
-  const entry = buildEntry(options);
-  if (options.toolProfile)
-    entry.env = { ...entry.env, CODEBUDDY_TOOL_PROFILE: options.toolProfile };
-  const next = upsertServerBlock(current, serverKey, entry);
-  if (next !== current) await writeCodexConfig(path, next);
-  return { path, serverKey, created: !existed, changed: next !== current };
-}
-async function removeCodexEntry(serverKey) {
-  const path = codexConfigPath();
-  const current = await readCodexConfig(path);
-  const next = removeServerBlock(current, serverKey);
-  const removed = next !== current;
-  const trimmed = next.trimEnd();
-  if (removed) await writeCodexConfig(path, trimmed ? `${trimmed}
-` : "");
-  return { removed, path };
-}
-async function listCodexEntries() {
-  const path = codexConfigPath();
-  const config = await readCodexConfig(path);
-  const entries = Array.from(config.matchAll(/^\[mcp_servers\."([^"]+)"\]\s*$/gm)).flatMap((match) => match[1] ? [match[1]] : []).filter((key) => key === "codebuddy" || key.startsWith("codebuddy-")).map((key) => {
-    const block = getServerBlock(config, key);
-    return {
-      key,
-      namespace: readEnvValue(block, "CODEBUDDY_NAMESPACE"),
-      databaseUrl: readEnvValue(block, "DATABASE_URL")
-    };
-  });
-  return { path, entries };
-}
-function upsertServerBlock(config, serverKey, entry) {
-  const trimmed = removeServerBlock(config, serverKey).trimEnd();
-  const block = formatServerBlock(serverKey, entry);
-  return `${trimmed}${trimmed ? "\n\n" : ""}${block}
-`;
-}
-function removeServerBlock(config, serverKey) {
-  const escaped = escapeRegExp(serverKey);
-  const end = String.raw`(?![\s\S])`;
-  const sectionPattern = String.raw`^\[mcp_servers\."${escaped}"\][\s\S]*?(?=^\[[^\]]+\]\s*$|${end})`;
-  const envPattern = String.raw`^\[mcp_servers\."${escaped}"\.env\][\s\S]*?(?=^\[[^\]]+\]\s*$|${end})`;
-  return config.replace(new RegExp(sectionPattern, "gm"), "").replace(new RegExp(envPattern, "gm"), "");
-}
-function getServerBlock(config, serverKey) {
-  const escaped = escapeRegExp(serverKey);
-  const end = String.raw`(?![\s\S])`;
-  const pattern = String.raw`^\[mcp_servers\."${escaped}"\][\s\S]*?(?=^\[mcp_servers\."${escaped}"\.env\][\s\S]*?(?=^\[[^\]]+\]\s*$|${end})|^\[[^\]]+\]\s*$|${end})`;
-  const server = config.match(new RegExp(pattern, "m"))?.[0] ?? "";
-  const env = config.match(
-    new RegExp(
-      String.raw`^\[mcp_servers\."${escaped}"\.env\][\s\S]*?(?=^\[[^\]]+\]\s*$|${end})`,
-      "m"
-    )
-  )?.[0] ?? "";
-  return `${server}
-${env}`;
-}
-function hasServerBlock(config, serverKey) {
-  return new RegExp(String.raw`^\[mcp_servers\."${escapeRegExp(serverKey)}"\]\s*$`, "m").test(
-    config
-  );
-}
-function formatServerBlock(serverKey, entry) {
-  const lines = [
-    `[mcp_servers.${tomlKey(serverKey)}]`,
-    `command = ${tomlString(entry.command)}`,
-    `args = ${tomlArray(entry.args)}`
-  ];
-  if (entry.env && Object.keys(entry.env).length > 0) {
-    lines.push("", `[mcp_servers.${tomlKey(serverKey)}.env]`);
-    for (const [key, value] of Object.entries(entry.env).sort(
-      ([left], [right]) => left.localeCompare(right)
-    )) {
-      lines.push(`${key} = ${tomlString(value)}`);
-    }
-  }
-  return lines.join("\n");
-}
-function readEnvValue(block, key) {
-  return block.match(new RegExp(`^${escapeRegExp(key)}\\s*=\\s*"([^"]*)"`, "m"))?.[1] ?? null;
-}
-function tomlKey(key) {
-  return `"${key.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
-}
-function tomlString(value) {
-  return JSON.stringify(value);
-}
-function tomlArray(values) {
-  return `[${values.map(tomlString).join(", ")}]`;
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-// src/integrations/hermes-config.ts
-import { mkdir as mkdir7, readFile as readFile9 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname9, join as join10 } from "path";
-import { isDeepStrictEqual } from "util";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-function hermesConfigPath(home = homedir2()) {
-  return join10(process.env.HERMES_HOME ?? join10(home, ".hermes"), "config.yaml");
-}
-async function readRaw(path) {
-  try {
-    return await readFile9(path, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") return "";
-    throw error;
-  }
-}
-function parseConfig(raw) {
-  try {
-    const value = parseYaml(raw) ?? {};
-    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-  } catch {
-    return null;
-  }
-}
-function servers(config) {
-  const value = config.mcp_servers;
-  return value && typeof value === "object" ? value : {};
-}
-var isItem = (line) => line.trim() !== "" && !line.trim().startsWith("#");
-var indentOf = (line) => line.length - line.trimStart().length;
-function editMcpServers(raw, name, entry) {
-  const lines = raw.split("\n");
-  const header = lines.findIndex((line) => /^mcp_servers:\s*(#.*)?$/.test(line));
-  const render = (indent2) => stringifyYaml({ [name]: entry }).trimEnd().split("\n").map((line) => `${" ".repeat(indent2)}${line}`);
-  if (header === -1) {
-    if (entry === null) return raw;
-    const body = raw === "" || raw.endsWith("\n") ? raw : `${raw}
-`;
-    return `${body}mcp_servers:
-${render(2).join("\n")}
-`;
-  }
-  let end = header + 1;
-  while (end < lines.length && !/^\S/.test(lines[end] ?? "")) end++;
-  const block = Array.from({ length: end - header - 1 }, (_, i) => header + 1 + i);
-  const items = block.filter((i) => isItem(lines[i] ?? ""));
-  const indent = items.length > 0 ? indentOf(lines[items[0]] ?? "") : 2;
-  const quoted = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const keyLine = new RegExp(`^ {${indent}}(?:${quoted}|"${quoted}"|'${quoted}'):\\s*(#.*)?$`);
-  const start = items.find((i) => keyLine.test(lines[i] ?? ""));
-  if (start === void 0) {
-    if (entry === null) return raw;
-    const at = (items.at(-1) ?? header) + 1;
-    lines.splice(at, 0, ...render(indent));
-    return lines.join("\n");
-  }
-  const next = block.find(
-    (i) => i > start && (lines[i] ?? "").trim() !== "" && indentOf(lines[i] ?? "") <= indent
-  );
-  let stop = next ?? end;
-  while (stop > start + 1 && (lines[stop - 1] ?? "").trim() === "") stop--;
-  lines.splice(start, stop - start, ...entry === null ? [] : render(indent));
-  if (entry === null && items.length > 0 && items.every((i) => i >= start && i < stop)) {
-    lines.splice(header, 1);
-  }
-  return lines.join("\n");
-}
-async function setHermesMcpServer(path, name, entry) {
-  const raw = await readRaw(path);
-  const before = parseConfig(raw);
-  if (!before) return "manual";
-  const current = servers(before)[name];
-  if (entry === null ? current === void 0 : isDeepStrictEqual(current, entry)) {
-    return "unchanged";
-  }
-  const nextServers = { ...servers(before) };
-  if (entry === null) delete nextServers[name];
-  else nextServers[name] = entry;
-  const { mcp_servers: _, ...rest } = before;
-  const expected = Object.keys(nextServers).length > 0 ? { ...rest, mcp_servers: nextServers } : rest;
-  const next = editMcpServers(raw, name, entry);
-  if (!isDeepStrictEqual(parseConfig(next), expected)) return "manual";
-  await mkdir7(dirname9(path), { recursive: true });
-  await writeAtomic(path, next, { mode: 384 });
-  return entry === null ? "removed" : current === void 0 ? "created" : "updated";
-}
-async function readHermesConfig(path) {
-  return parseConfig(await readRaw(path));
-}
-async function hasHermesMcpServer(path, name) {
-  const config = await readHermesConfig(path);
-  return config !== null && name in servers(config);
-}
-
-// src/clients/global-mcp.ts
-function globalMcpPath(target) {
-  return target === "codex" ? codexConfigPath() : hermesConfigPath();
-}
-async function setGlobalMcp(target, options) {
-  const { name, root, namespace, enabled } = options;
-  if (target === "hermes") {
-    return setHermesMcpServer(
-      hermesConfigPath(),
-      name,
-      enabled ? codebuddyMcpServer(root, namespace) : null
-    );
-  }
-  if (!enabled) return (await removeCodexEntry(name)).removed ? "removed" : "unchanged";
-  const result = await installCodexEntry({
-    namespace,
-    projectRoot: root,
-    serverName: name,
-    toolProfile: "core"
-  });
-  return result.created ? "created" : result.changed ? "updated" : "unchanged";
-}
-async function hasGlobalMcp(target, name) {
-  if (target === "hermes") return hasHermesMcpServer(hermesConfigPath(), name);
-  return (await listCodexEntries()).entries.some((entry) => entry.key === name);
-}
-
-// src/clients/install.ts
-async function installClient(options) {
-  const adapter = CLIENT_ADAPTERS[options.client];
-  if (!supportedModes(adapter).includes(options.mode)) {
-    throw new Error(
-      `${adapter.name} does not support ${MODE_LABELS[options.mode]} mode: ${adapter.gap ?? "no lifecycle hooks"}.`
-    );
-  }
-  return apply(options, options.mode, options.mode !== "lean");
-}
-async function ensureIndex(root) {
-  const target = join11(root, ".codebuddy", "cache", "index.json");
-  const existed = await access3(target).then(
-    () => true,
-    () => false
-  );
-  if (!existed) await indexRepository({ repositoryRoot: root });
-  return { surface: "index", target, action: existed ? "unchanged" : "built" };
-}
-async function uninstallClient(options) {
-  return apply(options, "mcp-only", false);
-}
-async function apply(options, mode, keepMcp) {
-  const root = resolve9(options.projectRoot ?? process.cwd());
-  const adapter = CLIENT_ADAPTERS[options.client];
-  const steps = [];
-  const notes = [];
-  const namespace = options.namespace ?? await resolveNamespaceFrom(root);
-  const name = `codebuddy-${namespace}`;
-  const shared = sharedRulesReaders(options.client);
-  const liveSiblings = mode === "mcp-only" || mode === "lean" ? await installedWithMcp(root, shared, namespace) : [];
-  if (liveSiblings.length > 0) {
-    const path = join11(root, adapter.rulesFile);
-    steps.push({ surface: "rules", target: path, action: "kept" });
-    notes.push(
-      `Kept the CodeBuddy block in ${adapter.rulesFile}: still used by ${liveSiblings.map((id) => CLIENT_ADAPTERS[id].name).join(", ")}.`
-    );
-  } else {
-    const hooked = mode === "agent" ? await hookedRulesSiblings(root, options.client) : [];
-    const rules = await installWorkflowRules({
-      client: options.client,
-      projectRoot: root,
-      // Lean sends no rules: the block would cost tokens every turn and shadow AGENTS.md.
-      mode: mode === "lean" ? "mcp-only" : hooked.length > 0 ? "hooks" : mode
-    });
-    steps.push({ surface: "rules", target: rules.path, action: rules.action });
-    if (hooked.length > 0) {
-      notes.push(
-        `Kept ${adapter.rulesFile} hook-driven: ${hooked.map((id) => CLIENT_ADAPTERS[id].name).join(", ")} hooks are installed; agents without hooks follow its agent-driven fallback.`
-      );
-    }
-  }
-  if (shared.length > 0) {
-    notes.push(
-      `${adapter.rulesFile} is also read by ${shared.map((id) => CLIENT_ADAPTERS[id].name).join(", ")}.`
-    );
-  }
-  const hooks = await setHooks(
-    root,
-    mode === "hooks" || mode === "lean",
-    options.client,
-    mode === "lean" ? "lean" : "full"
-  );
-  if (hooks) steps.push(hooks);
-  if (mode === "lean") steps.push(await ensureIndex(root));
-  if ("file" in adapter.mcp) {
-    const path = await projectMcpPath(root, adapter.mcp.file, adapter.mcp.format);
-    const action = keepMcp ? await upsertMcpServer(path, adapter.mcp.format, name, codebuddyMcpServer(root, namespace)) : await removeMcpServer(path, adapter.mcp.format, name);
-    steps.push({ surface: "mcp", target: path, action });
-    if (action === "manual") {
-      notes.push(
-        `${path} has comments CodeBuddy will not rewrite; ${keepMcp ? "add" : "remove"} the "${name}" entry under "mcp" by hand${keepMcp ? `: ${JSON.stringify(formatEntry(adapter.mcp.format, codebuddyMcpServer(root, namespace)))}` : ""}.`
-      );
-    }
-  } else if (options.global) {
-    const target = globalMcpPath(adapter.mcp.global);
-    const action = await setGlobalMcp(adapter.mcp.global, {
-      name,
-      root,
-      namespace,
-      enabled: keepMcp
-    });
-    steps.push({ surface: "mcp", target, action });
-    if (action === "manual") {
-      notes.push(
-        `${target} is not a YAML map CodeBuddy can edit safely; ${keepMcp ? "add" : "remove"} the "${name}" entry under mcp_servers by hand.`
-      );
-    }
-  } else {
-    notes.push(
-      `MCP config is global; ${keepMcp ? "add" : "remove"} it with --global, or: ${adapter.mcp.manual}.`
-    );
-  }
-  if (adapter.note && mode !== "mcp-only") notes.push(`${adapter.name}: ${adapter.note}.`);
-  return { client: options.client, steps, notes };
-}
-async function installedWithMcp(root, clients, namespace) {
-  const live = [];
-  for (const id of clients) {
-    if ((await detectClient(id, root, namespace)).mcp) live.push(id);
-  }
-  return live;
-}
-async function setHooks(root, enabled, client = "claude", variant = "full") {
-  const result = await setClientHooks(root, client, enabled, variant);
-  if (!result) return null;
-  const action = result.changed ? enabled ? "installed" : "removed" : "unchanged";
-  return { surface: "hooks", target: result.target, action };
-}
-async function detectClient(client, projectRoot = process.cwd(), namespace) {
-  const root = resolve9(projectRoot);
-  const adapter = CLIENT_ADAPTERS[client];
-  const rulesMode = await readManagedMode(join11(root, adapter.rulesFile));
-  const hooks = await clientHooksInstalled(root, client);
-  const name = `codebuddy-${namespace ?? await resolveNamespaceFrom(root)}`;
-  const mcp = "file" in adapter.mcp ? await hasMcpServer(
-    await projectMcpPath(root, adapter.mcp.file, adapter.mcp.format),
-    adapter.mcp.format,
-    name
-  ) : await hasGlobalMcp(adapter.mcp.global, name).catch(() => false);
-  const warnings = [];
-  if (hooks && rulesMode === "agent") {
-    warnings.push(
-      `hooks are installed but ${adapter.rulesFile} is agent-driven: retrieval and capture run twice. Run \`codebuddy clients install ${client} --mode hooks\`.`
-    );
-  }
-  if (rulesMode === "hooks" && hooks === false) {
-    warnings.push(
-      `${adapter.rulesFile} is hook-driven but hooks are not installed: turns are not captured.`
-    );
-  }
-  const effectiveRules = hooks === null && rulesMode === "hooks" ? "agent" : rulesMode;
-  const mode = hooks ? await clientHooksVariant(root, client) === "lean" ? "lean" : "hooks" : effectiveRules ?? (mcp ? "mcp-only" : "none");
-  return { client, mode, rulesMode, hooks, mcp, warnings };
-}
-
 // src/clients/verify.ts
 import { execFile } from "child_process";
-import { readFile as readFile10, realpath } from "fs/promises";
-import { join as join12, resolve as resolve10 } from "path";
+import { readFile, realpath } from "fs/promises";
+import { join as join3, resolve as resolve3 } from "path";
 import { pathToFileURL } from "url";
 var runHost = (bin, args, cwd) => new Promise((done) => {
   execFile(
@@ -2185,9 +732,9 @@ var runHost = (bin, args, cwd) => new Promise((done) => {
     (error, stdout) => done({ ok: !error, stdout: String(stdout ?? "") })
   );
 });
-var pass = (name, detail) => ({ name, status: "pass", detail });
-var fail = (name, detail) => ({ name, status: "fail", detail });
-var skip = (name, detail) => ({ name, status: "skip", detail });
+var pass = (name2, detail) => ({ name: name2, status: "pass", detail });
+var fail = (name2, detail) => ({ name: name2, status: "fail", detail });
+var skip = (name2, detail) => ({ name: name2, status: "skip", detail });
 function json(text3) {
   try {
     return JSON.parse(text3);
@@ -2196,48 +743,48 @@ function json(text3) {
   }
 }
 var CONFORMANCE = {
-  claude: async ({ root, name, run }) => {
+  claude: async ({ root, name: name2, run }) => {
     const hooks = await clientHooksInstalled(root, "claude") ? pass("hooks", ".claude/settings.json has the CodeBuddy hooks") : skip("hooks", "not installed in this repo");
-    const mcp = await run("claude", ["mcp", "get", name], root);
+    const mcp = await run("claude", ["mcp", "get", name2], root);
     return [
       hooks,
-      mcp.ok ? pass("mcp", `claude mcp get ${name}: ${mcp.stdout.match(/Scope: (.+)/)?.[1] ?? "found"}`) : skip("mcp", `claude mcp get ${name}: not configured`)
+      mcp.ok ? pass("mcp", `claude mcp get ${name2}: ${mcp.stdout.match(/Scope: (.+)/)?.[1] ?? "found"}`) : skip("mcp", `claude mcp get ${name2}: not configured`)
     ];
   },
-  opencode: async ({ root, name, run }) => {
+  opencode: async ({ root, name: name2, run }) => {
     const result = await run("opencode", ["debug", "config"], root);
     const config = json(result.stdout);
     if (!config) return [fail("config", "opencode debug config returned no JSON")];
     const installed = await clientHooksInstalled(root, "opencode");
     const href = pathToFileURL(
-      join12(await realpath(root).catch(() => root), ".opencode", "plugins", "codebuddy.js")
+      join3(await realpath(root).catch(() => root), ".opencode", "plugins", "codebuddy.js")
     ).href;
     const loaded = config.plugin?.includes(href) === true;
     return [
       installed ? loaded ? pass("plugin", "opencode debug config loads .opencode/plugins/codebuddy.js") : fail("plugin", "plugin file is installed but opencode does not load it") : skip("plugin", "not installed in this repo"),
-      config.mcp?.[name] ? pass("mcp", `opencode resolves the ${name} MCP entry`) : skip("mcp", `no ${name} entry in the resolved config`)
+      config.mcp?.[name2] ? pass("mcp", `opencode resolves the ${name2} MCP entry`) : skip("mcp", `no ${name2} entry in the resolved config`)
     ];
   },
-  codex: async ({ root, name, run }) => {
+  codex: async ({ root, name: name2, run }) => {
     const result = await run("codex", ["mcp", "list", "--json"], root);
-    const servers2 = json(result.stdout);
-    if (!Array.isArray(servers2)) return [fail("mcp", "codex mcp list --json returned no JSON")];
+    const servers = json(result.stdout);
+    if (!Array.isArray(servers)) return [fail("mcp", "codex mcp list --json returned no JSON")];
     return [
-      servers2.some((server) => server.name === name) ? pass("mcp", `codex mcp list has ${name}`) : skip("mcp", `no ${name} entry (clients install codex --global adds it)`)
+      servers.some((server) => server.name === name2) ? pass("mcp", `codex mcp list has ${name2}`) : skip("mcp", `no ${name2} entry (clients install codex --global adds it)`)
     ];
   },
-  hermes: async ({ root, name, run, env }) => {
+  hermes: async ({ root, name: name2, run, env }) => {
     const checks = [];
     const listed = await run("hermes", ["mcp", "list"], root);
     checks.push(
-      listed.ok && listed.stdout.includes(name) ? pass("mcp", `hermes mcp list has ${name}`) : skip("mcp", `no ${name} entry (clients install hermes --global adds it)`)
+      listed.ok && listed.stdout.includes(name2) ? pass("mcp", `hermes mcp list has ${name2}`) : skip("mcp", `no ${name2} entry (clients install hermes --global adds it)`)
     );
     if (!await hermesPluginInstalled(root)) {
       checks.push(skip("plugin", "not installed in this repo"));
       return checks;
     }
     const projectPlugins = /^(1|true|yes|on)$/i.test(env.HERMES_ENABLE_PROJECT_PLUGINS ?? "") || /^\s*HERMES_ENABLE_PROJECT_PLUGINS\s*=\s*["']?(1|true|yes|on)/im.test(
-      await readFile10(join12(hermesConfigPath(), "..", ".env"), "utf8").catch(() => "")
+      await readFile(join3(hermesConfigPath(), "..", ".env"), "utf8").catch(() => "")
     );
     const plugins = (await readHermesConfig(hermesConfigPath()))?.plugins;
     const enabled = Array.isArray(plugins?.enabled) && plugins.enabled.includes("codebuddy");
@@ -2249,7 +796,7 @@ var CONFORMANCE = {
   }
 };
 async function verifyClient(client, options = {}) {
-  const root = resolve10(options.root ?? process.cwd());
+  const root = resolve3(options.root ?? process.cwd());
   const run = options.run ?? runHost;
   const adapter = CLIENT_ADAPTERS[client];
   const version = await run(adapter.host.bin, ["--version"], root);
@@ -2268,9 +815,9 @@ async function verifyClient(client, options = {}) {
       checks: [skip("host", `${adapter.host.bin} not found or printed no version`)]
     };
   }
-  const name = `codebuddy-${options.namespace ?? await resolveNamespaceFrom(root)}`;
+  const name2 = `codebuddy-${options.namespace ?? await resolveNamespaceFrom(root)}`;
   const conformance = CONFORMANCE[client];
-  const checks = conformance ? await conformance({ root, name, run, env: options.env ?? process.env }).catch(
+  const checks = conformance ? await conformance({ root, name: name2, run, env: options.env ?? process.env }).catch(
     (error) => [fail("conformance", error.message)]
   ) : [];
   return {
@@ -2653,7 +1200,7 @@ th.n { text-align: right; }
 .chip { display: inline-block; font: 600 10px var(--mono); text-transform: uppercase; letter-spacing: .06em; padding: 2px 6px; border-radius: 4px; }
 .chip.recall { background: var(--recall-soft); color: var(--recall); }
 .chip.tool { background: var(--tool-soft); color: var(--tool); }
-.chip.capture, .chip.sync, .chip.guard, .chip.kw { background: var(--line); color: var(--capture); }
+.chip.capture, .chip.sync, .chip.guard, .chip.cli, .chip.kw { background: var(--line); color: var(--capture); }
 .chip.err { background: var(--bad-soft); color: var(--bad); }
 .feed { display: grid; gap: 10px; max-height: 520px; overflow: auto; }
 .prompt { border: 1px solid var(--line); border-radius: 8px; padding: 10px 12px; }
@@ -3008,12 +1555,12 @@ data: ${data}
   heartbeat.unref();
   return {
     url: `http://127.0.0.1:${port}/`,
-    close: () => new Promise((resolve13) => {
+    close: () => new Promise((resolve6) => {
       clearInterval(heartbeat);
       unwatchFile(path);
       for (const client of clients) client.end();
       server.closeAllConnections();
-      server.close(() => resolve13());
+      server.close(() => resolve6());
     })
   };
 }
@@ -3021,11 +1568,11 @@ async function listen(server, port) {
   for (let attempt = 0; attempt < 10; attempt += 1) {
     const candidate = port === 0 ? 0 : port + attempt;
     try {
-      await new Promise((resolve13, reject) => {
+      await new Promise((resolve6, reject) => {
         server.once("error", reject);
         server.listen(candidate, "127.0.0.1", () => {
           server.off("error", reject);
-          resolve13();
+          resolve6();
         });
       });
       return server.address().port;
@@ -3063,8 +1610,8 @@ function registerDashboardCommand(program, runSafely2) {
       );
       console.log(pc4.dim("  Ctrl+C to stop."));
       if (opts.open) openBrowser(dashboard.url);
-      await new Promise((resolve13) => {
-        const stop = () => void dashboard.close().then(resolve13);
+      await new Promise((resolve6) => {
+        const stop = () => void dashboard.close().then(resolve6);
         process.once("SIGINT", stop);
         process.once("SIGTERM", stop);
       });
@@ -3076,20 +1623,20 @@ function registerDashboardCommand(program, runSafely2) {
 import pc5 from "picocolors";
 
 // src/eval/runner.ts
-import { readFile as readFile11 } from "fs/promises";
-import { dirname as dirname10, isAbsolute, join as join13, resolve as resolve11 } from "path";
+import { readFile as readFile2 } from "fs/promises";
+import { dirname as dirname2, isAbsolute, join as join4, resolve as resolve4 } from "path";
 async function runEvaluation(input = {}) {
-  const datasetPath = resolve11(
-    input.datasetPath ?? join13(process.cwd(), "evals", "change-readiness.json")
+  const datasetPath = resolve4(
+    input.datasetPath ?? join4(process.cwd(), "evals", "change-readiness.json")
   );
-  const dataset = JSON.parse(await readFile11(datasetPath, "utf8"));
+  const dataset = JSON.parse(await readFile2(datasetPath, "utf8"));
   if (dataset.version !== 1 || !Array.isArray(dataset.cases)) {
     throw new Error(`Unsupported evaluation dataset: ${datasetPath}`);
   }
-  const datasetDirectory = dirname10(datasetPath);
+  const datasetDirectory = dirname2(datasetPath);
   const results = await Promise.all(
     dataset.cases.map(async (evaluationCase) => {
-      const fixtureRoot = isAbsolute(evaluationCase.fixture) ? evaluationCase.fixture : resolve11(input.repositoryRoot ?? datasetDirectory, evaluationCase.fixture);
+      const fixtureRoot = isAbsolute(evaluationCase.fixture) ? evaluationCase.fixture : resolve4(input.repositoryRoot ?? datasetDirectory, evaluationCase.fixture);
       const report = await buildChangeReport({
         repositoryRoot: fixtureRoot,
         namespace: `eval:${evaluationCase.id}`,
@@ -3253,6 +1800,7 @@ function registerHooksCommands(program, runSafely2) {
         );
         if (result.saved.length > 0) syncInBackground(hookRoot(input.cwd));
       }
+      await flushTelemetry(hookRoot(input.cwd));
     });
   });
   hooks.command("sync").description(
@@ -3373,7 +1921,7 @@ async function llmStatusReport(root, env = process.env) {
   };
 }
 function formatLlmStatus(report) {
-  const features = report.features ? Object.entries(report.features).map(([name, on]) => `${name} ${on ? "on" : "off"}`).join(", ") : "-";
+  const features = report.features ? Object.entries(report.features).map(([name2, on]) => `${name2} ${on ? "on" : "off"}`).join(", ") : "-";
   return [
     `status:     ${report.enabled ? "on" : `off (${report.reason})`}`,
     `provider:   ${report.provider}${report.model ? ` ${report.model}` : ""}`,
@@ -3579,7 +2127,7 @@ async function runInitWizard() {
           if (result.code === 0) {
             dockerSpinner.stop("Postgres container started.");
             for (let attempt = 0; attempt < 10 && !connected; attempt++) {
-              await new Promise((resolve13) => setTimeout(resolve13, 500));
+              await new Promise((resolve6) => setTimeout(resolve6, 500));
               connected = await pingOnce(databaseUrl);
             }
             if (!connected) {
@@ -3871,8 +2419,8 @@ function openEditor(path) {
 }
 
 // src/cli/commands/models.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join14 } from "path";
+import { existsSync } from "fs";
+import { join as join5 } from "path";
 import { spinner as spinner2 } from "@clack/prompts";
 import pc13 from "picocolors";
 
@@ -4157,8 +2705,8 @@ function keyPresent(provider, apiKey) {
   return Boolean(process.env[KEY_ENV2[provider]] || provider === "huggingface" && apiKey);
 }
 function localModelDownloaded(id, revision) {
-  const dir = join14(modelCacheDir(), id, ...revision ? [revision] : []);
-  return existsSync3(join14(dir, "onnx", "model_quantized.onnx"));
+  const dir = join5(modelCacheDir(), id, ...revision ? [revision] : []);
+  return existsSync(join5(dir, "onnx", "model_quantized.onnx"));
 }
 async function vectorCounts(postgresUrl, namespace, space) {
   const client = createDatabaseClient({ postgresUrl, maxConnections: 1, connectTimeoutSeconds: 3 });
@@ -4501,14 +3049,14 @@ function renderPlan(plan) {
 }
 function openEditor2(path) {
   const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
-  return new Promise((resolve13, reject) => {
+  return new Promise((resolve6, reject) => {
     const child = spawn5(editor, [path], { stdio: "inherit" });
     child.on("error", reject);
-    child.on("close", () => resolve13());
+    child.on("close", () => resolve6());
   });
 }
 function runGit(args) {
-  return new Promise((resolve13, reject) => {
+  return new Promise((resolve6, reject) => {
     const child = spawn5("git", args, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -4519,7 +3067,7 @@ function runGit(args) {
       stderr += String(c);
     });
     child.on("error", reject);
-    child.on("close", (code) => resolve13({ code: code ?? 0, stdout, stderr }));
+    child.on("close", (code) => resolve6({ code: code ?? 0, stdout, stderr }));
   });
 }
 function registerPlanCommands(program, runSafely2) {
@@ -4720,147 +3268,1239 @@ async function resolveMode(client, value) {
     if (!supportedModes(CLIENT_ADAPTERS[client]).includes(mode)) {
       throw new Error(`${clientDisplayName(client)} does not support --mode ${mode}.`);
     }
-    return mode;
-  }
-  return defaultRulesMode(client);
-}
-function registerRulesCommands(program, runSafely2) {
-  const rules = program.command("rules").description("Print or install the client workflow templates (CLAUDE.md / AGENTS.md).");
-  rules.command("show").option("--client <client>", `One of: ${WORKFLOW_CLIENTS.join(", ")}.`, "claude").option("--mode <mode>", "agent or hooks (default: follows installed hooks).").description("Print the workflow template for a client.").action(async (opts) => {
-    await runSafely2(async () => {
-      const client = parseClient(opts.client);
-      const mode = await resolveMode(client, opts.mode);
-      if (mode === "mcp-only") {
-        console.log("MCP-only mode installs no workflow rules.");
-        return;
-      }
-      console.log(renderWorkflowTemplate(client, mode));
-    });
+    return mode;
+  }
+  return defaultRulesMode(client);
+}
+function registerRulesCommands(program, runSafely2) {
+  const rules = program.command("rules").description("Print or install the client workflow templates (CLAUDE.md / AGENTS.md).");
+  rules.command("show").option("--client <client>", `One of: ${WORKFLOW_CLIENTS.join(", ")}.`, "claude").option("--mode <mode>", "agent or hooks (default: follows installed hooks).").description("Print the workflow template for a client.").action(async (opts) => {
+    await runSafely2(async () => {
+      const client = parseClient(opts.client);
+      const mode = await resolveMode(client, opts.mode);
+      if (mode === "mcp-only") {
+        console.log("MCP-only mode installs no workflow rules.");
+        return;
+      }
+      console.log(renderWorkflowTemplate(client, mode));
+    });
+  });
+  rules.command("install").option("--client <client>", `One of: ${WORKFLOW_CLIENTS.join(", ")}.`, "claude").option("--path <file>", "Override the target rules file.").option(
+    "--mode <mode>",
+    `One of: ${AUTOMATION_MODES.join(", ")} (default: follows installed hooks; mcp-only removes the block).`
+  ).description("Install/update the workflow template in the client's rules file (managed block).").action(async (opts) => {
+    await runSafely2(async () => {
+      const client = parseClient(opts.client);
+      const result = await installWorkflowRules({
+        client,
+        mode: await resolveMode(client, opts.mode),
+        ...opts.path ? { targetPath: opts.path } : {}
+      });
+      const where = relative5(process.cwd(), result.path) || result.path;
+      console.log(
+        `${actionLabel(result.action)} ${clientDisplayName(client)} workflow in ${where}`
+      );
+      if (result.action !== "unchanged") {
+        console.log(pc16.dim("  managed block between codebuddy:workflow markers; safe to re-run"));
+      }
+    });
+  });
+}
+function actionLabel(action) {
+  switch (action) {
+    case "created":
+      return pc16.green("created");
+    case "added":
+      return pc16.green("added");
+    case "updated":
+      return pc16.cyan("updated");
+    case "removed":
+      return pc16.yellow("removed");
+    default:
+      return pc16.dim("unchanged");
+  }
+}
+
+// src/cli/commands/suggest.ts
+import pc17 from "picocolors";
+function parsePaths4(value) {
+  return value.split(",").map((path) => path.trim()).filter(Boolean);
+}
+function registerSuggestCommand(program, runSafely2) {
+  program.command("suggest").option("--paths <paths>", "Comma-separated repo-relative paths to review.").option("--plan <id>", "Review the files listed in a plan.").option("--git", "Review current git changes.").option("--limit <n>", "Maximum suggestions to show.", Number).option("--json", "Print machine-readable JSON.").description("Suggest evidence-backed, read-only code-quality improvements.").action(
+    async (opts) => {
+      await runSafely2(async () => {
+        const namespace = await resolveNamespaceFrom();
+        const result = await generateSuggestions({
+          namespace,
+          ...opts.paths ? { paths: parsePaths4(opts.paths) } : {},
+          ...opts.plan ? { planId: opts.plan } : {},
+          ...opts.git !== void 0 ? { useGit: opts.git } : {},
+          ...opts.limit !== void 0 ? { limit: opts.limit } : {}
+        });
+        if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+        printSuggestions(result.suggestions);
+        console.log(
+          pc17.dim(
+            `
+${result.stats.produced} suggestion(s) across ${result.stats.pathsConsidered} path(s)`
+          )
+        );
+      });
+    }
+  );
+}
+function printSuggestions(suggestions) {
+  if (suggestions.length === 0) {
+    console.log(pc17.dim("no suggestions \u2014 nothing high-signal to report"));
+    return;
+  }
+  for (const suggestion of suggestions) {
+    console.log(`${severityBadge2(suggestion.severity)} ${pc17.bold(suggestion.title)}`);
+    console.log(`  ${suggestion.detail}`);
+    for (const evidence of suggestion.evidence) {
+      console.log(pc17.dim(`  \u21B3 ${evidence.kind}: ${evidence.detail}`));
+    }
+    if (suggestion.commandHint) console.log(pc17.dim(`  \u2192 ${suggestion.commandHint}`));
+  }
+}
+function severityBadge2(severity) {
+  switch (severity) {
+    case "high":
+      return pc17.red("[high]");
+    case "medium":
+      return pc17.yellow("[med ]");
+    case "low":
+      return pc17.cyan("[low ]");
+    default:
+      return pc17.dim("[info]");
+  }
+}
+
+// src/cli/commands/symbols.ts
+import { readFile as readFile3 } from "fs/promises";
+import { resolve as resolve5 } from "path";
+import pc18 from "picocolors";
+function registerSymbolsCommand(program, runSafely2) {
+  program.command("symbols").argument("<path>", "Repo-relative or absolute path to a code file.").option("--json", "Print machine-readable JSON.").description("List a file's top-level symbols (functions, classes, types, exports).").action(async (path, opts) => {
+    await runSafely2(async () => {
+      if (!supportsSymbols(path)) {
+        console.log(pc18.dim(`no symbol extraction for ${path} (unsupported language)`));
+        return;
+      }
+      const content = await readFile3(resolve5(path), "utf8");
+      const table = extractSymbolTable(content, path);
+      if (opts.json) {
+        console.log(JSON.stringify({ path, symbols: table }, null, 2));
+        return;
+      }
+      if (table.length === 0) {
+        console.log(pc18.dim("no top-level symbols found"));
+        return;
+      }
+      for (const symbol of table) {
+        const badge = symbol.exported ? pc18.green("export") : pc18.dim("local ");
+        console.log(
+          `${badge} ${pc18.cyan(symbol.kind.padEnd(9))} ${pc18.bold(symbol.name)} ${pc18.dim(`L${symbol.startLine}-${symbol.endLine}`)}`
+        );
+      }
+      console.log(pc18.dim(`
+${table.length} symbol(s)`));
+    });
+  });
+}
+
+// src/cli/commands/telemetry.ts
+import pc19 from "picocolors";
+
+// src/telemetry/collector.ts
+import { createHash, timingSafeEqual } from "crypto";
+import { appendFile, mkdir as mkdir2, readdir, readFile as readFile4 } from "fs/promises";
+import { createServer as createServer2 } from "http";
+import { join as join6 } from "path";
+import { z as z2 } from "zod";
+
+// src/telemetry/admin-page.ts
+var ADMIN_HTML = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>CodeBuddy Usage</title>
+<style>
+:root {
+  --bg: #f4f4f2; --panel: #fcfcfb; --fg: #0b0b0b; --muted: #52514e; --faint: #8a8984; --line: #e4e3de;
+  --bar: #2a78d6; --bar-soft: #e3edfa; --hook: #eb6834; --cli: #1baf7a;
+  --good: #0a7d0a; --bad: #c23030; --bad-soft: #fbeaea;
+  --sans: ui-sans-serif, -apple-system, "Segoe UI", Roboto, sans-serif;
+  --mono: ui-monospace, "SF Mono", Menlo, Consolas, monospace;
+}
+@media (prefers-color-scheme: dark) { :root {
+  --bg: #111110; --panel: #1a1a19; --fg: #f0efec; --muted: #c3c2b7; --faint: #8f8e86; --line: #2e2e2b;
+  --bar: #3987e5; --bar-soft: #1d2b3d; --hook: #d95926; --cli: #199e70;
+  --good: #3fbf3f; --bad: #f07070; --bad-soft: #3a1a1a; color-scheme: dark } }
+* { box-sizing: border-box; }
+body { margin: 0; background: var(--bg); color: var(--fg); font: 14px/1.5 var(--sans); }
+a { color: inherit; }
+.wrap { max-width: 1240px; margin: 0 auto; padding: 0 16px 56px; display: grid; gap: 16px; }
+.wrap > * { min-width: 0; }
+.top { position: sticky; top: 0; z-index: 5; background: color-mix(in srgb, var(--bg) 88%, transparent); backdrop-filter: blur(8px); border-bottom: 1px solid var(--line); }
+.bar-inner { max-width: 1240px; margin: 0 auto; padding: 12px 16px; display: flex; flex-wrap: wrap; align-items: center; gap: 10px 18px; }
+.brand { display: flex; align-items: center; gap: 10px; font-weight: 650; font-size: 16px; letter-spacing: -.01em; }
+.mark { width: 22px; height: 22px; border-radius: 6px; background: var(--bar); display: grid; place-items: center; color: #fff; font: 700 12px var(--mono); }
+.updated { font: 12px var(--mono); color: var(--faint); }
+.tabs { display: flex; gap: 4px; }
+.tabs a { text-decoration: none; color: var(--muted); font-weight: 500; font-size: 13px; padding: 6px 10px; border-radius: 7px; }
+.tabs a[aria-current="page"] { background: var(--panel); color: var(--fg); box-shadow: inset 0 0 0 1px var(--line); }
+.tabs a:focus-visible, .seg button:focus-visible, .btn:focus-visible, input:focus-visible, th button:focus-visible, tr.link:focus-visible { outline: 2px solid var(--bar); outline-offset: 1px; }
+.spacer { flex: 1; }
+.seg { display: inline-flex; border: 1px solid var(--line); border-radius: 8px; overflow: hidden; background: var(--panel); }
+.seg button { border: 0; background: none; color: var(--muted); font: 500 12px var(--sans); padding: 6px 11px; cursor: pointer; }
+.seg button + button { border-left: 1px solid var(--line); }
+.seg button[aria-pressed="true"] { background: var(--fg); color: var(--bg); }
+h2 { font-size: 12px; margin: 0; text-transform: uppercase; letter-spacing: .08em; color: var(--muted); font-weight: 600; }
+.head { display: flex; align-items: baseline; flex-wrap: wrap; gap: 6px 12px; margin-bottom: 12px; }
+.head .note { font-size: 12px; color: var(--faint); }
+.hero { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(190px, 100%), 1fr)); gap: 12px; padding-top: 16px; }
+.kpi { background: var(--panel); border: 1px solid var(--line); border-radius: 12px; padding: 14px 16px; }
+.kpi .label { font-size: 12px; color: var(--muted); }
+.kpi .value { font: 650 32px/1.15 var(--mono); font-variant-numeric: tabular-nums; margin-top: 6px; letter-spacing: -.02em; }
+.kpi .sub { font-size: 12px; color: var(--muted); margin-top: 4px; }
+.up { color: var(--good); font-weight: 600; }
+.down { color: var(--bad); font-weight: 600; }
+.panel { background: var(--panel); border: 1px solid var(--line); border-radius: 12px; padding: 16px; min-width: 0; }
+.grid2 { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(340px, 100%), 1fr)); gap: 16px; }
+.grid3 { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(260px, 100%), 1fr)); gap: 16px; }
+.chart svg { display: block; width: 100%; height: 190px; overflow: visible; }
+svg text { fill: var(--faint); font: 11px var(--mono); }
+.hit { fill: transparent; cursor: crosshair; }
+.hit:hover { fill: color-mix(in srgb, var(--fg) 6%, transparent); }
+.tip { position: absolute; pointer-events: none; background: var(--fg); color: var(--bg); font: 12px var(--mono); padding: 5px 8px; border-radius: 6px; white-space: nowrap; display: none; z-index: 10; }
+.rows { display: grid; gap: 8px; }
+.row { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 3px 12px; font-size: 13px; }
+.row .track { grid-column: 1 / -1; height: 8px; background: var(--bar-soft); border-radius: 4px; overflow: hidden; }
+.row .fill { height: 8px; background: var(--bar); border-radius: 4px; }
+.row .n { font-family: var(--mono); font-variant-numeric: tabular-nums; color: var(--muted); }
+.funnel .row { font-size: 14px; }
+.funnel .track { height: 22px; border-radius: 6px; }
+.funnel .fill { height: 22px; border-radius: 6px; }
+.scroll { overflow-x: auto; }
+table { width: 100%; border-collapse: collapse; font-size: 13px; }
+th { text-align: left; font: 600 11px var(--sans); text-transform: uppercase; letter-spacing: .06em; color: var(--muted); padding: 6px 8px; border-bottom: 1px solid var(--line); white-space: nowrap; }
+th button { all: unset; cursor: pointer; }
+th button::after { content: attr(data-dir); margin-left: 4px; color: var(--faint); }
+td { padding: 7px 8px; border-bottom: 1px solid var(--line); white-space: nowrap; }
+tr:last-child td { border-bottom: 0; }
+td.n, th.n { text-align: right; font-family: var(--mono); font-variant-numeric: tabular-nums; }
+tr.link { cursor: pointer; }
+tr.link:hover td { background: var(--bar-soft); }
+.inline { display: inline-block; height: 6px; background: var(--bar); border-radius: 3px; vertical-align: middle; margin-left: 8px; }
+.heat td { text-align: center; font: 12px var(--mono); padding: 6px 4px; border: 2px solid var(--panel); border-radius: 6px; min-width: 44px; }
+.heat td.lab { text-align: left; color: var(--muted); font-family: var(--sans); white-space: nowrap; }
+.heat td.empty { background: transparent; color: var(--faint); }
+.bad { color: var(--bad); }
+.muted { color: var(--muted); }
+.mono { font-family: var(--mono); }
+.empty-state { padding: 36px 16px; text-align: center; color: var(--muted); }
+.toolbar { display: flex; flex-wrap: wrap; gap: 10px; align-items: center; margin-bottom: 12px; }
+input[type="search"] { font: 13px var(--sans); padding: 7px 10px; border: 1px solid var(--line); border-radius: 8px; background: var(--bg); color: var(--fg); min-width: 0; flex: 1 1 200px; }
+.btn { border: 1px solid var(--line); background: var(--panel); color: var(--fg); font: 500 12px var(--sans); padding: 7px 12px; border-radius: 8px; cursor: pointer; text-decoration: none; }
+.chips { display: flex; flex-wrap: wrap; gap: 6px; }
+.chip { display: inline-flex; align-items: center; gap: 6px; font: 600 11px var(--mono); padding: 2px 8px; border-radius: 999px; background: var(--bar-soft); color: var(--fg); }
+.sw { width: 10px; height: 10px; border-radius: 3px; display: inline-block; }
+.sessions { display: grid; gap: 6px; max-height: 520px; overflow: auto; }
+.session { all: unset; display: grid; gap: 2px; padding: 8px 10px; border: 1px solid var(--line); border-radius: 8px; cursor: pointer; font-size: 12px; }
+.session[aria-pressed="true"] { border-color: var(--bar); box-shadow: inset 3px 0 0 var(--bar); }
+.session:focus-visible { outline: 2px solid var(--bar); }
+.split { display: grid; grid-template-columns: minmax(220px, 300px) minmax(0, 1fr); gap: 16px; }
+@media (max-width: 820px) { .split { grid-template-columns: 1fr; } .wf .step { grid-template-columns: 120px 52px minmax(0, 1fr) 56px; } }
+.wf { display: grid; gap: 3px; font-size: 12px; }
+.wf .step { display: grid; grid-template-columns: 170px 64px minmax(0, 1fr) 70px; gap: 10px; align-items: center; }
+.wf .lane { position: relative; height: 14px; background: var(--bg); border-radius: 3px; }
+.wf .seg-bar { position: absolute; top: 2px; height: 10px; min-width: 3px; border-radius: 3px; }
+.wf .name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-family: var(--mono); }
+.wf .at { font-family: var(--mono); color: var(--faint); text-align: right; }
+.wf .t { text-align: right; font-family: var(--mono); color: var(--muted); }
+.legend { display: flex; gap: 14px; font-size: 12px; color: var(--muted); margin-bottom: 10px; flex-wrap: wrap; }
+.legend span { display: inline-flex; align-items: center; gap: 6px; }
+footer { font-size: 12px; color: var(--faint); }
+[hidden] { display: none !important; }
+</style>
+</head>
+<body>
+<div class="top"><div class="bar-inner">
+  <div class="brand"><span class="mark">cb</span>CodeBuddy usage</div>
+  <nav class="tabs" aria-label="Views">
+    <a href="#overview" data-view="overview">Overview</a>
+    <a href="#users" data-view="users">Users</a>
+    <a href="#events" data-view="events">Events</a>
+  </nav>
+  <span class="spacer"></span>
+  <span class="updated" id="updated">loading\u2026</span>
+  <div class="seg" role="group" aria-label="Time range" id="range">
+    <button data-days="7">7d</button><button data-days="30" aria-pressed="true">30d</button><button data-days="90">90d</button><button data-days="365">1y</button>
+  </div>
+</div></div>
+
+<div class="wrap">
+  <section id="view-overview">
+    <div class="hero" id="hero" aria-label="Headline numbers"></div>
+    <div class="grid2" style="margin-top:16px">
+      <section class="panel"><div class="head"><h2>Total installs</h2><span class="note">all-time, by first-seen day</span></div><div class="chart" id="cumulative"></div></section>
+      <section class="panel"><div class="head"><h2>Daily active installs</h2><span class="note">installs that sent any event</span></div><div class="chart" id="active"></div></section>
+    </div>
+    <div class="grid2" style="margin-top:16px">
+      <section class="panel"><div class="head"><h2>Activation</h2><span class="note">installs active in range reaching each step</span></div><div class="rows funnel" id="funnel"></div></section>
+      <section class="panel"><div class="head"><h2>Retention by weekly cohort</h2><span class="note">share of each week's new installs active in later weeks</span></div><div class="scroll" id="cohorts"></div></section>
+    </div>
+    <section class="panel" style="margin-top:16px"><div class="head"><h2>Feature usage</h2><span class="note">MCP tools, hook steps (recall, capture\u2026) and CLI commands</span></div><div class="scroll" id="features"></div></section>
+    <div class="grid3" style="margin-top:16px">
+      <section class="panel"><div class="head"><h2>Agent clients</h2></div><div class="rows" id="clients"></div></section>
+      <section class="panel"><div class="head"><h2>Versions</h2></div><div class="rows" id="versions"></div></section>
+      <section class="panel"><div class="head"><h2>Platforms</h2></div><div class="rows" id="platforms"></div></section>
+    </div>
+    <section class="panel" style="margin-top:16px"><div class="head"><h2>npm downloads per day</h2><span class="note" id="npmNote"></span></div><div class="chart" id="npm"></div></section>
+  </section>
+
+  <section id="view-users" class="panel" style="margin-top:16px" hidden>
+    <div class="toolbar">
+      <h2>Users</h2><span class="muted" id="userCount" style="font-size:12px"></span><span class="spacer"></span>
+      <input type="search" id="userSearch" placeholder="Filter by id, client, version, platform\u2026" aria-label="Filter users">
+      <button class="btn" id="csv">Download CSV</button>
+    </div>
+    <div class="scroll" id="users"></div>
+  </section>
+
+  <section id="view-install" style="margin-top:16px" hidden></section>
+
+  <section id="view-events" class="panel" style="margin-top:16px" hidden>
+    <div class="toolbar"><h2>Latest events</h2><span class="spacer"></span><div class="chips" id="kindFilter"></div></div>
+    <div class="scroll" id="recent"></div>
+  </section>
+
+  <footer>Anonymous telemetry from installs that did not opt out: random install ids, tool and command names, timings, versions. No prompts, code, paths or repository names are collected. Shares count each install once, from its latest batch.</footer>
+</div>
+<div class="tip" id="tip" role="status"></div>
+<script>
+(function () {
+  var days = 30;
+  var summary = null, npm = null, install = null;
+  var userSort = { key: "lastSeen", dir: -1 };
+  var kindShown = "all";
+  var selectedSession = null;
+  var path = location.pathname;
+  var base = path.charAt(path.length - 1) === "/" ? path : path + "/";
+  var tip = document.getElementById("tip");
+  var NL = String.fromCharCode(10);
+  var KIND_COLOR = { tool: "var(--bar)", cli: "var(--cli)" };
+  function kindColor(kind) { return KIND_COLOR[kind] || "var(--hook)"; }
+  function kindGroup(kind) { return kind === "tool" ? "MCP tool" : kind === "cli" ? "CLI command" : "hook step"; }
+
+  function $(id) { return document.getElementById(id); }
+  function esc(value) {
+    return String(value == null ? "" : value).replace(/[&<>"']/g, function (c) {
+      return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c];
+    });
+  }
+  function num(n) { return Math.round(n).toLocaleString(); }
+  function compact(n) { return n >= 1e6 ? (n / 1e6).toFixed(1) + "M" : n >= 1e4 ? (n / 1e3).toFixed(1) + "k" : num(n); }
+  function pct(n) { return (n * 100).toFixed(n > 0 && n < 0.1 ? 1 : 0) + "%"; }
+  function plural(n, word) { return num(n) + " " + word + (n === 1 ? "" : "s"); }
+  function offset(n) { var s = Math.round(n / 1000); return "+" + (s >= 60 ? Math.floor(s / 60) + "m " + (s % 60) + "s" : s + "s"); }
+  function ms(n) { return n >= 60000 ? (n / 60000).toFixed(1) + " min" : n >= 1000 ? (n / 1000).toFixed(1) + " s" : Math.round(n) + " ms"; }
+  function date(iso) { return new Date(iso).toLocaleDateString(undefined, { month: "short", day: "numeric" }); }
+  function ago(iso) {
+    var s = Math.max(0, (Date.now() - Date.parse(iso)) / 1000);
+    return s < 60 ? "just now" : s < 3600 ? Math.floor(s / 60) + "m ago" : s < 86400 ? Math.floor(s / 3600) + "h ago" : Math.floor(s / 86400) + "d ago";
+  }
+  function get(url) { return fetch(base + url).then(function (r) { return r.ok ? r.json() : null; }); }
+
+  function kpi(label, value, sub) {
+    return '<div class="kpi"><div class="label">' + esc(label) + '</div><div class="value">' + esc(value) + '</div><div class="sub">' + (sub || "") + "</div></div>";
+  }
+  function delta(now, before) {
+    if (!before) return now ? '<span class="up">\u25B2 new</span> vs previous 7 days' : "no activity yet";
+    var change = (now - before) / before;
+    return '<span class="' + (change >= 0 ? "up" : "down") + '">' + (change >= 0 ? "\u25B2 " : "\u25BC ") + pct(Math.abs(change)) + "</span> vs previous 7 days";
+  }
+
+  /** Bars or a filled line over days, one measure; every point has a hover target. */
+  /** Draw into a container at its own pixel width, so labels never stretch. */
+  function draw(id, points, label, line) {
+    var el = $(id);
+    if (el) el.innerHTML = chart(points, label, line, el.clientWidth);
+  }
+  function chart(points, label, line, width) {
+    if (!points.length) return '<div class="empty-state">No data yet.</div>';
+    var w = Math.max(280, width || 640), h = 190, top = 10, bottom = 22, left = 40, plot = h - top - bottom;
+    var max = Math.max.apply(null, points.map(function (p) { return p.value; }).concat([1]));
+    var step = (w - left) / points.length;
+    var y = function (v) { return top + plot * (1 - v / max); };
+    var out = '<svg viewBox="0 0 ' + w + " " + h + '" preserveAspectRatio="none" role="img" aria-label="' + esc(label) + '">';
+    [0, 0.5, 1].forEach(function (f) {
+      out += '<line x1="' + left + '" x2="' + w + '" y1="' + y(max * f) + '" y2="' + y(max * f) + '" stroke="var(--line)"/>';
+      out += '<text x="' + (left - 6) + '" y="' + (y(max * f) + 4) + '" text-anchor="end">' + esc(compact(max * f)) + "</text>";
+    });
+    if (line) {
+      var pts = points.map(function (p, i) { return (left + i * step + step / 2).toFixed(1) + "," + y(p.value).toFixed(1); });
+      out += '<path d="M' + (left + step / 2) + "," + (top + plot) + " L" + pts.join(" L") + " L" + (left + (points.length - 0.5) * step) + "," + (top + plot) + ' Z" fill="var(--bar-soft)"/>';
+      out += '<polyline points="' + pts.join(" ") + '" fill="none" stroke="var(--bar)" stroke-width="2" vector-effect="non-scaling-stroke" stroke-linejoin="round"/>';
+    }
+    points.forEach(function (p, i) {
+      var x = left + i * step;
+      if (!line) {
+        var bh = plot * (p.value / max), bw = Math.max(1, step - 2);
+        out += '<rect x="' + (x + 1) + '" y="' + (top + plot - bh) + '" width="' + bw + '" height="' + bh + '" rx="' + Math.min(2, bw / 2) + '" fill="var(--bar)"/>';
+      }
+      out += '<rect class="hit" x="' + x + '" y="' + top + '" width="' + step + '" height="' + plot + '" data-tip="' + esc(p.date + " \xB7 " + num(p.value) + " " + label) + '"/>';
+    });
+    out += '<text x="' + left + '" y="' + (h - 5) + '">' + esc(points[0].date) + '</text><text x="' + w + '" y="' + (h - 5) + '" text-anchor="end">' + esc(points[points.length - 1].date) + "</text>";
+    return out + "</svg>";
+  }
+
+  function rows(items, total) {
+    if (!items.length) return '<div class="muted">No data yet.</div>';
+    return items.slice(0, 8).map(function (item) {
+      var share = total ? item.installs / total : 0;
+      return '<div class="row"><span>' + esc(item.label) + '</span><span class="n">' + num(item.installs) + " \xB7 " + pct(share) + '</span><div class="track"><div class="fill" style="width:' + (share * 100).toFixed(1) + '%"></div></div></div>';
+    }).join("");
+  }
+
+  function renderOverview() {
+    var t = summary.totals;
+    var npm30 = npmTotal(30);
+    $("hero").innerHTML =
+      kpi("Weekly active installs", num(t.wau), delta(t.wau, t.wauPrevious)) +
+      kpi("Total installs", num(t.allTimeInstalls), "+" + num(t.newInRange) + " in the last " + summary.days + " days \xB7 " + num(t.newToday) + " today") +
+      kpi("Week-1 retention", t.week1Retention == null ? "\u2013" : pct(t.week1Retention), t.week1Retention == null ? "needs a cohort older than 7 days" : "new installs active again the next week") +
+      kpi("Agent sessions", compact(t.sessions), num(t.dau) + " installs active today \xB7 " + num(t.mau) + " this month") +
+      kpi("npm downloads \xB7 30 days", npm30 == null ? "\u2013" : num(npm30), npm && npm.error ? esc(npm.error) : num(npmTotal(365) || 0) + " in the last year");
+    draw("cumulative", summary.daily.map(function (d) { return { date: d.date, value: d.totalInstalls }; }), "total installs", true);
+    draw("active", summary.daily.map(function (d) { return { date: d.date, value: d.installs }; }), "active installs", false);
+
+    var active = summary.funnel[0] ? summary.funnel[0].installs : 0;
+    $("funnel").innerHTML = active ? summary.funnel.map(function (step) {
+      var share = active ? step.installs / active : 0;
+      return '<div class="row"><span>' + esc(step.label) + '</span><span class="n">' + num(step.installs) + " \xB7 " + pct(share) + '</span><div class="track"><div class="fill" style="width:' + (share * 100).toFixed(1) + '%"></div></div></div>';
+    }).join("") : '<div class="empty-state">No active installs in this range.</div>';
+
+    var cohorts = summary.cohorts.filter(function (c) { return c.size > 0; });
+    var weeks = summary.cohorts.length;
+    $("cohorts").innerHTML = cohorts.length
+      ? '<table class="heat"><thead><tr><th>Cohort</th><th class="n">Installs</th>' + Array.from({ length: weeks }, function (_, i) { return '<th class="n">W' + i + "</th>"; }).join("") + "</tr></thead><tbody>" +
+        cohorts.map(function (c) {
+          var cells = "";
+          for (var i = 0; i < weeks; i += 1) {
+            var v = c.weeks[i];
+            if (v == null) { cells += '<td class="empty">\xB7</td>'; continue; }
+            var strength = Math.round(12 + v * 88);
+            cells += '<td style="background:color-mix(in oklab, var(--bar) ' + strength + '%, var(--panel));color:' + (v > 0.5 ? "#fff" : "var(--fg)") + '" title="' + esc(c.start + " cohort, week " + i + ": " + pct(v)) + '">' + pct(v) + "</td>";
+          }
+          return '<tr><td class="lab">' + esc(date(c.start)) + '</td><td class="n">' + num(c.size) + "</td>" + cells + "</tr>";
+        }).join("") + "</tbody></table>"
+      : '<div class="empty-state">Cohorts appear once new installs report in.</div>';
+
+    var maxCalls = Math.max.apply(null, summary.features.map(function (f) { return f.calls; }).concat([1]));
+    $("features").innerHTML = summary.features.length
+      ? '<table><thead><tr><th>Feature</th><th class="n">Calls</th><th class="n">Installs</th><th class="n">Median</th><th class="n">p95</th><th class="n">Errors</th></tr></thead><tbody>' +
+        summary.features.map(function (f) {
+          return '<tr><td class="mono">' + esc(f.label) + '<span class="inline" style="width:' + Math.max(2, (f.calls / maxCalls) * 120).toFixed(0) + 'px"></span></td><td class="n">' + num(f.calls) + '</td><td class="n">' + num(f.installs) +
+            '</td><td class="n">' + ms(f.p50ms) + '</td><td class="n">' + ms(f.p95ms) + '</td><td class="n' + (f.errorRate > 0.05 ? " bad" : "") + '">' + pct(f.errorRate) + "</td></tr>";
+        }).join("") + "</tbody></table>"
+      : '<div class="empty-state">No events yet. Installs send a batch at most every 10 minutes.</div>';
+    var installs = summary.versions.reduce(function (sum, v) { return sum + v.installs; }, 0);
+    $("clients").innerHTML = rows(summary.clients, installs);
+    $("versions").innerHTML = rows(summary.versions, installs);
+    $("platforms").innerHTML = rows(summary.platforms, installs);
+    renderNpm();
+  }
+
+  function npmTotal(n) {
+    if (!npm || !npm.downloads) return null;
+    return npm.downloads.slice(-n).reduce(function (sum, d) { return sum + d.downloads; }, 0);
+  }
+  function renderNpm() {
+    if (!npm) return;
+    if (npm.error) { $("npm").innerHTML = '<div class="empty-state">' + esc(npm.error) + "</div>"; return; }
+    $("npmNote").textContent = npm.package + " \xB7 public npm registry";
+    draw("npm", npm.downloads.slice(-Math.min(days, 365)).map(function (d) { return { date: d.day, value: d.downloads }; }), "downloads", false);
+  }
+
+  var USER_COLS = [
+    ["install", "Install"], ["firstSeen", "First seen"], ["lastSeen", "Last active"], ["activeDays", "Active days", 1],
+    ["sessions", "Sessions", 1], ["events", "Events", 1], ["errors", "Errors", 1], ["client", "Client"], ["version", "Version"], ["platform", "Platform"], ["topFeature", "Top feature"]
+  ];
+  function filteredUsers() {
+    var q = $("userSearch").value.trim().toLowerCase();
+    return summary.users.filter(function (u) {
+      return !q || [u.install, u.client, u.version, u.platform, u.topFeature].join(" ").toLowerCase().indexOf(q) !== -1;
+    }).sort(function (a, b) {
+      var x = a[userSort.key], y = b[userSort.key];
+      return (x < y ? -1 : x > y ? 1 : 0) * userSort.dir;
+    });
+  }
+  function renderUsers() {
+    var list = filteredUsers();
+    $("userCount").textContent = num(summary.users.length) + " installs active in the last " + summary.days + " days";
+    $("users").innerHTML = list.length
+      ? "<table><thead><tr>" + USER_COLS.map(function (c) {
+          return "<th" + (c[2] ? ' class="n"' : "") + '><button data-sort="' + c[0] + '" data-dir="' + (userSort.key === c[0] ? (userSort.dir > 0 ? "\u2191" : "\u2193") : "") + '">' + c[1] + "</button></th>";
+        }).join("") + "</tr></thead><tbody>" +
+        list.map(function (u) {
+          return '<tr class="link" tabindex="0" data-install="' + esc(u.install) + '"><td class="mono">' + esc(u.install) + "</td><td>" + esc(date(u.firstSeen)) + "</td><td>" + esc(ago(u.lastSeen)) +
+            '</td><td class="n">' + num(u.activeDays) + '</td><td class="n">' + num(u.sessions) + '</td><td class="n">' + num(u.events) + '</td><td class="n' + (u.errors ? " bad" : "") + '">' + num(u.errors) +
+            "</td><td>" + esc(u.client) + '</td><td class="mono">' + esc(u.version) + "</td><td>" + esc(u.platform) + '</td><td class="mono">' + esc(u.topFeature) + "</td></tr>";
+        }).join("") + "</tbody></table>"
+      : '<div class="empty-state">' + (summary.users.length ? "No installs match this filter." : "No users yet.") + "</div>";
+  }
+
+  function renderInstall() {
+    var el = $("view-install");
+    if (!install) { el.innerHTML = '<div class="panel empty-state">Loading\u2026</div>'; return; }
+    if (install.missing) { el.innerHTML = '<div class="panel empty-state">No events for this install in the last 90 days. <a href="#users">Back to users</a></div>'; return; }
+    var errors = install.events.filter(function (e) { return !e.ok; }).length;
+    var perDay = {};
+    install.perDay.forEach(function (d) { perDay[d.date] = d.events; });
+    var points = [];
+    for (var i = 89; i >= 0; i -= 1) {
+      var d = new Date(Date.now() - i * 86400000).toISOString().slice(0, 10);
+      points.push({ date: d, value: perDay[d] || 0 });
+    }
+    if (!selectedSession || !install.sessions.some(function (s) { return s.id === selectedSession; })) selectedSession = install.sessions[0] ? install.sessions[0].id : null;
+    el.innerHTML =
+      '<div class="toolbar"><a class="btn" href="#users">\u2190 Users</a><h2 style="font-size:14px;color:var(--fg);text-transform:none;letter-spacing:0">Install <span class="mono">' + esc(install.install) + "</span></h2>" +
+      '<span class="chips"><span class="chip">' + esc(install.client) + '</span><span class="chip">v' + esc(install.version) + '</span><span class="chip">' + esc(install.platform) + '</span><span class="chip">node ' + esc(install.node) + "</span></span></div>" +
+      '<div class="hero" style="padding-top:0">' + kpi("Events \xB7 90 days", num(install.events.length), errors ? '<span class="bad">' + plural(errors, "error") + "</span>" : "no errors") +
+      kpi("Sessions", num(install.sessions.length), "agent sessions with CodeBuddy") + kpi("Active days", num(install.perDay.length), "in the last 90 days") + kpi("Projects", num(install.projects), "hashed, never named") + "</div>" +
+      '<section class="panel" style="margin-top:16px"><div class="head"><h2>Activity</h2><span class="note">events per day, last 90 days</span></div><div class="chart" id="installActivity"></div></section>' +
+      '<section class="panel" style="margin-top:16px"><div class="head"><h2>Session traces</h2><span class="note">each step ends at its recorded time; bar length is its duration</span></div>' +
+      '<div class="split"><div class="sessions" id="sessionList">' + install.sessions.map(function (s) {
+        return '<button class="session" data-session="' + esc(s.id) + '" aria-pressed="' + (s.id === selectedSession) + '"><strong class="mono">' + esc(s.id === "none" ? "no session id" : s.id.slice(0, 8)) + "</strong>" +
+          '<span class="muted">' + esc(new Date(s.start).toLocaleString()) + " \xB7 " + num(s.events) + " steps" + (s.errors ? ' \xB7 <span class="bad">' + plural(s.errors, "error") + "</span>" : "") + "</span></button>";
+      }).join("") + '</div><div id="waterfall"></div></div></section>';
+    draw("installActivity", points, "events", false);
+    renderWaterfall();
+  }
+
+  function renderWaterfall() {
+    var target = $("waterfall");
+    if (!target || !install) return;
+    var steps = install.events.filter(function (e) { return e.session === selectedSession; })
+      .sort(function (a, b) { return a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : 0; }).slice(-200);
+    if (!steps.length) { target.innerHTML = '<div class="empty-state">Pick a session.</div>'; return; }
+    var start = Math.min.apply(null, steps.map(function (e) { return Date.parse(e.ts) - e.ms; }));
+    var end = Math.max.apply(null, steps.map(function (e) { return Date.parse(e.ts); }));
+    var span = Math.max(1, end - start);
+    target.innerHTML = '<div class="legend"><span><i class="sw" style="background:var(--bar)"></i>MCP tool</span><span><i class="sw" style="background:var(--hook)"></i>hook step</span><span><i class="sw" style="background:var(--cli)"></i>CLI command</span><span class="spacer"></span><span>' + esc(ms(span)) + " total</span></div>" +
+      '<div class="wf">' + steps.map(function (e) {
+        var s = Date.parse(e.ts) - e.ms;
+        var left = ((s - start) / span) * 100, width = Math.max(0.8, (e.ms / span) * 100);
+        return '<div class="step"><span class="name' + (e.ok ? "" : " bad") + '" title="' + esc(kindGroup(e.kind) + ": " + e.name) + '">' + (e.ok ? "" : "\u2715 ") + esc(e.feature) + '</span><span class="at">' + esc(offset(s - start)) + '</span><span class="lane"><span class="seg-bar" style="left:' + left.toFixed(2) + "%;width:" + width.toFixed(2) + "%;background:" + kindColor(e.kind) + '" data-tip="' + esc(e.feature + " \xB7 " + ms(e.ms) + (e.ok ? "" : " \xB7 error") + (e.tokensOut ? " \xB7 " + num(e.tokensOut) + " tokens out" : "")) + '"></span></span><span class="t">' + esc(ms(e.ms)) + "</span></div>";
+      }).join("") + "</div>";
+  }
+
+  function renderEvents() {
+    var kinds = ["all"];
+    summary.recent.forEach(function (e) { if (kinds.indexOf(e.kind) === -1) kinds.push(e.kind); });
+    $("kindFilter").innerHTML = '<div class="seg" role="group" aria-label="Event kind">' + kinds.map(function (k) {
+      return '<button data-kind="' + esc(k) + '" aria-pressed="' + (k === kindShown) + '">' + esc(k) + "</button>";
+    }).join("") + "</div>";
+    var list = summary.recent.filter(function (e) { return kindShown === "all" || e.kind === kindShown; });
+    $("recent").innerHTML = list.length
+      ? '<table><thead><tr><th>Received</th><th>Install</th><th>Kind</th><th>Name</th><th>Client</th><th>Version</th><th class="n">Time</th><th>Result</th></tr></thead><tbody>' +
+        list.map(function (e) {
+          return '<tr class="link" tabindex="0" data-install="' + esc(e.install) + '"><td>' + esc(new Date(e.receivedAt).toLocaleString()) + '</td><td class="mono">' + esc(e.install) + '</td><td><span class="sw" style="background:' + kindColor(e.kind) + '"></span> ' + esc(e.kind) +
+            '</td><td class="mono">' + esc(e.name) + "</td><td>" + esc(e.client) + '</td><td class="mono">' + esc(e.version) + '</td><td class="n">' + ms(e.ms) + '</td><td class="' + (e.ok ? "" : "bad") + '">' + (e.ok ? "ok" : "\u2715 error") + "</td></tr>";
+        }).join("") + "</tbody></table>"
+      : '<div class="empty-state">No events yet.</div>';
+  }
+
+  function route() {
+    var hash = location.hash.replace("#", "") || "overview";
+    var view = hash.indexOf("install/") === 0 ? "install" : ["overview", "users", "events"].indexOf(hash) !== -1 ? hash : "overview";
+    ["overview", "users", "install", "events"].forEach(function (v) { $("view-" + v).hidden = v !== view; });
+    document.querySelectorAll(".tabs a").forEach(function (a) {
+      var current = a.dataset.view === view || (view === "install" && a.dataset.view === "users");
+      if (current) a.setAttribute("aria-current", "page"); else a.removeAttribute("aria-current");
+    });
+    $("range").hidden = view === "install";
+    if (view === "install") {
+      var id = hash.slice(8);
+      if (!install || install.install !== id) {
+        install = null;
+        renderInstall();
+        get("api/install?id=" + encodeURIComponent(id)).then(function (data) { install = data || { install: id, missing: true }; renderInstall(); });
+      } else renderInstall();
+    } else render();
+  }
+
+  function render() {
+    if (!summary) return;
+    $("updated").textContent = "updated " + new Date(summary.generatedAt).toLocaleTimeString();
+    var hash = location.hash.replace("#", "") || "overview";
+    if (hash === "users") renderUsers();
+    else if (hash === "events") renderEvents();
+    else if (hash.indexOf("install/") !== 0) renderOverview();
+  }
+
+  function load() { get("api/summary?days=" + days).then(function (s) { if (s) { summary = s; render(); } }); }
+  get("api/npm").then(function (n) { npm = n; if (summary) render(); });
+
+  $("range").addEventListener("click", function (event) {
+    var button = event.target.closest("button");
+    if (!button) return;
+    days = Number(button.dataset.days);
+    document.querySelectorAll("#range button").forEach(function (b) { b.setAttribute("aria-pressed", String(b === button)); });
+    load();
+  });
+  $("userSearch").addEventListener("input", function () { if (summary) renderUsers(); });
+  document.addEventListener("click", function (event) {
+    var sort = event.target.closest("[data-sort]");
+    if (sort) {
+      var key = sort.dataset.sort;
+      userSort = { key: key, dir: userSort.key === key ? -userSort.dir : -1 };
+      renderUsers();
+      return;
+    }
+    var row = event.target.closest("tr[data-install]");
+    if (row) { location.hash = "install/" + row.dataset.install; return; }
+    var session = event.target.closest("[data-session]");
+    if (session) {
+      selectedSession = session.dataset.session;
+      document.querySelectorAll("#sessionList .session").forEach(function (b) { b.setAttribute("aria-pressed", String(b === session)); });
+      renderWaterfall();
+      return;
+    }
+    var kind = event.target.closest("[data-kind]");
+    if (kind) { kindShown = kind.dataset.kind; renderEvents(); }
+  });
+  document.addEventListener("keydown", function (event) {
+    var row = event.target.closest && event.target.closest("tr[data-install]");
+    if (row && (event.key === "Enter" || event.key === " ")) { event.preventDefault(); location.hash = "install/" + row.dataset.install; }
+  });
+  $("csv").addEventListener("click", function () {
+    if (!summary) return;
+    var cols = USER_COLS.map(function (c) { return c[0]; });
+    var lines = [cols.join(",")].concat(filteredUsers().map(function (u) {
+      return cols.map(function (c) { return '"' + String(u[c]).replace(/"/g, '""') + '"'; }).join(",");
+    }));
+    var link = document.createElement("a");
+    link.href = URL.createObjectURL(new Blob([lines.join(NL)], { type: "text/csv" }));
+    link.download = "codebuddy-users-" + new Date().toISOString().slice(0, 10) + ".csv";
+    link.click();
+  });
+  document.addEventListener("mousemove", function (event) {
+    var text = event.target.getAttribute && event.target.getAttribute("data-tip");
+    if (!text) { tip.style.display = "none"; return; }
+    tip.textContent = text;
+    tip.style.display = "block";
+    tip.style.left = Math.min(event.pageX + 12, document.documentElement.scrollWidth - tip.offsetWidth - 8) + "px";
+    tip.style.top = (event.pageY - 34) + "px";
+  });
+  var resizeTimer = 0;
+  window.addEventListener("resize", function () {
+    clearTimeout(resizeTimer);
+    resizeTimer = setTimeout(function () { if (location.hash.indexOf("#install/") === 0) renderInstall(); else render(); }, 150);
+  });
+  window.addEventListener("hashchange", route);
+  route();
+  load();
+  setInterval(load, 60000);
+})();
+</script>
+</body>
+</html>
+`;
+
+// src/telemetry/collector.ts
+var MAX_BODY_BYTES = 256 * 1024;
+var INSTALL_BATCHES_PER_HOUR = 30;
+var GLOBAL_BATCHES_PER_MINUTE = 600;
+var NPM_PACKAGE = "@orquentra/codebuddy";
+var name = z2.string().regex(/^[A-Za-z][A-Za-z0-9_:.-]{0,63}$/);
+var short = z2.string().max(64);
+var batchSchema = z2.object({
+  installId: z2.string().uuid(),
+  project: z2.string().regex(/^[0-9a-f]{16}$/),
+  version: short,
+  platform: short,
+  arch: short,
+  node: short,
+  clients: z2.array(name).max(10),
+  events: z2.array(
+    z2.object({
+      ts: z2.string().datetime(),
+      kind: name,
+      name,
+      ms: z2.number().int().min(0).max(864e5),
+      ok: z2.boolean(),
+      tokensIn: z2.number().int().min(0).max(1e7).optional(),
+      tokensOut: z2.number().int().min(0).max(1e7).optional(),
+      session: z2.string().regex(/^[0-9a-f]{16}$/).optional()
+    })
+  ).min(1).max(500)
+});
+async function startCollector(options) {
+  const { dataDir } = options;
+  await mkdir2(dataDir, { recursive: true });
+  const registry = await loadRegistry(dataDir);
+  let summaryCache;
+  let npmCache;
+  const perInstall = /* @__PURE__ */ new Map();
+  let globalCount = 0;
+  const resetInstalls = setInterval(() => perInstall.clear(), 36e5);
+  const resetGlobal = setInterval(() => {
+    globalCount = 0;
+  }, 6e4);
+  resetInstalls.unref();
+  resetGlobal.unref();
+  const ingest = createServer2(async (request, response) => {
+    const url = new URL(request.url ?? "/", "http://localhost");
+    if (url.pathname !== "/v1/events") {
+      response.writeHead(404).end();
+      return;
+    }
+    if (request.method !== "POST") {
+      response.writeHead(405).end();
+      return;
+    }
+    if (++globalCount > GLOBAL_BATCHES_PER_MINUTE) {
+      response.writeHead(429).end();
+      return;
+    }
+    const body = await readBody(request);
+    if (body === null) {
+      response.writeHead(413, { connection: "close" }).end();
+      return;
+    }
+    let batch;
+    try {
+      batch = batchSchema.parse(JSON.parse(body));
+    } catch {
+      response.writeHead(400).end();
+      return;
+    }
+    const seen = (perInstall.get(batch.installId) ?? 0) + 1;
+    perInstall.set(batch.installId, seen);
+    if (seen > INSTALL_BATCHES_PER_HOUR) {
+      response.writeHead(429).end();
+      return;
+    }
+    const receivedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (!registry.has(batch.installId)) {
+      registry.set(batch.installId, receivedAt);
+      await appendFile(
+        join6(dataDir, "installs.jsonl"),
+        `${JSON.stringify({ installId: batch.installId, firstSeen: receivedAt })}
+`
+      );
+    }
+    const { events, ...meta } = batch;
+    const lines = events.map((event) => JSON.stringify({ ...meta, ...event, receivedAt }));
+    await appendFile(
+      join6(dataDir, `events-${receivedAt.slice(0, 10)}.jsonl`),
+      `${lines.join("\n")}
+`
+    );
+    response.writeHead(204).end();
+    summaryCache = void 0;
   });
-  rules.command("install").option("--client <client>", `One of: ${WORKFLOW_CLIENTS.join(", ")}.`, "claude").option("--path <file>", "Override the target rules file.").option(
-    "--mode <mode>",
-    `One of: ${AUTOMATION_MODES.join(", ")} (default: follows installed hooks; mcp-only removes the block).`
-  ).description("Install/update the workflow template in the client's rules file (managed block).").action(async (opts) => {
-    await runSafely2(async () => {
-      const client = parseClient(opts.client);
-      const result = await installWorkflowRules({
-        client,
-        mode: await resolveMode(client, opts.mode),
-        ...opts.path ? { targetPath: opts.path } : {}
+  const admin = createServer2(async (request, response) => {
+    const host = (request.headers.host ?? "").replace(/:\d+$/, "");
+    if (host !== "127.0.0.1" && host !== "localhost" && !host.endsWith(".ts.net")) {
+      response.writeHead(403, { "content-type": "text/plain" }).end("Forbidden host");
+      return;
+    }
+    if (options.adminPassword && !passwordMatches(request, options.adminPassword)) {
+      response.writeHead(401, {
+        "www-authenticate": 'Basic realm="CodeBuddy admin", charset="UTF-8"',
+        "content-type": "text/plain"
+      }).end("Password required");
+      return;
+    }
+    if (request.method !== "GET") {
+      response.writeHead(405).end();
+      return;
+    }
+    const url = new URL(request.url ?? "/", "http://localhost");
+    url.pathname = url.pathname.replace(/^\/admin(?=\/|$)/, "") || "/";
+    const json2 = (value) => {
+      response.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" });
+      response.end(JSON.stringify(value));
+    };
+    if (url.pathname === "/") {
+      response.writeHead(200, {
+        "content-type": "text/html; charset=utf-8",
+        "cache-control": "no-store"
       });
-      const where = relative5(process.cwd(), result.path) || result.path;
-      console.log(
-        `${actionLabel(result.action)} ${clientDisplayName(client)} workflow in ${where}`
+      response.end(ADMIN_HTML);
+      return;
+    }
+    if (url.pathname === "/api/summary") {
+      const days = Math.min(365, Math.max(1, Number(url.searchParams.get("days")) || 30));
+      if (!summaryCache || summaryCache.days !== days || Date.now() - summaryCache.at > 3e4) {
+        summaryCache = {
+          at: Date.now(),
+          days,
+          value: summarize(
+            await readEvents(dataDir, Math.max(days, COHORT_WEEKS * 7)),
+            days,
+            Date.now(),
+            registry
+          )
+        };
+      }
+      json2(summaryCache.value);
+      return;
+    }
+    if (url.pathname === "/api/install") {
+      const trace = installTrace(
+        await readEvents(dataDir, 90),
+        (url.searchParams.get("id") ?? "").toLowerCase()
       );
-      if (result.action !== "unchanged") {
-        console.log(pc16.dim("  managed block between codebuddy:workflow markers; safe to re-run"));
+      if (!trace) {
+        response.writeHead(404, { "content-type": "application/json" }).end("null");
+        return;
       }
-    });
+      json2(trace);
+      return;
+    }
+    if (url.pathname === "/api/npm") {
+      if (!npmCache || Date.now() - npmCache.at > 36e5) {
+        npmCache = { at: Date.now(), value: await npmDownloads(options.fetchImpl ?? fetch) };
+      }
+      json2(npmCache.value);
+      return;
+    }
+    response.writeHead(404, { "content-type": "text/plain" }).end("Not found");
   });
+  const ingestPort = await listen2(ingest, options.ingestPort ?? 8787);
+  const adminPort = await listen2(admin, options.adminPort ?? 8788);
+  const close = (server) => new Promise((resolve6) => {
+    server.closeAllConnections();
+    server.close(() => resolve6());
+  });
+  return {
+    ingestUrl: `http://127.0.0.1:${ingestPort}/v1/events`,
+    adminUrl: `http://127.0.0.1:${adminPort}/`,
+    close: async () => {
+      clearInterval(resetInstalls);
+      clearInterval(resetGlobal);
+      await Promise.all([close(ingest), close(admin)]);
+    }
+  };
 }
-function actionLabel(action) {
-  switch (action) {
-    case "created":
-      return pc16.green("created");
-    case "added":
-      return pc16.green("added");
-    case "updated":
-      return pc16.cyan("updated");
-    case "removed":
-      return pc16.yellow("removed");
-    default:
-      return pc16.dim("unchanged");
-  }
+function passwordMatches(request, password3) {
+  const header = request.headers.authorization ?? "";
+  if (!header.startsWith("Basic ")) return false;
+  const decoded = Buffer.from(header.slice(6), "base64").toString("utf8");
+  const given = decoded.slice(decoded.indexOf(":") + 1);
+  const digest = (value) => createHash("sha256").update(value).digest();
+  return timingSafeEqual(digest(given), digest(password3));
+}
+function readBody(request) {
+  return new Promise((resolve6) => {
+    const chunks = [];
+    let size = 0;
+    request.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) resolve6(null);
+      else chunks.push(chunk);
+    });
+    request.on("end", () => resolve6(Buffer.concat(chunks).toString("utf8")));
+    request.on("error", () => resolve6(null));
+  });
 }
-
-// src/cli/commands/suggest.ts
-import pc17 from "picocolors";
-function parsePaths4(value) {
-  return value.split(",").map((path) => path.trim()).filter(Boolean);
+function listen2(server, port) {
+  return new Promise((resolve6, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve6(server.address().port));
+  });
 }
-function registerSuggestCommand(program, runSafely2) {
-  program.command("suggest").option("--paths <paths>", "Comma-separated repo-relative paths to review.").option("--plan <id>", "Review the files listed in a plan.").option("--git", "Review current git changes.").option("--limit <n>", "Maximum suggestions to show.", Number).option("--json", "Print machine-readable JSON.").description("Suggest evidence-backed, read-only code-quality improvements.").action(
-    async (opts) => {
-      await runSafely2(async () => {
-        const namespace = await resolveNamespaceFrom();
-        const result = await generateSuggestions({
-          namespace,
-          ...opts.paths ? { paths: parsePaths4(opts.paths) } : {},
-          ...opts.plan ? { planId: opts.plan } : {},
-          ...opts.git !== void 0 ? { useGit: opts.git } : {},
-          ...opts.limit !== void 0 ? { limit: opts.limit } : {}
-        });
-        if (opts.json) {
-          console.log(JSON.stringify(result, null, 2));
-          return;
+async function readEvents(dataDir, days, now = Date.now()) {
+  const since = new Date(now - (days - 1) * 864e5).toISOString().slice(0, 10);
+  const files = (await readdir(dataDir).catch(() => [])).filter((file) => /^events-\d{4}-\d{2}-\d{2}\.jsonl$/.test(file) && file.slice(7, 17) >= since).sort();
+  const events = [];
+  for (const file of files) {
+    for (const line of (await readFile4(join6(dataDir, file), "utf8")).split("\n")) {
+      if (!line) continue;
+      try {
+        events.push(JSON.parse(line));
+      } catch {
+      }
+    }
+  }
+  return events;
+}
+var DAY_MS = 864e5;
+var dayOf = (iso) => iso.slice(0, 10);
+var dayNumber = (iso) => Math.floor(Date.parse(iso) / DAY_MS);
+var COHORT_WEEKS = 8;
+function featureOf(event) {
+  if (event.kind === "tool") return event.name;
+  if (event.kind === "cli") return `cli:${event.name}`;
+  return event.kind;
+}
+var GOT_CONTEXT = (e) => e.kind === "recall" || e.kind === "tool" && /^(context_(pack|bootstrap|before_edit)|recall)$/.test(e.name);
+var SAVED_MEMORY = (e) => e.kind === "capture" || e.kind === "tool" && /^(context_after_turn|remember)$/.test(e.name);
+function summarize(events, days, now = Date.now(), registry = /* @__PURE__ */ new Map()) {
+  const today = Math.floor(now / DAY_MS);
+  const rangeStart = today - days + 1;
+  const firstSeenOf = (install, fallback) => registry.get(install) ?? fallback;
+  const activeDays = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const set = activeDays.get(event.installId) ?? /* @__PURE__ */ new Set();
+    set.add(dayNumber(event.receivedAt));
+    activeDays.set(event.installId, set);
+  }
+  const activeBetween = (from, to) => {
+    let count = 0;
+    for (const set of activeDays.values()) {
+      for (const d of set) {
+        if (d >= from && d <= to) {
+          count += 1;
+          break;
         }
-        printSuggestions(result.suggestions);
-        console.log(
-          pc17.dim(
-            `
-${result.stats.produced} suggestion(s) across ${result.stats.pathsConsidered} path(s)`
-          )
-        );
-      });
+      }
     }
-  );
+    return count;
+  };
+  const inRange = events.filter((e) => dayNumber(e.receivedAt) >= rangeStart);
+  const daily = /* @__PURE__ */ new Map();
+  for (let d = rangeStart; d <= today; d += 1) daily.set(d, { installs: /* @__PURE__ */ new Set(), events: 0 });
+  const features = /* @__PURE__ */ new Map();
+  const latest = /* @__PURE__ */ new Map();
+  const users = /* @__PURE__ */ new Map();
+  const funnel = {
+    active: /* @__PURE__ */ new Set(),
+    context: /* @__PURE__ */ new Set(),
+    memory: /* @__PURE__ */ new Set()
+  };
+  let errors = 0;
+  let tokensOut = 0;
+  for (const event of inRange) {
+    const d = dayNumber(event.receivedAt);
+    const bucket = daily.get(d);
+    if (bucket) {
+      bucket.installs.add(event.installId);
+      bucket.events += 1;
+    }
+    latest.set(event.installId, event);
+    const feature = featureOf(event);
+    const user = users.get(event.installId) ?? {
+      firstEvent: event.receivedAt,
+      lastSeen: event.receivedAt,
+      events: 0,
+      errors: 0,
+      sessions: /* @__PURE__ */ new Set(),
+      projects: /* @__PURE__ */ new Set(),
+      features: /* @__PURE__ */ new Map(),
+      days: /* @__PURE__ */ new Set()
+    };
+    if (event.receivedAt > user.lastSeen) user.lastSeen = event.receivedAt;
+    user.events += 1;
+    if (!event.ok) user.errors += 1;
+    if (event.session) user.sessions.add(event.session);
+    user.projects.add(event.project);
+    user.features.set(feature, (user.features.get(feature) ?? 0) + 1);
+    user.days.add(d);
+    users.set(event.installId, user);
+    funnel.active.add(event.installId);
+    if (GOT_CONTEXT(event)) funnel.context.add(event.installId);
+    if (SAVED_MEMORY(event)) funnel.memory.add(event.installId);
+    if (!event.ok) errors += 1;
+    tokensOut += event.tokensOut ?? 0;
+    const stats = features.get(feature) ?? { calls: 0, errors: 0, installs: /* @__PURE__ */ new Set(), ms: [] };
+    stats.calls += 1;
+    if (!event.ok) stats.errors += 1;
+    stats.installs.add(event.installId);
+    stats.ms.push(event.ms);
+    features.set(feature, stats);
+  }
+  const firstSeenDay = /* @__PURE__ */ new Map();
+  for (const [install, seen] of registry) firstSeenDay.set(install, dayNumber(seen));
+  for (const [install, user] of users) {
+    if (!firstSeenDay.has(install)) firstSeenDay.set(install, dayNumber(user.firstEvent));
+  }
+  for (const [install, set] of activeDays) {
+    if (!firstSeenDay.has(install)) firstSeenDay.set(install, Math.min(...set));
+  }
+  const newPerDay = /* @__PURE__ */ new Map();
+  for (const d of firstSeenDay.values()) newPerDay.set(d, (newPerDay.get(d) ?? 0) + 1);
+  let cumulative = [...firstSeenDay.values()].filter((d) => d < rangeStart).length;
+  const cohorts = [];
+  for (let age = COHORT_WEEKS - 1; age >= 0; age -= 1) {
+    const from = today - (age + 1) * 7 + 1;
+    const members = [...firstSeenDay].filter(([, d]) => d >= from && d < from + 7).map(([install]) => install);
+    const weeks = [];
+    for (let week = 0; week <= age; week += 1) {
+      const wFrom = from + week * 7;
+      const active = members.filter((install) => {
+        const set = activeDays.get(install);
+        if (!set) return week === 0;
+        for (const d of set) if (d >= wFrom && d < wFrom + 7) return true;
+        return false;
+      }).length;
+      weeks.push(members.length ? active / members.length : 0);
+    }
+    cohorts.push({
+      start: new Date(from * DAY_MS).toISOString().slice(0, 10),
+      size: members.length,
+      weeks
+    });
+  }
+  const week1 = cohorts.filter((c) => c.size > 0 && c.weeks.length > 1);
+  const week1Retention = week1.length ? week1.reduce((sum, c) => sum + (c.weeks[1] ?? 0) * c.size, 0) / week1.reduce((sum, c) => sum + c.size, 0) : null;
+  const share = (pick) => {
+    const counts = /* @__PURE__ */ new Map();
+    for (const event of latest.values()) {
+      for (const value of pick(event)) counts.set(value, (counts.get(value) ?? 0) + 1);
+    }
+    return [...counts].map(([label, installs]) => ({ label, installs })).sort((a, b) => b.installs - a.installs);
+  };
+  const median = (values) => {
+    const sorted = [...values].sort((a, b) => a - b);
+    return sorted[Math.floor(sorted.length / 2)] ?? 0;
+  };
+  const p95 = (values) => {
+    const sorted = [...values].sort((a, b) => a - b);
+    return sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * 0.95))] ?? 0;
+  };
+  const wau = activeBetween(today - 6, today);
+  const wauPrevious = activeBetween(today - 13, today - 7);
+  const returned = [...users.values()].filter((user) => user.days.size >= 2).length;
+  return {
+    generatedAt: new Date(now).toISOString(),
+    days,
+    totals: {
+      allTimeInstalls: firstSeenDay.size,
+      installs: users.size,
+      newInRange: [...firstSeenDay.values()].filter((d) => d >= rangeStart).length,
+      newToday: newPerDay.get(today) ?? 0,
+      projects: new Set(inRange.map((e) => `${e.installId}:${e.project}`)).size,
+      sessions: new Set(inRange.filter((e) => e.session).map((e) => e.session)).size,
+      events: inRange.length,
+      errorRate: inRange.length ? errors / inRange.length : 0,
+      tokensOut,
+      dau: activeBetween(today, today),
+      wau,
+      wauPrevious,
+      mau: activeBetween(today - 29, today),
+      week1Retention
+    },
+    daily: [...daily].map(([d, bucket]) => {
+      cumulative += newPerDay.get(d) ?? 0;
+      return {
+        date: new Date(d * DAY_MS).toISOString().slice(0, 10),
+        installs: bucket.installs.size,
+        events: bucket.events,
+        newInstalls: newPerDay.get(d) ?? 0,
+        totalInstalls: cumulative
+      };
+    }),
+    /** Installs active in the range that reached each step. */
+    funnel: [
+      { label: "Active", installs: funnel.active.size },
+      { label: "Received context", installs: funnel.context.size },
+      { label: "Saved memory", installs: funnel.memory.size },
+      { label: "Came back another day", installs: returned }
+    ],
+    cohorts,
+    features: [...features].map(([label, stats]) => ({
+      label,
+      calls: stats.calls,
+      installs: stats.installs.size,
+      errorRate: stats.errors / stats.calls,
+      p50ms: median(stats.ms),
+      p95ms: p95(stats.ms)
+    })).sort((a, b) => b.calls - a.calls).slice(0, 25),
+    clients: share((e) => e.clients.length ? e.clients : ["unknown"]),
+    versions: share((e) => [e.version]),
+    platforms: share((e) => [`${e.platform}/${e.arch}`]),
+    nodes: share((e) => [`node ${e.node}`]),
+    /** One row per install active in the range, most recently active first. */
+    users: [...users].map(([installId, user]) => {
+      const last = latest.get(installId);
+      return {
+        install: installId.slice(0, 8),
+        firstSeen: firstSeenOf(installId, user.firstEvent),
+        lastSeen: user.lastSeen,
+        activeDays: user.days.size,
+        events: user.events,
+        errors: user.errors,
+        sessions: user.sessions.size,
+        projects: user.projects.size,
+        client: last?.clients.join(",") || "unknown",
+        version: last?.version ?? "",
+        platform: last ? `${last.platform}/${last.arch}` : "",
+        topFeature: [...user.features].sort((a, b) => b[1] - a[1])[0]?.[0] ?? ""
+      };
+    }).sort((a, b) => b.lastSeen.localeCompare(a.lastSeen)).slice(0, 1e3),
+    recent: inRange.slice(-50).reverse().map((e) => ({
+      receivedAt: e.receivedAt,
+      install: e.installId.slice(0, 8),
+      kind: e.kind,
+      name: e.name,
+      ms: e.ms,
+      ok: e.ok,
+      version: e.version,
+      client: e.clients.join(",") || "unknown"
+    }))
+  };
 }
-function printSuggestions(suggestions) {
-  if (suggestions.length === 0) {
-    console.log(pc17.dim("no suggestions \u2014 nothing high-signal to report"));
-    return;
+function installTrace(events, prefix) {
+  const own = events.filter((e) => e.installId.startsWith(prefix));
+  const first = own[0];
+  if (!first || !/^[0-9a-f]{8}$/.test(prefix)) return null;
+  const sessions = /* @__PURE__ */ new Map();
+  const perDay = /* @__PURE__ */ new Map();
+  for (const event of own) {
+    perDay.set(dayOf(event.receivedAt), (perDay.get(dayOf(event.receivedAt)) ?? 0) + 1);
+    const key = event.session ?? "none";
+    const session = sessions.get(key) ?? {
+      start: event.ts,
+      end: event.ts,
+      events: 0,
+      errors: 0,
+      ms: 0,
+      features: /* @__PURE__ */ new Set()
+    };
+    if (event.ts < session.start) session.start = event.ts;
+    if (event.ts > session.end) session.end = event.ts;
+    session.events += 1;
+    if (!event.ok) session.errors += 1;
+    session.ms += event.ms;
+    session.features.add(featureOf(event));
+    sessions.set(key, session);
   }
-  for (const suggestion of suggestions) {
-    console.log(`${severityBadge2(suggestion.severity)} ${pc17.bold(suggestion.title)}`);
-    console.log(`  ${suggestion.detail}`);
-    for (const evidence of suggestion.evidence) {
-      console.log(pc17.dim(`  \u21B3 ${evidence.kind}: ${evidence.detail}`));
+  const last = own[own.length - 1] ?? first;
+  return {
+    install: prefix,
+    client: last.clients.join(",") || "unknown",
+    version: last.version,
+    platform: `${last.platform}/${last.arch}`,
+    node: last.node,
+    projects: new Set(own.map((e) => e.project)).size,
+    perDay: [...perDay].map(([date, count]) => ({ date, events: count })),
+    sessions: [...sessions].map(([id, session]) => ({ id, ...session, features: [...session.features] })).sort((a, b) => b.end.localeCompare(a.end)).slice(0, 50),
+    events: own.slice(-1e3).map((e) => ({
+      ts: e.ts,
+      kind: e.kind,
+      name: e.name,
+      feature: featureOf(e),
+      ms: e.ms,
+      ok: e.ok,
+      session: e.session ?? "none",
+      tokensOut: e.tokensOut ?? 0
+    }))
+  };
+}
+async function loadRegistry(dataDir) {
+  const registry = /* @__PURE__ */ new Map();
+  const path = join6(dataDir, "installs.jsonl");
+  const raw = await readFile4(path, "utf8").catch(() => null);
+  if (raw !== null) {
+    for (const line of raw.split("\n")) {
+      try {
+        const entry = JSON.parse(line);
+        if (!registry.has(entry.installId)) registry.set(entry.installId, entry.firstSeen);
+      } catch {
+      }
     }
-    if (suggestion.commandHint) console.log(pc17.dim(`  \u2192 ${suggestion.commandHint}`));
+    return registry;
   }
+  for (const event of await readEvents(dataDir, 3650)) {
+    if (!registry.has(event.installId)) registry.set(event.installId, event.receivedAt);
+  }
+  const lines = [...registry].map(
+    ([installId, firstSeen]) => JSON.stringify({ installId, firstSeen })
+  );
+  await appendFile(path, lines.length ? `${lines.join("\n")}
+` : "");
+  return registry;
 }
-function severityBadge2(severity) {
-  switch (severity) {
-    case "high":
-      return pc17.red("[high]");
-    case "medium":
-      return pc17.yellow("[med ]");
-    case "low":
-      return pc17.cyan("[low ]");
-    default:
-      return pc17.dim("[info]");
+async function npmDownloads(fetchImpl) {
+  const to = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const from = new Date(Date.now() - 364 * 864e5).toISOString().slice(0, 10);
+  try {
+    const response = await fetchImpl(
+      `https://api.npmjs.org/downloads/range/${from}:${to}/${NPM_PACKAGE}`,
+      { signal: AbortSignal.timeout(5e3) }
+    );
+    if (!response.ok) return { error: `npm API ${response.status}` };
+    const body = await response.json();
+    return { package: NPM_PACKAGE, downloads: body.downloads ?? [] };
+  } catch (error) {
+    return { error: error.message };
   }
 }
 
-// src/cli/commands/symbols.ts
-import { readFile as readFile12 } from "fs/promises";
-import { resolve as resolve12 } from "path";
-import pc18 from "picocolors";
-function registerSymbolsCommand(program, runSafely2) {
-  program.command("symbols").argument("<path>", "Repo-relative or absolute path to a code file.").option("--json", "Print machine-readable JSON.").description("List a file's top-level symbols (functions, classes, types, exports).").action(async (path, opts) => {
+// src/cli/commands/telemetry.ts
+function registerTelemetryCommands(program, runSafely2) {
+  const telemetry = program.command("telemetry").description("Show or change anonymous usage telemetry (no prompts, code or paths).");
+  telemetry.command("status").description("Show whether this machine sends anonymous usage data.").action(async () => {
     await runSafely2(async () => {
-      if (!supportsSymbols(path)) {
-        console.log(pc18.dim(`no symbol extraction for ${path} (unsupported language)`));
-        return;
-      }
-      const content = await readFile12(resolve12(path), "utf8");
-      const table = extractSymbolTable(content, path);
-      if (opts.json) {
-        console.log(JSON.stringify({ path, symbols: table }, null, 2));
-        return;
-      }
-      if (table.length === 0) {
-        console.log(pc18.dim("no top-level symbols found"));
-        return;
-      }
-      for (const symbol of table) {
-        const badge = symbol.exported ? pc18.green("export") : pc18.dim("local ");
-        console.log(
-          `${badge} ${pc18.cyan(symbol.kind.padEnd(9))} ${pc18.bold(symbol.name)} ${pc18.dim(`L${symbol.startLine}-${symbol.endLine}`)}`
-        );
-      }
-      console.log(pc18.dim(`
-${table.length} symbol(s)`));
+      const state = await readTelemetryState();
+      const blocked = telemetryBlocked(state);
+      console.log(
+        blocked ? `${pc19.yellow("\u25CB")} telemetry off (${blocked})` : `${pc19.green("\u25CF")} telemetry on`
+      );
+      console.log(pc19.dim(`  install id ${state.installId} (${telemetryStatePath()})`));
+      if (telemetryUrl()) console.log(pc19.dim(`  collector ${telemetryUrl()}`));
+    });
+  });
+  telemetry.command("enable").description("Allow anonymous usage data from this machine.").action(async () => {
+    await runSafely2(async () => {
+      const state = await readTelemetryState();
+      await writeTelemetryState({
+        installId: state.installId,
+        noticeAt: state.noticeAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      });
+      console.log(TELEMETRY_NOTICE);
+      console.log(pc19.green("Telemetry enabled."));
+    });
+  });
+  telemetry.command("disable").description("Stop sending anonymous usage data from this machine.").action(async () => {
+    await runSafely2(async () => {
+      const state = await readTelemetryState();
+      await writeTelemetryState({ ...state, disabled: true });
+      console.log("Telemetry disabled. Nothing more is sent from this machine.");
+    });
+  });
+  program.command("collector").description("[admin] Receive anonymous telemetry and serve the usage admin panel.").option("--data <dir>", "Where events are stored (one JSONL file per day).", "./telemetry-data").option(
+    "--ingest-port <port>",
+    "127.0.0.1 port for POST /v1/events (expose publicly).",
+    Number,
+    8787
+  ).option(
+    "--admin-port <port>",
+    "127.0.0.1 port for the admin panel (keep private).",
+    Number,
+    8788
+  ).action(async (opts) => {
+    await runSafely2(async () => {
+      const collector = await startCollector({
+        dataDir: opts.data,
+        ingestPort: opts.ingestPort,
+        adminPort: opts.adminPort,
+        ...process.env.CODEBUDDY_ADMIN_PASSWORD ? { adminPassword: process.env.CODEBUDDY_ADMIN_PASSWORD } : {}
+      });
+      console.log(`${pc19.green("\u25CF")} ingest ${pc19.bold(collector.ingestUrl)}`);
+      console.log(`${pc19.green("\u25CF")} admin  ${pc19.bold(collector.adminUrl)}`);
+      console.log(
+        pc19.dim(
+          process.env.CODEBUDDY_ADMIN_PASSWORD ? "  admin panel is password-protected (CODEBUDDY_ADMIN_PASSWORD)." : "  admin panel has no password: keep it private, or set CODEBUDDY_ADMIN_PASSWORD."
+        )
+      );
+      console.log(pc19.dim(`  events in ${opts.data}. Ctrl+C to stop.`));
+      await new Promise((resolve6) => {
+        const stop = () => void collector.close().then(resolve6);
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+      });
     });
   });
 }
@@ -4868,45 +4508,45 @@ ${table.length} symbol(s)`));
 // src/cli/commands/use-command.ts
 import { basename as basename2 } from "path";
 import { confirm as confirm2, isCancel as isCancel2, log as log2, note as note2, password as password2, select, spinner as spinner3, text as text2 } from "@clack/prompts";
-import pc19 from "picocolors";
+import pc20 from "picocolors";
 
 // src/core/global-config.ts
-import { chmod, mkdir as mkdir8, readFile as readFile13, writeFile as writeFile3 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname11, join as join15 } from "path";
-import { z as z2 } from "zod";
+import { chmod, mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { homedir } from "os";
+import { dirname as dirname3, join as join7 } from "path";
+import { z as z3 } from "zod";
 var GLOBAL_DIR = ".codebuddy";
 var GLOBAL_FILE = "global.json";
-var globalConfigSchema = z2.object({
-  hfToken: z2.string().min(1).optional(),
-  databaseUrl: z2.string().min(1).optional(),
+var globalConfigSchema = z3.object({
+  hfToken: z3.string().min(1).optional(),
+  databaseUrl: z3.string().min(1).optional(),
   // Where the codebuddy install lives on this machine. Cached so future
   // `codebuddy use` calls in unrelated projects can find the CLI entry
   // without re-resolving via process.argv every time.
-  installPath: z2.string().optional()
+  installPath: z3.string().optional()
 });
-function globalConfigPath(home = homedir3()) {
-  return join15(home, GLOBAL_DIR, GLOBAL_FILE);
+function globalConfigPath(home = homedir()) {
+  return join7(home, GLOBAL_DIR, GLOBAL_FILE);
 }
-async function readGlobalConfig(home = homedir3()) {
+async function readGlobalConfig(home = homedir()) {
   const path = globalConfigPath(home);
   try {
-    const raw = await readFile13(path, "utf8");
+    const raw = await readFile5(path, "utf8");
     return globalConfigSchema.parse(JSON.parse(raw));
   } catch (error) {
     if (error.code === "ENOENT") return {};
     throw error;
   }
 }
-async function writeGlobalConfig(next, home = homedir3()) {
+async function writeGlobalConfig(next, home = homedir()) {
   const path = globalConfigPath(home);
-  await mkdir8(dirname11(path), { recursive: true, mode: 448 });
+  await mkdir3(dirname3(path), { recursive: true, mode: 448 });
   await writeFile3(path, `${JSON.stringify(next, null, 2)}
 `, { mode: 384 });
   await chmod(path, 384);
   return { path };
 }
-async function mergeGlobalConfig(patch, home = homedir3()) {
+async function mergeGlobalConfig(patch, home = homedir()) {
   const current = await readGlobalConfig(home);
   const merged = { ...current, ...patch };
   const { path } = await writeGlobalConfig(merged, home);
@@ -4952,15 +4592,15 @@ async function runUseCommand(options = {}) {
       })
     ));
     note2(
-      `Project folder: ${pc19.bold(process.cwd())}
-Namespace:      ${pc19.bold(namespace)}`,
+      `Project folder: ${pc20.bold(process.cwd())}
+Namespace:      ${pc20.bold(namespace)}`,
       "codebuddy use"
     );
     const stored = await readGlobalConfig();
     const projectConfig = await readConfigFile();
     let embeddings = projectConfig.provider?.type;
     if (embeddings) {
-      log2.info(`Embeddings: ${embeddings} (change with ${pc19.cyan("codebuddy models use")}).`);
+      log2.info(`Embeddings: ${embeddings} (change with ${pc20.cyan("codebuddy models use")}).`);
     } else if (!interactive) {
       embeddings = "local";
     } else {
@@ -5001,7 +4641,7 @@ Namespace:      ${pc19.bold(namespace)}`,
       log2.info("Using HF_TOKEN from environment.");
     } else if (stored.hfToken) {
       hfToken = stored.hfToken;
-      log2.info(`Reusing saved Hugging Face token (${pc19.dim("~/.codebuddy/global.json")}).`);
+      log2.info(`Reusing saved Hugging Face token (${pc20.dim("~/.codebuddy/global.json")}).`);
     } else if (!interactive) {
       throw new Error(
         "Hugging Face embeddings need a token: set HF_TOKEN (no terminal to prompt for it)."
@@ -5054,7 +4694,7 @@ Namespace:      ${pc19.bold(namespace)}`,
         if (result.code === 0) {
           composeSpinner.stop("Postgres container started.");
           for (let attempt = 0; attempt < 12 && !connected; attempt++) {
-            await new Promise((resolve13) => setTimeout(resolve13, 500));
+            await new Promise((resolve6) => setTimeout(resolve6, 500));
             connected = await pingOnce2(databaseUrl);
           }
           if (!connected) {
@@ -5135,7 +4775,7 @@ Namespace:      ${pc19.bold(namespace)}`,
           databaseUrl
         });
         log2.success(
-          `Registered ${pc19.bold(install.serverKey)} in Claude Desktop. Restart with \u2318Q to activate.`
+          `Registered ${pc20.bold(install.serverKey)} in Claude Desktop. Restart with \u2318Q to activate.`
         );
       } catch (error) {
         log2.warn(`Claude Desktop registration skipped: ${error.message}`);
@@ -5150,7 +4790,7 @@ Namespace:      ${pc19.bold(namespace)}`,
           databaseUrl
         });
         log2.success(
-          `Registered ${pc19.bold(install.serverKey)} in Codex. Restart Codex to activate.`
+          `Registered ${pc20.bold(install.serverKey)} in Codex. Restart Codex to activate.`
         );
       } catch (error) {
         log2.warn(`Codex registration skipped: ${error.message}`);
@@ -5158,24 +4798,24 @@ Namespace:      ${pc19.bold(namespace)}`,
     }
     note2(
       [
-        `${pc19.green("\u2713")} CodeBuddy is ready for ${pc19.bold(folderName)}.`,
-        `${pc19.green("\u2713")} Scaffolded ${pc19.cyan(".codebuddy/policies.yaml")} for project-specific guardrails.`,
-        `${pc19.green("\u2713")} ${graphifyMessage}`,
-        `${pc19.green("\u2713")} Added agent workflow instructions to ${pc19.cyan("CLAUDE.md")} and ${pc19.cyan("AGENTS.md")}.`,
+        `${pc20.green("\u2713")} CodeBuddy is ready for ${pc20.bold(folderName)}.`,
+        `${pc20.green("\u2713")} Scaffolded ${pc20.cyan(".codebuddy/policies.yaml")} for project-specific guardrails.`,
+        `${pc20.green("\u2713")} ${graphifyMessage}`,
+        `${pc20.green("\u2713")} Added agent workflow instructions to ${pc20.cyan("CLAUDE.md")} and ${pc20.cyan("AGENTS.md")}.`,
         ``,
         `Next:`,
         `  1. Restart Claude Desktop and Codex.`,
-        `  2. Ask Claude or Codex to use the ${pc19.cyan("context_pack")} tool for each coding task.`,
+        `  2. Ask Claude or Codex to use the ${pc20.cyan("context_pack")} tool for each coding task.`,
         `  3. Indexing, Graphify, Markdown memory import, and embeddings now update automatically while the MCP server is running.`,
-        `  4. Run ${pc19.cyan("codebuddy doctor")} or ${pc19.cyan("codebuddy db doctor")} if you want a full health check.`,
+        `  4. Run ${pc20.cyan("codebuddy doctor")} or ${pc20.cyan("codebuddy db doctor")} if you want a full health check.`,
         ``,
         `Manage:`,
-        `  codebuddy claude list           ${pc19.dim("# see every project wired up")}`,
-        `  codebuddy codex list            ${pc19.dim("# see Codex entries")}`,
-        `  codebuddy db test               ${pc19.dim("# quick Postgres connectivity check")}`,
+        `  codebuddy claude list           ${pc20.dim("# see every project wired up")}`,
+        `  codebuddy codex list            ${pc20.dim("# see Codex entries")}`,
+        `  codebuddy db test               ${pc20.dim("# quick Postgres connectivity check")}`,
         `  codebuddy claude remove codebuddy-${namespace}`,
         `  codebuddy codex remove codebuddy-${namespace}`,
-        `  codebuddy postgres down         ${pc19.dim("# stop the DB (data preserved)")}`
+        `  codebuddy postgres down         ${pc20.dim("# stop the DB (data preserved)")}`
       ].join("\n"),
       "Done"
     );
@@ -5186,7 +4826,7 @@ Namespace:      ${pc19.bold(namespace)}`,
 
 // src/cli/commands/worklog.ts
 import { relative as relative6 } from "path";
-import pc20 from "picocolors";
+import pc21 from "picocolors";
 function registerWorklogCommands(program, runSafely2) {
   const worklog = program.command("worklog").description("Inspect the cross-chat worklog of completed turns.");
   worklog.command("list", { isDefault: true }).option("--limit <n>", "Maximum entries to show.", "20").option("--json", "Print machine-readable JSON.").description("List worklog entries, newest first.").action(async (opts) => {
@@ -5197,7 +4837,7 @@ function registerWorklogCommands(program, runSafely2) {
         return;
       }
       if (entries.length === 0) {
-        console.log(pc20.dim("no worklog entries yet"));
+        console.log(pc21.dim("no worklog entries yet"));
         return;
       }
       for (const entry of entries) console.log(renderRow2(entry));
@@ -5211,36 +4851,36 @@ function registerWorklogCommands(program, runSafely2) {
   worklog.command("latest").description("Show the most recent worklog entry.").action(async () => {
     await runSafely2(async () => {
       const [entry] = await new WorklogStore().list();
-      console.log(entry ? renderEntry(entry) : pc20.dim("no worklog entries yet"));
+      console.log(entry ? renderEntry(entry) : pc21.dim("no worklog entries yet"));
     });
   });
 }
 function renderRow2(entry) {
   const summary = entry.summary.replace(/\s+/g, " ");
-  const short = summary.length <= 70 ? summary : `${summary.slice(0, 69)}\u2026`;
-  return `${pc20.dim(entry.createdAt.slice(0, 16))}  ${pc20.dim(entry.id)}  ${short}  ${pc20.dim(`(${entry.files.length} file(s))`)}`;
+  const short2 = summary.length <= 70 ? summary : `${summary.slice(0, 69)}\u2026`;
+  return `${pc21.dim(entry.createdAt.slice(0, 16))}  ${pc21.dim(entry.id)}  ${short2}  ${pc21.dim(`(${entry.files.length} file(s))`)}`;
 }
 function renderEntry(entry) {
-  const lines = [`${pc20.bold(entry.id)}  ${pc20.dim(entry.createdAt)}  ${pc20.dim(entry.namespace)}`];
-  if (entry.sourceSessionId) lines.push(`${pc20.bold("session:")} ${entry.sourceSessionId}`);
-  if (entry.sourcePlanId) lines.push(`${pc20.bold("plan:")} ${entry.sourcePlanId}`);
-  if (entry.commitSha) lines.push(`${pc20.bold("commit:")} ${entry.commitSha}`);
-  if (entry.files.length > 0) lines.push(`${pc20.bold("files:")} ${entry.files.join(", ")}`);
+  const lines = [`${pc21.bold(entry.id)}  ${pc21.dim(entry.createdAt)}  ${pc21.dim(entry.namespace)}`];
+  if (entry.sourceSessionId) lines.push(`${pc21.bold("session:")} ${entry.sourceSessionId}`);
+  if (entry.sourcePlanId) lines.push(`${pc21.bold("plan:")} ${entry.sourcePlanId}`);
+  if (entry.commitSha) lines.push(`${pc21.bold("commit:")} ${entry.commitSha}`);
+  if (entry.files.length > 0) lines.push(`${pc21.bold("files:")} ${entry.files.join(", ")}`);
   if (entry.verification.length > 0) {
-    lines.push(`${pc20.bold("verification:")}`, ...entry.verification.map((line) => `  - ${line}`));
+    lines.push(`${pc21.bold("verification:")}`, ...entry.verification.map((line) => `  - ${line}`));
   }
   if (entry.savedMemory.length > 0) {
-    lines.push(`${pc20.bold("saved memory:")} ${entry.savedMemory.join(", ")}`);
+    lines.push(`${pc21.bold("saved memory:")} ${entry.savedMemory.join(", ")}`);
   }
   if (entry.queuedForReview.length > 0) {
-    lines.push(`${pc20.bold("queued for review:")} ${entry.queuedForReview.join(", ")}`);
+    lines.push(`${pc21.bold("queued for review:")} ${entry.queuedForReview.join(", ")}`);
   }
-  lines.push("", entry.summary, "", pc20.dim(relative6(process.cwd(), entry.path)));
+  lines.push("", entry.summary, "", pc21.dim(relative6(process.cwd(), entry.path)));
   return lines.join("\n");
 }
 
 // src/cli/commands/zvec.ts
-import pc21 from "picocolors";
+import pc22 from "picocolors";
 function registerZvecCommands(program, runSafely2) {
   const zvec = program.command("zvec").description("Optional zvec-grep semantic file discovery for the context tools.");
   zvec.command("status", { isDefault: true }).option("--json", "Print machine-readable JSON.").description("Show whether zvec-grep is enabled, installed, supported and indexed.").action(async (opts) => {
@@ -5250,22 +4890,22 @@ function registerZvecCommands(program, runSafely2) {
         console.log(JSON.stringify(report, null, 2));
         return;
       }
-      const mark = (ok2) => ok2 ? pc21.green("yes") : pc21.yellow("no");
+      const mark = (ok2) => ok2 ? pc22.green("yes") : pc22.yellow("no");
       console.log(`enabled:      ${mark(report.enabled)}`);
       console.log(`binary:       ${report.binary}`);
       console.log(
-        `version:      ${report.version ?? pc21.yellow("not found")}${report.version && !report.supported ? pc21.yellow(" (unsupported; need 0.2.x)") : ""}`
+        `version:      ${report.version ?? pc22.yellow("not found")}${report.version && !report.supported ? pc22.yellow(" (unsupported; need 0.2.x)") : ""}`
       );
       console.log(`index ready:  ${mark(report.indexReady)}`);
       console.log(
-        `zg server:    ${report.server} ${pc21.dim("(running = faster queries; optional)")}`
+        `zg server:    ${report.server} ${pc22.dim("(running = faster queries; optional)")}`
       );
       console.log(`status:       ${report.reason}`);
-      if (!report.version) console.log(pc21.dim("install: npm install -g @zvec/zvec-grep"));
+      if (!report.version) console.log(pc22.dim("install: npm install -g @zvec/zvec-grep"));
       else if (report.supported && !report.indexReady)
-        console.log(pc21.dim("next: codebuddy zvec index"));
+        console.log(pc22.dim("next: codebuddy zvec index"));
       else if (report.indexReady && !report.enabled)
-        console.log(pc21.dim("next: codebuddy zvec enable"));
+        console.log(pc22.dim("next: codebuddy zvec enable"));
     });
   });
   zvec.command("index").option("--model <model>", "Embedding model for a new index.", DEFAULT_ZVEC_MODEL).option("--rebuild", "Rebuild the index from scratch (e.g. after changing model).").description("Build or refresh the zg index for this repository (explicit; never automatic).").action(async (opts) => {
@@ -5275,21 +4915,21 @@ function registerZvecCommands(program, runSafely2) {
         ...opts.rebuild ? { rebuild: true } : {}
       });
       if (code !== 0) throw new Error(`zg index exited with code ${code}`);
-      console.log(pc21.dim("next: codebuddy zvec enable (.zvec-grep/ ignores itself in git)"));
+      console.log(pc22.dim("next: codebuddy zvec enable (.zvec-grep/ ignores itself in git)"));
     });
   });
   zvec.command("enable").description("Use zvec-grep candidates in context_pack / context_before_edit.").action(async () => {
     await runSafely2(async () => {
       await setZvecEnabled(true);
       console.log(
-        `${pc21.green("enabled")} zvec-grep retrieval (falls back to keywords if unavailable)`
+        `${pc22.green("enabled")} zvec-grep retrieval (falls back to keywords if unavailable)`
       );
     });
   });
   zvec.command("disable").description("Stop using zvec-grep; keyword ranking only.").action(async () => {
     await runSafely2(async () => {
       await setZvecEnabled(false);
-      console.log(`${pc21.yellow("disabled")} zvec-grep retrieval`);
+      console.log(`${pc22.yellow("disabled")} zvec-grep retrieval`);
     });
   });
 }
@@ -5598,6 +5238,13 @@ function createCli() {
   registerClientsCommands(program, runSafely);
   registerGitHubCommands(program, runSafely);
   registerSymbolsCommand(program, runSafely);
+  registerTelemetryCommands(program, runSafely);
+  let started = Date.now();
+  program.hook("preAction", () => {
+    started = Date.now();
+    return showTelemetryNoticeOnce();
+  });
+  program.hook("postAction", (_program, command) => traceCliCommand(command, started));
   program.action(async () => {
     await runSafely(() => runUseCommand());
   });
@@ -5625,17 +5272,20 @@ var HELP_GROUPS = [
       "prune"
     ]
   ],
-  ["Integrations:", ["serve", "claude", "codex", "github", "rules", "learn", "eval"]]
+  [
+    "Integrations:",
+    ["serve", "claude", "codex", "github", "rules", "learn", "eval", "telemetry", "collector"]
+  ]
 ];
 function groupHelp(program) {
   const groupOf = new Map(
-    HELP_GROUPS.flatMap(([group, names]) => names.map((name) => [name, group]))
+    HELP_GROUPS.flatMap(([group, names]) => names.map((name2) => [name2, group]))
   );
   for (const command of program.commands) {
     command.helpGroup(groupOf.get(command.name()) ?? "Other:");
   }
   const position = new Map(
-    HELP_GROUPS.flatMap(([, names]) => names).map((name, index) => [name, index])
+    HELP_GROUPS.flatMap(([, names]) => names).map((name2, index) => [name2, index])
   );
   program.commands.sort(
     (a, b) => (position.get(a.name()) ?? 999) - (position.get(b.name()) ?? 999)
@@ -5665,7 +5315,7 @@ async function runSafely(fn) {
   try {
     await fn();
   } catch (error) {
-    console.error(pc22.red(String(redactSecrets(error.message))));
+    console.error(pc23.red(String(redactSecrets(error.message))));
     process.exitCode = 1;
   }
 }
@@ -5679,9 +5329,9 @@ function parseDuration(value) {
   return amount * 60 * 1e3;
 }
 function printDoctor(report) {
-  const ok2 = pc22.green("ok");
-  const bad = pc22.red("fail");
-  const warn2 = pc22.yellow("warn");
+  const ok2 = pc23.green("ok");
+  const bad = pc23.red("fail");
+  const warn2 = pc23.yellow("warn");
   console.log(`scaffold root: ${report.scaffold.codebuddyDir.ok ? ok2 : bad}`);
   if (report.scaffold.codebuddyDir.warning)
     console.log(`  ${report.scaffold.codebuddyDir.warning}`);
@@ -5707,7 +5357,7 @@ function printDoctor(report) {
   );
   console.log(`estimated daily cap remaining: ${report.usage.estimatedDailyCapRemaining}`);
   if (report.usage.warning80Percent)
-    console.log(pc22.yellow("usage warning: daily cap is over 80% used"));
+    console.log(pc23.yellow("usage warning: daily cap is over 80% used"));
   console.log(
     `config permissions: ${report.config.exists ? report.config.mode : "missing"} ${report.config.ok ? ok2 : warn2}`
   );
@@ -5717,9 +5367,9 @@ function printDoctor(report) {
   }
 }
 function printDbDoctor(report) {
-  const ok2 = pc22.green("ok");
-  const bad = pc22.red("fail");
-  const warn2 = pc22.yellow("warn");
+  const ok2 = pc23.green("ok");
+  const bad = pc23.red("fail");
+  const warn2 = pc23.yellow("warn");
   console.log(`DB connectivity: ${report.db.ok ? ok2 : bad}`);
   if (report.db.postgresUrlSource) console.log(`  url source: ${report.db.postgresUrlSource}`);
   if (report.db.error) console.log(`  ${report.db.error}`);
@@ -5735,4 +5385,4 @@ function printDbDoctor(report) {
 export {
   createCli
 };
-//# sourceMappingURL=main-AHNGHC4L.js.map
+//# sourceMappingURL=main-YJKSYFPT.js.map