project-athena 0.1.3 → 0.2.0

package/dist/cli.js

@@ -9,6 +9,7 @@ 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);
@@ -150,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";
@@ -354,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";
@@ -366,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) {
@@ -577,18 +578,18 @@ 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, strip2, 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);
@@ -609,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
     };
   }
@@ -636,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);
@@ -657,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 rel of spec.files ?? []) {
-    const text = await readTextIfExists(path6.join(root, rel)).catch(() => null);
+  for (const rel2 of spec.athenaOwnedJson ?? []) {
+    if (await jsonOnlyAthena(path6.join(root, rel2))) owned.add(rel2);
+  }
+  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;
 }
@@ -699,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;
@@ -717,12 +722,14 @@ 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 strip2 = (value) => {
@@ -752,8 +759,9 @@ async function jsonOnlyAthena(file) {
 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;
@@ -779,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) {
@@ -799,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;
@@ -833,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";
@@ -989,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) {
@@ -1011,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",
@@ -1033,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();
@@ -1053,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);
   }
@@ -1065,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;
@@ -1093,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;
   }
@@ -1108,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;
       }
     }
@@ -1128,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) {
@@ -1173,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;
@@ -1198,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;
@@ -1212,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"),
@@ -1454,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();
@@ -1465,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) {
@@ -1577,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);
@@ -1632,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;
@@ -1702,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}`);
@@ -1735,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;
@@ -2461,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 = [
@@ -2619,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 {
       }
@@ -2902,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 }]) });
@@ -3380,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;
 }
@@ -3442,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;
@@ -3470,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 });
@@ -3523,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) {
@@ -4134,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"];
@@ -4166,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));
@@ -4233,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;
@@ -4255,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;
@@ -4264,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);
@@ -4303,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 {
     }
   }
@@ -4357,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");
@@ -4370,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;
   }
@@ -4413,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;
   }
@@ -4435,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.");
@@ -4611,6 +5089,19 @@ function wrapCode(text, w) {
     }).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);
@@ -4737,9 +5228,9 @@ function logoBlock(w) {
 }
 function linksBlock() {
   return [
-    pc4.italic('"Turn any codebase'),
-    pc4.italic(' into clear knowledge."'),
+    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),
@@ -4772,23 +5263,27 @@ function header() {
   return [...box(content, Math.min(total, fit.w + 4), { color: PALETTE.blue }), ""];
 }
 function compactLinks() {
-  return [`${paint(PALETTE.pink, "npm", true)}     ${paint(PALETTE.blue, NPM_URL)}`, `${paint(PALETTE.violet, "github", true)}  ${paint(PALETTE.blue, REPO_URL)}`];
+  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 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 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, "", ...links, credit.join(" ")] : [...status2, pc4.dim(REPO_URL)];
+  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)];
+var divider2 = () => [pc4.dim(VR), pc4.dim(VR), pc4.dim(VR)];
 
 // src/cli/ui/stages.ts
 import pc5 from "picocolors";
@@ -4913,7 +5408,7 @@ 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.");
   }
@@ -5018,7 +5513,7 @@ function printSummary(result, dryRun, mode) {
     "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",
-    "Share feedback and star on GitHub \u2605"
+    "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) },
@@ -5037,7 +5532,8 @@ function printSummary(result, dryRun, mode) {
     }),
     ...mode === "init" && !dryRun ? (() => {
       const unconfigured = ADAPTERS.filter((a) => !result.agentChanges.some((c2) => c2.adapter.id === a.id));
-      return unconfigured.length ? [() => line(dim(`Not configured: ${unconfigured.map((a) => a.displayName).join(", ")} \u2014 not detected; add with \`athena agents add <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))
@@ -5084,7 +5580,7 @@ async function analyzeCommand(opts) {
 }
 
 // src/services/status.ts
-import path22 from "path";
+import path27 from "path";
 
 // src/core/impact/impact.ts
 var RULES = [
@@ -5128,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,
@@ -5207,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*$/;
@@ -5302,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;
@@ -5319,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;
   }
@@ -5334,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 {
       }
@@ -5356,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 {
   }
@@ -5409,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 [];
@@ -5446,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." });
@@ -5460,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;
@@ -5525,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);
@@ -5572,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) };
 }
@@ -5585,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) {
@@ -5611,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++) {
@@ -5625,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) {
@@ -5646,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) };
@@ -5724,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;
@@ -5749,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/");
@@ -5761,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
@@ -5824,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));
@@ -5881,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
@@ -6068,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));
@@ -6078,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);
@@ -6091,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;
@@ -6180,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 });
     }
@@ -6188,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({
@@ -6202,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),
@@ -6212,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) {
@@ -6226,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";
@@ -6445,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;
@@ -6503,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")}
@@ -6512,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;
@@ -6542,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));
@@ -6561,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." });
@@ -6579,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 } };
 }
@@ -6590,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({
@@ -6618,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;
 }
@@ -6634,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 } });
   }
@@ -6653,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");
     }
@@ -6704,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));
@@ -6905,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));
@@ -6921,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;
@@ -6937,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
   });
@@ -6955,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";
@@ -7145,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} ---
@@ -7198,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"]);
@@ -7223,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) {
@@ -7282,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, {
@@ -7297,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()));
@@ -7313,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;
@@ -7465,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",
@@ -7482,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/") });
       }
     }
@@ -7714,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);
@@ -7763,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;
@@ -7788,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;
@@ -7828,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) => {
@@ -7886,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);
   };
@@ -7921,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();
@@ -7937,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 {
@@ -8027,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;
@@ -8044,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 {
@@ -8054,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}
 `);
 }
 
@@ -8191,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");
@@ -8204,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."));
@@ -8242,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() {
@@ -8288,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;
@@ -8326,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) {
@@ -8342,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,
@@ -8351,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));
@@ -8449,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) {
@@ -8656,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) {
@@ -8723,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.");
@@ -8914,6 +9433,216 @@ 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);
@@ -8979,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 });
@@ -9008,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(