project-athena 0.3.0 → 0.4.0

package/dist/{open-2QSZKKUG.js → open-UJZRYF4E.js}

@@ -1,20 +1,39 @@
 #!/usr/bin/env node
+import {
+  contentHash,
+  docAtRevision,
+  docHistory,
+  getRules,
+  listDocs,
+  readDoc,
+  rulesAdd,
+  rulesRemove,
+  rulesUpdate,
+  saveDoc,
+  searchDocs
+} from "./chunk-LEMPCNAY.js";
 import {
   configureAgents,
   listAgents,
   removeAgents
-} from "./chunk-JY6BFIJJ.js";
+} from "./chunk-QLW657NT.js";
+import {
+  watchProject
+} from "./chunk-DZDI2HRT.js";
+import {
+  AnalysisScheduler
+} from "./chunk-RVTNSNGK.js";
 import {
   getRelevantContext,
   graphSummary,
   refreshGraph
-} from "./chunk-CXUTYCZX.js";
+} from "./chunk-UAZLPNVC.js";
 import {
   runSecurityScan
-} from "./chunk-LMOFZNTQ.js";
+} from "./chunk-SJ4DQFIJ.js";
 import {
   reviewChanges
-} from "./chunk-EF6GHOIN.js";
+} from "./chunk-FVCDMQUQ.js";
 import {
   buildStatus
 } from "./chunk-ZB7LC6FP.js";
@@ -22,25 +41,11 @@ import {
   INSTANCE_FILE,
   findRunningInstance,
   runDoctor
-} from "./chunk-PR53DT7I.js";
+} from "./chunk-3XSDI5WF.js";
 import {
   aiStatus
 } from "./chunk-RXNRMIZP.js";
 import "./chunk-VSYBC3VY.js";
-import {
-  contentHash,
-  docAtRevision,
-  docHistory,
-  getRules,
-  listDocs,
-  readDoc,
-  rulesAdd,
-  rulesRemove,
-  rulesUpdate,
-  saveDoc,
-  searchDocs
-} from "./chunk-LEMPCNAY.js";
-import "./chunk-3IS2X2Z7.js";
 import {
   ACTIVITY_FILE,
   activityFile,
@@ -53,11 +58,20 @@ import {
   printHeader
 } from "./chunk-SHKXELUX.js";
 import {
-  watchProject
-} from "./chunk-32PRS2MG.js";
-import {
-  AnalysisScheduler
-} from "./chunk-XB66PZ6Z.js";
+  MEMORY_DIR,
+  MEMORY_FILES,
+  MEMORY_KINDS,
+  MEMORY_STATUSES,
+  addMemory,
+  confirmMemory,
+  forgetMemory,
+  getMemory,
+  listMemory,
+  memoryDir,
+  supersedeMemory,
+  updateMemory
+} from "./chunk-TDNZ2RYA.js";
+import "./chunk-3IS2X2Z7.js";
 import {
   c,
   dim,
@@ -76,28 +90,31 @@ import {
   applySync,
   ignorePlan,
   staleForCheck
-} from "./chunk-TGJUUB44.js";
+} from "./chunk-KHMBNT66.js";
 import {
   projectSession,
   releaseProjectSession
-} from "./chunk-PDFQ5BFG.js";
+} from "./chunk-WVQC2EGO.js";
 import "./chunk-GR4DL2VM.js";
 import {
   runPipeline
-} from "./chunk-SJOOXO34.js";
+} from "./chunk-GGXPG6OE.js";
 import {
   SCAN_FILE,
   saveScan
-} from "./chunk-PANVPNYF.js";
+} from "./chunk-MPG3IEGB.js";
 import "./chunk-ELKFRTZT.js";
 import {
   ATHENA_VERSION
 } from "./chunk-2R6PXY6Z.js";
 import "./chunk-PVCIGUIT.js";
 import "./chunk-OLPSEQS5.js";
+import "./chunk-SVTEJYMS.js";
+import "./chunk-QCC4VJUH.js";
 import "./chunk-JCGDR4UV.js";
-import "./chunk-2RS6TA3D.js";
+import "./chunk-YRIS7ZS6.js";
 import "./chunk-GHFRQAYT.js";
+import "./chunk-INT3IGMQ.js";
 import "./chunk-673EPYYH.js";
 import {
   KNOWLEDGE_DOCS,
@@ -113,7 +130,6 @@ import {
   AthenaError,
   notFound
 } from "./chunk-AD4OZCU2.js";
-import "./chunk-INT3IGMQ.js";
 import "./chunk-XW3MLHI2.js";
 import "./chunk-EUPETUWA.js";
 
@@ -121,8 +137,8 @@ import "./chunk-EUPETUWA.js";
 import { execFile } from "child_process";
 
 // src/server/instance.ts
-import { promises as fs6 } from "fs";
-import path4 from "path";
+import { promises as fs7 } from "fs";
+import path5 from "path";
 import { fileURLToPath } from "url";
 
 // src/server/app.ts
@@ -568,6 +584,111 @@ function registerGraphRoutes({ app, root, events, state }) {
   });
 }
 
