@orquentra/codebuddy 2.7.0 → 2.8.0

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

@@ -1,6 +1,48 @@
+import {
+  renderLeanBlock,
+  runLeanHookCommand
+} from "./chunk-UK6XTS2Y.js";
 import {
   runPreToolHookCommand
-} from "./chunk-AQHPEJR6.js";
+} from "./chunk-EJQVGFH2.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,25 @@ 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,
+  watchRepository,
+  writeTelemetryState
+} from "./chunk-6DONJW3W.js";
 import {
   DEFAULT_ZVEC_MODEL,
   buildZvecIndex,
   zvecStatus
-} from "./chunk-MSUAVR3R.js";
+} from "./chunk-GXOML4UZ.js";
 import {
   PlanFileStore,
   PlanLifecycle,
@@ -49,21 +90,21 @@ import {
   runResetHook,
   runStageHook,
   runSyncHook
-} from "./chunk-YJIA2MFL.js";
-import {
-  parseTraceLines,
-  readTraces,
-  tracePath
-} from "./chunk-TUR6YKEE.js";
-import "./chunk-DFV2SK6C.js";
+} from "./chunk-ZNLSCV3J.js";
 import {
   SessionCapsuleLedger,
   detectTestCommand,
   estimateTokens
 } from "./chunk-GKNYMNFM.js";
+import {
+  parseTraceLines,
+  readTraces,
+  tracePath
+} from "./chunk-XL2HLACE.js";
 import {
   hookRoot
 } from "./chunk-TGFTKWOR.js";
