project-athena 0.1.2 → 0.2.0

package/dist/cli.js

@@ -6,6 +6,10 @@ import { Command as Command2, Option } from "commander";
 // src/services/version.ts
 import { createRequire } from "module";
 var PACKAGE_NAME = "project-athena";
+var AUTHOR = "Sabarivasan";
+var NPM_URL = `https://www.npmjs.com/package/${PACKAGE_NAME}`;
+var REPO_URL = "https://github.com/Sabari-Vasan-SM/athena";
+var WEBSITE_URL = "https://athena.sabari.me";
 function readVersion() {
   try {
     const require2 = createRequire(import.meta.url);
@@ -91,33 +95,6 @@ function json(value) {
   out.write(`${JSON.stringify(value, null, 2)}
 `);
 }
-function banner() {
-  if (jsonMode || quiet) return;
-  const title = "ATHENA";
-  const sub = "Project Intelligence for AI Coding";
-  const w = sub.length + 4;
-  const pad = (s) => {
-    const left = Math.floor((w - s.length) / 2);
-    return " ".repeat(left) + s + " ".repeat(w - s.length - left);
-  };
-  if (unicode) {
-    line(c.dim(`\u256D${"\u2500".repeat(w)}\u256E`));
-    line(`${c.dim("\u2502")}${c.bold(c.cyan(pad(title)))}${c.dim("\u2502")}`);
-    line(`${c.dim("\u2502")}${c.dim(pad(sub))}${c.dim("\u2502")}`);
-    line(c.dim(`\u2570${"\u2500".repeat(w)}\u256F`));
-  } else {
-    line(c.bold(c.cyan(title)));
-    line(c.dim(sub));
-  }
-  line();
-}
-function tree(rootLabel, items) {
-  line(rootLabel);
-  items.forEach((item, i) => {
-    const last = i === items.length - 1;
-    line(`${c.dim(unicode ? last ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 " : last ? "`-- " : "|-- ")}${item}`);
-  });
-}
 var FRAMES = unicode ? ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"] : ["-", "\\", "|", "/"];
 function spinner(text) {
   let current = text;
@@ -174,7 +151,7 @@ function relativeTime(iso) {
 }
 
 // src/cli/commands/init.ts
-import path21 from "path";
+import path26 from "path";
 
 // src/core/state/state.ts
 import { promises as fs2 } from "fs";
@@ -378,8 +355,8 @@ function diffFileIndex(prev, next) {
 }
 
 // src/agents/registry.ts
-import { promises as fs6 } from "fs";
-import path10 from "path";
+import { promises as fs10 } from "fs";
+import path15 from "path";
 
 // src/core/util/paths.ts
 import path4 from "path";
@@ -390,9 +367,9 @@ function resolveInside(root, candidate) {
   if (candidate.includes("\0")) return null;
   const resolvedRoot = path4.resolve(root);
   const resolved = path4.resolve(resolvedRoot, candidate);
-  const rel = path4.relative(resolvedRoot, resolved);
-  if (rel === "") return resolved;
-  if (rel.startsWith("..") || path4.isAbsolute(rel)) return null;
+  const rel2 = path4.relative(resolvedRoot, resolved);
+  if (rel2 === "") return resolved;
+  if (rel2.startsWith("..") || path4.isAbsolute(rel2)) return null;
   return resolved;
 }
 function dirOf(posixPath) {
@@ -601,22 +578,22 @@ async function readJsonFile(file) {
 function isAthenaEntry(entry) {
   return JSON.stringify(entry ?? "").includes(ATHENA_MARK);
 }
-async function planJsonChange(root, rel, mutate2) {
-  const file = path5.join(root, rel);
+async function planJsonChange(root, rel2, mutate2) {
+  const file = path5.join(root, rel2);
   const { data, existed, malformed } = await readJsonFile(file);
-  if (malformed) throw new Error(`${rel} is not valid JSON \u2014 fix it before configuring hooks`);
+  if (malformed) throw new Error(`${rel2} is not valid JSON \u2014 fix it before configuring hooks`);
   const before = JSON.stringify(data);
   mutate2(data);
   const content = `${JSON.stringify(data, null, 2)}
 `;
-  return { path: rel, ownership: "block", action: !existed ? "create" : JSON.stringify(data) === before ? "unchanged" : "update", content };
+  return { path: rel2, ownership: "block", action: !existed ? "create" : JSON.stringify(data) === before ? "unchanged" : "update", content };
 }
-async function removeJsonHooks(root, rel, strip, isEmpty) {
-  const file = path5.join(root, rel);
+async function removeJsonHooks(root, rel2, strip2, isEmpty) {
+  const file = path5.join(root, rel2);
   const { data, existed, malformed } = await readJsonFile(file);
   if (!existed || malformed) return false;
   const before = JSON.stringify(data);
-  strip(data);
+  strip2(data);
   if (JSON.stringify(data) === before) return false;
   if (isEmpty(data)) await fs3.rm(file, { force: true });
   else await fs3.writeFile(file, `${JSON.stringify(data, null, 2)}
@@ -633,7 +610,7 @@ function hookScript(agent, platform = process.platform) {
   if (platform === "win32") {
     return {
       file: "athena-hook.cmd",
-      content: ["@echo off", `${command} event ${ATHENA_MARK} --agent ${agent} --hook %1`, "exit /b 0", ""].join("\r\n"),
+      content: ["@echo off", "rem Generated by Athena: forwards agent hook payloads to `athena event`.", `${command} event ${ATHENA_MARK} --agent ${agent} --hook %1`, "exit /b 0", ""].join("\r\n"),
       mode: 420
     };
   }
@@ -660,20 +637,20 @@ function stripMcpServers(data) {
 
 // src/agents/common/files.ts
 var OWNED_HEADER = "<!-- Generated by Athena. This file is owned by Athena and may be rewritten by `athena init`/`athena agents`. -->";
-async function planBlock(root, rel, body) {
-  const existing = await readTextIfExists(path6.join(root, rel));
+async function planBlock(root, rel2, body) {
+  const existing = await readTextIfExists(path6.join(root, rel2));
   const content = upsertIntegrationBlock(existing, body);
-  return { path: rel, ownership: "block", action: existing === null ? "create" : existing === content ? "unchanged" : "update", content };
+  return { path: rel2, ownership: "block", action: existing === null ? "create" : existing === content ? "unchanged" : "update", content };
 }
-async function planOwned(root, rel, content) {
-  const existing = await readTextIfExists(path6.join(root, rel));
+async function planOwned(root, rel2, content) {
+  const existing = await readTextIfExists(path6.join(root, rel2));
   if (existing !== null && !existing.includes("Generated by Athena")) {
-    return { path: rel, ownership: "owned", action: "unchanged", content: existing };
+    return { path: rel2, ownership: "owned", action: "unchanged", content: existing };
   }
-  return { path: rel, ownership: "owned", action: existing === null ? "create" : existing === content ? "unchanged" : "update", content };
+  return { path: rel2, ownership: "owned", action: existing === null ? "create" : existing === content ? "unchanged" : "update", content };
 }
-async function removeBlockFrom(root, rel) {
-  const file = path6.join(root, rel);
+async function removeBlockFrom(root, rel2) {
+  const file = path6.join(root, rel2);
   const existing = await readTextIfExists(file);
   if (existing === null || !existing.includes(INTEGRATION_START)) return false;
   const next = removeIntegrationBlock(existing);
@@ -681,36 +658,40 @@ async function removeBlockFrom(root, rel) {
   else await fs4.writeFile(file, next, "utf8");
   return true;
 }
-async function removeOwned(root, rel) {
-  const file = path6.join(root, rel);
+async function removeOwned(root, rel2) {
+  const file = path6.join(root, rel2);
   const existing = await readTextIfExists(file);
   if (existing === null || !existing.includes("Generated by Athena")) return false;
   await fs4.rm(file);
   return true;
 }
-async function checkBlock(root, rel, label) {
-  const text = await readTextIfExists(path6.join(root, rel));
-  if (text === null) return { ok: false, level: "warn", message: `${label}: ${rel} not found (run \`athena init\` or \`athena analyze\`)` };
+async function checkBlock(root, rel2, label) {
+  const text = await readTextIfExists(path6.join(root, rel2));
+  if (text === null) return { ok: false, level: "warn", message: `${label}: ${rel2} not found (run \`athena init\` or \`athena analyze\`)` };
   const s = text.indexOf(INTEGRATION_START);
   const e = text.indexOf(INTEGRATION_END);
-  if (s === -1 && e === -1) return { ok: false, level: "warn", message: `${label}: ${rel} has no Athena block` };
-  if (s === -1 || e < s) return { ok: false, level: "error", message: `${label}: ${rel} has a malformed Athena block (unmatched markers)` };
-  return { ok: true, level: "ok", message: `${label}: ${rel}` };
+  if (s === -1 && e === -1) return { ok: false, level: "warn", message: `${label}: ${rel2} has no Athena block` };
+  if (s === -1 || e < s) return { ok: false, level: "error", message: `${label}: ${rel2} has a malformed Athena block (unmatched markers)` };
+  return { ok: true, level: "ok", message: `${label}: ${rel2}` };
 }
 async function userEvidence(root, spec) {
   const found = [];
-  const owned = new Set(spec.athenaOwned ?? []);
-  for (const rel of spec.athenaOwnedJson ?? []) {
-    if (await jsonOnlyAthena(path6.join(root, rel))) owned.add(rel);
+  const owned = /* @__PURE__ */ new Set();
+  for (const rel2 of spec.athenaOwned ?? []) {
+    const text = await readTextIfExists(path6.join(root, rel2)).catch(() => null);
+    if (text !== null && /Generated by Athena|managed by Athena/.test(text)) owned.add(rel2);
+  }
+  for (const rel2 of spec.athenaOwnedJson ?? []) {
+    if (await jsonOnlyAthena(path6.join(root, rel2))) owned.add(rel2);
   }
-  for (const rel of spec.files ?? []) {
-    const text = await readTextIfExists(path6.join(root, rel)).catch(() => null);
+  for (const rel2 of spec.files ?? []) {
+    const text = await readTextIfExists(path6.join(root, rel2)).catch(() => null);
     if (text === null) continue;
     if (text.includes(OWNED_HEADER)) continue;
-    if (removeIntegrationBlock(text).trim()) found.push(rel);
+    if (removeIntegrationBlock(text).trim()) found.push(rel2);
   }
-  for (const rel of spec.dirs ?? []) {
-    if (await hasNonAthenaEntries(path6.join(root, rel), root, owned)) found.push(rel);
+  for (const rel2 of spec.dirs ?? []) {
+    if (await hasNonAthenaEntries(path6.join(root, rel2), root, owned)) found.push(rel2);
   }
   return found;
 }
@@ -723,8 +704,8 @@ async function hasNonAthenaEntries(dir, root, owned) {
   }
   for (const e of entries) {
     const abs = path6.join(dir, e.name);
-    const rel = path6.relative(root, abs).split(path6.sep).join("/");
-    if (owned.has(rel)) continue;
+    const rel2 = path6.relative(root, abs).split(path6.sep).join("/");
+    if (owned.has(rel2)) continue;
     if (e.isDirectory()) {
       if (await hasNonAthenaEntries(abs, root, owned)) return true;
     } else return true;
@@ -741,24 +722,26 @@ async function jsonOnlyAthena(file) {
     return false;
   }
   const record = data;
-  const servers = record?.mcpServers;
   let hadAthenaMcp = false;
-  if (servers && typeof servers === "object") {
-    hadAthenaMcp = "athena" in servers;
+  for (const key of ["mcpServers", "servers"]) {
+    const servers = record?.[key];
+    if (!servers || typeof servers !== "object" || Array.isArray(servers)) continue;
+    if (!("athena" in servers)) continue;
+    hadAthenaMcp = true;
     delete servers.athena;
-    if (Object.keys(servers).length === 0) delete record.mcpServers;
+    if (Object.keys(servers).length === 0) delete record[key];
   }
   if (!text.includes(ATHENA_MARK) && !hadAthenaMcp) return false;
-  const strip = (value) => {
+  const strip2 = (value) => {
     if (Array.isArray(value)) {
-      const kept = value.filter((v) => !JSON.stringify(v ?? "").includes(ATHENA_MARK)).map(strip);
+      const kept = value.filter((v) => !JSON.stringify(v ?? "").includes(ATHENA_MARK)).map(strip2);
       return kept.length ? kept : void 0;
     }
     if (value && typeof value === "object") {
       const out2 = {};
       for (const [k, v] of Object.entries(value)) {
         if (JSON.stringify(v ?? "").includes(ATHENA_MARK)) {
-          const cleaned = strip(v);
+          const cleaned = strip2(v);
           if (cleaned !== void 0) out2[k] = cleaned;
           continue;
         }
@@ -769,15 +752,16 @@ async function jsonOnlyAthena(file) {
     }
     return value;
   };
-  return strip(data) === void 0;
+  return strip2(data) === void 0;
 }
 
 // src/agents/common/hook-events.ts
 import crypto2 from "crypto";
 var TEST_COMMAND = /\b(test|vitest|jest|pytest|go test|cargo test|mocha|rspec|phpunit|gradle test|mvn test|tox|playwright|cypress)\b/i;
 var REVIEW_COMMAND = /\b(lint|eslint|ruff|clippy|tsc|typecheck|type-check|mypy|flake8|rubocop|golangci-lint|audit)\b/i;
-var READ_TOOLS = /* @__PURE__ */ new Set(["read", "glob", "grep", "notebookread", "webfetch", "websearch", "ls", "searchreplace"]);
-var EDIT_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "multiedit", "notebookedit", "applypatch", "create_diff", "str_replace"]);
+var READ_TOOLS = /* @__PURE__ */ new Set(["read", "glob", "grep", "notebookread", "webfetch", "websearch", "ls", "searchreplace", "read_file", "read_many_files", "list_directory", "grep_search", "web_fetch", "google_web_search"]);
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "multiedit", "notebookedit", "applypatch", "apply_patch", "create_diff", "str_replace", "write_file", "replace"]);
+var SEARCH_TOOLS = /* @__PURE__ */ new Set(["grep", "glob", "grep_search"]);
 function truncate(s, n = 160) {
   const one = s.replace(/\s+/g, " ").trim();
   return one.length > n ? `${one.slice(0, n - 1)}\u2026` : one;
@@ -803,18 +787,26 @@ function filesFrom(input, payload) {
   }
   return [...new Set(out2)];
 }
+function patchFiles(patch) {
+  const out2 = [];
+  for (const m of patch.matchAll(/^\*\*\* (?:Add|Update|Delete) File: (.+)$|^\*\*\* Move to: (.+)$/gm)) {
+    const f = (m[1] ?? m[2]).trim();
+    if (f) out2.push(f);
+  }
+  return [...new Set(out2)];
+}
 function classifyTool(tool, command, files) {
   const t = tool.toLowerCase().replace(/^mcp__/, "");
   const where = files.length ? ` ${files.slice(0, 2).join(", ")}${files.length > 2 ? ` +${files.length - 2}` : ""}` : "";
   if (EDIT_TOOLS.has(t)) return { kind: "edit", state: "CODING", message: `Editing${where || " files"}` };
-  if (READ_TOOLS.has(t)) return { kind: t === "grep" || t === "glob" ? "search" : "read", state: "ANALYZING", message: `Reading${where || ` (${tool})`}` };
-  if (t === "bash" || t === "shell" || t.includes("terminal")) {
+  if (READ_TOOLS.has(t)) return { kind: SEARCH_TOOLS.has(t) ? "search" : "read", state: "ANALYZING", message: `Reading${where || ` (${tool})`}` };
+  if (t === "bash" || t === "shell" || t === "powershell" || t === "run_shell_command" || t.includes("terminal")) {
     if (command && TEST_COMMAND.test(command)) return { kind: "command", state: "TESTING", message: `Running tests: ${command}` };
     if (command && REVIEW_COMMAND.test(command)) return { kind: "command", state: "REVIEWING", message: `Running checks: ${command}` };
     return { kind: "command", state: "CODING", message: command ? `Running: ${command}` : "Running a shell command" };
   }
   if (t === "task" || t === "agent") return { kind: "subagent", state: "PLANNING", message: "Delegating to a subagent" };
-  if (t === "todowrite" || t === "exitplanmode" || t === "plan") return { kind: "tool", state: "PLANNING", message: "Updating its plan" };
+  if (t === "todowrite" || t === "exitplanmode" || t === "plan" || t === "update_plan" || t === "write_todos" || t === "enter_plan_mode" || t === "exit_plan_mode") return { kind: "tool", state: "PLANNING", message: "Updating its plan" };
   return { kind: "tool", state: "CODING", message: `Using ${tool}` };
 }
 function normalizeHookEvent(agent, hookName, payload) {
@@ -823,22 +815,23 @@ function normalizeHookEvent(agent, hookName, payload) {
   const session = asString(payload.session_id) ?? asString(payload.conversation_id) ?? null;
   const toolInput = payload.tool_input && typeof payload.tool_input === "object" ? payload.tool_input : null;
   const tool = asString(payload.tool_name) ?? asString(payload.tool) ?? null;
+  const isPatch = tool?.toLowerCase() === "apply_patch";
   const rawCommand = asString(toolInput?.command) ?? asString(payload.command);
-  const command = rawCommand ? truncate(rawCommand) : null;
-  const files = filesFrom(toolInput, payload);
+  const command = rawCommand && !isPatch ? truncate(rawCommand) : null;
+  const files = isPatch && rawCommand ? patchFiles(rawCommand) : filesFrom(toolInput, payload);
   let c2 = null;
   if (h === "sessionstart" || h === "workspaceopen") c2 = { kind: "session-start", state: "IDLE", message: "Session started" };
   else if (h === "sessionend") c2 = { kind: "session-end", state: "IDLE", message: "Session ended" };
-  else if (h === "userpromptsubmit" || h === "beforesubmitprompt") c2 = { kind: "prompt", state: "PLANNING", message: "Received a new task from the developer" };
-  else if (h === "stop" || h === "afteragentresponse") c2 = { kind: "stop", state: "SUCCESS", message: "Finished responding" };
+  else if (h === "userpromptsubmit" || h === "beforesubmitprompt" || h === "beforeagent") c2 = { kind: "prompt", state: "PLANNING", message: "Received a new task from the developer" };
+  else if (h === "stop" || h === "afteragentresponse" || h === "afteragent") c2 = { kind: "stop", state: "SUCCESS", message: "Finished responding" };
   else if (h === "subagentstart") c2 = { kind: "subagent", state: "PLANNING", message: "Subagent started" };
   else if (h === "subagentstop") c2 = { kind: "subagent", state: "CODING", message: "Subagent finished" };
   else if (h === "beforeshellexecution") c2 = classifyTool("bash", command, files);
   else if (h === "aftershellexecution") return null;
   else if (h === "beforereadfile" || h === "beforetabfileread") c2 = classifyTool("read", null, files);
   else if (h === "afterfileedit" || h === "aftertabfileedit") c2 = classifyTool("edit", null, files);
-  else if (h === "pretooluse" || h === "permissionrequest") c2 = tool ? classifyTool(tool, command, files) : null;
-  else if (h === "posttooluse" || h === "posttoolusefailure") return null;
+  else if (h === "pretooluse" || h === "permissionrequest" || h === "beforetool") c2 = tool ? classifyTool(tool, command, files) : null;
+  else if (h === "posttooluse" || h === "posttoolusefailure" || h === "aftertool") return null;
   else if (h === "pretoolusefailure") return null;
   else c2 = { kind: "other", state: "CODING", message: `Hook: ${hook}` };
   if (!c2) return null;
@@ -857,7 +850,10 @@ function normalizeHookEvent(agent, hookName, payload) {
   };
 }
 var CLAUDE_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "Stop", "SessionEnd"];
+var CODEX_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "Stop", "SessionEnd"];
 var CURSOR_HOOK_EVENTS = ["sessionStart", "beforeSubmitPrompt", "beforeShellExecution", "afterFileEdit", "stop", "sessionEnd"];
+var COPILOT_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "Stop"];
+var GEMINI_HOOK_EVENTS = ["SessionStart", "BeforeAgent", "BeforeTool", "AfterAgent", "SessionEnd"];
 
 // src/agents/claude-code/adapter.ts
 var SETTINGS = ".claude/settings.json";
@@ -1013,7 +1009,7 @@ var antigravityAdapter = {
   capabilities: { instructionsFile: true, scopedRules: true, hooks: false, mcp: true },
   supportNote: 'Uses an Athena-owned workspace rule at .agents/rules/athena.md. Set its activation to "Always On" in Antigravity if it is not applied automatically.',
   async detectPresence(root) {
-    const evidence = await userEvidence(root, { files: ["GEMINI.md"], dirs: [".agents", ".agent"], athenaOwned: [RULE_FILE2] });
+    const evidence = await userEvidence(root, { dirs: [".agents", ".agent"], athenaOwned: [RULE_FILE2] });
     return { detectedInProject: evidence.length > 0, evidence };
   },
   async plan(ctx) {
@@ -1035,6 +1031,450 @@ var antigravityAdapter = {
   }
 };
 
+// src/agents/codex/adapter.ts
+import { promises as fs6 } from "fs";
+import os from "os";
+import path10 from "path";
+import { parse as parseToml } from "smol-toml";
+var INSTRUCTIONS = "AGENTS.md";
+var CONFIG = ".codex/config.toml";
+var HOOKS_FILE2 = ".codex/hooks.json";
+var TOML_START = "# athena:start (managed by Athena; `athena agents remove codex` removes it)";
+var TOML_END = "# athena:end";
+var codexAdapter = {
+  id: "codex",
+  displayName: "Codex",
+  capabilities: { instructionsFile: true, scopedRules: false, hooks: true, mcp: true },
+  supportNote: "Uses the Athena block in AGENTS.md, an MCP server entry in .codex/config.toml, and hooks in .codex/hooks.json that report activity. Codex loads .codex/ only for trusted projects.",
+  async detectPresence(root) {
+    const athenaOwned = await tomlOnlyAthena(path10.join(root, CONFIG)) ? [CONFIG] : [];
+    const evidence = await userEvidence(root, { dirs: [".codex"], athenaOwned, athenaOwnedJson: [HOOKS_FILE2] });
+    return { detectedInProject: evidence.length > 0, evidence };
+  },
+  async plan(ctx) {
+    const changes = [await planBlock(ctx.root, INSTRUCTIONS, athenaInstructions({ heading: "##" }))];
+    changes.push(await planConfig(ctx.root));
+    changes.push(
+      await planJsonChange(ctx.root, HOOKS_FILE2, (data) => {
+        const hooks = data.hooks && typeof data.hooks === "object" && !Array.isArray(data.hooks) ? data.hooks : {};
+        for (const event of CODEX_HOOK_EVENTS) {
+          const list = (Array.isArray(hooks[event]) ? hooks[event] : []).filter((e) => !isAthenaEntry(e));
+          list.push({ hooks: [{ type: "command", command: codexHookCommand(event), timeout: 10 }] });
+          hooks[event] = list;
+        }
+        data.hooks = hooks;
+      })
+    );
+    return changes;
+  },
+  async remove(root) {
+    const touched = [];
+    if (await removeBlockFrom(root, INSTRUCTIONS)) touched.push(INSTRUCTIONS);
+    if (await removeConfigBlock(root)) touched.push(CONFIG);
+    const removed = await removeJsonHooks(
+      root,
+      HOOKS_FILE2,
+      (data) => {
+        const hooks = data.hooks;
+        if (!hooks) return;
+        for (const event of Object.keys(hooks)) {
+          hooks[event] = (hooks[event] ?? []).filter((e) => !isAthenaEntry(e));
+          if (!hooks[event].length) delete hooks[event];
+        }
+        pruneEmpty(data, "hooks");
+      },
+      (data) => Object.keys(data).length === 0
+    );
+    if (removed) touched.push(HOOKS_FILE2);
+    return touched;
+  },
+  async check(root) {
+    const checks = [await checkBlock(root, INSTRUCTIONS, "Codex")];
+    const config = await readTextIfExists(path10.join(root, CONFIG));
+    checks.push(
+      config?.includes(TOML_START) && config.includes("[mcp_servers.athena]") ? { ok: true, level: "ok", message: `Codex: MCP server registered in ${CONFIG}` } : { ok: false, level: "warn", message: `Codex: no Athena MCP entry in ${CONFIG} \u2014 re-run \`athena agents add codex\`` }
+    );
+    const hooks = await readTextIfExists(path10.join(root, HOOKS_FILE2));
+    if (hooks === null) checks.push({ ok: false, level: "warn", message: `Codex: ${HOOKS_FILE2} not found \u2014 activity reporting is off` });
+    else {
+      const configured = CODEX_HOOK_EVENTS.filter((e) => new RegExp(`"${e}"`).test(hooks) && hooks.includes(ATHENA_MARK));
+      checks.push(
+        configured.length === CODEX_HOOK_EVENTS.length ? { ok: true, level: "ok", message: `Codex: activity hooks installed (${configured.length} events)` } : { ok: false, level: "warn", message: `Codex: only ${configured.length}/${CODEX_HOOK_EVENTS.length} activity hooks installed \u2014 re-run \`athena agents add codex\`` }
+      );
+    }
+    checks.push(await trustCheck(root));
+    return checks;
+  }
+};
+function codexHookCommand(event) {
+  const cmd = hookCommand();
+  const exe = /[\s"'$`\\]/.test(cmd) ? JSON.stringify(cmd) : cmd;
+  return `${exe} event ${ATHENA_MARK} --agent codex --hook ${event}`;
+}
+function mcpBlock() {
+  return [TOML_START, "[mcp_servers.athena]", `command = ${JSON.stringify(hookCommand())}`, 'args = ["mcp"]', TOML_END].join("\n");
+}
+function stripTomlBlock(text) {
+  const lines = text.split("\n");
+  const out2 = [];
+  let inside = false;
+  for (const line2 of lines) {
+    if (!inside && line2.startsWith("# athena:start")) inside = true;
+    else if (inside && line2.trim() === TOML_END) inside = false;
+    else if (!inside) out2.push(line2);
+  }
+  return out2.join("\n");
+}
+function parseTomlOrThrow(text) {
+  try {
+    return parseToml(text);
+  } catch {
+    throw new Error(`${CONFIG} is not valid TOML \u2014 fix it before configuring Codex`);
+  }
+}
+async function planConfig(root) {
+  const existing = await readTextIfExists(path10.join(root, CONFIG));
+  const base = existing === null ? "" : stripTomlBlock(existing);
+  const parsed = parseTomlOrThrow(base);
+  const servers = parsed.mcp_servers;
+  if (servers && "athena" in servers) return { path: CONFIG, ownership: "block", action: "unchanged", content: existing ?? "" };
+  const head = base.trimEnd();
+  const content = `${head ? `${head}
+
+` : ""}${mcpBlock()}
+`;
+  return { path: CONFIG, ownership: "block", action: existing === null ? "create" : existing === content ? "unchanged" : "update", content };
+}
+async function removeConfigBlock(root) {
+  const file = path10.join(root, CONFIG);
+  const existing = await readTextIfExists(file);
+  if (existing === null || !existing.includes(TOML_START)) return false;
+  const next = stripTomlBlock(existing).trimEnd();
+  if (next.trim() === "") await fs6.rm(file, { force: true });
+  else await fs6.writeFile(file, `${next}
+`, "utf8");
+  return true;
+}
+async function tomlOnlyAthena(file) {
+  const text = await readTextIfExists(file).catch(() => null);
+  return text !== null && text.includes(TOML_START) && stripTomlBlock(text).trim() === "";
+}
+async function trustCheck(root) {
+  const home = process.env.CODEX_HOME?.trim() || path10.join(os.homedir(), ".codex");
+  const hint = `Codex loads .codex/ only for trusted projects: trust this folder when Codex asks, or add [projects."${root}"] trust_level = "trusted" to ${path10.join(home, "config.toml")}`;
+  const text = await readTextIfExists(path10.join(home, "config.toml")).catch(() => null);
+  if (text === null) return { ok: false, level: "warn", message: `Codex: could not confirm this project is trusted. ${hint}` };
+  let projects = {};
+  try {
+    projects = parseToml(text).projects ?? {};
+  } catch {
+    return { ok: false, level: "warn", message: `Codex: could not read ${path10.join(home, "config.toml")} to confirm trust. ${hint}` };
+  }
+  for (let dir = root; ; dir = path10.dirname(dir)) {
+    const entry = projects[dir];
+    if (entry?.trust_level === "trusted") return { ok: true, level: "ok", message: `Codex: project is trusted${dir === root ? "" : ` (via ${dir})`}` };
+    if (entry?.trust_level === "untrusted") return { ok: false, level: "warn", message: `Codex: ${dir} is marked untrusted, so Codex ignores .codex/. ${hint}` };
+    if (path10.dirname(dir) === dir) break;
+  }
+  return { ok: false, level: "warn", message: `Codex: this project is not trusted yet. ${hint}` };
+}
+
+// src/agents/copilot/adapter.ts
+import { promises as fs7 } from "fs";
+import path11 from "path";
+var INSTRUCTIONS2 = ".github/copilot-instructions.md";
+var MCP_FILE3 = ".vscode/mcp.json";
+var HOOKS_DIR = ".github/hooks";
+var HOOKS_FILE3 = `${HOOKS_DIR}/athena.json`;
+var copilotAdapter = {
+  id: "copilot",
+  displayName: "GitHub Copilot",
+  capabilities: { instructionsFile: true, scopedRules: false, hooks: true, mcp: true },
+  supportNote: "Uses the Athena block in .github/copilot-instructions.md, an MCP server entry in .vscode/mcp.json (VS Code), and hooks in .github/hooks/athena.json that report activity (VS Code hooks are in Preview; Copilot CLI reads the same file).",
+  async detectPresence(root) {
+    const evidence = await userEvidence(root, { files: [INSTRUCTIONS2], dirs: [".github/instructions", HOOKS_DIR], athenaOwnedJson: [HOOKS_FILE3] });
+    if (await exists(path11.join(root, MCP_FILE3)) && !await jsonOnlyAthena(path11.join(root, MCP_FILE3))) evidence.push(MCP_FILE3);
+    return { detectedInProject: evidence.length > 0, evidence };
+  },
+  async plan(ctx) {
+    const changes = [await planBlock(ctx.root, INSTRUCTIONS2, athenaInstructions({ heading: "##" }))];
+    changes.push(
+      await planJsonChange(ctx.root, MCP_FILE3, (data) => {
+        const servers = data.servers && typeof data.servers === "object" && !Array.isArray(data.servers) ? data.servers : {};
+        servers.athena = { type: "stdio", command: hookCommand(), args: ["mcp"] };
+        data.servers = servers;
+      })
+    );
+    changes.push(
+      await planJsonChange(ctx.root, HOOKS_FILE3, (data) => {
+        data.version = typeof data.version === "number" ? data.version : 1;
+        const hooks = data.hooks && typeof data.hooks === "object" && !Array.isArray(data.hooks) ? data.hooks : {};
+        for (const event of COPILOT_HOOK_EVENTS) {
+          const list = (Array.isArray(hooks[event]) ? hooks[event] : []).filter((e) => !isAthenaEntry(e));
+          list.push({ type: "command", bash: posixCommand(event), powershell: powershellCommand(event), timeoutSec: 10 });
+          hooks[event] = list;
+        }
+        data.hooks = hooks;
+      })
+    );
+    return changes;
+  },
+  async remove(root) {
+    const touched = [];
+    if (await removeBlockFrom(root, INSTRUCTIONS2)) touched.push(INSTRUCTIONS2);
+    const mcpRemoved = await removeJsonHooks(
+      root,
+      MCP_FILE3,
+      (data) => {
+        const servers = data.servers;
+        if (!servers || typeof servers !== "object") return;
+        delete servers.athena;
+        pruneEmpty(data, "servers");
+      },
+      (d) => Object.keys(d).length === 0
+    );
+    if (mcpRemoved) touched.push(MCP_FILE3);
+    const hooksRemoved = await removeJsonHooks(
+      root,
+      HOOKS_FILE3,
+      (data) => {
+        const hooks = data.hooks;
+        if (!hooks || typeof hooks !== "object") return;
+        for (const event of Object.keys(hooks)) {
+          if (!Array.isArray(hooks[event])) continue;
+          hooks[event] = hooks[event].filter((e) => !isAthenaEntry(e));
+          if (!hooks[event].length) delete hooks[event];
+        }
+        pruneEmpty(data, "hooks");
+        if (Object.keys(data).length === 1 && "version" in data) delete data.version;
+      },
+      (d) => Object.keys(d).length === 0
+    );
+    if (hooksRemoved) touched.push(HOOKS_FILE3);
+    for (const dir of [HOOKS_DIR, ".vscode"]) await fs7.rmdir(path11.join(root, dir)).catch(() => {
+    });
+    return touched;
+  },
+  async check(root) {
+    const checks = [await checkBlock(root, INSTRUCTIONS2, "GitHub Copilot")];
+    const mcp = await readJsonFile(path11.join(root, MCP_FILE3)).catch(() => null);
+    const servers = mcp?.data.servers;
+    if (mcp?.malformed) checks.push({ ok: false, level: "error", message: `GitHub Copilot: ${MCP_FILE3} is not valid JSON` });
+    else
+      checks.push(
+        servers && typeof servers === "object" && "athena" in servers ? { ok: true, level: "ok", message: `GitHub Copilot: MCP server registered in ${MCP_FILE3} (VS Code)` } : { ok: false, level: "warn", message: `GitHub Copilot: no Athena MCP entry in ${MCP_FILE3} \u2014 re-run \`athena agents add copilot\`` }
+      );
+    const hooks = await readTextIfExists(path11.join(root, HOOKS_FILE3));
+    if (hooks === null) checks.push({ ok: false, level: "warn", message: `GitHub Copilot: ${HOOKS_FILE3} not found \u2014 activity reporting is off` });
+    else {
+      const configured = COPILOT_HOOK_EVENTS.filter((e) => new RegExp(`"${e}"`).test(hooks) && hooks.includes(ATHENA_MARK));
+      checks.push(
+        configured.length === COPILOT_HOOK_EVENTS.length ? { ok: true, level: "ok", message: `GitHub Copilot: activity hooks installed (${configured.length} events)` } : { ok: false, level: "warn", message: `GitHub Copilot: only ${configured.length}/${COPILOT_HOOK_EVENTS.length} activity hooks installed \u2014 re-run \`athena agents add copilot\`` }
+      );
+    }
+    return checks;
+  }
+};
+function posixCommand(event) {
+  const cmd = hookCommand();
+  const exe = /[\s"'$`\\]/.test(cmd) ? `'${cmd.replace(/'/g, `'\\''`)}'` : cmd;
+  return `${exe} event ${ATHENA_MARK} --agent copilot --hook ${event} 2>/dev/null || true`;
+}
+function powershellCommand(event) {
+  const exe = `'${hookCommand().replace(/'/g, "''")}'`;
+  return `& ${exe} event ${ATHENA_MARK} --agent copilot --hook ${event} 2>$null; exit 0`;
+}
+
+// src/agents/gemini-cli/adapter.ts
+import { promises as fs8 } from "fs";
+import path12 from "path";
+var CONTEXT = "GEMINI.md";
+var SETTINGS2 = ".gemini/settings.json";
+var geminiCliAdapter = {
+  id: "gemini-cli",
+  displayName: "Gemini CLI",
+  capabilities: { instructionsFile: true, scopedRules: false, hooks: true, mcp: true },
+  supportNote: "Uses the Athena block in GEMINI.md, plus an MCP server entry and hooks that report activity in .gemini/settings.json. Gemini CLI ignores .gemini/settings.json in folders it does not trust (when folder trust is enabled).",
+  async detectPresence(root) {
+    const evidence = await userEvidence(root, { files: [CONTEXT], dirs: [".gemini"], athenaOwnedJson: [SETTINGS2] });
+    return { detectedInProject: evidence.length > 0, evidence };
+  },
+  async plan(ctx) {
+    const changes = [await planBlock(ctx.root, CONTEXT, athenaInstructions({ heading: "##" }))];
+    changes.push(
+      await planJsonChange(ctx.root, SETTINGS2, (data) => {
+        mergeMcpServers(data);
+        const hooks = data.hooks && typeof data.hooks === "object" && !Array.isArray(data.hooks) ? data.hooks : {};
+        for (const event of GEMINI_HOOK_EVENTS) {
+          const list = (Array.isArray(hooks[event]) ? hooks[event] : []).filter((e) => !isAthenaEntry(e));
+          list.push({
+            ...event === "BeforeTool" ? { matcher: "*" } : {},
+            hooks: [{ name: "athena-activity", type: "command", command: geminiHookCommand(event), timeout: 1e4 }]
+          });
+          hooks[event] = list;
+        }
+        data.hooks = hooks;
+      })
+    );
+    return changes;
+  },
+  async remove(root) {
+    const touched = [];
+    if (await removeBlockFrom(root, CONTEXT)) touched.push(CONTEXT);
+    const removed = await removeJsonHooks(
+      root,
+      SETTINGS2,
+      (data) => {
+        stripMcpServers(data);
+        const hooks = data.hooks;
+        if (!hooks || typeof hooks !== "object") return;
+        for (const event of Object.keys(hooks)) {
+          if (!Array.isArray(hooks[event])) continue;
+          hooks[event] = hooks[event].filter((e) => !isAthenaEntry(e));
+          if (!hooks[event].length) delete hooks[event];
+        }
+        pruneEmpty(data, "hooks");
+      },
+      (d) => Object.keys(d).length === 0
+    );
+    if (removed) touched.push(SETTINGS2);
+    await fs8.rmdir(path12.join(root, ".gemini")).catch(() => {
+    });
+    return touched;
+  },
+  async check(root) {
+    const checks = [await checkBlock(root, CONTEXT, "Gemini CLI")];
+    const settings = await readJsonFile(path12.join(root, SETTINGS2)).catch(() => null);
+    if (!settings?.existed) {
+      checks.push({ ok: false, level: "warn", message: `Gemini CLI: ${SETTINGS2} not found \u2014 no MCP server and activity reporting is off` });
+      return checks;
+    }
+    if (settings.malformed) {
+      checks.push({ ok: false, level: "error", message: `Gemini CLI: ${SETTINGS2} is not valid JSON` });
+      return checks;
+    }
+    const servers = settings.data.mcpServers;
+    checks.push(
+      servers && typeof servers === "object" && "athena" in servers ? { ok: true, level: "ok", message: `Gemini CLI: MCP server registered in ${SETTINGS2}` } : { ok: false, level: "warn", message: `Gemini CLI: no Athena MCP entry in ${SETTINGS2} \u2014 re-run \`athena agents add gemini-cli\`` }
+    );
+    const text = await readTextIfExists(path12.join(root, SETTINGS2)) ?? "";
+    const hooks = settings.data.hooks ?? {};
+    const configured = GEMINI_HOOK_EVENTS.filter((e) => isAthenaEntry(hooks[e]));
+    checks.push(
+      configured.length === GEMINI_HOOK_EVENTS.length && text.includes(ATHENA_MARK) ? { ok: true, level: "ok", message: `Gemini CLI: activity hooks installed (${configured.length} events)` } : { ok: false, level: "warn", message: `Gemini CLI: only ${configured.length}/${GEMINI_HOOK_EVENTS.length} activity hooks installed \u2014 re-run \`athena agents add gemini-cli\`` }
+    );
+    checks.push({ ok: true, level: "warn", message: "Gemini CLI: if folder trust is enabled, trust this folder \u2014 Gemini CLI ignores .gemini/settings.json (MCP, hooks) in untrusted folders" });
+    return checks;
+  }
+};
+function geminiHookCommand(event) {
+  const cmd = hookCommand();
+  const exe = /[\s"'$`\\]/.test(cmd) ? JSON.stringify(cmd) : cmd;
+  return `${exe} event ${ATHENA_MARK} --agent gemini-cli --hook ${event}`;
+}
+
+// src/agents/windsurf/adapter.ts
+import path13 from "path";
+var RULE_FILE3 = ".windsurf/rules/athena.md";
+var WINDSURF_RULE_LIMIT = 12e3;
+var windsurfAdapter = {
+  id: "windsurf",
+  displayName: "Windsurf",
+  capabilities: { instructionsFile: true, scopedRules: true, hooks: false, mcp: false },
+  supportNote: 'Uses an Athena-owned workspace rule at .windsurf/rules/athena.md (trigger: always_on), which Windsurf and Devin Desktop read. MCP is configured per user in Windsurf, so Athena does not register it: add `{ "mcpServers": { "athena": { "command": "athena", "args": ["mcp"] } } }` to your mcp_config.json yourself. No activity hooks.',
+  async detectPresence(root) {
+    const evidence = await userEvidence(root, { files: [".windsurfrules"], dirs: [".windsurf"], athenaOwned: await generatedByAthena(root, [RULE_FILE3]) });
+    return { detectedInProject: evidence.length > 0, evidence };
+  },
+  async plan(ctx) {
+    const content = ["---", "trigger: always_on", "---", OWNED_HEADER, "", athenaInstructions({ heading: "#" }), ""].join("\n");
+    if (content.length > WINDSURF_RULE_LIMIT) throw new Error(`Windsurf rule exceeds ${WINDSURF_RULE_LIMIT} characters`);
+    return [await planOwned(ctx.root, RULE_FILE3, content)];
+  },
+  async remove(root) {
+    return await removeOwned(root, RULE_FILE3) ? [RULE_FILE3] : [];
+  },
+  async check(root) {
+    const text = await readTextIfExists(path13.join(root, RULE_FILE3));
+    if (text === null) return [{ ok: false, level: "warn", message: `Windsurf: ${RULE_FILE3} not found` }];
+    if (!text.includes("Generated by Athena")) return [{ ok: false, level: "warn", message: `Windsurf: ${RULE_FILE3} is a developer file, so Athena did not write its rule there` }];
+    const checks = [];
+    if (text.length > WINDSURF_RULE_LIMIT) checks.push({ ok: false, level: "error", message: `Windsurf: ${RULE_FILE3} exceeds the 12,000 character rule limit` });
+    else if (!/^---\r?\n[\s\S]*?trigger:\s*always_on[\s\S]*?\r?\n---/.test(text)) checks.push({ ok: false, level: "warn", message: `Windsurf: ${RULE_FILE3} frontmatter was modified (trigger is not always_on)` });
+    else checks.push({ ok: true, level: "ok", message: `Windsurf: ${RULE_FILE3}` });
+    return checks;
+  }
+};
+async function generatedByAthena(root, rels) {
+  const out2 = [];
+  for (const rel2 of rels) {
+    const text = await readTextIfExists(path13.join(root, rel2)).catch(() => null);
+    if (text?.includes("Generated by Athena")) out2.push(rel2);
+  }
+  return out2;
+}
+
+// src/agents/cline/adapter.ts
+import { promises as fs9 } from "fs";
+import path14 from "path";
+var RULES_DIR = ".clinerules";
+var RULE_FILE4 = ".clinerules/athena.md";
+var ALT_RULE_FILE = ".cline/rules/athena.md";
+var clineAdapter = {
+  id: "cline",
+  displayName: "Cline",
+  capabilities: { instructionsFile: true, scopedRules: true, hooks: false, mcp: false },
+  supportNote: 'Uses an Athena-owned workspace rule at .clinerules/athena.md (or .cline/rules/athena.md when .clinerules is a single file). MCP servers are configured per user in Cline, so Athena does not register it: add an "athena" server with command `athena` and args ["mcp"] in Cline\'s MCP settings yourself. No activity hooks.',
+  async detectPresence(root) {
+    const evidence = await userEvidence(root, { files: [RULES_DIR], dirs: [RULES_DIR, ".cline"], athenaOwned: await generatedByAthena2(root, [RULE_FILE4, ALT_RULE_FILE]) });
+    return { detectedInProject: evidence.length > 0, evidence };
+  },
+  async plan(ctx) {
+    const content = [OWNED_HEADER, "", athenaInstructions({ heading: "#" }), ""].join("\n");
+    return [await planOwned(ctx.root, await rulePath(ctx.root), content)];
+  },
+  async remove(root) {
+    const touched = [];
+    for (const rel2 of [RULE_FILE4, ALT_RULE_FILE]) {
+      if (!await isDirectory(path14.join(root, path14.dirname(rel2)))) continue;
+      if (await removeOwned(root, rel2)) touched.push(rel2);
+    }
+    return touched;
+  },
+  async check(root) {
+    const rel2 = await rulePath(root);
+    const text = await readTextIfExists(path14.join(root, rel2));
+    if (text === null) return [{ ok: false, level: "warn", message: `Cline: ${rel2} not found` }];
+    if (!text.includes("Generated by Athena")) return [{ ok: false, level: "warn", message: `Cline: ${rel2} is a developer file, so Athena did not write its rule there` }];
+    const checks = [{ ok: true, level: "ok", message: `Cline: ${rel2}` }];
+    if (rel2 === ALT_RULE_FILE && !await isDirectory(path14.join(root, RULES_DIR)) && await exists2(path14.join(root, RULES_DIR))) {
+      checks.push({ ok: true, level: "warn", message: `Cline: .clinerules is a single file, so Athena's rule is in ${ALT_RULE_FILE}; older Cline versions that only read .clinerules will not see it` });
+    }
+    return checks;
+  }
+};
+async function rulePath(root) {
+  const clinerules = path14.join(root, RULES_DIR);
+  if (await exists2(clinerules) && !await isDirectory(clinerules)) return ALT_RULE_FILE;
+  const alt = await readTextIfExists(path14.join(root, ALT_RULE_FILE)).catch(() => null);
+  if (alt?.includes("Generated by Athena")) return ALT_RULE_FILE;
+  return RULE_FILE4;
+}
+async function exists2(p) {
+  return await fs9.lstat(p).catch(() => null) !== null;
+}
+async function isDirectory(p) {
+  return (await fs9.lstat(p).catch(() => null))?.isDirectory() ?? false;
+}
+async function generatedByAthena2(root, rels) {
+  const out2 = [];
+  for (const rel2 of rels) {
+    const text = await readTextIfExists(path14.join(root, rel2)).catch(() => null);
+    if (text?.includes("Generated by Athena")) out2.push(rel2);
+  }
+  return out2;
+}
+
 // src/agents/agents-md/adapter.ts
 var agentsMdAdapter = {
   id: "agents-md",
@@ -1057,9 +1497,23 @@ var agentsMdAdapter = {
 };
 
 // src/agents/registry.ts
-var ADAPTERS = [claudeCodeAdapter, cursorAdapter, antigravityAdapter, agentsMdAdapter];
+var ADAPTERS = [claudeCodeAdapter, cursorAdapter, codexAdapter, copilotAdapter, geminiCliAdapter, antigravityAdapter, windsurfAdapter, clineAdapter, agentsMdAdapter];
 function resolveAdapters(names2) {
-  const alias = { claude: "claude-code", claudecode: "claude-code", agents: "agents-md", "agents.md": "agents-md", gemini: "antigravity" };
+  const alias = {
+    claude: "claude-code",
+    claudecode: "claude-code",
+    agents: "agents-md",
+    "agents.md": "agents-md",
+    gemini: "gemini-cli",
+    geminicli: "gemini-cli",
+    "openai-codex": "codex",
+    "codex-cli": "codex",
+    "github-copilot": "copilot",
+    "gh-copilot": "copilot",
+    "copilot-cli": "copilot",
+    "google-antigravity": "antigravity",
+    codeium: "windsurf"
+  };
   const out2 = [];
   for (const raw of names2) {
     const n = raw.trim().toLowerCase();
@@ -1077,11 +1531,11 @@ async function applyChanges(root, changes) {
     if (c2.action === "unchanged") continue;
     const abs = resolveInside(root, c2.path);
     if (!abs) throw new Error(`Refusing to write outside the project: ${c2.path}`);
-    const st = await fs6.lstat(abs).catch(() => null);
+    const st = await fs10.lstat(abs).catch(() => null);
     if (st?.isSymbolicLink()) throw new Error(`Refusing to write through symlink: ${c2.path}`);
-    await fs6.mkdir(path10.dirname(abs), { recursive: true });
+    await fs10.mkdir(path15.dirname(abs), { recursive: true });
     await writeFileAtomic(abs, c2.content);
-    if (abs.endsWith(".sh")) await fs6.chmod(abs, 493).catch(() => {
+    if (abs.endsWith(".sh")) await fs10.chmod(abs, 493).catch(() => {
     });
     applied.push(c2);
   }
@@ -1089,22 +1543,22 @@ async function applyChanges(root, changes) {
 }
 
 // src/services/pipeline.ts
-import { promises as fs12 } from "fs";
-import path18 from "path";
+import { promises as fs16 } from "fs";
+import path23 from "path";
 import crypto4 from "crypto";
 
 // src/core/analyzer/analyze.ts
-import path15 from "path";
-import { promises as fs11 } from "fs";
+import path20 from "path";
+import { promises as fs15 } from "fs";
 
 // src/core/fs/walker.ts
-import { promises as fs8 } from "fs";
-import path12 from "path";
+import { promises as fs12 } from "fs";
+import path17 from "path";
 import crypto3 from "crypto";
 
 // src/core/fs/ignore.ts
-import { promises as fs7 } from "fs";
-import path11 from "path";
+import { promises as fs11 } from "fs";
+import path16 from "path";
 import ignoreFactory from "ignore";
 var IgnoreMatcher = class _IgnoreMatcher {
   base;
@@ -1117,9 +1571,9 @@ var IgnoreMatcher = class _IgnoreMatcher {
   }
   static async load(root, config) {
     const m = new _IgnoreMatcher(config);
-    const exclude = await fs7.readFile(path11.join(root, ".git", "info", "exclude"), "utf8").catch(() => null);
+    const exclude = await fs11.readFile(path16.join(root, ".git", "info", "exclude"), "utf8").catch(() => null);
     if (exclude) m.setGitignore("", exclude);
-    const rootGi = await fs7.readFile(path11.join(root, ".gitignore"), "utf8").catch(() => null);
+    const rootGi = await fs11.readFile(path16.join(root, ".gitignore"), "utf8").catch(() => null);
     if (rootGi) m.setGitignore("", rootGi, true);
     return m;
   }
@@ -1132,16 +1586,16 @@ var IgnoreMatcher = class _IgnoreMatcher {
     this.scoped.delete(dir);
   }
   /** Is the repo-relative POSIX path ignored? `isDir` enables directory-only patterns ("build/"). */
-  ignores(rel, isDir = false) {
-    if (!rel || rel === ".") return false;
-    const test = isDir ? `${rel}/` : rel;
+  ignores(rel2, isDir = false) {
+    if (!rel2 || rel2 === ".") return false;
+    const test = isDir ? `${rel2}/` : rel2;
     if (this.include?.ignores(test)) return false;
     if (this.base.ignores(test)) return true;
     for (const [dir, ig] of this.scoped) {
       if (dir === "") {
         if (ig.ignores(test)) return true;
-      } else if (rel.startsWith(`${dir}/`)) {
-        const sub = rel.slice(dir.length + 1);
+      } else if (rel2.startsWith(`${dir}/`)) {
+        const sub = rel2.slice(dir.length + 1);
         if (ig.ignores(isDir ? `${sub}/` : sub)) return true;
       }
     }
@@ -1152,41 +1606,41 @@ var IgnoreMatcher = class _IgnoreMatcher {
 // src/core/fs/walker.ts
 var SNIFF_BYTES = 8e3;
 async function walkProject(root, opts) {
-  const rootReal = await fs8.realpath(root);
+  const rootReal = await fs12.realpath(root);
   const matcher = opts.matcher ?? await IgnoreMatcher.load(rootReal, opts.config);
   const result = { files: [], skippedBinary: 0, skippedLarge: 0, skippedUnreadable: 0, truncated: false, warnings: [] };
   const visitedDirs = /* @__PURE__ */ new Set([rootReal]);
   const pending = [];
-  const isIgnored = (rel, isDir) => matcher.ignores(rel, isDir);
+  const isIgnored = (rel2, isDir) => matcher.ignores(rel2, isDir);
   const stack = [rootReal];
   while (stack.length) {
     opts.signal?.throwIfAborted();
     const dir = stack.pop();
     let entries;
     try {
-      entries = await fs8.readdir(dir, { withFileTypes: true });
+      entries = await fs12.readdir(dir, { withFileTypes: true });
     } catch (err) {
       result.skippedUnreadable++;
-      result.warnings.push(`Cannot read directory ${toPosix(path12.relative(rootReal, dir)) || "."}: ${err.code ?? "error"}`);
+      result.warnings.push(`Cannot read directory ${toPosix(path17.relative(rootReal, dir)) || "."}: ${err.code ?? "error"}`);
       continue;
     }
     entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
-    const dirRel = toPosix(path12.relative(rootReal, dir));
+    const dirRel = toPosix(path17.relative(rootReal, dir));
     if (dirRel && entries.some((e) => e.name === ".gitignore" && e.isFile())) {
-      const gi = await fs8.readFile(path12.join(dir, ".gitignore"), "utf8").catch(() => null);
+      const gi = await fs12.readFile(path17.join(dir, ".gitignore"), "utf8").catch(() => null);
       if (gi !== null) matcher.setGitignore(dirRel, gi);
     }
     for (const ent of entries) {
-      const abs = path12.join(dir, ent.name);
-      const rel = toPosix(path12.relative(rootReal, abs));
+      const abs = path17.join(dir, ent.name);
+      const rel2 = toPosix(path17.relative(rootReal, abs));
       let isDir = ent.isDirectory();
       let isFile = ent.isFile();
       if (ent.isSymbolicLink()) {
         try {
-          const target = await fs8.realpath(abs);
-          const relTarget = path12.relative(rootReal, target);
-          if (relTarget.startsWith("..") || path12.isAbsolute(relTarget)) continue;
-          const st = await fs8.stat(target);
+          const target = await fs12.realpath(abs);
+          const relTarget = path17.relative(rootReal, target);
+          if (relTarget.startsWith("..") || path17.isAbsolute(relTarget)) continue;
+          const st = await fs12.stat(target);
           isDir = st.isDirectory();
           isFile = st.isFile();
           if (isDir) {
@@ -1197,18 +1651,18 @@ async function walkProject(root, opts) {
         }
       }
       if (isDir) {
-        if (isIgnored(rel, true)) continue;
-        const real = await fs8.realpath(abs).catch(() => abs);
+        if (isIgnored(rel2, true)) continue;
+        const real = await fs12.realpath(abs).catch(() => abs);
         if (visitedDirs.has(real)) continue;
         visitedDirs.add(real);
         stack.push(abs);
       } else if (isFile) {
-        if (isIgnored(rel, false)) continue;
+        if (isIgnored(rel2, false)) continue;
         if (result.files.length + pending.length >= opts.config.maxFiles) {
           result.truncated = true;
           break;
         }
-        pending.push(rel);
+        pending.push(rel2);
       }
     }
     if (result.truncated) break;
@@ -1222,9 +1676,9 @@ async function walkProject(root, opts) {
   return result;
   async function flush() {
     const batch = pending.splice(0, pending.length);
-    await mapLimit(batch, 32, async (rel) => {
+    await mapLimit(batch, 32, async (rel2) => {
       opts.signal?.throwIfAborted();
-      const entry = await indexFile(rootReal, rel, opts.config.maxFileBytes, opts.reuse?.[rel]);
+      const entry = await indexFile(rootReal, rel2, opts.config.maxFileBytes, opts.reuse?.[rel2]);
       if (!entry) {
         result.skippedUnreadable++;
         return;
@@ -1236,21 +1690,21 @@ async function walkProject(root, opts) {
     opts.onProgress?.(result.files.length);
   }
 }
-async function indexFile(root, rel, maxBytes, prev) {
-  const abs = path12.join(root, rel);
+async function indexFile(root, rel2, maxBytes, prev) {
+  const abs = path17.join(root, rel2);
   try {
-    const st = await fs8.stat(abs);
+    const st = await fs12.stat(abs);
     if (prev && prev.s === st.size && prev.m === Math.floor(st.mtimeMs)) {
-      return { path: rel, size: st.size, mtimeMs: prev.m, hash: prev.h, binary: prev.b === 1, large: prev.h.startsWith("meta:") };
+      return { path: rel2, size: st.size, mtimeMs: prev.m, hash: prev.h, binary: prev.b === 1, large: prev.h.startsWith("meta:") };
     }
     if (st.size > maxBytes) {
-      return { path: rel, size: st.size, mtimeMs: Math.floor(st.mtimeMs), hash: `meta:${st.size}:${Math.floor(st.mtimeMs)}`, binary: false, large: true };
+      return { path: rel2, size: st.size, mtimeMs: Math.floor(st.mtimeMs), hash: `meta:${st.size}:${Math.floor(st.mtimeMs)}`, binary: false, large: true };
     }
-    const buf = await fs8.readFile(abs);
+    const buf = await fs12.readFile(abs);
     const sniff = buf.subarray(0, SNIFF_BYTES);
     const binary = sniff.includes(0);
     return {
-      path: rel,
+      path: rel2,
       size: st.size,
       mtimeMs: Math.floor(st.mtimeMs),
       hash: crypto3.createHash("sha256").update(buf).digest("hex"),
@@ -1478,8 +1932,8 @@ function emptyModel(name, root) {
 }
 
 // src/core/analyzer/context.ts
-import { promises as fs9 } from "fs";
-import path13 from "path";
+import { promises as fs13 } from "fs";
+import path18 from "path";
 function createContext(root, config, files, model, signal) {
   const byPath = new Map(files.map((f) => [f.path, f]));
   const cache = /* @__PURE__ */ new Map();
@@ -1489,19 +1943,19 @@ function createContext(root, config, files, model, signal) {
     files,
     model,
     signal,
-    has: (rel) => byPath.has(rel),
-    async read(rel) {
-      if (cache.has(rel)) return cache.get(rel);
-      const entry = byPath.get(rel);
+    has: (rel2) => byPath.has(rel2),
+    async read(rel2) {
+      if (cache.has(rel2)) return cache.get(rel2);
+      const entry = byPath.get(rel2);
       if (!entry || entry.binary || entry.large) return null;
       signal?.throwIfAborted();
       let text = null;
       try {
-        text = await fs9.readFile(path13.join(root, rel), "utf8");
+        text = await fs13.readFile(path18.join(root, rel2), "utf8");
       } catch {
         text = null;
       }
-      if (!text || text.length < 256e3) cache.set(rel, text);
+      if (!text || text.length < 256e3) cache.set(rel2, text);
       return text;
     },
     find(match) {
@@ -1601,7 +2055,7 @@ var structureDetector = {
 };
 
 // src/core/analyzer/detectors/manifests.ts
-import { parse as parseToml } from "smol-toml";
+import { parse as parseToml2 } from "smol-toml";
 import { parse as parseYaml } from "yaml";
 import ignoreFactory2 from "ignore";
 var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -1656,7 +2110,7 @@ async function parsePyproject(ctx, p) {
   if (!text) return null;
   let t;
   try {
-    t = parseToml(text);
+    t = parseToml2(text);
   } catch {
     ctx.warn(`Could not parse ${p} (invalid TOML)`);
     return null;
@@ -1726,7 +2180,7 @@ async function parsePipfile(ctx, p) {
   const text = await ctx.read(p);
   if (!text) return null;
   try {
-    const t = parseToml(text);
+    const t = parseToml2(text);
     return { manifest: { path: p, ecosystem: "python", dependencies: keys(t.packages).map((k) => k.toLowerCase()), devDependencies: keys(t["dev-packages"]).map((k) => k.toLowerCase()) } };
   } catch {
     ctx.warn(`Could not parse ${p}`);
@@ -1759,7 +2213,7 @@ async function parseCargo(ctx, p) {
   if (!text) return null;
   let t;
   try {
-    t = parseToml(text);
+    t = parseToml2(text);
   } catch {
     ctx.warn(`Could not parse ${p} (invalid TOML)`);
     return null;
@@ -2485,8 +2939,8 @@ var dependenciesDetector = {
 };
 
 // src/core/analyzer/detectors/env.ts
-import { promises as fs10 } from "fs";
-import path14 from "path";
+import { promises as fs14 } from "fs";
+import path19 from "path";
 
 // src/core/security/secrets.ts
 var SECRET_PATTERNS = [
@@ -2643,7 +3097,7 @@ var envDetector = {
     for (const f of ctx.find(/(^|\/)\.env(\.[a-z.]+)?$/)) if (!TEMPLATE_ENV.test(f.path)) present.add(f.path);
     for (const name of REAL_ENV_NAMES) {
       try {
-        const st = await fs10.stat(path14.join(ctx.root, name));
+        const st = await fs14.stat(path19.join(ctx.root, name));
         if (st.isFile()) present.add(name);
       } catch {
       }
@@ -2926,8 +3380,8 @@ async function prisma(ctx) {
         if (!fm) continue;
         const attributes = [...fm[3].matchAll(/@[\w.]+(\([^)]*\))?/g)].map((a) => a[0]);
         fields.push({ name: fm[1], type: fm[2], attributes });
-        const rel = attributes.find((a) => a.startsWith("@relation"));
-        if (rel) relations.push(`${fm[1]} \u2192 ${fm[2].replace(/[[\]?]/g, "")}`);
+        const rel2 = attributes.find((a) => a.startsWith("@relation"));
+        if (rel2) relations.push(`${fm[1]} \u2192 ${fm[2].replace(/[[\]?]/g, "")}`);
       }
       const lineNo = text.slice(0, m.index).split("\n").length;
       out2.push({ name: m[2], kind: "model", fields, indexes, relations, file: f.path, provenance: detected("code", [{ file: f.path, line: lineNo }]) });
@@ -3404,11 +3858,11 @@ async function gitInfo(cwd) {
     const counts = /* @__PURE__ */ new Map();
     for (const line2 of log.stdout.split("\n")) {
       const p = line2.trim();
-      if (!p) continue;
+      if (!p || p === ".athena" || p.startsWith(".athena/")) continue;
       const dir = p.includes("/") ? p.split("/").slice(0, 2).join("/") : ".";
       counts.set(dir, (counts.get(dir) ?? 0) + 1);
     }
-    info2.hotspots = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([path42, commits]) => ({ path: path42, commits }));
+    info2.hotspots = [...counts.entries()].sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)).slice(0, 10).map(([path49, commits]) => ({ path: path49, commits }));
   }
   return info2;
 }
@@ -3466,8 +3920,8 @@ function isSafeRef(ref) {
 async function headMovement(cwd, from, to, limit = 20) {
   if (!/^[0-9a-f]{7,64}$/i.test(from) || !/^[0-9a-f]{7,64}$/i.test(to)) return null;
   if (from === to) return { commits: [], diverged: false, truncated: false };
-  const exists2 = await git(cwd, ["cat-file", "-e", `${from}^{commit}`]);
-  if (!exists2.ok) return { commits: [], diverged: true, truncated: false };
+  const exists3 = await git(cwd, ["cat-file", "-e", `${from}^{commit}`]);
+  if (!exists3.ok) return { commits: [], diverged: true, truncated: false };
   const ancestor = await git(cwd, ["merge-base", "--is-ancestor", from, to]);
   const log = await git(cwd, ["log", `-n${limit + 1}`, "--format=%H%x1f%s", `${from}..${to}`]);
   if (!log.ok) return null;
@@ -3494,10 +3948,10 @@ var DETECTORS = [
 ];
 async function analyzeProject(rootInput, opts = {}) {
   const started = Date.now();
-  const root = await fs11.realpath(path15.resolve(rootInput));
+  const root = await fs15.realpath(path20.resolve(rootInput));
   const loaded = opts.config ? { config: opts.config } : await loadConfig(root);
   const config = loaded.config;
-  const model = emptyModel(path15.basename(root), root);
+  const model = emptyModel(path20.basename(root), root);
   if ("warning" in loaded && loaded.warning) model.warnings.push(loaded.warning);
   opts.onStage?.("scan");
   const walk2 = await walkProject(root, { config, signal: opts.signal, reuse: opts.reuse });
@@ -3547,7 +4001,7 @@ function redactDeep(value) {
 }
 
 // src/core/knowledge/generate.ts
-import path17 from "path";
+import path22 from "path";
 
 // src/core/knowledge/md.ts
 function esc(s) {
@@ -3569,11 +4023,11 @@ function evidenceList(evidence, max = 3) {
 function status(p) {
   return p.status === "UNKNOWN" ? "UNKNOWN" : `${p.status} \xB7 ${p.confidence}`;
 }
-function table(headers, rows) {
-  if (!rows.length) return "";
+function table(headers, rows2) {
+  if (!rows2.length) return "";
   const head = `| ${headers.join(" | ")} |`;
   const sep = `| ${headers.map(() => "---").join(" | ")} |`;
-  return [head, sep, ...rows.map((r) => `| ${r.join(" | ")} |`)].join("\n");
+  return [head, sep, ...rows2.map((r) => `| ${r.join(" | ")} |`)].join("\n");
 }
 function unknown(what, hint) {
   return `**${what}:** UNKNOWN${hint ? ` \u2014 ${hint}` : ""}`;
@@ -3917,8 +4371,8 @@ function renderDependencyRisks(m, scan) {
   const missing = scan.tools.filter((t) => t.status !== "ok");
   const findings = ran.flatMap((t) => t.findings.map((f) => ({ ...f, tool: t.tool })));
   if (findings.length) {
-    const rows = findings.slice(0, 60).map((f) => [esc(f.package), f.severity.toUpperCase(), esc(f.title.slice(0, 90)), esc(f.id ?? "\u2014"), esc(f.tool), f.fixAvailable ? "yes" : "unknown"]);
-    lines.push(`**Detected by tooling:** ${findings.length} vulnerable dependenc${findings.length === 1 ? "y" : "ies"}.`, "", table(["Package", "Severity", "Advisory", "ID", "Tool", "Fix available"], rows));
+    const rows2 = findings.slice(0, 60).map((f) => [esc(f.package), f.severity.toUpperCase(), esc(f.title.slice(0, 90)), esc(f.id ?? "\u2014"), esc(f.tool), f.fixAvailable ? "yes" : "unknown"]);
+    lines.push(`**Detected by tooling:** ${findings.length} vulnerable dependenc${findings.length === 1 ? "y" : "ies"}.`, "", table(["Package", "Severity", "Advisory", "ID", "Tool", "Fix available"], rows2));
     if (findings.length > 60) lines.push("", `_Showing 60 of ${findings.length}. See \`.athena/security-scan.json\`._`);
   } else if (ran.length) {
     lines.push(`**Detected:** no known vulnerable dependencies reported by ${ran.map((t) => esc(t.tool)).join(", ")} at the time of the scan.`);
@@ -4158,7 +4612,7 @@ function seedRules(m) {
 
 // src/core/model/security-scan.ts
 import { z as z5 } from "zod";
-import path16 from "path";
+import path21 from "path";
 var SCAN_FILE = "security-scan.json";
 var Severity = z5.enum(["critical", "high", "moderate", "low", "unknown"]);
 var SEVERITY_ORDER = ["critical", "high", "moderate", "low", "unknown"];
@@ -4190,11 +4644,11 @@ var SecurityScan = z5.object({
 });
 var loadScan = (root) => loadScanFromDir(athenaDir(root));
 async function saveScan(root, scan) {
-  await writeFileAtomic(path16.join(athenaDir(root), SCAN_FILE), `${JSON.stringify(scan, null, 2)}
+  await writeFileAtomic(path21.join(athenaDir(root), SCAN_FILE), `${JSON.stringify(scan, null, 2)}
 `);
 }
 async function loadScanFromDir(dir) {
-  const raw = await readTextIfExists(path16.join(dir, SCAN_FILE));
+  const raw = await readTextIfExists(path21.join(dir, SCAN_FILE));
   if (!raw) return null;
   try {
     const parsed = SecurityScan.safeParse(JSON.parse(raw));
@@ -4257,7 +4711,7 @@ async function planKnowledge(athenaDir2, model, opts = {}) {
   for (const id of ids) {
     const doc = KNOWLEDGE_DOCS.find((d) => d.id === id);
     const sections = renderSections(id, model, extras);
-    const before = await readTextIfExists(path17.join(athenaDir2, doc.file));
+    const before = await readTextIfExists(path22.join(athenaDir2, doc.file));
     if (before === null) {
       plans.push({ id, file: doc.file, status: "created", before, after: composeNewDocument(id, sections), blocks: sections.map((s) => s.id), changedBlocks: sections.map((s) => s.id), preservedModified: [] });
       continue;
@@ -4279,7 +4733,7 @@ async function planKnowledge(athenaDir2, model, opts = {}) {
 async function writePlannedKnowledge(athenaDir2, plans) {
   const reports = [];
   for (const p of plans) {
-    if (p.status !== "unchanged") await writeFileAtomic(path17.join(athenaDir2, p.file), p.after);
+    if (p.status !== "unchanged") await writeFileAtomic(path22.join(athenaDir2, p.file), p.after);
     reports.push({ id: p.id, file: p.file, status: p.status, blocks: p.blocks, preservedModified: p.preservedModified, contentHash: sha256(p.after).slice(0, 16) });
   }
   return reports;
@@ -4288,7 +4742,7 @@ async function writeKnowledge(athenaDir2, model, opts = {}) {
   return writePlannedKnowledge(athenaDir2, await planKnowledge(athenaDir2, model, opts));
 }
 async function ensureRules(athenaDir2, model) {
-  const file = path17.join(athenaDir2, "rules.md");
+  const file = path22.join(athenaDir2, "rules.md");
   const existing = await readTextIfExists(file);
   if (existing !== null) return { id: "rules", file: "rules.md", status: "unchanged", blocks: [], preservedModified: [], contentHash: sha256(existing).slice(0, 16) };
   const text = seedRules(model);
@@ -4327,11 +4781,11 @@ ${missing.join("\n")}
 }
 async function indexWithIntegrations(root, files, written) {
   const index = buildFileIndex(files);
-  for (const rel of written) {
+  for (const rel2 of written) {
     try {
-      const abs = path18.join(root, rel);
-      const [st, buf] = await Promise.all([fs12.stat(abs), fs12.readFile(abs)]);
-      index[rel] = { h: sha256(buf).slice(0, 16), s: st.size, m: Math.floor(st.mtimeMs) };
+      const abs = path23.join(root, rel2);
+      const [st, buf] = await Promise.all([fs16.stat(abs), fs16.readFile(abs)]);
+      index[rel2] = { h: sha256(buf).slice(0, 16), s: st.size, m: Math.floor(st.mtimeMs) };
     } catch {
     }
   }
@@ -4381,7 +4835,7 @@ async function runPipeline(opts) {
   const prev = await readState(finalDir);
   if (prev.kind === "corrupted" && !opts.dryRun) {
     const backup = await backupCorruptedState(finalDir);
-    notes.push(`state.json was corrupted (${prev.reason}); ${backup ? `moved to ${path18.relative(root, backup)}` : "it will be replaced"} and rebuilt.`);
+    notes.push(`state.json was corrupted (${prev.reason}); ${backup ? `moved to ${path23.relative(root, backup)}` : "it will be replaced"} and rebuilt.`);
   }
   const prevState = prev.kind === "ok" ? prev.state : null;
   opts.onStage?.("analyze");
@@ -4394,21 +4848,21 @@ async function runPipeline(opts) {
     return { analysis, docs: [], agentChanges: agentChanges2, state: null, notes };
   }
   const fresh = !await exists(finalDir);
-  const workDir = fresh ? path18.join(root, `${ATHENA_DIR}.tmp-${crypto4.randomBytes(4).toString("hex")}`) : finalDir;
+  const workDir = fresh ? path23.join(root, `${ATHENA_DIR}.tmp-${crypto4.randomBytes(4).toString("hex")}`) : finalDir;
   let docs;
   try {
     opts.onStage?.("write");
-    await fs12.mkdir(workDir, { recursive: true });
+    await fs16.mkdir(workDir, { recursive: true });
     const previousBlocks = prevState ? Object.fromEntries(Object.entries(prevState.documents).map(([k, v]) => [k, v.blocks])) : void 0;
     docs = await writeKnowledge(workDir, analysis.model, { force: opts.force, previousBlocks });
     docs.push(await ensureRules(workDir, analysis.model));
-    await writeFileAtomic(path18.join(workDir, "model.json"), `${JSON.stringify(analysis.model, null, 2)}
+    await writeFileAtomic(path23.join(workDir, "model.json"), `${JSON.stringify(analysis.model, null, 2)}
 `);
-    await ensureGitignoreEntries(path18.join(workDir, ".gitignore"));
+    await ensureGitignoreEntries(path23.join(workDir, ".gitignore"));
     opts.signal?.throwIfAborted();
-    if (fresh) await fs12.rename(workDir, finalDir);
+    if (fresh) await fs16.rename(workDir, finalDir);
   } catch (err) {
-    if (fresh) await fs12.rm(workDir, { recursive: true, force: true }).catch(() => {
+    if (fresh) await fs16.rm(workDir, { recursive: true, force: true }).catch(() => {
     });
     throw err;
   }
@@ -4437,21 +4891,21 @@ async function runPipeline(opts) {
 }
 
 // src/cli/context.ts
-import { promises as fs14 } from "fs";
-import path20 from "path";
+import { promises as fs18 } from "fs";
+import path25 from "path";
 
 // src/services/project.ts
-import { promises as fs13 } from "fs";
-import path19 from "path";
+import { promises as fs17 } from "fs";
+import path24 from "path";
 async function findProjectRoot(start) {
   let dir = start;
   for (; ; ) {
     try {
-      const st = await fs13.stat(path19.join(dir, ATHENA_DIR));
+      const st = await fs17.stat(path24.join(dir, ATHENA_DIR));
       if (st.isDirectory()) return dir;
     } catch {
     }
-    const parent = path19.dirname(dir);
+    const parent = path24.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -4459,11 +4913,11 @@ async function findProjectRoot(start) {
 
 // src/cli/context.ts
 async function resolveCwd(opts) {
-  const dir = path20.resolve(opts.cwd ?? process.cwd());
+  const dir = path25.resolve(opts.cwd ?? process.cwd());
   try {
-    const st = await fs14.stat(dir);
+    const st = await fs18.stat(dir);
     if (!st.isDirectory()) throw new AthenaError(`Not a directory: ${dir}`);
-    return await fs14.realpath(dir);
+    return await fs18.realpath(dir);
   } catch (err) {
     if (err instanceof AthenaError) throw err;
     throw new AthenaError(`Directory not accessible: ${dir}`, "Check the path and your permissions.");
@@ -4476,6 +4930,470 @@ async function requireProjectRoot(opts) {
   return root;
 }
 
+// src/cli/ui/dashboard.ts
+import pc3 from "picocolors";
+
+// src/cli/ui/layout.ts
+import pc2 from "picocolors";
+var ANSI = /\x1b\[[0-9;?]*[A-Za-z]|\x1b\]8;;[^\x07]*\x07/g;
+var strip = (s) => s.replace(ANSI, "");
+var width = (s) => [...strip(s)].length;
+function termWidth() {
+  const cols = process.stdout.columns || Number(process.env.COLUMNS) || 80;
+  return Math.max(40, Math.min(cols, 160));
+}
+function truncate2(s, max) {
+  if (width(s) <= max) return s;
+  if (max <= 0) return "";
+  let out2 = "";
+  let visible = 0;
+  let i = 0;
+  while (i < s.length) {
+    ANSI.lastIndex = 0;
+    const rest = s.slice(i);
+    const m = rest.match(new RegExp(`^(?:${ANSI.source})`));
+    if (m) {
+      out2 += m[0];
+      i += m[0].length;
+      continue;
+    }
+    const ch = String.fromCodePoint(s.codePointAt(i));
+    if (visible === max - 1) {
+      out2 += unicode ? "\u2026" : ".";
+      break;
+    }
+    out2 += ch;
+    visible++;
+    i += ch.length;
+  }
+  return pc2.isColorSupported ? `${out2}\x1B[0m` : out2;
+}
+var padEnd = (s, w) => {
+  const cut = truncate2(s, w);
+  return cut + " ".repeat(Math.max(0, w - width(cut)));
+};
+var center = (s, w) => {
+  const n = width(s);
+  if (n >= w) return truncate2(s, w);
+  const left = Math.floor((w - n) / 2);
+  return " ".repeat(left) + s + " ".repeat(w - n - left);
+};
+var truecolor = /^(truecolor|24bit)$/i.test(process.env.COLORTERM ?? "") || ["iTerm.app", "vscode", "WezTerm", "ghostty", "Hyper"].includes(process.env.TERM_PROGRAM ?? "");
+var hex = (h) => [parseInt(h.slice(1, 3), 16), parseInt(h.slice(3, 5), 16), parseInt(h.slice(5, 7), 16)];
+function ansi256([r, g, b]) {
+  const q = (v) => v < 48 ? 0 : v < 115 ? 1 : Math.round((v - 35) / 40);
+  return 16 + 36 * q(r) + 6 * q(g) + q(b);
+}
+function paint(color, s, bold = false) {
+  if (!pc2.isColorSupported || !s) return s;
+  const rgb = typeof color === "string" ? hex(color) : color;
+  const fg = truecolor ? `\x1B[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m` : `\x1B[38;5;${ansi256(rgb)}m`;
+  return `${bold ? "\x1B[1m" : ""}${fg}${s}\x1B[0m`;
+}
+function cell(ch, fg, bg) {
+  if (!pc2.isColorSupported) return ch;
+  const code2 = (c2, layer) => {
+    const rgb = typeof c2 === "string" ? hex(c2) : c2;
+    return truecolor ? `\x1B[${layer};2;${rgb[0]};${rgb[1]};${rgb[2]}m` : `\x1B[${layer};5;${ansi256(rgb)}m`;
+  };
+  return `${fg ? code2(fg, 38) : ""}${bg ? code2(bg, 48) : ""}${ch}\x1B[0m`;
+}
+var PALETTE = {
+  green: "#34d399",
+  cyan: "#22d3ee",
+  blue: "#3b82f6",
+  violet: "#a855f7",
+  pink: "#f472b6",
+  amber: "#fbbf24",
+  slate: "#64748b"
+};
+var BRAND = [PALETTE.cyan, PALETTE.blue, PALETTE.violet];
+function mix(stops, t) {
+  const rgb = stops.map(hex);
+  if (rgb.length === 1) return rgb[0];
+  const x = Math.min(0.9999, Math.max(0, t)) * (rgb.length - 1);
+  const i = Math.floor(x);
+  const f = x - i;
+  const [a, b] = [rgb[i], rgb[i + 1]];
+  return [0, 1, 2].map((k) => Math.round(a[k] + (b[k] - a[k]) * f));
+}
+function gradientBlock(lines, stops = BRAND, bold = true) {
+  const w = Math.max(...lines.map((l) => [...l].length));
+  return lines.map((l) => [...l].map((ch, i) => ch === " " ? ch : paint(mix(stops, i / Math.max(1, w - 1)), ch, bold)).join(""));
+}
+var gradient = (s, stops = BRAND, bold = false) => gradientBlock([s], stops, bold)[0];
+var B = unicode ? { tl: "\u256D", tr: "\u256E", bl: "\u2570", br: "\u256F", h: "\u2500", v: "\u2502" } : { tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|" };
+var HR = B.h;
+var VR = B.v;
+function box(content, w, opts = {}) {
+  const color = opts.color ?? PALETTE.slate;
+  const padX = opts.padX ?? 1;
+  const inner = w - 2;
+  const edge = (s) => paint(color, s);
+  const title = opts.title ? ` ${opts.title} ` : "";
+  const top = title ? edge(`${B.tl}${B.h}`) + title + edge(B.h.repeat(Math.max(0, inner - 1 - width(title))) + B.tr) : edge(B.tl + B.h.repeat(inner) + B.tr);
+  const body = content.map((l) => edge(B.v) + " ".repeat(padX) + padEnd(l, inner - padX * 2) + " ".repeat(padX) + edge(B.v));
+  return [top, ...body, edge(B.bl + B.h.repeat(inner) + B.br)];
+}
+function columns(blocks, widths, gap = 2) {
+  const h = Math.max(...blocks.map((b) => b.length));
+  const rows2 = [];
+  for (let r = 0; r < h; r++) rows2.push(blocks.map((b, i) => padEnd(b[r] ?? "", widths[i])).join(" ".repeat(gap)).trimEnd());
+  return rows2;
+}
+function vcenter(block, h) {
+  const top = Math.max(0, Math.floor((h - block.length) / 2));
+  return [...Array(top).fill(""), ...block];
+}
+
+// src/cli/ui/dashboard.ts
+var C = PALETTE;
+var accent = (s) => paint(PALETTE.amber, s, true);
+var warnText = (s) => paint(PALETTE.amber, s);
+function sectionTitle(title) {
+  const total = termWidth();
+  const head = `  ${paint(PALETTE.violet, unicode ? "\u2726" : "*", true)} ${gradient(title, [PALETTE.cyan, PALETTE.violet], true)} `;
+  const rest = Math.max(0, total - width(head) - 2);
+  return [head + paint(PALETTE.blue, HR.repeat(rest))];
+}
+function rows(items) {
+  const labelW = Math.max(...items.map(([l]) => l.length)) + 2;
+  return (w) => items.map(([label, value]) => pc3.dim(padEnd(label, labelW)) + padEnd(value ? paint(PALETTE.cyan, value) : pc3.dim("Not detected"), w - labelW));
+}
+function fileTree(root, files) {
+  const nameW = Math.max(...files.map((f) => f.name.length)) + 2;
+  return (w) => [
+    pc3.bold(root),
+    ...files.map((f, i) => {
+      const branch = unicode ? i === files.length - 1 ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 " : i === files.length - 1 ? "`-- " : "|-- ";
+      const name = f.highlight ? paint(PALETTE.amber, padEnd(f.name, nameW)) : padEnd(f.name, nameW);
+      return padEnd(pc3.dim(branch) + name + pc3.dim(f.note ? `# ${f.note}` : ""), w);
+    })
+  ];
+}
+function wrapCode(text, w) {
+  const out2 = [];
+  let cur = "";
+  for (const word of text.split(" ")) {
+    if (cur && cur.length + 1 + word.length > w) {
+      out2.push(cur);
+      cur = word;
+    } else cur = cur ? `${cur} ${word}` : word;
+  }
+  if (cur) out2.push(cur);
+  let inCode = false;
+  return out2.map(
+    (l) => l.split("`").map((part, i) => {
+      if (i > 0) inCode = !inCode;
+      return inCode ? paint(PALETTE.cyan, part) : part;
+    }).join("")
+  );
+}
+function wrapLines(text, indent = 2) {
+  const w = Math.max(20, termWidth() - 1);
+  const out2 = [];
+  let cur = "";
+  for (const word of text.split(" ")) {
+    if (cur && cur.length + 1 + word.length > w) {
+      out2.push(cur);
+      cur = " ".repeat(indent) + word;
+    } else cur = cur ? `${cur} ${word}` : word;
+  }
+  if (cur) out2.push(cur);
+  return out2;
+}
+function numbered(steps) {
+  return (w) => steps.flatMap((s, i) => {
+    const badge = paint(PALETTE.green, ` ${i + 1} `, true);
+    const [first = "", ...rest] = wrapCode(s, Math.max(10, w - 5));
+    return [`${badge}  ${first}`, ...rest.map((r) => `     ${r}`)];
+  });
+}
+function quote(text) {
+  return (w) => {
+    const lines = wrapCode(`\u201C${text}\u201D`, Math.max(10, w - 6)).map((l) => pc3.italic(l));
+    return box([...lines, paint(PALETTE.cyan, `\u2014 Sabarivasan`)], Math.min(w, Math.max(...lines.map(width)) + 6), { color: PALETTE.slate, padX: 2 });
+  };
+}
+function renderBody(body, w) {
+  const parts = Array.isArray(body) && body.length && typeof body[0] !== "string" ? body : [body];
+  return parts.flatMap((p) => typeof p === "function" ? p(w) : p);
+}
+function panels(list) {
+  const total = termWidth();
+  const title = (p) => `${paint(p.color, unicode ? p.icon : "*", true)} ${paint(p.color, p.title, true)}`;
+  if (total >= 120) {
+    const gap = 2;
+    const avail = total - gap * (list.length - 1) - 1;
+    const weights = [0.36, 0.32, 0.32];
+    const widths = list.map((_, i) => Math.floor(avail * (weights[i] ?? 1 / list.length)));
+    const bodies = list.map((p, i) => renderBody(p.body, widths[i] - 4));
+    const h = Math.max(...bodies.map((b) => b.length));
+    const boxes = list.map((p, i) => box([title(p), "", ...bodies[i], ...Array(h - bodies[i].length).fill("")], widths[i], { color: p.color, padX: 1 }));
+    return columns(boxes, widths, gap);
+  }
+  const w = Math.min(total - 1, 100);
+  return list.flatMap((p, i) => [...i ? [""] : [], ...box([title(p), "", ...renderBody(p.body, w - 4)], w, { color: p.color })]);
+}
+
+// src/cli/ui/brand.ts
+import pc4 from "picocolors";
+var LETTERS = {
+  A: [" \u2588\u2588\u2588\u2588\u2588\u2557 ", "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557", "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551", "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551", "\u2588\u2588\u2551  \u2588\u2588\u2551", "\u255A\u2550\u255D  \u255A\u2550\u255D"],
+  T: ["\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557", "\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D", "   \u2588\u2588\u2551   ", "   \u2588\u2588\u2551   ", "   \u2588\u2588\u2551   ", "   \u255A\u2550\u255D   "],
+  H: ["\u2588\u2588\u2557  \u2588\u2588\u2557", "\u2588\u2588\u2551  \u2588\u2588\u2551", "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551", "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551", "\u2588\u2588\u2551  \u2588\u2588\u2551", "\u255A\u2550\u255D  \u255A\u2550\u255D"],
+  E: ["\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557", "\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D", "\u2588\u2588\u2588\u2588\u2588\u2557  ", "\u2588\u2588\u2554\u2550\u2550\u255D  ", "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557", "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D"],
+  N: ["\u2588\u2588\u2588\u2557   \u2588\u2588\u2557", "\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551", "\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551", "\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551", "\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551", "\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D"]
+};
+var LOGO = [0, 1, 2, 3, 4, 5].map((r) => [..."ATHENA"].map((ch) => LETTERS[ch][r]).join(""));
+var LOGO_WIDTH = width(LOGO[0]);
+var ROBOT_PIXELS = [
+  "...........AA...........",
+  "..........AAAA..........",
+  "...........KK...........",
+  "....KKKKKKKKKKKKKKKK....",
+  "...KBBBBBBBBBBBBBBBBK...",
+  "..KBBBBBBBBBBBBBBBBBBK..",
+  "..KBBBBWWBBBBBBYYYYBBK..",
+  "YYKBBBWBBWBBBBYYDDYYBKYY",
+  "YYKBBBBBBBBBBBYYDDYYBKYY",
+  "YYKBBBBBBBBBBBBYYYYBBKYY",
+  "YYKBBBBBYYYYYYYYBBBBBKYY",
+  "..KBBBBBBYYYYYYBBBBBBK..",
+  "..KBBBBBBBYYYYBBBBBBBK..",
+  "..KBBBBBBBBBBBBBBBBBBK..",
+  "..KBBBBBBBBBBBBBBBBBBK..",
+  "..KBBBBBKKKKKKKKKKKK....",
+  "...KBBBK................",
+  "....KBK.................",
+  ".....K..................",
+  "........................"
+];
+var PIXEL_COLORS = { K: "#1e40af", B: "#4ba3e3", Y: "#f5c542", D: "#2e3f9e", A: "#5b7cfa", W: "#0f172a" };
+var ROBOT_ASCII = [
+  "      \u25CF      ",
+  "      \u2503      ",
+  "  \u256D\u2500\u2500\u2500\u2538\u2500\u2500\u2500\u256E  ",
+  " \u2590\u2502 \u25E0   \u25C9 \u2502\u258C ",
+  " \u2590\u2502  \u2570\u2500\u256F  \u2502\u258C ",
+  "  \u2502       \u2502  ",
+  "  \u2570\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u256F  ",
+  "   \u2570\u256F        ",
+  "             ",
+  "             "
+];
+var ROBOT_HEIGHT = ROBOT_PIXELS.length / 2;
+var ROBOT_WIDTH = pc4.isColorSupported ? ROBOT_PIXELS[0].length : ROBOT_ASCII[0].length;
+var BUBBLE = ["\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E", "\u2502 Analyze    \u2502", "\u2502 Understand \u2502", "\u2502 Document   \u2502", "\u2502 Empower \u2726  \u2502", "\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F"];
+var BUBBLE_WIDTH = 14;
+function paintRobot() {
+  if (!pc4.isColorSupported) return ROBOT_ASCII;
+  const color = (p) => PIXEL_COLORS[p] ?? null;
+  const out2 = [];
+  for (let r = 0; r < ROBOT_PIXELS.length; r += 2) {
+    const top = ROBOT_PIXELS[r];
+    const bottom = ROBOT_PIXELS[r + 1];
+    let row = "";
+    for (let x = 0; x < top.length; x++) {
+      const [t, b] = [color(top[x]), color(bottom[x])];
+      if (!t && !b) row += " ";
+      else if (t === b) row += cell("\u2588", t, null);
+      else if (!b) row += cell("\u2580", t, null);
+      else if (!t) row += cell("\u2584", b, null);
+      else row += cell("\u2580", t, b);
+    }
+    out2.push(row);
+  }
+  return out2;
+}
+function paintBubble() {
+  return BUBBLE.map((row) => {
+    const inner = row.slice(1, -1);
+    const edge = (s) => paint(PALETTE.slate, s);
+    if (row.startsWith("\u256D") || row.startsWith("\u2570")) return edge(row);
+    return edge("\u2502") + inner.replace("\u2726", paint(PALETTE.amber, "\u2726")).replace(/[A-Za-z]+/, (w) => paint(PALETTE.cyan, w)) + edge("\u2502");
+  });
+}
+function logoBlock(w) {
+  const rule = (label) => {
+    const side = Math.max(2, Math.floor((w - width(label) - 2) / 2));
+    return `${pc4.dim(HR.repeat(side))} ${label} ${pc4.dim(HR.repeat(side))}`;
+  };
+  return [
+    ...gradientBlock(LOGO),
+    "",
+    center(gradient("Project Intelligence for AI Coding", [PALETTE.blue, PALETTE.violet], true), w),
+    center(rule(`${pc4.dim("developed by")} ${paint(PALETTE.cyan, AUTHOR, true)}`), w)
+  ];
+}
+function linksBlock() {
+  return [
+    pc4.italic('"Turn any codebase into clear knowledge."'),
+    "",
+    `${paint(PALETTE.green, "web", true)}     ${paint(PALETTE.cyan, WEBSITE_URL, true)}`,
+    `${paint(PALETTE.pink, "npm", true)}     ${pc4.dim(`v${ATHENA_VERSION}`)}`,
+    paint(PALETTE.blue, NPM_URL),
+    paint(PALETTE.violet, "github", true),
+    paint(PALETTE.blue, REPO_URL)
+  ];
+}
+var LINKS_WIDTH = Math.max(NPM_URL.length, REPO_URL.length);
+function printHeader() {
+  if (isJson() || isQuiet()) return;
+  for (const l of header()) line(l);
+}
+function header() {
+  if (!unicode) return [pc4.bold(pc4.cyan("ATHENA")) + pc4.dim(`  Project Intelligence for AI Coding \xB7 v${ATHENA_VERSION}`), ""];
+  const total = termWidth();
+  const logoW = LOGO_WIDTH;
+  const divider = (h) => Array.from({ length: h }, () => pc4.dim(VR));
+  const robotBubble = columns([paintRobot(), vcenter(paintBubble(), ROBOT_HEIGHT - 2)], [ROBOT_WIDTH, BUBBLE_WIDTH], 1);
+  const logo = vcenter(logoBlock(logoW), ROBOT_HEIGHT);
+  const links = vcenter(linksBlock(), ROBOT_HEIGHT);
+  const H = ROBOT_HEIGHT;
+  const layouts = [
+    { w: ROBOT_WIDTH + 1 + BUBBLE_WIDTH + 3 + logoW + 3 + 1 + 3 + LINKS_WIDTH, build: () => columns([robotBubble, logo, divider(H), links], [ROBOT_WIDTH + 1 + BUBBLE_WIDTH, logoW, 1, LINKS_WIDTH], 3) },
+    { w: ROBOT_WIDTH + 3 + logoW + 3 + 1 + 3 + LINKS_WIDTH, build: () => columns([paintRobot(), logo, divider(H), links], [ROBOT_WIDTH, logoW, 1, LINKS_WIDTH], 3) },
+    { w: ROBOT_WIDTH + 3 + logoW, build: () => [...columns([paintRobot(), logo], [ROBOT_WIDTH, logoW], 3), "", ...compactLinks()] },
+    { w: logoW, build: () => [...logoBlock(logoW), "", ...compactLinks()] }
+  ];
+  const fit = layouts.find((l) => l.w + 4 <= total);
+  if (!fit) return [pc4.bold(gradient("ATHENA", BRAND, true)) + pc4.dim(`  Project Intelligence for AI Coding \xB7 v${ATHENA_VERSION}`), pc4.dim(REPO_URL), ""];
+  const content = fit.build();
+  return [...box(content, Math.min(total, fit.w + 4), { color: PALETTE.blue }), ""];
+}
+function compactLinks() {
+  return [
+    `${paint(PALETTE.green, "web", true)}     ${paint(PALETTE.cyan, WEBSITE_URL, true)}`,
+    `${paint(PALETTE.pink, "npm", true)}     ${paint(PALETTE.blue, NPM_URL)}`,
+    `${paint(PALETTE.violet, "github", true)}  ${paint(PALETTE.blue, REPO_URL)}`
+  ];
+}
+function footer(title, subtitle, tone = "success") {
+  const total = termWidth();
+  const color = tone === "success" ? PALETTE.green : PALETTE.amber;
+  const mark = tone === "success" ? "\u2713" : "!";
+  const status2 = [`${paint(color, ` ${mark} `, true)}  ${paint(color, title, true)}`, `     ${subtitle}`, ""];
+  const links = compactLinks();
+  const credit = [pc4.dim("Developed by"), `${paint(PALETTE.cyan, AUTHOR, true)} ${paint(PALETTE.pink, "\u2665")}`, ""];
+  const statusW = Math.max(...status2.map(width));
+  const linksW = 8 + LINKS_WIDTH;
+  const wide = statusW + 4 + linksW + 3 + 1 + 3 + 14 + 4;
+  const content = wide <= total ? columns([status2, links, divider2(), credit], [statusW, linksW, 1, 14], 3) : total >= linksW + 4 ? [...status2.filter(Boolean), "", ...links, credit.filter(Boolean).join(" ")] : [...status2, pc4.dim(REPO_URL)];
+  const w = wide <= total ? wide : Math.min(total, Math.max(statusW, linksW) + 4);
+  return box(content, w, { color });
+}
+var divider2 = () => [pc4.dim(VR), pc4.dim(VR), pc4.dim(VR)];
+
+// src/cli/ui/stages.ts
+import pc5 from "picocolors";
+var STAGES = [
+  { id: "scan", label: "Scanning project structure" },
+  { id: "detect", label: "Detecting stack, database, API & auth" },
+  { id: "git", label: "Reading Git metadata" },
+  { id: "finalize", label: "Redacting secrets & validating" },
+  { id: "write", label: "Generating documentation" },
+  { id: "agents", label: "Configuring AI agents" }
+];
+var STAGE_ALIASES = { analyze: "scan" };
+var FRAMES2 = unicode ? ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"] : ["-", "\\", "|", "/"];
+var BAR_STOPS = [PALETTE.green, PALETTE.cyan, PALETTE.blue, PALETTE.violet];
+var StageBoard = class {
+  state = new Map(STAGES.map((s) => [s.id, "pending"]));
+  started = /* @__PURE__ */ new Map();
+  elapsed = /* @__PURE__ */ new Map();
+  results = /* @__PURE__ */ new Map();
+  current = null;
+  frame = 0;
+  drawn = 0;
+  timer = null;
+  live = isTTY && !isJson() && !isQuiet();
+  enabled = !isJson() && !isQuiet();
+  restoreCursor = () => process.stdout.write("\x1B[?25h");
+  start() {
+    if (!this.live) return;
+    process.stdout.write("\x1B[?25l");
+    process.once("exit", this.restoreCursor);
+    this.render();
+    this.timer = setInterval(() => {
+      this.frame++;
+      this.render();
+    }, 80);
+    this.timer.unref();
+  }
+  /** Accepts raw pipeline stage names; unknown names are ignored. */
+  enter(raw) {
+    const id = STAGE_ALIASES[raw] ?? raw;
+    if (!this.state.has(id) || this.current === id) return;
+    this.closeCurrent("done");
+    this.current = id;
+    this.state.set(id, "running");
+    this.started.set(id, performance.now());
+  }
+  finish(results) {
+    this.closeCurrent("done");
+    for (const [id, st] of this.state) if (st === "pending") this.state.set(id, "skipped");
+    for (const [id, r] of Object.entries(results)) this.results.set(id, r);
+    this.stop();
+  }
+  fail() {
+    this.closeCurrent("failed");
+    this.stop();
+  }
+  closeCurrent(to) {
+    if (!this.current) return;
+    this.state.set(this.current, to);
+    this.elapsed.set(this.current, performance.now() - this.started.get(this.current));
+    this.current = null;
+  }
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    if (!this.enabled) return;
+    if (this.live) {
+      this.render();
+      this.restoreCursor();
+      process.removeListener("exit", this.restoreCursor);
+    } else for (const l of this.lines()) line(l);
+  }
+  render() {
+    const rows2 = this.lines();
+    let s = this.drawn ? `\x1B[${this.drawn}F` : "";
+    for (const r of rows2) s += `\x1B[2K${r}
+`;
+    process.stdout.write(s);
+    this.drawn = rows2.length;
+  }
+  lines() {
+    const total = termWidth();
+    const showBar = total >= 100;
+    const barW = total >= 130 ? 26 : 18;
+    return STAGES.map((s, i) => {
+      const st = this.state.get(s.id);
+      const icon = st === "done" ? paint(PALETTE.green, sym.ok, true) : st === "running" ? paint(PALETTE.cyan, FRAMES2[this.frame % FRAMES2.length]) : st === "failed" ? pc5.red(sym.err) : pc5.dim(st === "skipped" ? "\u2013" : sym.ring);
+      const label = st === "pending" || st === "skipped" ? pc5.dim(s.label) : s.label;
+      const ms = this.elapsed.get(s.id) ?? (st === "running" ? performance.now() - this.started.get(s.id) : void 0);
+      const time2 = st === "skipped" ? pc5.dim("skipped") : ms === void 0 ? "" : pc5.dim(ms < 1e3 ? `${Math.max(1, Math.round(ms))}ms` : `${(ms / 1e3).toFixed(1)}s`);
+      const r = this.results.get(s.id);
+      const result = r ? r.tone === "warn" ? paint(PALETTE.amber, `${sym.warn} ${r.text}`) : r.tone === "dim" ? pc5.dim(r.text) : `${paint(PALETTE.green, sym.ok)} ${r.text}` : "";
+      const bar = showBar ? `${this.bar(st, barW, i)}  ` : "";
+      return truncate2(`  ${icon}  ${padEnd(label, 40)}${bar}${padEnd(time2, 8)}${result}`, total - 1);
+    });
+  }
+  bar(st, w, row) {
+    const fill = unicode ? "\u2501" : "#";
+    const track = unicode ? "\u2500" : "-";
+    if (st === "done") return paint(mix(BAR_STOPS, row / (STAGES.length - 1)), fill.repeat(w));
+    if (st === "failed") return pc5.red(fill.repeat(w));
+    if (st !== "running") return pc5.dim(track.repeat(w));
+    const seg = 6;
+    const span = w - seg;
+    const t = this.frame % (span * 2);
+    const pos = t <= span ? t : span * 2 - t;
+    return pc5.dim(track.repeat(pos)) + paint(PALETTE.cyan, fill.repeat(seg)) + pc5.dim(track.repeat(w - pos - seg));
+  }
+};
+
 // src/cli/commands/init.ts
 function parseAgentsOption(value, disabled) {
   if (disabled) return [];
@@ -4490,12 +5408,12 @@ function parseAgentsOption(value, disabled) {
 }
 async function initCommand(opts) {
   const root = await resolveCwd(opts);
-  const existing = await readState(path21.join(root, ".athena"));
+  const existing = await readState(path26.join(root, ".athena"));
   if (existing.kind === "ok") {
     throw new AthenaError("Athena is already initialized in this project.", "Run `athena analyze` to refresh knowledge, or `athena clean` to start over.");
   }
   const agents = parseAgentsOption(opts.agents, opts.noAgents);
-  banner();
+  printHeader();
   const result = await runWithProgress(root, { mode: "init", dryRun: opts.dryRun, agents, signal: opts.signal });
   if (isJson()) {
     json(summarize(result, root, Boolean(opts.dryRun)));
@@ -4504,8 +5422,8 @@ async function initCommand(opts) {
   printSummary(result, Boolean(opts.dryRun), "init");
 }
 async function runWithProgress(root, o) {
-  const sp = spinner("Scanning project files...");
-  const started = Date.now();
+  const board = new StageBoard();
+  board.start();
   try {
     const result = await runPipeline({
       root,
@@ -4514,22 +5432,50 @@ async function runWithProgress(root, o) {
       force: o.force,
       agents: o.agents,
       signal: o.signal,
-      onStage: (stage) => {
-        const labels = { analyze: "Scanning project files...", scan: "Scanning project files...", detect: "Detecting technologies, schema, routes and infrastructure...", git: "Reading Git metadata...", finalize: "Redacting and validating...", write: "Writing knowledge...", agents: "Configuring AI agents..." };
-        sp.update(labels[stage] ?? stage);
-      }
+      onStage: (stage) => board.enter(stage)
     });
-    sp.succeed(`Analyzed ${result.analysis.model.stats.filesScanned} files in ${((Date.now() - started) / 1e3).toFixed(1)}s`);
+    board.finish(stageResults(result, o.mode, Boolean(o.dryRun)));
     return result;
   } catch (err) {
-    sp.stop();
+    board.fail();
     throw err;
   }
 }
-function detectionLine(label, count, detail) {
-  if (count > 0) ok(`${label}${detail ? dim(` \u2014 ${detail}`) : ""}`);
-  else line(`${c.dim(sym.ring)} ${c.dim(`${label} \u2014 not detected`)}`);
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function stageResults(result, mode, dryRun) {
+  const m = result.analysis.model;
+  const skipped = m.stats.skippedBinary + m.stats.skippedLarge + m.stats.skippedUnreadable;
+  const found = [
+    m.frameworks.length && plural(new Set(m.frameworks.map((f) => f.name)).size, "framework"),
+    m.dbEntities.length && plural(m.dbEntities.length, "entity").replace("entitys", "entities"),
+    m.routes.length && plural(m.routes.length, "route"),
+    m.auth.length && "auth"
+  ].filter(Boolean);
+  const changed = result.docs.filter((d) => d.status !== "unchanged").length;
+  const agents = result.agentChanges.map((a) => a.adapter.displayName);
+  return {
+    scan: { text: `Found ${plural(m.stats.filesScanned, "file")}${skipped ? ` \xB7 ${skipped} skipped` : ""}` },
+    detect: found.length ? { text: found.join(" \xB7 ") } : { text: "No frameworks detected", tone: "dim" },
+    git: m.git.isRepo ? { text: `On ${m.git.branch ?? "detached HEAD"}${m.git.head ? ` @ ${m.git.head.slice(0, 7)}` : ""}` } : { text: m.git.available ? "Not a Git repository" : "Git not installed", tone: "dim" },
+    finalize: m.security.secrets.length ? { text: `${plural(m.security.secrets.length, "potential secret")} (values redacted)`, tone: "warn" } : { text: "No likely secrets found" },
+    write: dryRun ? { text: "Dry run \u2014 nothing written", tone: "dim" } : { text: mode === "init" ? `${plural(result.docs.length, "document")} generated` : changed ? `${changed} updated \xB7 ${result.docs.length - changed} unchanged` : "Already up to date" },
+    agents: agents.length ? { text: agents.join(", ") } : { text: "None configured", tone: "dim" }
+  };
 }
+var DOC_NOTES = {
+  "project.md": "Project overview",
+  "architecture.md": "System architecture",
+  "database.md": "Database schema",
+  "api.md": "API reference",
+  "auth.md": "Authentication flow",
+  "security.md": "Security analysis",
+  "testing.md": "Testing strategy",
+  "debugging.md": "Debugging guide",
+  "performance.md": "Performance notes",
+  "code-review.md": "Review checklist",
+  "deployment.md": "Deployment guide",
+  "rules.md": "Your project rules"
+};
 function printSummary(result, dryRun, mode) {
   const m = result.analysis.model;
   if (isQuiet()) {
@@ -4540,63 +5486,65 @@ function printSummary(result, dryRun, mode) {
     line(dryRun ? "Dry run: nothing written." : changed.length ? `Updated: ${changed.join(", ")}` : "Knowledge up to date.");
     return;
   }
-  line();
   const uniq = (xs) => [...new Set(xs)];
-  detectionLine("Project", m.stats.filesScanned, `${m.name}${m.languages[0] ? ` \xB7 ${m.languages.slice(0, 3).map((l) => l.name).join(", ")}` : ""}`);
-  detectionLine("Frameworks", m.frameworks.length, uniq(m.frameworks.map((f) => f.name)).slice(0, 5).join(", "));
-  detectionLine("Workspace", m.workspace.isMonorepo ? m.workspace.packages.length : 0, m.workspace.isMonorepo ? `monorepo \xB7 ${m.workspace.packages.length} packages` : void 0);
-  detectionLine("Database", m.databases.length + m.dbEntities.length, `${uniq(m.databases.map((d) => d.name)).slice(0, 3).join(", ")}${m.dbEntities.length ? ` \xB7 ${m.dbEntities.length} entities` : ""}`);
-  detectionLine("API", m.routes.length + m.apiSpecs.length, `${m.routes.length} route${m.routes.length === 1 ? "" : "s"}${m.apiSpecs.length ? ` \xB7 ${m.apiSpecs.length} specs` : ""}`);
-  detectionLine("Authentication", m.auth.length, uniq(m.auth.map((a) => a.name)).slice(0, 3).join(", "));
-  detectionLine("Testing", m.tests.frameworks.length + m.tests.testFileCount, `${uniq(m.tests.frameworks.map((f) => f.name)).slice(0, 3).join(", ")} \xB7 ${m.tests.testFileCount} test files`);
-  detectionLine("Deployment", m.containers.dockerfiles.length + m.ci.length + m.infrastructure.length, [m.containers.dockerfiles.length ? "Docker" : "", m.ci.length ? uniq(m.ci.map((j) => j.system)).join(", ") : "", ...uniq(m.infrastructure.filter((i) => i.kind === "hosting").map((i) => i.name))].filter(Boolean).slice(0, 4).join(", "));
-  if (m.security.secrets.length) warn(`Security \u2014 ${m.security.secrets.length} potential hardcoded secret(s); see .athena/security.md (values not stored)`);
-  else ok(`Security${dim(" \u2014 no likely secrets matched")}`);
-  if (m.warnings.length) {
-    line();
-    for (const w of m.warnings.slice(0, 5)) warn(c.yellow(w));
-    if (m.warnings.length > 5) line(dim(`  +${m.warnings.length - 5} more warnings (see .athena/project.md)`));
-  }
+  const list = (xs, n = 4) => uniq(xs).slice(0, n).join(" \xB7 ");
   line();
-  if (dryRun) {
-    heading("Dry run \u2014 nothing was written.");
-    line("Would create .athena/ with 12 knowledge files, model.json and state.json.");
-    for (const { adapter, changes } of result.agentChanges) for (const ch of changes) bullet(`${adapter.displayName}: would ${ch.action} ${ch.path}`);
-    return;
-  }
-  if (mode === "init") {
-    tree(c.bold(".athena/"), [...result.docs.map((d) => d.file), "model.json", "state.json"]);
-  } else {
-    const changed = result.docs.filter((d) => d.status !== "unchanged");
-    if (changed.length) {
-      heading("Knowledge updated:");
-      for (const d of changed) bullet(`${d.file} ${dim(`(${d.status})`)}`);
-    } else ok("Knowledge already up to date.");
-  }
-  const preserved = result.docs.filter((d) => d.preservedModified.length);
-  if (preserved.length) {
-    line();
-    for (const d of preserved) warn(`${d.file}: kept your edits in ${d.preservedModified.join(", ")} ${dim("(use --force to regenerate)")}`);
-  }
+  for (const l of sectionTitle(dryRun ? "Dry Run Complete" : "Analysis Complete!")) line(l);
+  line(`  Analyzed ${accent(String(m.stats.filesScanned))} files in ${accent(`${(result.analysis.durationMs / 1e3).toFixed(1)}s`)}`);
   line();
-  if (result.agentChanges.length) {
-    for (const { adapter, changes } of result.agentChanges) {
+  const overview = [
+    ["Project", `${m.name}${m.languages[0] ? ` \xB7 ${list(m.languages.map((l) => l.name), 3)}` : ""}`],
+    ["Frameworks", list(m.frameworks.map((f) => f.name), 5)],
+    ["Workspace", m.workspace.isMonorepo ? `monorepo \xB7 ${plural(m.workspace.packages.length, "package")}` : ""],
+    ["Database", m.databases.length + m.dbEntities.length ? [list(m.databases.map((d) => d.name), 3), m.dbEntities.length ? plural(m.dbEntities.length, "entity").replace("entitys", "entities") : ""].filter(Boolean).join(" \xB7 ") : ""],
+    ["API", m.routes.length + m.apiSpecs.length ? [m.routes.length ? plural(m.routes.length, "route") : "", m.apiSpecs.length ? plural(m.apiSpecs.length, "spec") : ""].filter(Boolean).join(" \xB7 ") : ""],
+    ["Auth", list(m.auth.map((a) => a.name), 3)],
+    ["Testing", m.tests.frameworks.length + m.tests.testFileCount ? [list(m.tests.frameworks.map((f) => f.name), 3), plural(m.tests.testFileCount, "test file")].filter(Boolean).join(" \xB7 ") : ""],
+    ["Deployment", [m.containers.dockerfiles.length ? "Docker" : "", ...uniq(m.ci.map((j) => j.system)), ...uniq(m.infrastructure.filter((i) => i.kind === "hosting").map((i) => i.name))].filter(Boolean).slice(0, 4).join(" \xB7 ")],
+    ["Security", m.security.secrets.length ? warnText(`${plural(m.security.secrets.length, "potential secret")} \u2014 see security.md`) : "No likely secrets matched"]
+  ];
+  const files = dryRun ? ["Would create .athena/ with:", ...[...KNOWLEDGE_DOCS.map((d) => d.file), "model.json", "state.json"].map((f) => `  ${f}`)] : fileTree(
+    ".athena/",
+    result.docs.map((d) => ({ name: d.file, note: mode === "init" ? DOC_NOTES[d.file] ?? "" : d.status, highlight: mode === "analyze" && d.status !== "unchanged" }))
+  );
+  const configured = result.agentChanges.length > 0;
+  const steps = dryRun ? ["Run `athena init` without --dry-run to write the files"] : mode === "init" ? [
+    "Review `.athena/rules.md` and enable the rules that apply",
+    "Run `athena open` to browse and edit in the web UI",
+    configured ? "Your agents now read `.athena/` \u2014 watch with `athena activity`" : "Connect an agent: `athena agents add claude-code`",
+    "After code changes run `athena sync` to keep docs current",
+    "Guides and docs: https://athena.sabari.me \xB7 star us on GitHub \u2605"
+  ] : ["Review changes with `git diff .athena/`", "Run `athena open` to browse in the web UI", "Use `athena sync --watch` to stay current"];
+  for (const l of panels([
+    { title: "Project Overview", icon: "\u25C6", color: C.blue, body: rows(overview) },
+    { title: mode === "init" ? "Generated Files" : "Knowledge Files", icon: "\u25A4", color: C.violet, body: files },
+    { title: "Next Steps", icon: "\u279C", color: C.green, body: mode === "init" && !dryRun ? [numbered(steps), [""], quote("Better documentation leads to better software.")] : numbered(steps) }
+  ]))
+    line(l);
+  const preserved = result.docs.filter((d) => d.preservedModified.length);
+  const notes = [
+    ...m.warnings.slice(0, 5).map((w) => () => warn(c.yellow(w))),
+    ...m.warnings.length > 5 ? [() => line(dim(`  +${m.warnings.length - 5} more warnings (see .athena/project.md)`))] : [],
+    ...preserved.map((d) => () => warn(`${d.file}: kept your edits in ${d.preservedModified.join(", ")} ${dim("(use --force to regenerate)")}`)),
+    ...(dryRun ? [] : result.agentChanges).map(({ adapter, changes }) => () => {
       const touched = changes.filter((c2) => c2.action !== "unchanged").map((c2) => `${c2.path} (${c2.action})`);
       ok(`${adapter.displayName} integration${dim(` \u2014 ${touched.length ? touched.join(", ") : changes.map((c2) => c2.path).join(", ") + " (unchanged)"}`)}`);
-    }
-  } else if (mode === "init") {
-    line(dim("No agent integrations configured. Use `athena init --agents claude,cursor,antigravity` or `athena agents` later."));
-  }
-  for (const n of result.notes) warn(n);
-  if (mode === "init") {
-    const unconfigured = ADAPTERS.filter((a) => !result.agentChanges.some((c2) => c2.adapter.id === a.id));
-    if (unconfigured.length) line(dim(`Not configured: ${unconfigured.map((a) => a.displayName).join(", ")} (not detected in this project). Add with --agents.`));
+    }),
+    ...mode === "init" && !dryRun ? (() => {
+      const unconfigured = ADAPTERS.filter((a) => !result.agentChanges.some((c2) => c2.adapter.id === a.id));
+      const text = `Not configured (not detected in this project): ${unconfigured.map((a) => a.id).join(", ")}. Add one with \`athena agents add <id>\`.`;
+      return unconfigured.length ? [() => wrapLines(text).forEach((l) => line(dim(l)))] : [];
+    })() : [],
+    ...dryRun ? result.agentChanges.flatMap(({ adapter, changes }) => changes.map((ch) => () => bullet(`${adapter.displayName}: would ${ch.action} ${ch.path}`))) : [],
+    ...result.notes.map((n) => () => warn(n))
+  ];
+  if (notes.length) {
+    line();
+    for (const print of notes) print();
   }
   line();
-  line(c.bold(c.green(mode === "init" ? "Athena ready." : "Analysis complete.")));
-  if (mode === "init") {
-    line(dim("Next: review .athena/rules.md and enable the rules that apply, then run `athena open` for the web UI."));
-  }
+  const lines = dryRun ? footer("Dry run \u2014 nothing was written.", "Re-run without --dry-run to create .athena/", "warn") : mode === "init" ? footer("Athena is ready!", `Your project intelligence is ready in ${accent(".athena/")}`) : footer("Analysis complete.", `Knowledge in ${accent(".athena/")} is up to date with your code`);
+  for (const l of lines) line(l);
 }
 function summarize(result, root, dryRun) {
   const m = result.analysis.model;
@@ -4625,13 +5573,14 @@ function summarize(result, root, dryRun) {
 async function analyzeCommand(opts) {
   const root = await requireProjectRoot(opts);
   const agents = parseAgentsOption(opts.agents, false);
+  printHeader();
   const result = await runWithProgress(root, { mode: "analyze", force: opts.force, agents, signal: opts.signal });
   if (isJson()) json(summarize(result, root, false));
   else printSummary(result, false, "analyze");
 }
 
 // src/services/status.ts
-import path22 from "path";
+import path27 from "path";
 
 // src/core/impact/impact.ts
 var RULES = [
@@ -4675,7 +5624,7 @@ async function buildStatus(root, signal) {
   const state = st.state;
   const documents = [];
   for (const d of KNOWLEDGE_DOCS) {
-    const text = await readTextIfExists(path22.join(dir, d.file));
+    const text = await readTextIfExists(path27.join(dir, d.file));
     documents.push({
       file: d.file,
       title: d.title,
@@ -4754,8 +5703,8 @@ async function statusCommand(opts) {
 }
 
 // src/services/doctor.ts
-import { constants, promises as fs18 } from "fs";
-import path26 from "path";
+import { constants, promises as fs22 } from "fs";
+import path31 from "path";
 
 // src/core/knowledge/rules.ts
 var RULE_RE = /^([-*+])\s+(?:\[(disabled)\]\s+)?(.+?)\s*$/;
@@ -4849,11 +5798,11 @@ function relativeTime2(iso, now = Date.now()) {
 }
 
 // src/services/instance.ts
-import { promises as fs15 } from "fs";
-import path23 from "path";
+import { promises as fs19 } from "fs";
+import path28 from "path";
 var INSTANCE_FILE = ".server.json";
 async function findRunningInstance(root) {
-  const file = path23.join(athenaDir(root), INSTANCE_FILE);
+  const file = path28.join(athenaDir(root), INSTANCE_FILE);
   const raw = await readTextIfExists(file);
   if (!raw) return null;
   let info2;
@@ -4866,7 +5815,7 @@ async function findRunningInstance(root) {
   try {
     process.kill(info2.pid, 0);
   } catch {
-    await fs15.rm(file, { force: true }).catch(() => {
+    await fs19.rm(file, { force: true }).catch(() => {
     });
     return null;
   }
@@ -4881,19 +5830,19 @@ async function findRunningInstance(root) {
 }
 
 // src/services/which.ts
-import { promises as fs16 } from "fs";
-import path24 from "path";
+import { promises as fs20 } from "fs";
+import path29 from "path";
 async function whichExecutable(command) {
   if (command.includes("/") || command.includes("\\")) {
-    return await fs16.access(command).then(() => true).catch(() => false) ? command : null;
+    return await fs20.access(command).then(() => true).catch(() => false) ? command : null;
   }
-  const dirs = (process.env.PATH ?? "").split(path24.delimiter).filter(Boolean);
+  const dirs = (process.env.PATH ?? "").split(path29.delimiter).filter(Boolean);
   const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
   for (const dir of dirs) {
     for (const ext of exts) {
-      const candidate = path24.join(dir, command + ext.toLowerCase());
+      const candidate = path29.join(dir, command + ext.toLowerCase());
       try {
-        const st = await fs16.stat(candidate);
+        const st = await fs20.stat(candidate);
         if (st.isFile()) return candidate;
       } catch {
       }
@@ -4903,41 +5852,41 @@ async function whichExecutable(command) {
 }
 
 // src/services/agent-activity.ts
-import { promises as fs17 } from "fs";
-import path25 from "path";
+import { promises as fs21 } from "fs";
+import path30 from "path";
 var ACTIVITY_FILE = ".agent-events.jsonl";
 var MAX_LINES = 2e3;
 var MAX_BYTES = 512 * 1024;
 function activityFile(root) {
-  return path25.join(athenaDir(root), ACTIVITY_FILE);
+  return path30.join(athenaDir(root), ACTIVITY_FILE);
 }
 function sanitizeEvent(root, event) {
-  const rel = (p) => {
-    const abs = path25.isAbsolute(p) ? p : path25.resolve(root, p);
-    const r = toPosix(path25.relative(root, abs));
+  const rel2 = (p) => {
+    const abs = path30.isAbsolute(p) ? p : path30.resolve(root, p);
+    const r = toPosix(path30.relative(root, abs));
     return !r || r.startsWith("..") ? toPosix(p) : r;
   };
-  const stripRoot = (text) => text.split(`${root}${path25.sep}`).join("").split(toPosix(root) + "/").join("");
+  const stripRoot = (text) => text.split(`${root}${path30.sep}`).join("").split(toPosix(root) + "/").join("");
   return {
     ...event,
     message: redact(stripRoot(event.message)),
     command: event.command ? redact(stripRoot(event.command)) : null,
-    files: event.files.map(rel)
+    files: event.files.map(rel2)
   };
 }
 async function appendEvent(root, event) {
   const file = activityFile(root);
-  await fs17.mkdir(path25.dirname(file), { recursive: true });
-  await fs17.appendFile(file, `${JSON.stringify(sanitizeEvent(root, event))}
+  await fs21.mkdir(path30.dirname(file), { recursive: true });
+  await fs21.appendFile(file, `${JSON.stringify(sanitizeEvent(root, event))}
 `);
   await rotateIfNeeded(file);
 }
 async function rotateIfNeeded(file) {
   try {
-    const st = await fs17.stat(file);
+    const st = await fs21.stat(file);
     if (st.size < MAX_BYTES) return;
-    const lines = (await fs17.readFile(file, "utf8")).split("\n").filter(Boolean);
-    await fs17.writeFile(file, `${lines.slice(-MAX_LINES / 2).join("\n")}
+    const lines = (await fs21.readFile(file, "utf8")).split("\n").filter(Boolean);
+    await fs21.writeFile(file, `${lines.slice(-MAX_LINES / 2).join("\n")}
 `);
   } catch {
   }
@@ -4956,7 +5905,7 @@ function parseEventLines(text) {
 }
 async function readRecentEvents(root, limit = 200) {
   try {
-    const text = await fs17.readFile(activityFile(root), "utf8");
+    const text = await fs21.readFile(activityFile(root), "utf8");
     return parseEventLines(text).slice(-limit);
   } catch {
     return [];
@@ -4993,7 +5942,7 @@ async function runDoctor(cwd) {
   add({ area: "Project", level: "ok", message: root });
   const dir = athenaDir(root);
   try {
-    await fs18.access(dir, constants.R_OK | constants.W_OK);
+    await fs22.access(dir, constants.R_OK | constants.W_OK);
     add({ area: "Knowledge directory", level: "ok", message: ".athena/ is readable and writable" });
   } catch {
     add({ area: "Knowledge directory", level: "error", message: ".athena/ is not writable", hint: "Check file permissions." });
@@ -5007,13 +5956,13 @@ async function runDoctor(cwd) {
   const missing = [];
   const malformed = [];
   for (const d of KNOWLEDGE_DOCS) {
-    const text = await readTextIfExists(path26.join(dir, d.file));
+    const text = await readTextIfExists(path31.join(dir, d.file));
     if (text === null) missing.push(d.file);
     else if (d.id !== "rules" && (text.match(/athena:generated:start/g)?.length ?? 0) !== parseBlocks(text).length) malformed.push(d.file);
   }
   add({ area: "Knowledge files", level: missing.length ? "error" : "ok", message: missing.length ? `Missing: ${missing.join(", ")}` : `${KNOWLEDGE_DOCS.length} knowledge files present`, hint: missing.length ? "Run `athena analyze` to regenerate missing files." : void 0 });
   if (malformed.length) add({ area: "Knowledge files", level: "warn", message: `Unmatched generated-section markers in: ${malformed.join(", ")}`, hint: "Those sections are treated as developer content and will not be refreshed." });
-  const rulesText = await readTextIfExists(path26.join(dir, "rules.md"));
+  const rulesText = await readTextIfExists(path31.join(dir, "rules.md"));
   if (rulesText !== null) {
     const rules = listRules(parseRules(rulesText));
     const enabled = rules.filter((r) => r.enabled).length;
@@ -5072,10 +6021,10 @@ async function doctorCommand(opts) {
 }
 
 // src/services/rules.ts
-import path28 from "path";
+import path33 from "path";
 
 // src/services/knowledge.ts
-import path27 from "path";
+import path32 from "path";
 var MAX_DOC_BYTES = 1e6;
 function resolveDoc(id) {
   const doc = KNOWLEDGE_DOCS.find((d) => d.id === id);
@@ -5119,12 +6068,12 @@ async function meta(root, id, text) {
 }
 async function listDocs(root) {
   const out2 = [];
-  for (const d of KNOWLEDGE_DOCS) out2.push(await meta(root, d.id, await readTextIfExists(path27.join(athenaDir(root), d.file))));
+  for (const d of KNOWLEDGE_DOCS) out2.push(await meta(root, d.id, await readTextIfExists(path32.join(athenaDir(root), d.file))));
   return out2;
 }
 async function readDoc(root, id) {
   const doc = resolveDoc(id);
-  const text = await readTextIfExists(path27.join(athenaDir(root), doc.file));
+  const text = await readTextIfExists(path32.join(athenaDir(root), doc.file));
   if (text === null) throw notFound(`${doc.file} does not exist. Run \`athena analyze\` to regenerate it.`);
   return { ...await meta(root, doc.id, text), content: text, segments: segmentDocument(text) };
 }
@@ -5132,7 +6081,7 @@ async function saveDoc(root, id, content, baseHash) {
   const doc = resolveDoc(id);
   if (typeof content !== "string") throw new AthenaError("content must be a string");
   if (Buffer.byteLength(content) > MAX_DOC_BYTES) throw new AthenaError(`Document exceeds ${MAX_DOC_BYTES} bytes`, void 0, 1, "unprocessable");
-  const file = path27.join(athenaDir(root), doc.file);
+  const file = path32.join(athenaDir(root), doc.file);
   const current = await readTextIfExists(file);
   const currentHash = current === null ? null : contentHash(current);
   if (currentHash !== baseHash) {
@@ -5158,7 +6107,7 @@ async function searchDocs(root, query, limit = 50) {
   if (q.length < 2) return [];
   const hits = [];
   for (const d of KNOWLEDGE_DOCS) {
-    const text = await readTextIfExists(path27.join(athenaDir(root), d.file));
+    const text = await readTextIfExists(path32.join(athenaDir(root), d.file));
     if (!text) continue;
     const lines = text.split("\n");
     for (let i = 0; i < lines.length && hits.length < limit; i++) {
@@ -5172,14 +6121,14 @@ async function searchDocs(root, query, limit = 50) {
 }
 async function docHistory(root, id, limit = 50) {
   const doc = resolveDoc(id);
-  const rel = `.athena/${doc.file}`;
-  const r = await git(root, ["log", `-n${limit}`, "--follow", "--format=%H%x1f%cI%x1f%s", "--", rel]);
+  const rel2 = `.athena/${doc.file}`;
+  const r = await git(root, ["log", `-n${limit}`, "--follow", "--format=%H%x1f%cI%x1f%s", "--", rel2]);
   if (!r.ok) return { available: false, reason: "Git history is not available (not a Git repository, or git is not installed).", entries: [] };
   const entries = r.stdout.split("\n").filter(Boolean).map((l) => {
     const [sha, date, subject] = l.split("");
     return { sha, date, subject: subject ?? "" };
   });
-  if (!entries.length) return { available: true, reason: `${rel} has not been committed yet.`, entries };
+  if (!entries.length) return { available: true, reason: `${rel2} has not been committed yet.`, entries };
   return { available: true, entries };
 }
 async function docAtRevision(root, id, sha) {
@@ -5193,7 +6142,7 @@ async function docAtRevision(root, id, sha) {
 
 // src/services/rules.ts
 async function load(root) {
-  const file = path28.join(athenaDir(root), "rules.md");
+  const file = path33.join(athenaDir(root), "rules.md");
   const text = await readTextIfExists(file);
   if (text === null) throw notFound(".athena/rules.md not found. Run `athena analyze` to recreate it.");
   return { file, text, doc: parseRules(text) };
@@ -5271,7 +6220,7 @@ var rulesEditCommand = (n, text, opts) => mutate(opts, (d) => updateRule(d, pars
 var rulesRemoveCommand = (n, opts) => mutate(opts, (d) => removeRule(d, parseIndex(n)), `Rule ${n} removed.`);
 
 // src/cli/commands/clean.ts
-import { promises as fs19 } from "fs";
+import { promises as fs23 } from "fs";
 import { createInterface } from "readline/promises";
 async function confirm(question) {
   if (!process.stdin.isTTY) return false;
@@ -5296,7 +6245,7 @@ async function cleanCommand(opts) {
   }
   const touched = [];
   if (!opts.keepAgents) for (const a of ADAPTERS) touched.push(...await a.remove(root));
-  await fs19.rm(athenaDir(root), { recursive: true, force: true });
+  await fs23.rm(athenaDir(root), { recursive: true, force: true });
   if (isJson()) json({ ok: true, removed: [".athena/", ...touched] });
   else {
     ok("Removed .athena/");
@@ -5308,14 +6257,14 @@ async function cleanCommand(opts) {
 import { execFile as execFile3 } from "child_process";
 
 // src/server/instance.ts
-import { promises as fs24 } from "fs";
-import path38 from "path";
+import { promises as fs28 } from "fs";
+import path43 from "path";
 import { fileURLToPath } from "url";
 
 // src/server/app.ts
-import { promises as fs23, watch } from "fs";
+import { promises as fs27, watch } from "fs";
 import crypto7 from "crypto";
-import path37 from "path";
+import path42 from "path";
 import Fastify from "fastify";
 
 // src/services/agents.ts
@@ -5371,23 +6320,32 @@ async function configureAgents(root, names2) {
 async function removeAgents(root, names2) {
   const st = await readState(athenaDir(root));
   const removed = [];
-  for (const a of resolve(names2)) {
+  const targets = resolve(names2);
+  for (const a of targets) {
     removed.push(...await a.remove(root));
     if (st.kind === "ok") delete st.state.agents[a.id];
   }
-  if (st.kind === "ok") await writeState(athenaDir(root), st.state);
+  if (st.kind === "ok") {
+    for (const a of ADAPTERS) {
+      const s = st.state.agents[a.id];
+      if (!s?.configured || targets.includes(a) || !s.files.some((f) => removed.includes(f))) continue;
+      const planned = await a.plan({ root, projectName: st.state.projectName });
+      await applyChanges(root, planned.filter((p) => removed.includes(p.path)));
+    }
+    await writeState(athenaDir(root), st.state);
+  }
   return removed;
 }
 
 // src/services/overview.ts
-import path29 from "path";
+import path34 from "path";
 async function getOverview(root) {
   const st = await readState(athenaDir(root));
   if (st.kind === "missing") throw new AthenaError("Athena is not initialized in this project.", "Run `athena init`.", 3);
   if (st.kind === "corrupted") throw new AthenaError(`.athena/state.json is corrupted (${st.reason}).`, "Run `athena analyze` to rebuild it.");
   const state = st.state;
   let model = null;
-  const raw = await readTextIfExists(path29.join(athenaDir(root), "model.json"));
+  const raw = await readTextIfExists(path34.join(athenaDir(root), "model.json"));
   if (raw) {
     try {
       const parsed = ProjectModel.safeParse(JSON.parse(raw));
@@ -5428,8 +6386,8 @@ async function getOverview(root) {
 }
 
 // src/services/sync.ts
-import { promises as fs20 } from "fs";
-import path30 from "path";
+import { promises as fs24 } from "fs";
+import path35 from "path";
 import { createTwoFilesPatch } from "diff";
 
 // src/core/impact/model-diff.ts
@@ -5615,7 +6573,7 @@ function detectRenames(prev, next, added, deleted) {
   return { added: remainingAdded, modified: [], deleted: deleted.filter((d) => !usedDeleted.has(d)), renamed };
 }
 async function readPreviousModel(dir) {
-  const raw = await readTextIfExists(path30.join(dir, "model.json"));
+  const raw = await readTextIfExists(path35.join(dir, "model.json"));
   if (!raw) return null;
   try {
     const parsed = ProjectModel.safeParse(JSON.parse(raw));
@@ -5625,7 +6583,7 @@ async function readPreviousModel(dir) {
   }
 }
 async function readIgnored(dir) {
-  const raw = await readTextIfExists(path30.join(dir, IGNORE_FILE));
+  const raw = await readTextIfExists(path35.join(dir, IGNORE_FILE));
   if (!raw) return null;
   try {
     const j = JSON.parse(raw);
@@ -5638,7 +6596,7 @@ async function planSync(root, opts = {}) {
   const started = Date.now();
   const dir = athenaDir(root);
   const st = await readState(dir);
-  if (st.kind === "missing" && !await readTextIfExists(path30.join(dir, "rules.md"))) {
+  if (st.kind === "missing" && !await readTextIfExists(path35.join(dir, "rules.md"))) {
     throw new AthenaError("Athena is not initialized in this project.", "Run `athena init` first.", 3);
   }
   const prevState = st.kind === "ok" ? st.state : null;
@@ -5727,7 +6685,7 @@ async function applySync(root, plan) {
   if (!inner) throw new AthenaError("This sync plan is no longer available.", "Create a new plan and try again.", 1, "conflict");
   const dir = athenaDir(root);
   for (const d of plan.documents) {
-    const current = hashOf(await readTextIfExists(path30.join(dir, d.file)));
+    const current = hashOf(await readTextIfExists(path35.join(dir, d.file)));
     if (current !== d.baseHash) {
       throw conflict(`${d.file} changed after the sync plan was created.`, "Review the new plan before applying.", { file: d.file });
     }
@@ -5735,10 +6693,10 @@ async function applySync(root, plan) {
   const st = await readState(dir);
   if (st.kind === "corrupted") await backupCorruptedState(dir);
   const prevState = st.kind === "ok" ? st.state : inner.prevState;
-  await fs20.mkdir(dir, { recursive: true });
+  await fs24.mkdir(dir, { recursive: true });
   const docs = await writePlannedKnowledge(dir, inner.plans);
   docs.push(await ensureRules(dir, inner.analysis.model));
-  await writeFileAtomic(path30.join(dir, "model.json"), `${JSON.stringify(inner.analysis.model, null, 2)}
+  await writeFileAtomic(path35.join(dir, "model.json"), `${JSON.stringify(inner.analysis.model, null, 2)}
 `);
   const managedFiles = Object.values(prevState?.agents ?? {}).flatMap((a) => a.files);
   const state = composeState({
@@ -5749,7 +6707,7 @@ async function applySync(root, plan) {
     fileIndex: await indexWithIntegrations(root, inner.analysis.files, managedFiles)
   });
   await writeState(dir, state);
-  await fs20.rm(path30.join(dir, IGNORE_FILE), { force: true });
+  await fs24.rm(path35.join(dir, IGNORE_FILE), { force: true });
   internals.delete(plan);
   return {
     applied: plan.documents.map((d) => d.file),
@@ -5759,7 +6717,7 @@ async function applySync(root, plan) {
 }
 async function ignorePlan(root, planId) {
   if (!/^[a-f0-9]{16}$/.test(planId)) throw new AthenaError("Invalid plan id");
-  await writeFileAtomic(path30.join(athenaDir(root), IGNORE_FILE), `${JSON.stringify({ planId, ignoredAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
+  await writeFileAtomic(path35.join(athenaDir(root), IGNORE_FILE), `${JSON.stringify({ planId, ignoredAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
 `);
 }
 function fileChangeCount(plan) {
@@ -5773,6 +6731,10 @@ function summarizePlan(plan) {
   const { documents, ...rest } = plan;
   return { ...rest, documents: documents.map(({ diff: _diff, ...d }) => d) };
 }
+var HISTORY_SECTIONS = /* @__PURE__ */ new Set(["hotspots"]);
+function staleForCheck(plan) {
+  return plan.documents.filter((d) => d.status === "created" || !d.changedSections.length || d.changedSections.some((s) => !HISTORY_SECTIONS.has(s)));
+}
 
 // src/services/security.ts
 import { execFile as execFile2 } from "child_process";
@@ -5992,7 +6954,7 @@ async function runSecurityScan(root, model, opts = {}) {
 }
 
 // src/services/review.ts
-import path31 from "path";
+import path36 from "path";
 var TEST_FILE = /(^|\/)(__tests__|tests?|spec|specs|e2e)\/|\.(test|spec|e2e)\.[cm]?[jt]sx?$|(^|\/)test_[^/]+\.py$|_test\.(py|go|exs)$|_spec\.rb$|Tests?\.(java|kt|cs)$/;
 var SOURCE_FILE = /\.(m|c)?(t|j)sx?$|\.(py|go|rs|java|kt|cs|php|rb|dart|ex|swift|vue|svelte)$/;
 var ROUTE_FILE = /(^|\/)(routes?|controllers?|handlers?|api|endpoints?|resolvers?)\/|(^|\/)(urls\.py|routes\.rb)$|(^|\/)app\/(.+\/)?route\.(t|j)sx?$/i;
@@ -6050,7 +7012,7 @@ async function reviewChanges(root, opts = {}) {
   const untracked = changedFiles.filter((f) => f.status === "untracked");
   let extra = "";
   for (const f of untracked.slice(0, 200)) {
-    const text = await readTextIfExists(path31.join(root, f.path));
+    const text = await readTextIfExists(path36.join(root, f.path));
     if (text && text.length < 512 * 1024) extra += `+++ b/${f.path}
 @@ -0,0 +1,${text.split("\n").length} @@
 ${text.split("\n").map((l) => `+${l}`).join("\n")}
@@ -6059,7 +7021,7 @@ ${text.split("\n").map((l) => `+${l}`).join("\n")}
   const added = addedLines(patch + extra);
   let untrackedAdded = 0;
   for (const f of untracked) {
-    const text = await readTextIfExists(path31.join(root, f.path));
+    const text = await readTextIfExists(path36.join(root, f.path));
     if (text) untrackedAdded += text.split("\n").filter((l) => l.length > 0).length;
   }
   const numstat = (await git(root, [...diffArgs, "--numstat", "--", "."])).stdout;
@@ -6089,7 +7051,7 @@ ${text.split("\n").map((l) => `+${l}`).join("\n")}
   const envFiles = paths.filter((p) => ENV_FILE.test(p));
   if (envFiles.length) add({ level: "blocker", check: "env-file", message: "Environment file included in the change", files: envFiles, hint: "Add it to .gitignore and commit a .env.example with names only." });
   for (const p of paths.filter((x) => MANIFEST_FILE.test(x))) {
-    const now = await readTextIfExists(path31.join(root, p));
+    const now = await readTextIfExists(path36.join(root, p));
     const before = (await git(root, ["show", `${opts.base ?? "HEAD"}:${p}`])).stdout;
     if (!now || !before) continue;
     const newDeps = [...depsOf(p, now)].filter((d) => !depsOf(p, before).has(d));
@@ -6108,7 +7070,7 @@ ${text.split("\n").map((l) => `+${l}`).join("\n")}
   if (authFiles.length) add({ level: "warning", check: "auth", message: "Authentication/authorization code changed", files: authFiles.slice(0, 10), hint: "Review against `.athena/auth.md` and `.athena/security.md`." });
   const large = [];
   for (const f of changedFiles.filter((x) => x.status === "added" || x.status === "untracked")) {
-    const text = await readTextIfExists(path31.join(root, f.path)).catch(() => null);
+    const text = await readTextIfExists(path36.join(root, f.path)).catch(() => null);
     if (text && Buffer.byteLength(text) > LARGE_ADDED_BYTES) large.push(f.path);
   }
   if (large.length) add({ level: "warning", check: "large-files", message: "Large files added", files: large, hint: "Consider whether these belong in Git." });
@@ -6126,9 +7088,9 @@ ${text.split("\n").map((l) => `+${l}`).join("\n")}
     knowledgeInSync = await opts.checkSync(root).catch(() => null);
     if (knowledgeInSync === false) add({ level: "info", check: "knowledge", message: "Athena knowledge is out of date for these changes", files: [], hint: "Run `athena sync` so agents read current context." });
   }
-  const rulesText = await readTextIfExists(path31.join(athenaDir(root), "rules.md"));
+  const rulesText = await readTextIfExists(path36.join(athenaDir(root), "rules.md"));
   const rules = rulesText ? listRules(parseRules(rulesText)).filter((r) => r.enabled) : [];
-  const reviewDoc = await readTextIfExists(path31.join(athenaDir(root), "code-review.md"));
+  const reviewDoc = await readTextIfExists(path36.join(athenaDir(root), "code-review.md"));
   const checklist = reviewDoc ? [...reviewDoc.matchAll(/^- \[ \] (.+)$/gm)].map((m) => m[1].trim()) : [];
   return { base, changedFiles, findings, rules, checklist, knowledgeInSync, stats: { added: addedCount + untrackedAdded, removed: removedCount, files: changedFiles.length } };
 }
@@ -6137,11 +7099,11 @@ function hasBlockers(result) {
 }
 
 // src/services/context.ts
-import path33 from "path";
+import path38 from "path";
 
 // src/core/graph/graph.ts
 import { z as z6 } from "zod";
-import path32 from "path";
+import path37 from "path";
 var NodeKind = z6.enum(["package", "file", "route", "entity", "framework", "command", "infra", "doc"]);
 var EdgeKind = z6.enum(["contains", "imports", "handles", "defines", "depends_on", "documents", "runs"]);
 var GraphNode = z6.object({
@@ -6165,7 +7127,7 @@ var IMPORT_RE = /^\s*(?:import\s[^'"]*from\s*['"]([^'"]+)['"]|import\s*['"]([^'"
 var PY_IMPORT_RE = /^\s*(?:from\s+([.\w]+)\s+import|import\s+([.\w]+))/gm;
 function resolveImport(fromFile, spec, fileSet) {
   if (!spec.startsWith(".")) return null;
-  const base = toPosix(path32.posix.normalize(path32.posix.join(path32.posix.dirname(fromFile), spec)));
+  const base = toPosix(path37.posix.normalize(path37.posix.join(path37.posix.dirname(fromFile), spec)));
   const candidates = [base, ...[".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".py", ".vue", ".svelte"].flatMap((ext) => [`${base}${ext}`, `${base}/index${ext}`, `${base}/__init__${ext}`])];
   return candidates.find((c2) => fileSet.has(c2)) ?? null;
 }
@@ -6181,7 +7143,7 @@ async function buildGraph(model, opts) {
     if (from === to || !nodes.has(from) || !nodes.has(to)) return;
     if (!edges.some((e) => e.from === from && e.to === to && e.kind === kind)) edges.push({ from, to, kind });
   };
-  const fileNode = (p) => addNode({ id: nodeId("file", p), kind: "file", name: path32.posix.basename(p), path: p, meta: {} });
+  const fileNode = (p) => addNode({ id: nodeId("file", p), kind: "file", name: path37.posix.basename(p), path: p, meta: {} });
   for (const pkg of model.workspace.packages) {
     addNode({ id: nodeId("package", pkg.name), kind: "package", name: pkg.name, path: pkg.path, meta: { kind: pkg.kind, ecosystem: pkg.ecosystem } });
   }
@@ -6200,8 +7162,8 @@ async function buildGraph(model, opts) {
   for (const e of model.dbEntities) {
     const id = addNode({ id: nodeId("entity", `${e.name}@${e.file}`), kind: "entity", name: e.name, path: e.file, meta: { kind: e.kind, fields: e.fields.length, indexes: e.indexes.length } });
     addEdge(id, fileNode(e.file), "defines");
-    for (const rel of e.relations) {
-      const target = rel.split("\u2192")[1]?.trim();
+    for (const rel2 of e.relations) {
+      const target = rel2.split("\u2192")[1]?.trim();
       const other = target ? model.dbEntities.find((x) => x.name.toLowerCase() === target.toLowerCase()) : void 0;
       if (other) addEdge(id, nodeId("entity", `${other.name}@${other.file}`), "depends_on");
     }
@@ -6251,11 +7213,11 @@ async function buildGraph(model, opts) {
   };
 }
 async function saveGraph(root, graph) {
-  await writeFileAtomic(path32.join(athenaDir(root), GRAPH_FILE), `${JSON.stringify(graph, null, 2)}
+  await writeFileAtomic(path37.join(athenaDir(root), GRAPH_FILE), `${JSON.stringify(graph, null, 2)}
 `);
 }
 async function loadGraph(root) {
-  const raw = await readTextIfExists(path32.join(athenaDir(root), GRAPH_FILE));
+  const raw = await readTextIfExists(path37.join(athenaDir(root), GRAPH_FILE));
   if (!raw) return null;
   try {
     const parsed = ProjectGraph.safeParse(JSON.parse(raw));
@@ -6452,7 +7414,7 @@ function formatContext(ctx) {
 
 // src/services/context.ts
 async function loadModel(root) {
-  const raw = await readTextIfExists(path33.join(athenaDir(root), "model.json"));
+  const raw = await readTextIfExists(path38.join(athenaDir(root), "model.json"));
   if (!raw) return null;
   try {
     const parsed = ProjectModel.safeParse(JSON.parse(raw));
@@ -6468,7 +7430,7 @@ async function refreshGraph(root, opts = {}) {
   const graph = await buildGraph(analysis.model, {
     files,
     signal: opts.signal,
-    read: async (rel) => readTextIfExists(path33.join(root, rel)).catch(() => null)
+    read: async (rel2) => readTextIfExists(path38.join(root, rel2)).catch(() => null)
   });
   await saveGraph(root, graph);
   return graph;
@@ -6484,14 +7446,14 @@ async function getRelevantContext(root, task, opts = {}) {
   const documents = [];
   for (const d of KNOWLEDGE_DOCS) {
     if (d.id === "rules") continue;
-    const text = await readTextIfExists(path33.join(dir, d.file));
+    const text = await readTextIfExists(path38.join(dir, d.file));
     if (text) documents.push({ id: d.id, file: d.file, sections: documentSections(text) });
   }
   if (!documents.length) throw new AthenaError("No knowledge documents found.", "Run `athena init` first.", 3);
   return selectContext({
     task,
     documents,
-    rulesMarkdown: await readTextIfExists(path33.join(dir, "rules.md")),
+    rulesMarkdown: await readTextIfExists(path38.join(dir, "rules.md")),
     graph: await getGraph(root, { build: opts.buildGraph, signal: opts.signal }),
     maxChars: opts.maxChars
   });
@@ -6502,7 +7464,7 @@ async function graphSummary(root) {
 }
 
 // src/services/ai.ts
-import path34 from "path";
+import path39 from "path";
 
 // src/ai/provider.ts
 import { z as z7 } from "zod";
@@ -6692,7 +7654,7 @@ async function buildEnrichPayload(root, opts = {}) {
   for (const id of wanted) {
     const doc = KNOWLEDGE_DOCS.find((d) => d.id === id);
     if (!doc) throw new AthenaError(`Unknown document: ${id}`, `Available: ${KNOWLEDGE_DOCS.map((d) => d.id).join(", ")}`);
-    const text = await readTextIfExists(path34.join(athenaDir(root), doc.file));
+    const text = await readTextIfExists(path39.join(athenaDir(root), doc.file));
     if (!text) continue;
     included.push(doc.file);
     parts.push(`--- ${doc.file} ---
@@ -6745,14 +7707,14 @@ async function enrich(root, opts = {}) {
     body,
     ""
   ].join("\n");
-  const file = path34.join(athenaDir(root), SUGGESTIONS_FILE);
+  const file = path39.join(athenaDir(root), SUGGESTIONS_FILE);
   await writeFileAtomic(file, markdown);
   return { markdown, file: SUGGESTIONS_FILE, provider: result.provider, model: result.model, chars: payload.chars, documents: payload.documents };
 }
 
 // src/services/watch.ts
-import { promises as fs21 } from "fs";
-import path35 from "path";
+import { promises as fs25 } from "fs";
+import path40 from "path";
 import { watch as chokidarWatch } from "chokidar";
 async function gitDir(root) {
   const r = await git(root, ["rev-parse", "--absolute-git-dir"]);
@@ -6770,7 +7732,7 @@ async function watchProject(root, opts) {
   let rerun = false;
   let latest = null;
   let closed = false;
-  const toRel = (abs) => toPosix(path35.relative(root, abs));
+  const toRel = (abs) => toPosix(path40.relative(root, abs));
   const run3 = async () => {
     if (closed) return null;
     if (running) {
@@ -6829,14 +7791,14 @@ async function watchProject(root, opts) {
     }, wait);
   };
   const onPath = (abs) => {
-    const rel = toRel(abs);
-    if (!rel || rel.startsWith("..")) return;
-    if (rel === ".gitignore" || rel.endsWith("/.gitignore")) {
-      const dir = rel === ".gitignore" ? "" : rel.slice(0, -"/.gitignore".length);
-      void fs21.readFile(abs, "utf8").then((text) => matcher.setGitignore(dir, text)).catch(() => matcher.removeGitignore(dir));
-    }
-    pending.add(rel);
-    opts.onEvent({ type: "changes", paths: [rel] });
+    const rel2 = toRel(abs);
+    if (!rel2 || rel2.startsWith("..")) return;
+    if (rel2 === ".gitignore" || rel2.endsWith("/.gitignore")) {
+      const dir = rel2 === ".gitignore" ? "" : rel2.slice(0, -"/.gitignore".length);
+      void fs25.readFile(abs, "utf8").then((text) => matcher.setGitignore(dir, text)).catch(() => matcher.removeGitignore(dir));
+    }
+    pending.add(rel2);
+    opts.onEvent({ type: "changes", paths: [rel2] });
     schedule();
   };
   const watcher = chokidarWatch(root, {
@@ -6844,12 +7806,12 @@ async function watchProject(root, opts) {
     persistent: true,
     followSymlinks: false,
     ignored: (abs, stats) => {
-      const rel = toRel(abs);
-      if (!rel || rel === ".") return false;
-      if (rel.startsWith("..")) return true;
-      if (rel === ".git" || rel.startsWith(".git/")) return true;
-      if (stats) return matcher.ignores(rel, stats.isDirectory());
-      return matcher.ignores(rel, false) || matcher.ignores(rel, true);
+      const rel2 = toRel(abs);
+      if (!rel2 || rel2 === ".") return false;
+      if (rel2.startsWith("..")) return true;
+      if (rel2 === ".git" || rel2.startsWith(".git/")) return true;
+      if (stats) return matcher.ignores(rel2, stats.isDirectory());
+      return matcher.ignores(rel2, false) || matcher.ignores(rel2, true);
     }
   });
   const ready = new Promise((resolve2) => watcher.once("ready", () => resolve2()));
@@ -6860,7 +7822,7 @@ async function watchProject(root, opts) {
   let lastHead = null;
   if (gd) {
     lastHead = (await git(root, ["rev-parse", "HEAD"])).stdout.trim() || null;
-    headWatcher = chokidarWatch([path35.join(gd, "HEAD"), path35.join(gd, "refs", "heads")], { ignoreInitial: true, persistent: true, depth: 5 });
+    headWatcher = chokidarWatch([path40.join(gd, "HEAD"), path40.join(gd, "refs", "heads")], { ignoreInitial: true, persistent: true, depth: 5 });
     headWatcher.on("all", () => {
       void git(root, ["rev-parse", "HEAD"]).then((r) => {
         const head = r.ok ? r.stdout.trim() : null;
@@ -7012,8 +7974,8 @@ function allowedOriginsFor(host, port) {
 }
 
 // src/server/static.ts
-import { promises as fs22 } from "fs";
-import path36 from "path";
+import { promises as fs26 } from "fs";
+import path41 from "path";
 var TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -7029,20 +7991,20 @@ var TYPES = {
 };
 async function buildAssetMap(webDir) {
   try {
-    await fs22.access(path36.join(webDir, "index.html"));
+    await fs26.access(path41.join(webDir, "index.html"));
   } catch {
     return null;
   }
   const map = /* @__PURE__ */ new Map();
   async function walk2(dir) {
-    for (const ent of await fs22.readdir(dir, { withFileTypes: true })) {
-      const abs = path36.join(dir, ent.name);
+    for (const ent of await fs26.readdir(dir, { withFileTypes: true })) {
+      const abs = path41.join(dir, ent.name);
       if (ent.isDirectory()) await walk2(abs);
       else if (ent.isFile()) {
-        const ext = path36.extname(ent.name).toLowerCase();
+        const ext = path41.extname(ent.name).toLowerCase();
         const type = TYPES[ext];
         if (!type) continue;
-        const urlPath = `/${path36.relative(webDir, abs).split(path36.sep).join("/")}`;
+        const urlPath = `/${path41.relative(webDir, abs).split(path41.sep).join("/")}`;
         map.set(urlPath, { abs, type, immutable: urlPath.startsWith("/assets/") });
       }
     }
@@ -7261,11 +8223,11 @@ async function createServer(opts) {
   const readNewAgentEvents = async () => {
     try {
       const file = activityFile(root);
-      const st = await fs23.stat(file).catch(() => null);
+      const st = await fs27.stat(file).catch(() => null);
       if (!st) return;
       if (st.size < activityOffset) activityOffset = 0;
       if (st.size === activityOffset) return;
-      const handle = await fs23.open(file, "r");
+      const handle = await fs27.open(file, "r");
       try {
         const length = st.size - activityOffset;
         const buf = Buffer.alloc(length);
@@ -7310,7 +8272,7 @@ async function createServer(opts) {
     try {
       const result = await applySync(root, plan);
       for (const d of plan.documents) {
-        const text = await fs23.readFile(path37.join(athenaDir(root), d.file), "utf8").catch(() => null);
+        const text = await fs27.readFile(path42.join(athenaDir(root), d.file), "utf8").catch(() => null);
         if (text !== null) recentWrites.set(d.file, contentHash(text));
       }
       currentPlan = null;
@@ -7335,7 +8297,7 @@ async function createServer(opts) {
   });
   let scanRunning = false;
   const projectModel = async () => {
-    const raw = await fs23.readFile(path37.join(athenaDir(root), "model.json"), "utf8").catch(() => null);
+    const raw = await fs27.readFile(path42.join(athenaDir(root), "model.json"), "utf8").catch(() => null);
     if (raw) {
       const parsed = ProjectModel.safeParse(JSON.parse(raw));
       if (parsed.success) return parsed.data;
@@ -7375,7 +8337,7 @@ async function createServer(opts) {
   );
   app.get("/api/review", async (req) => {
     const base = typeof req.query.base === "string" && req.query.base ? req.query.base : void 0;
-    return reviewChanges(root, { base, checkSync: async (r) => (await planSync(r)).upToDate });
+    return reviewChanges(root, { base, checkSync: async (r) => staleForCheck(await planSync(r)).length === 0 });
   });
   let graphBuilding = false;
   app.get("/api/context", async (req) => {
@@ -7433,7 +8395,7 @@ data: ${JSON.stringify(data)}
   const sendAsset = async (reply, urlPath) => {
     if (!assets) return reply.code(503).type("text/html; charset=utf-8").send(MISSING_UI_HTML);
     const asset = assets.get(urlPath) ?? assets.get("/index.html");
-    const body = await fs23.readFile(asset.abs);
+    const body = await fs27.readFile(asset.abs);
     reply.header("Cache-Control", asset.immutable ? "public, max-age=31536000, immutable" : "no-cache");
     return reply.type(asset.type).send(body);
   };
@@ -7468,7 +8430,7 @@ data: ${JSON.stringify(data)}
         name,
         setTimeout(async () => {
           pending.delete(name);
-          const text = await fs23.readFile(path37.join(dir, name), "utf8").catch(() => null);
+          const text = await fs27.readFile(path42.join(dir, name), "utf8").catch(() => null);
           const hash = text === null ? null : contentHash(text);
           if (hash && recentWrites.get(name) === hash) return;
           invalidateStatus();
@@ -7484,7 +8446,7 @@ data: ${JSON.stringify(data)}
   {
     const history = await readRecentEvents(root, 200);
     for (const e of history) applyAgentEvent(e, false);
-    activityOffset = await fs23.stat(activityFile(root)).then((st) => st.size).catch(() => 0);
+    activityOffset = await fs27.stat(activityFile(root)).then((st) => st.size).catch(() => 0);
   }
   if (opts.watch) {
     try {
@@ -7574,8 +8536,8 @@ async function findAvailablePort(host, start = DEFAULT_PORT, attempts = 100) {
 
 // src/server/instance.ts
 function defaultWebDir() {
-  const here = path38.dirname(fileURLToPath(import.meta.url));
-  return path38.basename(here) === "dist" ? path38.join(here, "web") : path38.resolve(here, "../../dist/web");
+  const here = path43.dirname(fileURLToPath(import.meta.url));
+  return path43.basename(here) === "dist" ? path43.join(here, "web") : path43.resolve(here, "../../dist/web");
 }
 function browserUrl(info2) {
   const host = info2.host.includes(":") ? `[${info2.host}]` : info2.host;
@@ -7591,8 +8553,8 @@ async function startServer(opts) {
   const server = await createServer({ root: opts.root, token, host, port, webDir: opts.webDir ?? defaultWebDir(), allowRemote: opts.allowRemote, watch: opts.watch ?? true });
   await server.app.listen({ host, port });
   const info2 = { pid: process.pid, host, port, instanceId: server.instanceId, token, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  const file = path38.join(athenaDir(opts.root), INSTANCE_FILE);
-  await fs24.writeFile(file, `${JSON.stringify(info2, null, 2)}
+  const file = path43.join(athenaDir(opts.root), INSTANCE_FILE);
+  await fs28.writeFile(file, `${JSON.stringify(info2, null, 2)}
 `, { mode: 384 });
   await ensureGitignored(opts.root, INSTANCE_FILE);
   return {
@@ -7601,16 +8563,16 @@ async function startServer(opts) {
     url: browserUrl(info2),
     async close() {
       const current = await readTextIfExists(file);
-      if (current && current.includes(server.instanceId)) await fs24.rm(file, { force: true });
+      if (current && current.includes(server.instanceId)) await fs28.rm(file, { force: true });
       await server.close();
     }
   };
 }
 async function ensureGitignored(root, entry) {
-  const file = path38.join(athenaDir(root), ".gitignore");
+  const file = path43.join(athenaDir(root), ".gitignore");
   const text = await readTextIfExists(file) ?? "";
   if (text.split(/\r?\n/).includes(entry)) return;
-  await fs24.writeFile(file, `${text}${text.endsWith("\n") || !text ? "" : "\n"}${entry}
+  await fs28.writeFile(file, `${text}${text.endsWith("\n") || !text ? "" : "\n"}${entry}
 `);
 }
 
@@ -7654,7 +8616,7 @@ async function openCommand(opts) {
   }
   if (isJson()) json({ running: true, reused: false, url: running.url, port: running.info.port, pid: process.pid });
   else {
-    banner();
+    printHeader();
     line(c.bold(c.green("Athena is running")));
     line();
     line(`Local: ${c.cyan(running.url)}`);
@@ -7711,10 +8673,10 @@ function printPlan(plan, opts = {}) {
     return;
   }
   heading("Knowledge to update");
-  const width = Math.max(...plan.documents.map((d) => d.file.length));
+  const width2 = Math.max(...plan.documents.map((d) => d.file.length));
   for (const d of plan.documents) {
     const sign = d.status === "created" ? c.green("+") : c.yellow("~");
-    line(`  ${sign} ${d.file.padEnd(width)}  ${c.green(`+${d.additions}`)} ${c.red(`\u2212${d.deletions}`)}  ${dim(d.changedSections.join(", "))}`);
+    line(`  ${sign} ${d.file.padEnd(width2)}  ${c.green(`+${d.additions}`)} ${c.red(`\u2212${d.deletions}`)}  ${dim(d.changedSections.join(", "))}`);
     for (const r of d.reasons.slice(0, 3)) line(`      ${dim(`${sym.arrow} ${r}`)}`);
     if (d.preservedSections.length) line(`      ${c.yellow(sym.warn)} ${dim(`your edits kept in: ${d.preservedSections.join(", ")}`)}`);
   }
@@ -7738,9 +8700,15 @@ async function syncCommand(opts) {
     sp.stop();
     throw err;
   }
+  const stale = staleForCheck(plan);
+  const inSync = stale.length === 0;
   if (isJson() && (opts.dryRun || opts.check)) {
-    json({ ...summarizePlan(plan), ...opts.diff ? { diffs: Object.fromEntries(plan.documents.map((d) => [d.file, d.diff])) } : {} });
-    return opts.check && !plan.upToDate ? 1 : EXIT.OK;
+    json({
+      ...summarizePlan(plan),
+      ...opts.check ? { inSync, stale: stale.map((d) => d.file) } : {},
+      ...opts.diff ? { diffs: Object.fromEntries(plan.documents.map((d) => [d.file, d.diff])) } : {}
+    });
+    return opts.check && !inSync ? 1 : EXIT.OK;
   }
   if (!isJson() && !isQuiet()) {
     heading("Athena Sync");
@@ -7751,8 +8719,12 @@ async function syncCommand(opts) {
     line(`Proposed: ${plan.documents.map((d) => d.file).join(", ")}`);
   }
   if (opts.check) {
-    if (!isJson()) line(plan.upToDate ? c.green("Knowledge is synchronized.") : c.yellow("Knowledge is out of date. Run `athena sync` to review and apply."));
-    return plan.upToDate ? EXIT.OK : 1;
+    if (!inSync) line(c.yellow("Knowledge is out of date. Run `athena sync` to review and apply."));
+    else {
+      line(c.green("Knowledge is synchronized."));
+      if (!plan.upToDate) info(dim("Only Git-history sections (change hotspots) differ; they are not checked. `athena sync` refreshes them."));
+    }
+    return inSync ? EXIT.OK : 1;
   }
   if (opts.dryRun) {
     if (!isJson()) line(dim("Dry run \u2014 nothing was written."));
@@ -7789,7 +8761,7 @@ async function syncCommand(opts) {
 }
 
 // src/cli/commands/event.ts
-import path39 from "path";
+import path44 from "path";
 var STDIN_TIMEOUT_MS = 2e3;
 var MAX_PAYLOAD_BYTES = 256 * 1024;
 async function readStdin() {
@@ -7835,7 +8807,7 @@ async function eventCommand(opts) {
     let root = null;
     for (const c2 of cwdCandidates) {
       if (!c2) continue;
-      root = await findProjectRoot(path39.resolve(c2));
+      root = await findProjectRoot(path44.resolve(c2));
       if (root) break;
     }
     if (!root) return;
@@ -7873,7 +8845,7 @@ async function activityCommand(opts) {
     const agents = await listAgents(root);
     const reporting = agents.filter((a) => a.activityObservation === "hooks");
     line(dim("No agent activity recorded yet."));
-    line(dim(reporting.length ? `Hooks are installed for: ${reporting.map((a) => a.name).join(", ")}. Events appear once an agent runs in this project.` : "Install hooks with `athena agents add claude-code` (or cursor) to record agent activity."));
+    line(dim(reporting.length ? `Hooks are installed for: ${reporting.map((a) => a.name).join(", ")}. Events appear once an agent runs in this project.` : "Install hooks with `athena agents add claude-code` (or cursor, codex, copilot, gemini-cli) to record agent activity."));
     return;
   }
   for (const e of events) {
@@ -7889,7 +8861,7 @@ async function activityCommand(opts) {
 }
 
 // src/cli/commands/security.ts
-import path40 from "path";
+import path45 from "path";
 var TONE = {
   critical: c.red,
   high: c.red,
@@ -7898,7 +8870,7 @@ var TONE = {
   unknown: c.dim
 };
 async function loadModel2(root, signal) {
-  const raw = await readTextIfExists(path40.join(athenaDir(root), "model.json"));
+  const raw = await readTextIfExists(path45.join(athenaDir(root), "model.json"));
   if (raw) {
     try {
       const parsed = ProjectModel.safeParse(JSON.parse(raw));
@@ -7996,7 +8968,7 @@ async function reviewCommand(opts) {
     result = await reviewChanges(root, {
       base: opts.base,
       signal: opts.signal,
-      checkSync: opts.noSync ? void 0 : async (r) => (await planSync(r, { signal: opts.signal })).upToDate
+      checkSync: opts.noSync ? void 0 : async (r) => staleForCheck(await planSync(r, { signal: opts.signal })).length === 0
     });
     sp.stop();
   } catch (err) {
@@ -8203,13 +9175,13 @@ async function aiEnrichCommand(opts) {
 }
 
 // src/mcp/server.ts
-import path41 from "path";
+import path46 from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z8 } from "zod";
 var textResult = (text) => ({ content: [{ type: "text", text }] });
 async function docText(root, file) {
-  const text = await readTextIfExists(path41.join(athenaDir(root), file));
+  const text = await readTextIfExists(path46.join(athenaDir(root), file));
   return text ?? `${file} does not exist yet. Run \`athena init\` or \`athena analyze\` in this project.`;
 }
 function createMcpServer(opts) {
@@ -8270,7 +9242,7 @@ _Last dependency scan: ${scan.scannedAt}._` : "\n\n_No dependency audit has been
     "get_project_rules",
     { title: "Project rules", description: "Developer-defined rules this project expects agents to follow. Disabled rules are excluded.", inputSchema: {} },
     async () => {
-      const text = await readTextIfExists(path41.join(athenaDir(root), "rules.md"));
+      const text = await readTextIfExists(path46.join(athenaDir(root), "rules.md"));
       if (!text) return textResult("No rules.md found. Run `athena init` in this project.");
       const rules = listRules(parseRules(text)).filter((r) => r.enabled);
       return textResult(rules.length ? ["# Project rules (all apply)", "", ...rules.map((r) => `- [${r.section}] ${r.text}`)].join("\n") : "rules.md contains no enabled rules.");
@@ -8461,17 +9433,227 @@ async function watchCommand(opts) {
   await watcher.close();
 }
 
+// src/cli/commands/git-hook.ts
+import path48 from "path";
+
+// src/services/git-hook.ts
+import { promises as fs29 } from "fs";
+import path47 from "path";
+var HOOK_START = "# athena:start";
+var HOOK_END = "# athena:end";
+var HOOK_MANAGER_COMMAND = "npx --no-install athena sync --check";
+var SHELL_SHEBANG = /^#!\s*(?:\/usr\/bin\/env\s+)?(?:\/usr\/local\/bin\/|\/usr\/bin\/|\/bin\/)?(?:sh|bash|dash|zsh|ksh)(?:\s|$)/;
+var HOOK_MANAGERS = [
+  { name: "husky", pattern: /husky/i },
+  { name: "lefthook", pattern: /lefthook/i },
+  { name: "pre-commit", pattern: /pre-commit\.com|INSTALL_PYTHON|pre_commit/ },
+  { name: "simple-git-hooks", pattern: /simple-git-hooks/i },
+  { name: "overcommit", pattern: /overcommit/i }
+];
+async function locateHook(projectRoot) {
+  const top = await git(projectRoot, ["rev-parse", "--show-toplevel"]);
+  if (!top.ok || !top.stdout.trim()) throw new AthenaError("`athena git-hook` needs a Git repository.", "Run `git init` first, or use `athena sync --check` in your own tooling.");
+  const topLevel = await fs29.realpath(top.stdout.trim());
+  const hooks = await git(topLevel, ["rev-parse", "--git-path", "hooks"]);
+  if (!hooks.ok || !hooks.stdout.trim()) throw new AthenaError("Could not find the Git hooks directory.");
+  const hooksDir = path47.resolve(topLevel, hooks.stdout.trim());
+  const projectPrefix = path47.relative(topLevel, await fs29.realpath(projectRoot)).split(path47.sep).join("/");
+  return { topLevel, hooksDir, hookFile: path47.join(hooksDir, "pre-commit"), projectPrefix };
+}
+function shQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function renderHookBlock(opts) {
+  const cmd = opts.command ?? hookCommand();
+  const probe = cmd.split(/\s+/)[0];
+  const cwdArg = opts.projectPrefix ? ` -C ${shQuote(opts.projectPrefix)}` : "";
+  const athena = `${cmd} --no-color${cwdArg}`;
+  const lines = [
+    `${HOOK_START} (added by \`athena git-hook install\`; remove with \`athena git-hook uninstall\`)`,
+    `if command -v ${probe} >/dev/null 2>&1; then`,
+    "  athena_rc=0",
+    `  athena_out=$(${athena} sync --check --quiet 2>&1) || athena_rc=$?`,
+    '  if [ "$athena_rc" -eq 3 ]; then',
+    "    echo 'athena: Athena is not initialized in this project; skipping the knowledge check.' >&2",
+    '  elif [ "$athena_rc" -ne 0 ]; then',
+    `    printf '%s\\n' "$athena_out" >&2`,
+    "    echo 'athena: commit blocked: .athena/ knowledge is out of date. Run `athena sync`, stage .athena/ and commit again (or skip once with `git commit --no-verify`).' >&2",
+    "    exit 1",
+    "  fi"
+  ];
+  if (opts.review) {
+    lines.push(
+      "  athena_rc=0",
+      `  athena_out=$(${athena} review --no-sync 2>&1) || athena_rc=$?`,
+      '  if [ "$athena_rc" -ne 0 ] && [ "$athena_rc" -ne 3 ]; then',
+      `    printf '%s\\n' "$athena_out" >&2`,
+      "    echo 'athena: commit blocked: `athena review` found blockers (possible secrets or env files). Fix them, or skip once with `git commit --no-verify`.' >&2",
+      "    exit 1",
+      "  fi"
+    );
+  }
+  lines.push("else", `  echo 'athena: \`${probe}\` not found on PATH; skipping Athena pre-commit checks.' >&2`, "fi", HOOK_END);
+  return `${lines.join("\n")}
+`;
+}
+function parseHook(text) {
+  const start = text.indexOf(`${HOOK_START}`);
+  if (start < 0) return null;
+  const lineStart = text.lastIndexOf("\n", start) + 1;
+  const endIdx = text.indexOf(HOOK_END, start);
+  if (endIdx < 0) return null;
+  let blockEnd = endIdx + HOOK_END.length;
+  if (text[blockEnd] === "\n") blockEnd++;
+  return { before: text.slice(0, lineStart), block: text.slice(lineStart, blockEnd), after: text.slice(blockEnd) };
+}
+function detectManager(loc, text) {
+  const rel2 = path47.relative(loc.topLevel, loc.hooksDir).split(path47.sep);
+  if (rel2.includes(".husky")) return "husky";
+  if (text) {
+    for (const m of HOOK_MANAGERS) if (m.pattern.test(text)) return m.name;
+  }
+  return null;
+}
+var NEW_FILE_HEADER = "#!/bin/sh\n";
+async function hookStatus(projectRoot) {
+  const loc = await locateHook(projectRoot);
+  const text = await readTextIfExists(loc.hookFile);
+  const parsed = text ? parseHook(text) : null;
+  return {
+    ...loc,
+    installed: Boolean(parsed),
+    review: Boolean(parsed?.block.includes(" review ")),
+    ownsFile: Boolean(parsed && `${parsed.before}${parsed.after}`.trim() === NEW_FILE_HEADER.trim()),
+    manager: detectManager(loc, text && parsed ? `${parsed.before}${parsed.after}` : text)
+  };
+}
+async function installHook(projectRoot, opts = {}) {
+  const loc = await locateHook(projectRoot);
+  const block = renderHookBlock({ projectPrefix: loc.projectPrefix, review: Boolean(opts.review) });
+  const text = await readTextIfExists(loc.hookFile);
+  let next;
+  let action;
+  const parsed = text ? parseHook(text) : null;
+  if (text === null) {
+    const manager = detectManager(loc, null);
+    if (manager) throw managedError(manager);
+    next = `${NEW_FILE_HEADER}
+${block}`;
+    action = "created";
+  } else if (parsed) {
+    next = `${parsed.before}${block}${parsed.after}`;
+    action = next === text ? "unchanged" : "updated";
+  } else {
+    const manager = detectManager(loc, text);
+    if (manager) throw managedError(manager);
+    const firstLine = text.split("\n", 1)[0];
+    if (!SHELL_SHEBANG.test(firstLine)) {
+      throw conflict(
+        `${path47.relative(loc.topLevel, loc.hookFile) || loc.hookFile} already exists and is not a shell script, so Athena will not modify it.`,
+        `Add this command to your pre-commit hook yourself: ${HOOK_MANAGER_COMMAND}`
+      );
+    }
+    const rest = text.slice(firstLine.length + 1);
+    next = `${firstLine}
+${block}
+${rest}`;
+    action = "added-to-existing";
+  }
+  if (action !== "unchanged") {
+    await fs29.mkdir(loc.hooksDir, { recursive: true });
+    await fs29.writeFile(loc.hookFile, next, "utf8");
+  }
+  await fs29.chmod(loc.hookFile, 493);
+  return { action, status: await hookStatus(projectRoot) };
+}
+async function uninstallHook(projectRoot) {
+  const loc = await locateHook(projectRoot);
+  const text = await readTextIfExists(loc.hookFile);
+  const parsed = text ? parseHook(text) : null;
+  if (!parsed) return { removed: false, deletedFile: false, status: await hookStatus(projectRoot) };
+  let rest = parsed.after;
+  if (rest.startsWith("\n")) rest = rest.slice(1);
+  const remaining = `${parsed.before}${rest}`;
+  let deletedFile = false;
+  if (!remaining.trim() || remaining.trim() === NEW_FILE_HEADER.trim()) {
+    await fs29.rm(loc.hookFile, { force: true });
+    deletedFile = true;
+  } else {
+    await fs29.writeFile(loc.hookFile, remaining, "utf8");
+  }
+  return { removed: true, deletedFile, status: await hookStatus(projectRoot) };
+}
+function managedError(manager) {
+  return conflict(
+    `Git hooks in this repository are managed by ${manager}, so Athena will not write a hook file.`,
+    `Add this line to your ${manager} pre-commit configuration instead: ${HOOK_MANAGER_COMMAND}`
+  );
+}
+
+// src/cli/commands/git-hook.ts
+var rel = (s) => path48.relative(s.topLevel, s.hookFile).split(path48.sep).join("/") || s.hookFile;
+function managerTip() {
+  line(dim(`Using husky, lefthook or pre-commit? Add \`${HOOK_MANAGER_COMMAND}\` to its pre-commit config instead.`));
+}
+async function gitHookInstallCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const { action, status: status2 } = await installHook(root, { review: opts.review });
+  if (isJson()) {
+    json({ action, ...status2 });
+    return EXIT.OK;
+  }
+  const what = status2.review ? "knowledge check + review" : "knowledge check";
+  const message = {
+    created: `Installed the pre-commit hook (${what}) at ${rel(status2)}`,
+    updated: `Updated Athena's block in ${rel(status2)} (${what})`,
+    unchanged: `Pre-commit hook already installed at ${rel(status2)} (${what})`,
+    "added-to-existing": `Added Athena's block to your existing ${rel(status2)} (${what}); the rest of the hook is unchanged`
+  };
+  ok(message[action]);
+  info(dim("Commits are blocked when .athena/ knowledge is out of date. Teammates without Athena installed are not blocked."));
+  if (!isQuiet()) managerTip();
+  return EXIT.OK;
+}
+async function gitHookUninstallCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const r = await uninstallHook(root);
+  if (isJson()) {
+    json({ removed: r.removed, deletedFile: r.deletedFile, ...r.status });
+    return EXIT.OK;
+  }
+  if (!r.removed) line(`No Athena pre-commit hook found in ${rel(r.status)}.`);
+  else if (r.deletedFile) ok(`Removed ${rel(r.status)}`);
+  else ok(`Removed Athena's block from ${rel(r.status)}; the rest of the hook is unchanged`);
+  return EXIT.OK;
+}
+async function gitHookStatusCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const s = await hookStatus(root);
+  if (isJson()) {
+    json(s);
+    return EXIT.OK;
+  }
+  if (s.installed) {
+    ok(`Installed in ${rel(s)} (${s.review ? "knowledge check + review" : "knowledge check"}${s.ownsFile ? "" : "; shared with your own hook"})`);
+  } else {
+    line(`Not installed ${dim(`(${rel(s)})`)}`);
+    if (s.manager) line(dim(`Hooks here are managed by ${s.manager}: add \`${HOOK_MANAGER_COMMAND}\` to its pre-commit config.`));
+    else line(dim("Run `athena git-hook install` (add `--review` to also block commits with secrets or env files)."));
+  }
+  return EXIT.OK;
+}
+
 // src/cli/commands/agents.ts
 async function agentsListCommand(opts) {
   const root = await requireProjectRoot(opts);
-  const rows = await listAgents(root);
+  const rows2 = await listAgents(root);
   if (isJson()) {
-    json(rows);
+    json(rows2);
     return;
   }
   heading("AI Agent Integrations");
   line();
-  for (const r of rows) {
+  for (const r of rows2) {
     const icon = r.configured ? c.green(sym.dot) : c.dim(sym.ring);
     line(`${icon} ${c.bold(r.name)} ${dim(`(${r.id})`)} \u2014 ${r.configured ? "configured" : "not configured"}${r.detectedInProject ? dim(` \xB7 detected: ${r.evidence.join(", ")}`) : ""}`);
     line(`  ${dim(r.note)}`);
@@ -8504,6 +9686,10 @@ function onSignal() {
 ${c.yellow("Interrupted.")} ${dim(getInterruptMessage())}
 `);
 }
+process.stdout.on("error", (err) => {
+  if (err.code === "EPIPE") process.exit(0);
+  throw err;
+});
 process.on("SIGINT", onSignal);
 process.on("SIGTERM", onSignal);
 var PLANNED = [];
@@ -8522,7 +9708,7 @@ function run2(fn) {
 function buildProgram() {
   const program = new Command2();
   program.name("athena").description("Athena \u2014 local-first project intelligence for AI coding agents").version(ATHENA_VERSION, "-v, --version", "Print the Athena version").addOption(new Option("-C, --cwd <dir>", "Run as if started in <dir>")).option("--json", "Machine-readable JSON output").option("-q, --quiet", "Only print warnings, errors and results").option("--no-color", "Disable colors (also respects NO_COLOR)").showHelpAfterError("(run `athena --help` for usage)").configureHelp({ sortSubcommands: false });
-  program.command("init").description("Analyze the project and create .athena/ knowledge").option("--agents <list>", 'Agents to configure: comma-separated ids (claude-code, cursor, antigravity, agents-md), "all" or "none". Default: detected agents + AGENTS.md').option("--no-agents", "Do not configure any agent integration").option("--dry-run", "Analyze and show what would be written, without writing").action(
+  program.command("init").description("Analyze the project and create .athena/ knowledge").option("--agents <list>", 'Agents to configure: comma-separated ids (claude-code, cursor, codex, copilot, gemini-cli, antigravity, windsurf, cline, agents-md), "all" or "none". Default: detected agents + AGENTS.md').option("--no-agents", "Do not configure any agent integration").option("--dry-run", "Analyze and show what would be written, without writing").action(
     run2(async (cmdOpts, cmd) => {
       const g = globals(cmd);
       await initCommand({ ...g, agents: typeof cmdOpts.agents === "string" ? cmdOpts.agents : void 0, noAgents: cmdOpts.agents === false, dryRun: cmdOpts.dryRun, signal: controller.signal });
@@ -8551,8 +9737,12 @@ function buildProgram() {
   rules.command("remove <number>").description("Delete a rule").action(run2(async (n, _o, cmd) => rulesRemoveCommand(n, globals(cmd))));
   const agents = program.command("agents").description("Manage AI agent integrations");
   agents.command("list", { isDefault: true }).description("Show supported agents and integration status").action(run2(async (_o, cmd) => agentsListCommand(globals(cmd))));
-  agents.command("add <agents...>").description('Configure integrations (claude-code, cursor, antigravity, agents-md, or "all")').action(run2(async (names2, _o, cmd) => agentsAddCommand(names2, globals(cmd))));
+  agents.command("add <agents...>").description('Configure integrations (claude-code, cursor, codex, copilot, gemini-cli, antigravity, windsurf, cline, agents-md, or "all")').action(run2(async (names2, _o, cmd) => agentsAddCommand(names2, globals(cmd))));
   agents.command("remove <agents...>").description("Remove Athena-managed integration files/blocks").action(run2(async (names2, _o, cmd) => agentsRemoveCommand(names2, globals(cmd))));
+  const gitHook = program.command("git-hook").description("Install a Git pre-commit hook that blocks commits when knowledge is out of date");
+  gitHook.command("status", { isDefault: true }).description("Show whether the Athena pre-commit hook is installed").action(run2(async (_o, cmd) => gitHookStatusCommand(globals(cmd))));
+  gitHook.command("install").description("Add the Athena pre-commit hook (existing hooks are kept; Athena adds a marked block)").option("--review", "Also run `athena review` and block commits with possible secrets or env files").action(run2(async (o, cmd) => gitHookInstallCommand({ ...globals(cmd), review: o.review })));
+  gitHook.command("uninstall").description("Remove Athena's pre-commit hook or block").action(run2(async (_o, cmd) => gitHookUninstallCommand(globals(cmd))));
   program.command("open").description("Start (or reuse) the local web UI and open it in your browser").option("-p, --port <port>", "Port to bind (default: first free port from 7432)").option("--host <host>", "Interface to bind (default: 127.0.0.1)").option("--allow-remote", "Allow binding to a non-loopback interface").option("--no-open", "Do not launch a browser").option("--no-watch", "Do not watch the project for changes").action(run2(async (o, cmd) => openCommand({ ...globals(cmd), ...o, signal: controller.signal })));
   program.command("activity").description("Show AI agent activity observed through hooks").option("-n, --limit <count>", "Number of events to show (default 30)").option("--agent <id>", "Only show events from this agent").action(run2(async (o, cmd) => activityCommand({ ...globals(cmd), ...o })));
   program.command("event").description("Record an agent hook event (called by AI coding agents, reads JSON on stdin)").option("--agent <id>", "Agent that fired the hook").option("--hook <name>", "Hook event name").option("--athena-hook", "Marker used to identify Athena-managed hook entries").option("--verbose-errors", "Print errors to stderr (hooks stay silent by default)").action(