+// src/server/routes/memory.ts
+import { promises as fs2 } from "fs";
+import path from "path";
+var memoryWriteKey = (file) => `memory/${file}`;
+var ID = "^m-[a-z0-9]{4,16}$";
+var idParams = { type: "object", required: ["id"], additionalProperties: false, properties: { id: { type: "string", pattern: ID } } };
+var fields = {
+  title: { type: "string", maxLength: 1e3 },
+  details: { type: "string", maxLength: 1e4 },
+  files: { type: "array", maxItems: 50, items: { type: "string", maxLength: 500 } },
+  tags: { type: "array", maxItems: 30, items: { type: "string", maxLength: 100 } },
+  evidence: { type: "string", maxLength: 2e3 }
+};
+function memoryCounts(entries) {
+  return {
+    total: entries.length,
+    unreviewed: entries.filter((e) => e.status === "unreviewed").length,
+    confirmed: entries.filter((e) => e.status === "confirmed").length,
+    superseded: entries.filter((e) => e.status === "superseded").length,
+    stale: entries.filter((e) => e.stale).length,
+    flagged: entries.filter((e) => e.flags.length > 0).length
+  };
+}
+function registerMemoryRoutes({ app, root, events, recentWrites }) {
+  const recordWrites = async () => {
+    for (const file of Object.values(MEMORY_FILES)) {
+      const text = await fs2.readFile(path.join(memoryDir(root), file), "utf8").catch(() => null);
+      if (text !== null) recentWrites.set(memoryWriteKey(file), contentHash(text));
+    }
+  };
+  const changed = async (action, id, message) => {
+    await recordWrites();
+    events.emit({ source: "web-ui", type: "memory.changed", level: "success", message, data: { action, id } });
+  };
+  app.get(
+    "/api/memory",
+    {
+      schema: {
+        querystring: {
+          type: "object",
+          additionalProperties: false,
+          properties: { kind: { type: "string", enum: [...MEMORY_KINDS] }, status: { type: "string", enum: [...MEMORY_STATUSES] }, stale: { type: "string", enum: ["true", "false"] } }
+        }
+      }
+    },
+    async (req) => {
+      const all = await listMemory(root);
+      const { kind, status, stale } = req.query;
+      const entries = all.filter((e) => (!kind || e.kind === kind) && (!status || e.status === status) && (stale === void 0 || e.stale === (stale === "true")));
+      return { entries, counts: memoryCounts(all) };
+    }
+  );
+  app.get("/api/memory/:id", { schema: { params: idParams } }, async (req) => getMemory(root, req.params.id));
+  app.post(
+    "/api/memory",
+    {
+      schema: {
+        body: {
+          type: "object",
+          required: ["kind", "title"],
+          additionalProperties: false,
+          properties: { kind: { type: "string", enum: [...MEMORY_KINDS] }, ...fields, supersedes: { type: "string", pattern: ID } }
+        }
+      }
+    },
+    async (req, reply) => {
+      const entry = await addMemory(root, req.body, "developer");
+      await changed("add", entry.id, `Added memory: ${entry.title}`);
+      return reply.code(201).send(entry);
+    }
+  );
+  app.post("/api/memory/:id/confirm", { schema: { params: idParams } }, async (req) => {
+    const entry = await confirmMemory(root, req.params.id);
+    await changed("confirm", entry.id, `Confirmed memory: ${entry.title}`);
+    return entry;
+  });
+  app.post(
+    "/api/memory/:id/supersede",
+    { schema: { params: idParams, body: { type: "object", required: ["by"], additionalProperties: false, properties: { by: { type: "string", pattern: ID } } } } },
+    async (req) => {
+      const { id } = req.params;
+      const { by } = req.body;
+      await getMemory(root, id);
+      if (id !== by && !(await listMemory(root)).some((e) => e.id === by)) throw new AthenaError(`Cannot supersede ${id}: no memory with id ${by}.`);
+      const entry = await supersedeMemory(root, id, by);
+      await changed("supersede", entry.id, `Memory ${id} superseded by ${by}`);
+      return entry;
+    }
+  );
+  app.patch(
+    "/api/memory/:id",
+    { schema: { params: idParams, body: { type: "object", minProperties: 1, additionalProperties: false, properties: fields } } },
+    async (req) => {
+      const entry = await updateMemory(root, req.params.id, req.body);
+      await changed("edit", entry.id, `Edited memory: ${entry.title}`);
+      return entry;
+    }
+  );
+  app.delete("/api/memory/:id", { schema: { params: idParams } }, async (req) => {
+    await forgetMemory(root, req.params.id);
+    await changed("forget", req.params.id, `Forgot memory ${req.params.id}`);
+    return { ok: true };
+  });
+}
+
 // src/server/routes/review.ts
 function registerReviewRoutes({ app, root, scheduler }) {
   app.get("/api/review", async (req) => {
@@ -711,11 +832,11 @@ function registerSessionRoutes({ app, root, instanceId, getStatus }) {
 }
 
 // src/server/routes/static.ts
-import { promises as fs3 } from "fs";
+import { promises as fs4 } from "fs";
 
 // src/server/static.ts
-import { promises as fs2 } from "fs";
-import path from "path";
+import { promises as fs3 } from "fs";
+import path2 from "path";
 var TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -731,20 +852,20 @@ var TYPES = {
 };
 async function buildAssetMap(webDir) {
   try {
-    await fs2.access(path.join(webDir, "index.html"));
+    await fs3.access(path2.join(webDir, "index.html"));
   } catch {
     return null;
   }
   const map = /* @__PURE__ */ new Map();
   async function walk(dir) {
-    for (const ent of await fs2.readdir(dir, { withFileTypes: true })) {
-      const abs = path.join(dir, ent.name);
+    for (const ent of await fs3.readdir(dir, { withFileTypes: true })) {
+      const abs = path2.join(dir, ent.name);
       if (ent.isDirectory()) await walk(abs);
       else if (ent.isFile()) {
-        const ext = path.extname(ent.name).toLowerCase();
+        const ext = path2.extname(ent.name).toLowerCase();
         const type = TYPES[ext];
         if (!type) continue;
-        const urlPath = `/${path.relative(webDir, abs).split(path.sep).join("/")}`;
+        const urlPath = `/${path2.relative(webDir, abs).split(path2.sep).join("/")}`;
         map.set(urlPath, { abs, type, immutable: urlPath.startsWith("/assets/") });
       }
     }
@@ -763,7 +884,7 @@ function registerStaticRoutes(app, assets) {
   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 fs3.readFile(asset.abs);
+    const body = await fs4.readFile(asset.abs);
     reply.header("Cache-Control", asset.immutable ? "public, max-age=31536000, immutable" : "no-cache");
     return reply.type(asset.type).send(body);
   };
@@ -785,8 +906,8 @@ function registerStaticRoutes(app, assets) {
 }
 
 // src/server/routes/sync.ts
-import { promises as fs4 } from "fs";
-import path2 from "path";
+import { promises as fs5 } from "fs";
+import path3 from "path";
 function summarizePlan(plan) {
   if (!plan) return null;
   return { ...plan, documents: plan.documents.map(({ diff: _diff, ...rest }) => rest) };
@@ -824,7 +945,7 @@ function registerSyncRoutes(ctx) {
     try {
       const result = await ctx.scheduler.exclusive(() => applySync(root, plan));
       for (const d of plan.documents) {
-        const text = await fs4.readFile(path2.join(athenaDir(root), d.file), "utf8").catch(() => null);
+        const text = await fs5.readFile(path3.join(athenaDir(root), d.file), "utf8").catch(() => null);
         if (text !== null) ctx.recentWrites.set(d.file, contentHash(text));
       }
       state.currentPlan = null;
@@ -950,8 +1071,8 @@ var SseHub = class {
 };
 
 // src/server/watchers.ts
-import { promises as fs5, watch } from "fs";
-import path3 from "path";
+import { promises as fs6, watch } from "fs";
+import path4 from "path";
 function watchKnowledgeDir(ctx, feed) {
   const { events, recentWrites } = ctx;
   let docsWatcher = null;
@@ -974,7 +1095,7 @@ function watchKnowledgeDir(ctx, feed) {
         name,
         setTimeout(async () => {
           pending.delete(name);
-          const text = await fs5.readFile(path3.join(dir, name), "utf8").catch(() => null);
+          const text = await fs6.readFile(path4.join(dir, name), "utf8").catch(() => null);
           const hash = text === null ? null : contentHash(text);
           if (hash && recentWrites.get(name) === hash) return;
           ctx.invalidateStatus();
@@ -992,6 +1113,73 @@ function watchKnowledgeDir(ctx, feed) {
     for (const t of pending.values()) clearTimeout(t);
   };
 }
+var MEMORY_FILE_NAMES = new Set(Object.values(MEMORY_FILES));
+function watchMemoryDir(ctx, debounceMs = 150) {
+  const { events, recentWrites } = ctx;
+  const dir = memoryDir(ctx.root);
+  const pending = /* @__PURE__ */ new Map();
+  let memWatcher = null;
+  let parentWatcher = null;
+  let stopped = false;
+  const onChange = (name) => {
+    clearTimeout(pending.get(name));
+    pending.set(
+      name,
+      setTimeout(async () => {
+        pending.delete(name);
+        const text = await fs6.readFile(path4.join(dir, name), "utf8").catch(() => null);
+        const hash = text === null ? null : contentHash(text);
+        const key = memoryWriteKey(name);
+        if ((recentWrites.get(key) ?? null) === hash) return;
+        if (hash) recentWrites.set(key, hash);
+        else recentWrites.delete(key);
+        if (stopped) return;
+        events.emit({ source: "filesystem", type: "memory.changed", level: "info", message: text === null ? `memory/${name} was deleted on disk` : `memory/${name} changed on disk`, data: { action: "external", file: name } });
+      }, debounceMs)
+    );
+  };
+  const attach = () => {
+    if (memWatcher || stopped) return true;
+    try {
+      memWatcher = watch(dir, { persistent: false }, (_type, filename) => {
+        const name = filename?.toString();
+        if (name && MEMORY_FILE_NAMES.has(name)) onChange(name);
+      });
+      memWatcher.on("error", () => {
+      });
+    } catch {
+      return false;
+    }
+    for (const name of MEMORY_FILE_NAMES) onChange(name);
+    return true;
+  };
+  void Promise.all(
+    [...MEMORY_FILE_NAMES].map(async (name) => {
+      const text = await fs6.readFile(path4.join(dir, name), "utf8").catch(() => null);
+      if (text !== null && !recentWrites.has(memoryWriteKey(name))) recentWrites.set(memoryWriteKey(name), contentHash(text));
+    })
+  ).then(() => {
+    if (stopped || attach()) return;
+    try {
+      parentWatcher = watch(athenaDir(ctx.root), { persistent: false }, (_type, filename) => {
+        if (filename?.toString() === MEMORY_DIR && attach()) {
+          parentWatcher?.close();
+          parentWatcher = null;
+        }
+      });
+      parentWatcher.on("error", () => {
+      });
+    } catch {
+      parentWatcher = null;
+    }
+  });
+  return () => {
+    stopped = true;
+    memWatcher?.close();
+    parentWatcher?.close();
+    for (const t of pending.values()) clearTimeout(t);
+  };
+}
 async function watchProjectFiles(ctx, debounceMs) {
   const { events, state } = ctx;
   try {
@@ -1108,9 +1296,11 @@ async function createServer(opts) {
   registerContextRoutes(ctx);
   registerGraphRoutes(ctx);
   registerActivityRoutes(ctx);
+  registerMemoryRoutes(ctx);
   registerEventRoutes(app, hub);
   registerStaticRoutes(app, assets);
   const stopDocsWatcher = watchKnowledgeDir(ctx, feed);
+  const stopMemoryWatcher = watchMemoryDir(ctx, opts.watchDebounceMs === void 0 ? void 0 : Math.min(opts.watchDebounceMs, 150));
   await feed.seed();
   if (opts.watch) await watchProjectFiles(ctx, opts.watchDebounceMs);
   return {
@@ -1123,6 +1313,7 @@ async function createServer(opts) {
       ctx.state.watcher = null;
       ctx.scheduler.close();
       stopDocsWatcher();
+      stopMemoryWatcher();
       events.close();
       await app.close();
       hub.close();
@@ -1151,8 +1342,8 @@ async function findAvailablePort(host, start = DEFAULT_PORT, attempts = 100) {
 
 // src/server/instance.ts
 function defaultWebDir() {
-  const here = path4.dirname(fileURLToPath(import.meta.url));
-  return path4.basename(here) === "dist" ? path4.join(here, "web") : path4.resolve(here, "../../dist/web");
+  const here = path5.dirname(fileURLToPath(import.meta.url));
+  return path5.basename(here) === "dist" ? path5.join(here, "web") : path5.resolve(here, "../../dist/web");
 }
 function browserUrl(info) {
   const host = info.host.includes(":") ? `[${info.host}]` : info.host;
@@ -1168,8 +1359,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 info = { pid: process.pid, host, port, instanceId: server.instanceId, token, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  const file = path4.join(athenaDir(opts.root), INSTANCE_FILE);
-  await fs6.writeFile(file, `${JSON.stringify(info, null, 2)}
+  const file = path5.join(athenaDir(opts.root), INSTANCE_FILE);
+  await fs7.writeFile(file, `${JSON.stringify(info, null, 2)}
 `, { mode: 384 });
   await ensureGitignored(opts.root, INSTANCE_FILE);
   return {
@@ -1178,16 +1369,16 @@ async function startServer(opts) {
     url: browserUrl(info),
     async close() {
       const current = await readTextIfExists(file);
-      if (current && current.includes(server.instanceId)) await fs6.rm(file, { force: true });
+      if (current && current.includes(server.instanceId)) await fs7.rm(file, { force: true });
       await server.close();
     }
   };
 }
 async function ensureGitignored(root, entry) {
-  const file = path4.join(athenaDir(root), ".gitignore");
+  const file = path5.join(athenaDir(root), ".gitignore");
   const text = await readTextIfExists(file) ?? "";
   if (text.split(/\r?\n/).includes(entry)) return;
-  await fs6.writeFile(file, `${text}${text.endsWith("\n") || !text ? "" : "\n"}${entry}
+  await fs7.writeFile(file, `${text}${text.endsWith("\n") || !text ? "" : "\n"}${entry}
 `);
 }
 
@@ -1256,4 +1447,4 @@ export {
   openBrowser,
   openCommand
 };
-//# sourceMappingURL=open-2QSZKKUG.js.map
+//# sourceMappingURL=open-UJZRYF4E.js.map

package/dist/{program-V2USHGXN.js → program-CWJNGCTZ.js}

@@ -31,7 +31,10 @@ ${c.yellow("Interrupted.")} ${dim(getInterruptMessage())}
 `);
 }
 process.stdout.on("error", (err) => {
-  if (err.code === "EPIPE") process.exit(0);
+  if (err.code === "EPIPE") {
+    if (process.env.ATHENA_DEBUG) process.stderr.write("athena: stdout was closed by the reader (EPIPE); exiting quietly\n");
+    process.exit(0);
+  }
   throw err;
 });
 process.on("SIGINT", onSignal);
@@ -55,23 +58,23 @@ function buildProgram() {
   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(
     run(async (cmdOpts, cmd) => {
       const g = globals(cmd);
-      await (await import("./init-2V34DVRQ.js")).initCommand({ ...g, agents: typeof cmdOpts.agents === "string" ? cmdOpts.agents : void 0, noAgents: cmdOpts.agents === false, dryRun: cmdOpts.dryRun, signal: controller.signal });
+      await (await import("./init-WQCAOJ2R.js")).initCommand({ ...g, agents: typeof cmdOpts.agents === "string" ? cmdOpts.agents : void 0, noAgents: cmdOpts.agents === false, dryRun: cmdOpts.dryRun, signal: controller.signal });
     })
   );
-  program.command("analyze").description("Re-analyze the project and refresh generated knowledge (developer edits are preserved)").option("--force", "Regenerate sections even if they were edited by hand").option("--agents <list>", "Reconfigure these agent integrations").action(run(async (o, cmd) => (await import("./analyze-F3YOILNL.js")).analyzeCommand({ ...globals(cmd), ...o, signal: controller.signal })));
-  program.command("sync").description("Review and apply knowledge updates for changes since the last analysis").option("-y, --yes", "Apply without asking").option("--dry-run", "Show the plan without writing").option("--check", "Exit with code 1 if knowledge is out of date (for CI/hooks)").option("--staged", "With --check: check the staged knowledge against the staged code (the index), ignoring untracked and unstaged changes").option("--diff", "Print full diffs of proposed document changes").option("--force", "Also regenerate sections that were edited by hand").action(run(async (o, cmd) => (await import("./sync-3ZNJDSSU.js")).syncCommand({ ...globals(cmd), ...o, signal: controller.signal })));
-  program.command("watch").description("Watch the project and propose knowledge updates as files change").option("--auto-apply", "Apply updates automatically instead of proposing them").option("--debounce <ms>", "Quiet period before checking changes (default 1500)").action(run(async (o, cmd) => (await import("./watch-USN5CQIV.js")).watchCommand({ ...globals(cmd), ...o, signal: controller.signal })));
-  program.command("context <task>").description("Show which knowledge an agent should read for a task (deterministic)").option("--full", "Print the full context an agent would receive").option("--max-chars <n>", "Character budget for selected sections").action(run(async (task, o, cmd) => (await import("./context-AH5MFHRG.js")).contextCommand(task, { ...globals(cmd), ...o, signal: controller.signal })));
-  program.command("graph").description("Inspect the project graph (packages, files, routes, entities and their relationships)").option("--build", "Rebuild the graph from the current code").option("--node <id>", "Show one node and its relationships").option("--kind <kind>", "Filter by node kind (package, file, route, entity, framework, command, infra)").option("--search <term>", "Filter nodes by name or path").action(run(async (o, cmd) => (await import("./context-AH5MFHRG.js")).graphCommand({ ...globals(cmd), ...o, signal: controller.signal })));
-  program.command("architecture").description("Summarize the project graph").action(run(async (_o, cmd) => (await import("./context-AH5MFHRG.js")).architectureCommand({ ...globals(cmd), signal: controller.signal })));
-  program.command("mcp").description("Serve Athena project intelligence over MCP (stdio) for AI agents").option("--allow-write", "Permit the update_knowledge tool to apply changes (read-only by default)").action(run(async (o, cmd) => (await import("./mcp-T2GRTEX5.js")).mcpCommand({ ...globals(cmd), ...o, signal: controller.signal })));
+  program.command("analyze").description("Re-analyze the project and refresh generated knowledge (developer edits are preserved)").option("--force", "Regenerate sections even if they were edited by hand").option("--agents <list>", "Reconfigure these agent integrations").action(run(async (o, cmd) => (await import("./analyze-ZY3MXBOI.js")).analyzeCommand({ ...globals(cmd), ...o, signal: controller.signal })));
+  program.command("sync").description("Review and apply knowledge updates for changes since the last analysis").option("-y, --yes", "Apply without asking").option("--dry-run", "Show the plan without writing").option("--check", "Exit with code 1 if knowledge is out of date (for CI/hooks)").option("--staged", "With --check: check the staged knowledge against the staged code (the index), ignoring untracked and unstaged changes").option("--diff", "Print full diffs of proposed document changes").option("--force", "Also regenerate sections that were edited by hand").action(run(async (o, cmd) => (await import("./sync-KFJANRXF.js")).syncCommand({ ...globals(cmd), ...o, signal: controller.signal })));
+  program.command("watch").description("Watch the project and propose knowledge updates as files change").option("--auto-apply", "Apply updates automatically instead of proposing them").option("--debounce <ms>", "Quiet period before checking changes (default 1500)").action(run(async (o, cmd) => (await import("./watch-CY7QHIYN.js")).watchCommand({ ...globals(cmd), ...o, signal: controller.signal })));
+  program.command("context <task>").description("Show which knowledge an agent should read for a task (deterministic)").option("--full", "Print the full context an agent would receive").option("--max-chars <n>", "Character budget for selected sections").action(run(async (task, o, cmd) => (await import("./context-PLPCAPCO.js")).contextCommand(task, { ...globals(cmd), ...o, signal: controller.signal })));
+  program.command("graph").description("Inspect the project graph (packages, files, routes, entities and their relationships)").option("--build", "Rebuild the graph from the current code").option("--node <id>", "Show one node and its relationships").option("--kind <kind>", "Filter by node kind (package, file, route, entity, framework, command, infra)").option("--search <term>", "Filter nodes by name or path").action(run(async (o, cmd) => (await import("./context-PLPCAPCO.js")).graphCommand({ ...globals(cmd), ...o, signal: controller.signal })));
+  program.command("architecture").description("Summarize the project graph").action(run(async (_o, cmd) => (await import("./context-PLPCAPCO.js")).architectureCommand({ ...globals(cmd), signal: controller.signal })));
+  program.command("mcp").description("Serve Athena project intelligence over MCP (stdio) for AI agents").option("--allow-write", "Permit the update_knowledge tool to apply changes (read-only by default)").option("--no-memory-write", "Disable the remember tool (agents cannot record unreviewed memories)").action(run(async (o, cmd) => (await import("./mcp-U7EPH43L.js")).mcpCommand({ ...globals(cmd), ...o, signal: controller.signal })));
   const ai = program.command("ai").description("Optional AI provider integration (never required)");
   ai.command("status", { isDefault: true }).description("Show configured and available AI providers").action(run(async (_o, cmd) => (await import("./ai-ASL4FFQ7.js")).aiStatusCommand(globals(cmd))));
   ai.command("enrich").description("Ask the configured provider for INFERRED suggestions based on your knowledge documents").option("--docs <list>", "Documents to send (default: project,architecture,database,api)").option("--consent", "Consent to sending redacted knowledge to a remote provider for this run").option("--dry-run", "Show exactly what would be sent, and send nothing").action(run(async (o, cmd) => (await import("./ai-ASL4FFQ7.js")).aiEnrichCommand({ ...globals(cmd), ...o, signal: controller.signal })));
-  program.command("security").description("Scan dependencies with the audit tools installed for this project, and report secret findings").option("--no-audit", "Skip dependency audits (report secrets only)").option("--fail-on <severity>", "Exit 1 when a finding at or above this severity exists (critical, high, moderate, low)").option("--last", "Show the last scan instead of running a new one").option("--unrated <policy>", 'With --fail-on: "fail" (default) also fails on findings the tool did not rate (pip-audit, govulncheck); "warn" only reports them', "fail").action(run(async (o, cmd) => (await import("./security-PI4LXCOB.js")).securityCommand({ ...globals(cmd), noAudit: o.audit === false, failOn: o.failOn, unrated: o.unrated, last: o.last, signal: controller.signal })));
-  program.command("review").description("Check the current diff for facts worth reviewing, and list the project rules and checklist").option("--base <ref>", "Compare against this Git ref instead of the working tree").option("--staged", "Review only what is staged for commit (used by the pre-commit hook)").option("--no-sync", "Skip the knowledge freshness check").option("--no-fail", "Always exit 0, even when blockers are found").action(run(async (o, cmd) => (await import("./review-R3R2J5BJ.js")).reviewCommand({ ...globals(cmd), base: o.base, staged: o.staged, noSync: o.sync === false, noFail: o.fail === false, signal: controller.signal })));
-  program.command("status").description("Show knowledge health and changes since the last analysis").action(run(async (_o, cmd) => (await import("./status-6M73WX5I.js")).statusCommand({ ...globals(cmd), signal: controller.signal })));
-  program.command("doctor").description("Check the Athena installation, project and integrations").action(run(async (_o, cmd) => (await import("./doctor-RSJMLE2P.js")).doctorCommand(globals(cmd))));
+  program.command("security").description("Scan dependencies with the audit tools installed for this project, and report secret findings").option("--no-audit", "Skip dependency audits (report secrets only)").option("--fail-on <severity>", "Exit 1 when a finding at or above this severity exists (critical, high, moderate, low)").option("--last", "Show the last scan instead of running a new one").option("--unrated <policy>", 'With --fail-on: "fail" (default) also fails on findings the tool did not rate (pip-audit, govulncheck); "warn" only reports them', "fail").action(run(async (o, cmd) => (await import("./security-LME3XFL3.js")).securityCommand({ ...globals(cmd), noAudit: o.audit === false, failOn: o.failOn, unrated: o.unrated, last: o.last, signal: controller.signal })));
+  program.command("review").description("Check the current diff for facts worth reviewing, and list the project rules and checklist").option("--base <ref>", "Compare against this Git ref instead of the working tree").option("--staged", "Review only what is staged for commit (used by the pre-commit hook)").option("--no-sync", "Skip the knowledge freshness check").option("--no-fail", "Always exit 0, even when blockers are found").action(run(async (o, cmd) => (await import("./review-OOKXSYMP.js")).reviewCommand({ ...globals(cmd), base: o.base, staged: o.staged, noSync: o.sync === false, noFail: o.fail === false, signal: controller.signal })));
+  program.command("status").description("Show knowledge health and changes since the last analysis").action(run(async (_o, cmd) => (await import("./status-RR57ZNGI.js")).statusCommand({ ...globals(cmd), signal: controller.signal })));
+  program.command("doctor").description("Check the Athena installation, project and integrations").action(run(async (_o, cmd) => (await import("./doctor-BX677KRE.js")).doctorCommand(globals(cmd))));
   const rules = program.command("rules").description("List and edit project rules (.athena/rules.md)");
   rules.command("list", { isDefault: true }).description("List rules with their numbers").action(run(async (_o, cmd) => (await import("./rules-4FXJUCXB.js")).rulesListCommand(globals(cmd))));
   rules.command("add <text>").description("Add a rule").option("-s, --section <name>", "Section heading", "General").action(run(async (text, o, cmd) => (await import("./rules-4FXJUCXB.js")).rulesAddCommand(text, { ...globals(cmd), ...o })));
@@ -79,23 +82,37 @@ function buildProgram() {
   rules.command("enable <number>").description("Enable a rule").action(run(async (n, _o, cmd) => (await import("./rules-4FXJUCXB.js")).rulesEnableCommand(n, globals(cmd))));
   rules.command("disable <number>").description("Disable a rule without deleting it").action(run(async (n, _o, cmd) => (await import("./rules-4FXJUCXB.js")).rulesDisableCommand(n, globals(cmd))));
   rules.command("remove <number>").description("Delete a rule").action(run(async (n, _o, cmd) => (await import("./rules-4FXJUCXB.js")).rulesRemoveCommand(n, globals(cmd))));
+  const repeat = (value, prev = []) => [...prev, ...value.split(",").map((s) => s.trim()).filter(Boolean)];
+  const mem = () => import("./memory-VSVNLEJC.js");
+  const memory = program.command("memory").description("Record, review and recall project memory (.athena/memory/)");
+  memory.command("list", { isDefault: true }).description("List memory entries with their label (FACT/INFERRED), status and staleness").option("--kind <kind>", "Only this kind (decision, gotcha, bug, convention, todo, fact)").option("--status <status>", "Only this status (unreviewed, confirmed, superseded)").option("--stale", "Only entries whose linked files changed since").action(run(async (o, cmd) => (await mem()).memoryListCommand({ ...globals(cmd), ...o })));
+  memory.command("show <id>").description("Show one entry in full: files, tags, evidence, staleness, warnings").action(run(async (id, _o, cmd) => (await mem()).memoryShowCommand(id, globals(cmd))));
+  memory.command("add").description("Record a memory as the developer (confirmed, FACT)").option("--kind <kind>", "decision, gotcha, bug, convention, todo or fact").option("--title <title>", "One-line summary").option("--details <text>", 'Longer explanation ("-" reads it from stdin)').option("--file <path>", "Linked project file (repeatable); the entry goes stale when it changes", repeat).option("--tag <tag>", "Tag (repeatable)", repeat).option("--evidence <text>", "Where this was observed (commit, issue, test, log)").option("--supersedes <id>", "Older memory this one replaces").action(run(async (o, cmd) => (await mem()).memoryAddCommand({ ...globals(cmd), ...o })));
+  memory.command("search <query>").description("Find entries whose title, details, tags or files contain the text").action(run(async (q, _o, cmd) => (await mem()).memorySearchCommand(q, globals(cmd))));
+  memory.command("recall <task...>").description("Rank the memory relevant to a task (what an agent would be given), with reasons").option("--file <path>", "File you are about to work on (repeatable)", repeat).option("--tag <tag>", "Tag to match (repeatable)", repeat).option("-n, --limit <count>", "Maximum entries (default 8)").action(run(async (task, o, cmd) => (await mem()).memoryRecallCommand(task, { ...globals(cmd), ...o })));
+  memory.command("confirm <ids...>").description("Confirm entries as FACT (and re-anchor them to the current files)").action(run(async (ids, _o, cmd) => (await mem()).memoryConfirmCommand(ids, globals(cmd))));
+  memory.command("supersede <id>").description("Mark an entry as replaced by a newer one (kept as history)").option("--by <id>", "The newer memory").action(run(async (id, o, cmd) => (await mem()).memorySupersedeCommand(id, { ...globals(cmd), ...o })));
+  memory.command("forget <ids...>").description("Delete entries").option("-y, --yes", "Skip confirmation").action(run(async (ids, o, cmd) => (await mem()).memoryForgetCommand(ids, { ...globals(cmd), ...o })));
+  memory.command("edit <id>").description("Change an entry (fields you pass replace the old values)").option("--title <title>", "New title").option("--details <text>", 'New details ("-" reads them from stdin)').option("--file <path>", "Linked files (repeatable; replaces the list)", repeat).option("--tag <tag>", "Tags (repeatable; replaces the list)", repeat).option("--evidence <text>", "New evidence").action(run(async (id, o, cmd) => (await mem()).memoryEditCommand(id, { ...globals(cmd), ...o })));
+  memory.command("stale").description("Entries whose linked files changed since they were recorded or confirmed").action(run(async (_o, cmd) => (await mem()).memoryStaleCommand(globals(cmd))));
+  memory.command("review").description("Walk through unreviewed (agent-written) entries: confirm, forget or skip").action(run(async (_o, cmd) => (await mem()).memoryReviewCommand(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(run(async (_o, cmd) => (await import("./agents-3HTSQGL2.js")).agentsListCommand(globals(cmd))));
-  agents.command("add <agents...>").description('Configure integrations (claude-code, cursor, codex, copilot, gemini-cli, antigravity, windsurf, cline, agents-md, or "all")').action(run(async (names, _o, cmd) => (await import("./agents-3HTSQGL2.js")).agentsAddCommand(names, globals(cmd))));
-  agents.command("remove <agents...>").description("Remove Athena-managed integration files/blocks").action(run(async (names, _o, cmd) => (await import("./agents-3HTSQGL2.js")).agentsRemoveCommand(names, globals(cmd))));
+  agents.command("list", { isDefault: true }).description("Show supported agents and integration status").action(run(async (_o, cmd) => (await import("./agents-DFSNEOP5.js")).agentsListCommand(globals(cmd))));
+  agents.command("add <agents...>").description('Configure integrations (claude-code, cursor, codex, copilot, gemini-cli, antigravity, windsurf, cline, agents-md, or "all")').action(run(async (names, _o, cmd) => (await import("./agents-DFSNEOP5.js")).agentsAddCommand(names, globals(cmd))));
+  agents.command("remove <agents...>").description("Remove Athena-managed integration files/blocks").action(run(async (names, _o, cmd) => (await import("./agents-DFSNEOP5.js")).agentsRemoveCommand(names, 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(run(async (_o, cmd) => (await import("./git-hook-YZNZGAAP.js")).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(run(async (o, cmd) => (await import("./git-hook-YZNZGAAP.js")).gitHookInstallCommand({ ...globals(cmd), review: o.review })));
   gitHook.command("uninstall").description("Remove Athena's pre-commit hook or block").action(run(async (_o, cmd) => (await import("./git-hook-YZNZGAAP.js")).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(run(async (o, cmd) => (await import("./open-2QSZKKUG.js")).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(run(async (o, cmd) => (await import("./activity-P4UUFHWV.js")).activityCommand({ ...globals(cmd), ...o })));
+  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(run(async (o, cmd) => (await import("./open-UJZRYF4E.js")).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(run(async (o, cmd) => (await import("./activity-BKW7G4I5.js")).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(
     run(async (o, cmd) => {
       const g = globals(cmd);
       await (await import("./event-TNT6CQZR.js")).eventCommand({ agent: o.agent, hook: o.hook, cwd: g.cwd, verbose: o.verboseErrors });
     })
   );
-  program.command("clean").description("Remove .athena/ and Athena agent integrations").option("-y, --yes", "Skip confirmation").option("--keep-agents", "Keep agent integration files/blocks").action(run(async (o, cmd) => (await import("./clean-S7PKCOLM.js")).cleanCommand({ ...globals(cmd), ...o })));
+  program.command("clean").description("Remove .athena/ and Athena agent integrations").option("-y, --yes", "Skip confirmation").option("--keep-agents", "Keep agent integration files/blocks").action(run(async (o, cmd) => (await import("./clean-MDBYH62P.js")).cleanCommand({ ...globals(cmd), ...o })));
   program.command("version").description("Print the Athena version").action(run(async (_o, cmd) => {
     if (globals(cmd).json) json({ version: ATHENA_VERSION, node: process.versions.node, platform: process.platform });
     else line(ATHENA_VERSION);
@@ -145,4 +162,4 @@ export {
   buildProgram,
   main
 };
-//# sourceMappingURL=program-V2USHGXN.js.map
+//# sourceMappingURL=program-CWJNGCTZ.js.map