+import "./chunk-DFV2SK6C.js";
 import {
   bootstrapDatabase,
   buildProviderFromConfig,
@@ -75,11 +116,11 @@ import {
   pingDatabase,
   runDoctor,
   runMigrations
-} from "./chunk-AK2UAE32.js";
+} from "./chunk-NY2YXP3R.js";
 import {
   MemoryFileStore,
   VERSION
-} from "./chunk-JUAFCLRB.js";
+} from "./chunk-6KGYAFG7.js";
 import {
   computeFactHash,
   generateEntityId
@@ -92,23 +133,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 +186,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 +378,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 +403,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 +415,7 @@ ${output.slice(-MAX_TEST_OUTPUT_CHARS)}`;
     });
     child.on("error", (error) => {
       clearTimeout(timer);
-      resolve13({
+      resolve6({
         status: "failed",
         command,
         source,
@@ -585,1016 +626,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 +666,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);
@@ -1636,546 +678,50 @@ async function hookBlockTokens(root, namespace) {
     const leanFirst = await renderLean();
     await ledger.markSent("lean", leanFirst.emitted);
     const leanLater = await renderLean();
-    return {
-      first: estimateTokens(first.text),
-      later: estimateTokens(later.text),
-      lean: { first: estimateTokens(leanFirst.text), later: estimateTokens(leanLater.text) }
-    };
-  } finally {
-    await rm3(scratch, { recursive: true, force: true });
-  }
-}
-async function measureClientCosts(projectRoot = process.cwd(), namespace) {
-  const root = resolve7(projectRoot);
-  const ns = namespace ?? await resolveNamespaceFrom(root);
-  const mcpSchema = await mcpSchemaTokens(root, ns);
-  const block = await hookBlockTokens(root, ns);
-  return CLIENT_IDS.flatMap((client) => {
-    const adapter = CLIENT_ADAPTERS[client];
-    return supportedModes(adapter).flatMap((mode) => {
-      if (mode === "mcp-only") return [];
-      if (mode === "lean") {
-        const later2 = adapter.ephemeralContext ? block.lean.first : block.lean.later;
-        return [
-          { client, mode, rules: 0, mcpSchema: 0, firstBlock: block.lean.first, laterBlock: later2 }
-        ];
-      }
-      const hooks = mode === "hooks";
-      const later = adapter.ephemeralContext ? block.first : block.later;
-      return [
-        {
-          client,
-          mode,
-          rules: estimateTokens(renderManagedBlock(client, mode)),
-          mcpSchema: adapter.defersMcpSchemas ? mcpSchema.listing : mcpSchema.full,
-          firstBlock: hooks ? block.first : 0,
-          laterBlock: hooks ? later : 0
-        }
-      ];
-    });
-  });
-}
-
-// 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 {
+      first: estimateTokens(first.text),
+      later: estimateTokens(later.text),
+      lean: { first: estimateTokens(leanFirst.text), later: estimateTokens(leanLater.text) }
+    };
+  } finally {
+    await rm(scratch, { recursive: true, force: true });
   }
-  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 };
+async function measureClientCosts(projectRoot = process.cwd(), namespace) {
+  const root = resolve2(projectRoot);
+  const ns = namespace ?? await resolveNamespaceFrom(root);
+  const mcpSchema = await mcpSchemaTokens(root, ns);
+  const block = await hookBlockTokens(root, ns);
+  return CLIENT_IDS.flatMap((client) => {
+    const adapter = CLIENT_ADAPTERS[client];
+    return supportedModes(adapter).flatMap((mode) => {
+      if (mode === "mcp-only") return [];
+      if (mode === "lean") {
+        const later2 = adapter.ephemeralContext ? block.lean.first : block.lean.later;
+        return [
+          { client, mode, rules: 0, mcpSchema: 0, firstBlock: block.lean.first, laterBlock: later2 }
+        ];
+      }
+      const hooks = mode === "hooks";
+      const later = adapter.ephemeralContext ? block.first : block.later;
+      return [
+        {
+          client,
+          mode,
+          rules: estimateTokens(renderManagedBlock(client, mode)),
+          mcpSchema: adapter.defersMcpSchemas ? mcpSchema.listing : mcpSchema.full,
+          firstBlock: hooks ? block.first : 0,
+          laterBlock: hooks ? later : 0
+        }
+      ];
+    });
+  });
 }
 
 // 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 +731,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 +742,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 +795,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 +814,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 {
@@ -3008,12 +1554,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 +1567,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 +1609,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 +1622,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 +1799,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 +1920,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 +2126,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 +2418,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 +2704,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 +3048,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 +3066,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) {
@@ -4833,8 +3380,8 @@ function severityBadge2(severity) {
 }
 
 // src/cli/commands/symbols.ts
-import { readFile as readFile12 } from "fs/promises";
-import { resolve as resolve12 } from "path";
+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) => {
@@ -4843,7 +3390,7 @@ function registerSymbolsCommand(program, runSafely2) {
         console.log(pc18.dim(`no symbol extraction for ${path} (unsupported language)`));
         return;
       }
-      const content = await readFile12(resolve12(path), "utf8");
+      const content = await readFile3(resolve5(path), "utf8");
       const table = extractSymbolTable(content, path);
       if (opts.json) {
         console.log(JSON.stringify({ path, symbols: table }, null, 2));
@@ -4865,48 +3412,712 @@ ${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; --line: #e2e1dc;
+  --bar: #2a78d6; --bar-soft: #e3edfa; --bad: #b42318;
+  --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: #121211; --panel: #1a1a19; --fg: #f0efec; --muted: #c3c2b7; --line: #2e2e2b;
+  --bar: #3987e5; --bar-soft: #1d2b3d; --bad: #f97066; color-scheme: dark } }
+* { box-sizing: border-box; }
+body { margin: 0; background: var(--bg); color: var(--fg); font: 14px/1.5 var(--sans); }
+.wrap { max-width: 1200px; margin: 0 auto; padding: 20px 16px 48px; display: grid; gap: 16px; }
+.wrap > * { min-width: 0; }
+header { display: flex; flex-wrap: wrap; align-items: center; gap: 12px 20px; }
+h1 { font-size: 20px; margin: 0; letter-spacing: -.01em; }
+h1 small { font: 500 13px var(--mono); color: var(--muted); margin-left: 8px; }
+h2 { font-size: 13px; margin: 0 0 10px; text-transform: uppercase; letter-spacing: .08em; color: var(--muted); font-weight: 600; }
+.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 12px; cursor: pointer; }
+.seg button + button { border-left: 1px solid var(--line); }
+.seg button[aria-pressed="true"] { background: var(--fg); color: var(--bg); }
+.seg button:focus-visible { outline: 2px solid var(--bar); outline-offset: -2px; }
+.kpis { display: grid; grid-template-columns: repeat(auto-fit, minmax(160px, 1fr)); gap: 12px; }
+.kpi { background: var(--panel); border: 1px solid var(--line); border-radius: 10px; padding: 12px 14px; }
+.kpi .label { font-size: 12px; color: var(--muted); }
+.kpi .value { font: 600 28px/1.2 var(--mono); font-variant-numeric: tabular-nums; margin-top: 4px; }
+.kpi .sub { font-size: 12px; color: var(--muted); margin-top: 2px; }
+.panel { background: var(--panel); border: 1px solid var(--line); border-radius: 10px; padding: 14px 16px; min-width: 0; position: relative; }
+.cols { display: grid; grid-template-columns: repeat(auto-fit, minmax(320px, 1fr)); gap: 16px; }
+.chart svg { display: block; width: 100%; height: 180px; }
+.chart rect.hit { fill: transparent; }
+.chart rect.hit:hover + rect.mark, .chart rect.mark:hover { opacity: .75; }
+svg text { fill: var(--muted); font: 11px var(--mono); }
+.tip { position: absolute; pointer-events: none; background: var(--fg); color: var(--bg); font: 12px var(--mono); padding: 4px 8px; border-radius: 6px; white-space: nowrap; display: none; z-index: 2; }
+.rows { display: grid; gap: 6px; }
+.row { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 2px 12px; font-size: 13px; }
+.row .track { grid-column: 1 / -1; height: 6px; background: var(--bar-soft); border-radius: 3px; }
+.row .fill { height: 6px; background: var(--bar); border-radius: 3px; }
+.row .n { font-family: var(--mono); font-variant-numeric: tabular-nums; color: var(--muted); }
+.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; }
+td { padding: 6px 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; }
+.bad { color: var(--bad); }
+.muted { color: var(--muted); }
+.mono { font-family: var(--mono); }
+.btn { border: 1px solid var(--line); background: var(--panel); color: var(--fg); font: 500 12px var(--sans); padding: 6px 12px; border-radius: 8px; cursor: pointer; }
+.btn:focus-visible { outline: 2px solid var(--bar); outline-offset: 2px; }
+.users { max-height: 560px; overflow: auto; }
+.users thead th { position: sticky; top: 0; background: var(--panel); }
+.empty { padding: 32px 16px; text-align: center; color: var(--muted); }
+</style>
+</head>
+<body>
+<div class="wrap">
+  <header>
+    <h1>CodeBuddy usage<small id="updated"></small></h1>
+    <span class="spacer"></span>
+    <div class="seg" role="group" aria-label="Time range" id="range">
+      <button data-days="7">7 days</button>
+      <button data-days="30" aria-pressed="true">30 days</button>
+      <button data-days="90">90 days</button>
+      <button data-days="365">1 year</button>
+    </div>
+  </header>
+  <section class="kpis" id="kpis" aria-label="Summary"></section>
+  <div class="cols">
+    <section class="panel"><h2>Daily active installs</h2><div class="chart" id="active"></div></section>
+    <section class="panel"><h2>npm downloads per day</h2><div class="chart" id="npm"></div></section>
+  </div>
+  <section class="panel"><h2>Feature usage</h2><div class="scroll" id="features"></div></section>
+  <div class="cols">
+    <section class="panel"><h2>Agent clients</h2><div class="rows" id="clients"></div></section>
+    <section class="panel"><h2>Versions</h2><div class="rows" id="versions"></div></section>
+    <section class="panel"><h2>Platforms</h2><div class="rows" id="platforms"></div></section>
+  </div>
+  <section class="panel">
+    <div style="display:flex;align-items:center;gap:12px;margin-bottom:10px"><h2 style="margin:0">Users</h2><span class="muted" id="userCount" style="font-size:12px"></span><span class="spacer"></span><button class="btn" id="csv">Download CSV</button></div>
+    <div class="scroll users" id="users"></div>
+  </section>
+  <section class="panel"><h2>Latest events</h2><div class="scroll" id="recent"></div></section>
+  <p class="muted" style="margin:0;font-size:12px">Anonymous telemetry from installs that did not opt out: random install ids, tool names, timings and versions. No prompts, code, paths or repository names are collected. Shares count each install once, from its latest batch.</p>
+</div>
+<div class="tip" id="tip"></div>
+<script>
+(function () {
+  var days = 30;
+  // Works at "/" and under a proxy mount such as "/admin" (with or without a trailing slash).
+  var base = location.pathname.replace(/\\/?$/, "/");
+  var summary = null;
+  var npm = null;
+  var tip = document.getElementById("tip");
+
+  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.1 ? 1 : 0) + "%"; }
+  function ms(n) { return n >= 1000 ? (n / 1000).toFixed(1) + " s" : Math.round(n) + " ms"; }
+
+  function kpi(label, value, sub) {
+    return '<div class="kpi"><div class="label">' + esc(label) + '</div><div class="value">' + esc(value) +
+      '</div><div class="sub">' + esc(sub || "") + "</div></div>";
+  }
+
+  /** Bars of one measure over days; hover shows the exact value. */
+  function bars(points, label) {
+    if (!points.length) return '<div class="empty">No data yet.</div>';
+    var w = 600, h = 180, top = 10, bottom = 22, left = 36;
+    var max = Math.max.apply(null, points.map(function (p) { return p.value; }).concat([1]));
+    var step = (w - left) / points.length;
+    var bw = Math.max(1, step - 2);
+    var out = '<svg viewBox="0 0 ' + w + " " + h + '" preserveAspectRatio="none" role="img" aria-label="' + esc(label) + '">';
+    [0, 0.5, 1].forEach(function (f) {
+      var y = top + (h - top - bottom) * (1 - f);
+      out += '<line x1="' + left + '" x2="' + w + '" y1="' + y + '" y2="' + y + '" stroke="var(--line)" stroke-width="1"/>';
+      out += '<text x="' + (left - 6) + '" y="' + (y + 4) + '" text-anchor="end">' + esc(compact(max * f)) + "</text>";
+    });
+    points.forEach(function (p, i) {
+      var bh = (h - top - bottom) * (p.value / max);
+      var x = left + i * step + 1;
+      var tipText = esc(p.date + " \xB7 " + num(p.value) + " " + label);
+      out += '<rect class="hit" x="' + (left + i * step) + '" y="' + top + '" width="' + step + '" height="' + (h - top - bottom) + '" data-tip="' + tipText + '"/>';
+      out += '<rect class="mark" x="' + x + '" y="' + (h - bottom - bh) + '" width="' + bw + '" height="' + bh + '" rx="' + Math.min(2, bw / 2) + '" fill="var(--bar)" data-tip="' + tipText + '"/>';
+    });
+    var first = points[0].date, last = points[points.length - 1].date;
+    out += '<text x="' + left + '" y="' + (h - 6) + '">' + esc(first) + '</text><text x="' + w + '" y="' + (h - 6) + '" text-anchor="end">' + esc(last) + "</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 npmPoints() {
+    if (!npm || !npm.downloads) return [];
+    return npm.downloads.slice(-Math.min(days, 365)).map(function (d) { return { date: d.day, value: d.downloads }; });
+  }
+  function npmTotal(n) {
+    if (!npm || !npm.downloads) return null;
+    return npm.downloads.slice(-n).reduce(function (sum, d) { return sum + d.downloads; }, 0);
+  }
+
+  function render() {
+    if (!summary) return;
+    var t = summary.totals;
+    var npm30 = npmTotal(30), npm365 = npmTotal(365);
+    document.getElementById("updated").textContent = "updated " + new Date(summary.generatedAt).toLocaleTimeString();
+    document.getElementById("kpis").innerHTML =
+      kpi("Active installs \xB7 7 days", num(t.active7d), num(t.active1d) + " today") +
+      kpi("Active installs \xB7 30 days", num(t.active30d), num(t.newToday) + " new today") +
+      kpi("Installs in range", num(t.installs), num(t.projects) + " projects") +
+      kpi("Agent sessions", num(t.sessions), "in " + summary.days + " days") +
+      kpi("Events", compact(t.events), pct(1 - t.errorRate) + " succeeded") +
+      kpi("Tokens delivered", compact(t.tokensOut), "context sent to agents") +
+      kpi("npm downloads \xB7 30 days", npm30 == null ? "\u2013" : num(npm30), npm365 == null ? (npm && npm.error ? npm.error : "") : num(npm365) + " in the last year");
+    document.getElementById("active").innerHTML = bars(summary.daily.map(function (d) { return { date: d.date, value: d.installs }; }), "active installs");
+    document.getElementById("npm").innerHTML = npm && npm.error ? '<div class="empty">' + esc(npm.error) + "</div>" : bars(npmPoints(), "downloads");
+    document.getElementById("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\\">Errors</th></tr></thead><tbody>" +
+        summary.features.map(function (f) {
+          return "<tr><td class=\\"mono\\">" + esc(f.label) + '</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' + (f.errorRate > 0.05 ? " bad" : "") + '">' + pct(f.errorRate) + "</td></tr>";
+        }).join("") + "</tbody></table>"
+      : '<div class="empty">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);
+    document.getElementById("clients").innerHTML = rows(summary.clients, installs);
+    document.getElementById("versions").innerHTML = rows(summary.versions, installs);
+    document.getElementById("platforms").innerHTML = rows(summary.platforms, installs);
+    document.getElementById("userCount").textContent = num(summary.users.length) + " installs seen in " + summary.days + " days";
+    document.getElementById("users").innerHTML = summary.users.length
+      ? "<table><thead><tr><th>Install</th><th>First seen</th><th>Last active</th><th class=\\"n\\">Events</th><th class=\\"n\\">Sessions</th><th class=\\"n\\">Projects</th><th>Client</th><th>Version</th><th>Platform</th><th>Top feature</th></tr></thead><tbody>" +
+        summary.users.map(function (u) {
+          return '<tr><td class="mono">' + esc(u.install) + "</td><td>" + esc(new Date(u.firstSeen).toLocaleDateString()) + "</td><td>" + esc(new Date(u.lastSeen).toLocaleString()) +
+            '</td><td class="n">' + num(u.events) + '</td><td class="n">' + num(u.sessions) + '</td><td class="n">' + num(u.projects) + "</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">No users yet.</div>';
+    document.getElementById("recent").innerHTML = summary.recent.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>" +
+        summary.recent.map(function (e) {
+          return "<tr><td>" + esc(new Date(e.receivedAt).toLocaleString()) + '</td><td class="mono">' + esc(e.install) + "</td><td>" + 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" : "error") + "</td></tr>";
+        }).join("") + "</tbody></table>"
+      : '<div class="empty">No events yet.</div>';
+  }
+
+  function load() {
+    fetch(base + "api/summary?days=" + days).then(function (r) { return r.json(); }).then(function (s) { summary = s; render(); });
+  }
+  fetch(base + "api/npm").then(function (r) { return r.json(); }).then(function (n) { npm = n; render(); });
+
+  document.getElementById("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();
+  });
+  document.getElementById("csv").addEventListener("click", function () {
+    if (!summary) return;
+    var cols = ["install", "firstSeen", "lastSeen", "events", "sessions", "projects", "client", "version", "platform", "topFeature"];
+    var lines = [cols.join(",")].concat(summary.users.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("\\n")], { 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";
+    var x = Math.min(event.pageX + 12, document.documentElement.scrollWidth - tip.offsetWidth - 8);
+    tip.style.left = x + "px";
+    tip.style.top = (event.pageY - 32) + "px";
+  });
+  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 });
+  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();
+    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;
+  });
+  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"
+      });
+      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, days), days)
+        };
+      }
+      json2(summaryCache.value);
+      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 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));
+  });
+}
+function listen2(server, port) {
+  return new Promise((resolve6, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve6(server.address().port));
+  });
+}
+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;
+}
+function summarize(events, days, now = Date.now()) {
+  const day = (iso) => iso.slice(0, 10);
+  const today = day(new Date(now).toISOString());
+  const activeWithin = (window) => {
+    const since = day(new Date(now - (window - 1) * 864e5).toISOString());
+    return new Set(events.filter((e) => day(e.receivedAt) >= since).map((e) => e.installId)).size;
+  };
+  const daily = /* @__PURE__ */ new Map();
+  for (let index = days - 1; index >= 0; index -= 1) {
+    daily.set(day(new Date(now - index * 864e5).toISOString()), {
+      installs: /* @__PURE__ */ new Set(),
+      events: 0
+    });
+  }
+  const firstSeen = /* @__PURE__ */ new Map();
+  const tools = /* @__PURE__ */ new Map();
+  const kinds = /* @__PURE__ */ new Map();
+  const latest = /* @__PURE__ */ new Map();
+  const users = /* @__PURE__ */ new Map();
+  let errors = 0;
+  let tokensOut = 0;
+  for (const event of events) {
+    const bucket = daily.get(day(event.receivedAt));
+    if (bucket) {
+      bucket.installs.add(event.installId);
+      bucket.events += 1;
+    }
+    const seen = firstSeen.get(event.installId);
+    if (!seen || event.receivedAt < seen) firstSeen.set(event.installId, event.receivedAt);
+    latest.set(event.installId, event);
+    const user = users.get(event.installId) ?? {
+      lastSeen: event.receivedAt,
+      events: 0,
+      sessions: /* @__PURE__ */ new Set(),
+      projects: /* @__PURE__ */ new Set(),
+      features: /* @__PURE__ */ new Map()
+    };
+    if (event.receivedAt > user.lastSeen) user.lastSeen = event.receivedAt;
+    user.events += 1;
+    if (event.session) user.sessions.add(event.session);
+    user.projects.add(event.project);
+    const feature = event.kind === "tool" ? event.name : event.kind;
+    user.features.set(feature, (user.features.get(feature) ?? 0) + 1);
+    users.set(event.installId, user);
+    kinds.set(event.kind, (kinds.get(event.kind) ?? 0) + 1);
+    if (!event.ok) errors += 1;
+    tokensOut += event.tokensOut ?? 0;
+    const key = event.kind === "tool" ? event.name : `${event.kind}`;
+    const tool = tools.get(key) ?? { calls: 0, errors: 0, installs: /* @__PURE__ */ new Set(), ms: [] };
+    tool.calls += 1;
+    if (!event.ok) tool.errors += 1;
+    tool.installs.add(event.installId);
+    tool.ms.push(event.ms);
+    tools.set(key, tool);
+  }
+  const newPerDay = /* @__PURE__ */ new Map();
+  for (const seen of firstSeen.values())
+    newPerDay.set(day(seen), (newPerDay.get(day(seen)) ?? 0) + 1);
+  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;
+  };
+  return {
+    generatedAt: new Date(now).toISOString(),
+    days,
+    totals: {
+      installs: firstSeen.size,
+      projects: new Set(events.map((e) => `${e.installId}:${e.project}`)).size,
+      sessions: new Set(events.filter((e) => e.session).map((e) => e.session)).size,
+      events: events.length,
+      errorRate: events.length ? errors / events.length : 0,
+      tokensOut,
+      active1d: activeWithin(1),
+      active7d: activeWithin(7),
+      active30d: activeWithin(30),
+      newToday: newPerDay.get(today) ?? 0
+    },
+    daily: [...daily].map(([date, bucket]) => ({
+      date,
+      installs: bucket.installs.size,
+      events: bucket.events,
+      newInstalls: newPerDay.get(date) ?? 0
+    })),
+    features: [...tools].map(([label, tool]) => ({
+      label,
+      calls: tool.calls,
+      installs: tool.installs.size,
+      errorRate: tool.errors / tool.calls,
+      p50ms: median(tool.ms)
+    })).sort((a, b) => b.calls - a.calls).slice(0, 20),
+    kinds: [...kinds].map(([label, count]) => ({ label, count })).sort((a, b) => b.count - a.count),
+    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, most recently active first. */
+    users: [...users].map(([installId, user]) => {
+      const last = latest.get(installId);
+      return {
+        install: installId.slice(0, 8),
+        firstSeen: firstSeen.get(installId) ?? user.lastSeen,
+        lastSeen: user.lastSeen,
+        events: user.events,
+        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: events.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"
+    }))
+  };
+}
+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/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 () => {
+      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);
+      });
+    });
+  });
+}
+
 // 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 +4163,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 +4212,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 +4265,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 +4346,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 +4361,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 +4369,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 +4397,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 +4408,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 +4422,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 +4461,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 +4486,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 +4809,8 @@ function createCli() {
   registerClientsCommands(program, runSafely);
   registerGitHubCommands(program, runSafely);
   registerSymbolsCommand(program, runSafely);
+  registerTelemetryCommands(program, runSafely);
+  program.hook("preAction", () => showTelemetryNoticeOnce());
   program.action(async () => {
     await runSafely(() => runUseCommand());
   });
@@ -5625,17 +4838,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 +4881,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 +4895,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 +4923,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 +4933,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 +4951,4 @@ function printDbDoctor(report) {
 export {
   createCli
 };
-//# sourceMappingURL=main-AHNGHC4L.js.map
+//# sourceMappingURL=main-QUASSFP7.js.map