project-athena 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,81 @@
 # Changelog
 
+## 0.3.0 — 2026-09-30
+
+Performance release: work is now proportional to what changed. On a 20,000-file repository (vs 0.2.1): a `sync --check` with nothing changed takes ~0.42 s instead of 2.9 s, `status` 0.14 s instead of 0.34 s, agent hooks start in ~28 ms instead of 112 ms, and peak memory is 20–52% lower in every scenario. The generated `model.json` is unchanged (golden-tested against the 0.2.1 analyzer). Benchmarks: `npm run bench`.
+
+After upgrading, the first run rebuilds `.athena/state.json` in the new format automatically. If you use the pre-commit hook, run `athena git-hook install` again so it checks staged content.
+
+### Performance
+
+- `athena open` reuses parsed `.athena` artifacts: a new `ProjectSession` loads `model.json`, `graph.json`, `security-scan.json` and `state.json` once and re-reads them only when the file changes (inode, size or mtime). The overview, graph, context, security and `athena security` paths share it, and the graph summary checks for `model.json` with a stat instead of parsing and validating the whole model.
+- The event stream (`/api/events`) coalesces bursts into one write per 250 ms (intermediate activity states collapse to the latest), serializes each event once for all clients, and applies backpressure: a client that stops reading gets nothing more until its socket drains, keeps at most 100 queued events (oldest dropped) plus the latest activity, and then receives a `resync` frame with the number of events it missed. At most 16 event streams are open at once (503 beyond that).
+- `GET /api/sync` no longer includes each proposed document's full diff; the Sync page fetches a diff from the new `GET /api/sync/:doc` only when the document is expanded.
+- `athena event` (run by agent hooks on every tool call) starts about 2.5× faster and uses about 40% less memory (p50 112 ms / 100 MB → ~45 ms / 57 MB on the 20k-file benchmark): it no longer loads commander or any other command's dependencies. All other commands load their code on demand, which also lowers memory for `status`, `review` and `sync`.
+- `athena event` no longer loads zod: the paths it needs moved to a dependency-free module (`src/core/paths.ts`). p50 of 10 on an Apple M-series laptop: ~43 ms / 57 MB → ~26 ms / 49 MB. The startup test now fails if zod reaches the event chunk.
+- The CLI is now built with code splitting: `dist/cli.js` is a small entry that loads chunks from `dist/` as needed.
+- Project graph building is linear in the number of edges (edge de-duplication, import traversal and package lookups no longer rescan everything); 50k import edges now build in about 0.1 s instead of 3.2 s, and 100k in about 0.25 s. Graph output is unchanged. `athena graph --node` and task-context expansion use a per-graph index.
+- Git metadata is collected with concurrent `git` processes, the `git --version` check runs once per process, and history is read once, bounded to the last 180 days / 2,000 commits. The contributor count in `model.json` (`git.contributorCount`) now counts authors in that window instead of the whole history.
+- Nested `.gitignore` matching only consults the path's own ancestor directories instead of every `.gitignore` in the project.
+- Analysis is staged and incremental: a stat-only walk, one content pass in which every new or changed file is read exactly once (hashing and all per-file detector work share the same bytes), then an aggregate stage that builds the model from cached per-file facts. Unchanged files are not read at all. The generated `model.json` is unchanged (guarded by a golden test against the 0.2.1 analyzer).
+- 20,000-file benchmark (Apple M-series, vs 0.2.1): warm `sync --check` 2.9 s → 0.50 s (×5.8), `sync --check` after a one-file change 2.9 s → 0.49 s, cold `init` 3.5 s → 2.3 s; peak memory lower in every scenario (warm sync 195 → 162 MB). 200,000 files: warm `sync --check` 46 s → 4.1 s, cold `init` 51 s → 40 s, peak memory 730 → 589 MB (init).
+- File text is no longer cached without limit during analysis: a 64 MB byte-budgeted LRU serves the rare aggregate-stage lookup, and text is dropped as soon as a file's facts are computed.
+- Sync planning goes through one scheduler per project (`src/services/scheduler.ts`): at most one analysis runs at a time, requests that arrive meanwhile share a single follow-up run, and new file changes can cancel a plan that is still in progress (planning is read-only). The file watcher, the local server (`POST /api/sync/check`, review, re-plans after edits) and the MCP server use it, so concurrent checks no longer start concurrent full analyses; applying a proposal and a full re-analysis from the web UI never interleave with planning.
+- While `athena open` (or another watcher) is running, a plan after file changes re-checks only the paths the watcher reported instead of walking the whole tree (about 265 → 170 ms for a one-file change in the 20k-file benchmark, in-process). It walks the whole tree on the first plan, after a `.gitignore`, `.athena/config.json` or `.git/info/exclude` change, a directory add/delete, a watcher error, when the project contains symbolic links, and at least every 5 minutes.
+- `athena status` (and the server's status, the MCP `get_project_changes` tool) no longer walks the tree: it stats the files in the cached index and asks Git for new files (`git ls-files`, `git status --porcelain=v2 -z`). 254 → ~140 ms on the 20k-file benchmark; ~0.85 s for 200k files. The output is unchanged; it falls back to walking when Git can't give the same answer (no Git or no index, `include` patterns, ignore rules changed since the last analysis, submodules, nested repositories, symlinked directories).
+- The server's status report is cached until the watcher reports a change (with a 30 s safety TTL, instead of a flat 3 s), and concurrent requests share one computation.
+
+### Changed
+
+- **The pre-commit hook checks what is being committed.** New `athena sync --check --staged` compares the `.athena/` knowledge as staged with what Athena generates from the code as staged, so untracked files (a scratch file, a local `.env`) and unstaged edits no longer block a commit, and a staged change reverted in the working tree still counts. It mirrors the index into `.athena/cache/staged/` (gitignored, updated incrementally): files that match the working tree are sparse stand-ins that reuse the last analysis's hashes and the facts cache, so only staged changes are read (20k files, warm: ~0.54 s vs ~0.44 s for the working-tree check). When `athena sync` already wrote a document that isn't staged, the output says which files to `git add`; JSON output has `staged`, `inSync`, `stale` and per-document details. Exit code 3 when `.athena/` is not in the index; 2 when the index has unresolved conflicts. `athena git-hook install` writes the new command (re-run it to update an existing hook; `athena git-hook status` shows `staged: false` and a hint for old hooks), and the suggested husky/lefthook line is now `npx --no-install athena sync --check --staged`.
+- The manifest detector is split into one module per ecosystem (`src/core/analyzer/detectors/manifests/`); `model.json` output is byte-identical.
+- Files modified within 2 seconds of the file index being written are re-read on the next run instead of trusted by size and mtime (Git's "racily clean" rule), so a same-size edit in the same clock tick is never missed.
+- The local server is split into route modules (`src/server/routes/*`) sharing one server context; routes, authentication, Host/Origin checks, security headers, CSP and rate limiting are unchanged.
+- `GET /api/sync` returns the proposal without `documents[].diff` (reasons, changed and preserved sections, additions/deletions and `diffTruncated` are still included). New `GET /api/sync/:doc[?planId=…]` returns one proposed document's diff; the id must be a knowledge document in the current proposal (404 otherwise, 409 when `planId` is stale). `POST /api/sync/check` still returns the full plan.
+- A corrupted `model.json` now gives a clear error with a hint (`model.json is corrupted (…)`, run `athena analyze`) instead of an internal error when starting a security scan from the web UI.
+- Test, source, auth, API and schema path patterns now come from one module (`src/core/patterns.ts`). `athena review` recognizes more test layouts (`integration_tests/`, `androidTest/`, `test_driver/`, `*_test.dart`), and change impact recognizes the same test files as review plus test runner configs.
+- New per-file facts cache in `.athena/cache/v1/` (gitignored; `cache/` is added to `.athena/.gitignore`, also for existing projects). Facts are keyed by content hash and discarded automatically when detector versions or the `ignore`/`include`/`maxFileBytes` settings change. Safe to delete; `athena clean` removes it with `.athena/`.
+- `state.json` schema 2: the file index moved to `.athena/cache/v1/files.json` (full SHA-256 hashes), so `state.json` stays small regardless of repository size. Version-1 files are migrated automatically on first read; older Athena versions will treat a v2 `state.json` as corrupted and rebuild it.
+- `athena init` creates the machine-local fingerprint salt (`.athena/local.json`) together with `.athena/`, so secret-finding fingerprints in the first `model.json` already use the project's stable key.
+
+## 0.2.1 — 2026-09-30
+
+Security release. Upgrading is recommended for everyone. After upgrading, run `athena sync` once (the `security.md` format changed) and, if you use the pre-commit hook with `--review`, run `athena git-hook install --review` again so it reviews staged changes.
+
+### Breaking
+
+- `athena review --base <ref>` exits with code 2 when the base can't be resolved or has no merge base with HEAD. Shallow CI clones need full history, e.g. `actions/checkout` with `fetch-depth: 0`.
+- `ai.baseUrl` and `ai.consent` in the committed `.athena/config.json` are now ignored (with a warning in `athena ai status`, `athena ai enrich` and `athena doctor`). Move them to the environment (`ATHENA_AI_BASE_URL`, `ATHENA_AI_CONSENT=1`), `.athena/local.json` (gitignored), or your user config (`~/.config/athena/config.json`, `$XDG_CONFIG_HOME/athena/config.json`, or `%APPDATA%\athena\config.json` on Windows). `provider`, `model`, `mode` and `maxChars` still work from `.athena/config.json`.
+- `--fail-on` now fails on unrated findings by default (`--unrated warn` to relax).
+- `security-scan.json` and `athena security --json`: severity `unknown` has been renamed to `unrated`, in both findings and `counts`. Old scan files are still read. Tools that run once per input have a new optional `target` field (for example `pip-audit` per requirements file).
+- The `security.md` format changed: the Fingerprint column was removed from Secret Management. Run `athena sync` to update it.
+
+### Security
+
+- `athena security --fail-on` now also fails when an audit tool ran but failed or timed out, since nothing was checked. A tool that isn't installed is still only reported. The web UI shows `unrated` findings.
+- **AI credential exfiltration**: a repository could set its own `ai.baseUrl` and `ai.consent` in `.athena/config.json` and receive your API key and knowledge. Both are now read only from machine-local sources (env > `.athena/local.json` > user config), providers refuse a base URL without a trusted source, and an Ollama endpoint that isn't loopback counts as remote and needs consent.
+- **Local server**: per-client rate limiting on `/api/*` (token bucket, 30 req/s, burst 120, 429 when exceeded); `--allow-remote` keeps the Host/Origin allowlist (bind address plus loopback) instead of disabling it, and warns that the connection is plain HTTP; `/api/context` clamps `maxChars` to 200,000; a failed security-scan start (e.g. missing `model.json`) no longer leaves every later scan stuck at 423; shutdown no longer hangs on open event streams.
+- **MCP**: every tool that returns repository content redacts secret-looking values and wraps the text in `<athena-document path="…" trust="untrusted-data">` delimiters with a note that it is project data, not instructions (embedded delimiters are neutralized).
+- **Agent hooks**: generated hook scripts quote `ATHENA_HOOK_COMMAND`, the agent name and the hook argument (POSIX single quotes; cmd.exe double quotes with `%` doubled), so paths with spaces, quotes, `$` or `&` can't break or inject into the script.
+- **Agent activity log**: commands and messages are additionally masked for `Authorization: Bearer|Basic …`, `--password …`, `mysql -p…` and `scheme://user:password@` credentials; rotation renames the log to `.agent-events.1.jsonl` (one generation kept) instead of rewriting it, so concurrent appends are never lost, and recent-event reads include the previous generation.
+- **GitHub Action**: the PR comment is only updated when it was written by `github-actions[bot]` and carries the versioned `<!-- athena-review:v1 -->` marker (the old marker is still recognized from the same bot), so another user's comment can't be hijacked. Review findings now also produce `::error`/`::warning` file annotations (with line numbers where available, escaped, never secret values).
+- **Web UI**: the Security and graph views refresh after `security.*` and `graph.*` events.
+- `athena review` scans each run of consecutive added lines as one block, so multi-line secrets such as PEM private keys are now flagged (at the line where they start, never with the value).
+- `athena review` fails closed on Git errors: a failing `git` command, an unknown `--base`, or a missing merge base (shallow clone) is now an error (exit 2) instead of an empty, "clean" review. Ctrl+C stops running `git` processes.
+- The diff is streamed with a 64 MB budget; a larger diff fails the review instead of being silently truncated.
+- `--base` now compares `merge-base(base, HEAD)..HEAD` for both the file list and the patch, so commits that exist only on the base branch no longer appear in the review.
+- The dependency check uses the analyzer's manifest parsers (`name =` / `version =` are no longer reported as dependencies), and a new manifest reports all of its dependencies.
+- New `athena review --staged` reviews the index (contents read from Git, untracked files ignored). The `--review` pre-commit hook now runs `athena review --staged --no-sync`, so unstaged or untracked files (such as a local `.env`) no longer block commits while staged secrets still do, and a review that can't run blocks the commit with its own message. Re-run `athena git-hook install --review` to update an installed hook.
+- Untracked files are read once, never through a symlink that points outside the project, and only up to 512 KB. Files that could not be checked are listed in a `skipped` warning (JSON: `incomplete`, `skipped`), and the review no longer says it found nothing to flag.
+- `athena security --fail-on` now counts findings the tool did not rate. pip-audit and govulncheck never report severity, so these findings were stored as `unknown` and never failed the build. They are now `unrated` and fail by default; `--unrated warn` reports them without failing.
+- pnpm audit output is parsed in pnpm's own advisories format. Before this, every pnpm project was reported as having no vulnerable dependencies.
+- An npm audit that reports an error (for example when offline) is now marked `failed` with npm's message. Before, it was reported as a clean audit. The same applies to empty or unrecognised output from any audit tool. npm exiting 1 because it found vulnerabilities still counts as a successful run.
+- govulncheck's multi-line JSON output is now parsed, and a vulnerability is reported only when govulncheck returns a finding for it. The title says whether the vulnerable code is called, only imported, or only required.
+- pip-audit now audits each `requirements*.txt` (`-r <file>`, at most 10), or a PEP 621 `pyproject.toml` as a project path. It no longer audits whichever Python environment is active. With nothing to audit, pip-audit is reported as `unavailable` with the reason "no requirements file to audit".
+- `athena security` scans the project files for secrets on every run. Before, it took the secret count from the cached `model.json`, so the count could be out of date.
+- Rewrote the secret patterns to remove catastrophic backtracking (ReDoS). `generic-secret-assignment` took over 1 s on 40 KB of crafted input. It now finds a bounded quoted value first, then checks the identifier before it (at most 64 chars) for a keyword. Private keys are matched by finding the BEGIN header and then the END within 16 KB. Open-ended token patterns now use bounded or lookbehind-anchored matches. Generic keyword patterns skip lines longer than 4096 characters. CI checks every pattern for time on crafted input and with the `recheck` ReDoS analyzer.
+- `security.md`, which is committed, no longer lists a fingerprint for each secret. The old value was an unsalted, truncated SHA-256 of the secret, so anyone could test guessed values against it offline. Secret fingerprints in `model.json` are now an HMAC keyed with the per-machine salt in `.athena/local.json` (gitignored), or with a random per-process key.
+
 ## 0.2.0 — 2026-09-26
 
 - **Website link**: the terminal header, footer and next steps now link to https://athena.sabari.me, which is also the package homepage.

package/README.md

@@ -104,6 +104,7 @@ Apply updates to 2 documents? [y/N]
 - **Your edits are still safe.** Developer-edited sections are preserved and listed. Applying is refused if a document changed after the proposal was made.
 - When files change but no knowledge is affected, only the local index is refreshed.
 - `athena sync --check` exits with 1 when knowledge is out of date, which is useful in CI or a pre-commit hook (see [Use in CI and git hooks](#use-in-ci-and-git-hooks)). Change hotspots come from Git history and move with every commit, so the check ignores them; `athena sync` still refreshes them.
+- `athena sync --check --staged` checks what a commit would contain instead of the working tree: the `.athena/` knowledge as staged against the code as staged. Untracked files and unstaged edits don't count. This is what the pre-commit hook runs.
 - Ignore rules: defaults, root and nested `.gitignore` files, `.git/info/exclude`, and `.athena/config.json`.
 
 ## Watching what agents do
@@ -192,16 +193,22 @@ A complete workflow is in [examples/github-workflow.yml](examples/github-workflo
 ```text
 $ athena git-hook install
 ✓ Installed the pre-commit hook (knowledge check) at .git/hooks/pre-commit
-Commits are blocked when .athena/ knowledge is out of date. Teammates without Athena installed are not blocked.
-Using husky, lefthook or pre-commit? Add `npx --no-install athena sync --check` to its pre-commit config instead.
+Commits are blocked when the staged .athena/ knowledge is out of date for the staged code (untracked and unstaged files are ignored). Teammates without Athena installed are not blocked.
+Using husky, lefthook or pre-commit? Add `npx --no-install athena sync --check --staged` to its pre-commit config instead.
 
 $ git commit -m "Add refunds"
-Proposed: api.md, security.md
-Knowledge is out of date. Run `athena sync` to review and apply.
-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`).
+  ~ api.md       endpoints
+  ~ security.md  attack-surface
+Staged knowledge is out of date for the staged code. Run `athena sync`, then stage .athena/.
+athena: commit blocked: staged .athena/ knowledge is out of date. Run `athena sync`, stage .athena/ and commit again (or skip once with `git commit --no-verify`).
 ```
 
-- `athena git-hook install --review` also runs `athena review` and blocks commits that add possible secrets or env files. It checks the whole working tree (staged, unstaged and untracked files that aren't ignored), not only what is staged.
+- The hook checks the commit, not the working tree: an untracked scratch file, a local `.env` or an unstaged edit never blocks a commit, and a change you staged and then reverted in the working tree still counts. If `athena sync` already updated a document but it isn't staged, the output says which files to `git add`.
+- The check mirrors the index into `.athena/cache/staged/` (gitignored). Files that match the working tree are stand-ins that reuse the last analysis and the facts cache, so only staged changes are read; the directory is updated incrementally and is safe to delete. Submodules are checked as they are in the working tree. Local env files that aren't committed (such as `.env`) are machine-local: the check accepts staged knowledge written with or without them.
+- Knowledge generated by `athena sync` describes the working tree. If untracked files that are not gitignored change it (a new route in a file you don't commit), the staged check reports the difference; commit, ignore or stash those files before syncing.
+- Hooks installed by earlier versions check the working tree; `athena git-hook status` points them out and `athena git-hook install` updates them.
+
+- `athena git-hook install --review` also runs `athena review --staged` and blocks commits that add possible secrets or env files. Like the knowledge check, it only looks at what is staged.
 - The hook is a `#!/bin/sh` script in the directory Git actually uses (`git rev-parse --git-path hooks`), so `core.hooksPath` and linked worktrees work. For a project in a subfolder of the repository, the hook runs Athena there.
 - If `athena` is not on `PATH`, the hook prints a note and lets the commit through, so it never blocks teammates who don't use Athena.
 - **An existing pre-commit hook is kept.** If it is a shell script, Athena adds its block between `# athena:start` and `# athena:end` right after the shebang, so it runs before your own commands. Athena refuses to touch hooks written in other languages and hooks it recognizes as managed by husky, lefthook or pre-commit (from `core.hooksPath` or the hook's contents), and prints the line to add instead.
@@ -211,7 +218,7 @@ athena: commit blocked: .athena/ knowledge is out of date. Run `athena sync`, st
 
 ```bash
 # .husky/pre-commit
-npx --no-install athena sync --check
+npx --no-install athena sync --check --staged
 ```
 
 ```yaml
@@ -219,7 +226,7 @@ npx --no-install athena sync --check
 pre-commit:
   commands:
     athena:
-      run: npx --no-install athena sync --check
+      run: npx --no-install athena sync --check --staged
 ```
 
 ### Example project
@@ -246,7 +253,7 @@ Documents to read
 
 **MCP.** `athena mcp` serves this to any MCP-capable agent over stdio, and `athena agents add` registers it (`.mcp.json` for Claude Code, `.cursor/mcp.json` for Cursor, `[mcp_servers.athena]` in `.codex/config.toml` for Codex, `servers.athena` in `.vscode/mcp.json` for GitHub Copilot in VS Code, `mcpServers.athena` in `.gemini/settings.json` for Gemini CLI). Tools: `get_relevant_context`, `get_project_context`, `get_architecture`, `get_database_schema`, `get_api_context`, `get_security_context`, `get_project_rules`, `get_knowledge_document`, `get_project_changes`, `get_project_graph`, `get_athena_status`, `update_knowledge`.
 
-The server is **read-only by default**: `update_knowledge` reports what would change and refuses to write unless you start it with `--allow-write`.
+The server is **read-only by default**: `update_knowledge` reports what would change and refuses to write unless you start it with `--allow-write`. Repository content it returns is passed through the secret redactor and wrapped in `<athena-document … trust="untrusted-data">` delimiters, so agents can tell project data from instructions.
 
 ## Optional AI
 
@@ -258,8 +265,9 @@ athena ai enrich --dry-run        # show exactly what would be sent
 athena ai enrich --consent        # ask for suggestions
 ```
 
-- **Providers:** Anthropic, OpenAI, Google, and Ollama for a fully local setup. Configure in `.athena/config.json` under `"ai"`; API keys come from environment variables only and are never written to disk by Athena.
-- **Consent first.** Nothing leaves your machine without `--consent` (or `"consent": true`). `--dry-run` prints the provider, endpoint, documents and exact size first.
+- **Providers:** Anthropic, OpenAI, Google, and Ollama for a fully local setup. Choose `provider`, `model` and `maxChars` in `.athena/config.json` under `"ai"`; API keys come from environment variables only and are never written to disk by Athena.
+- **Trusted settings stay on your machine.** `.athena/config.json` is committed, so anyone who can push to the repository controls it. The two settings that decide where your API key and knowledge go — `baseUrl` (a custom endpoint or remote Ollama) and `consent` — are therefore only read from machine-local sources, in this order: environment variables `ATHENA_AI_BASE_URL` and `ATHENA_AI_CONSENT=1`; `.athena/local.json` (gitignored), e.g. `{ "ai": { "baseUrl": "https://proxy.internal", "consent": true } }`; your user config at `~/.config/athena/config.json` (`$XDG_CONFIG_HOME/athena/config.json`, or `%APPDATA%\athena\config.json` on Windows) with the same `"ai"` shape. If `.athena/config.json` sets them, Athena ignores them and says so in `athena ai status`, `athena ai enrich` and `athena doctor`.
+- **Consent first.** Nothing leaves your machine without consent: `athena ai enrich --consent`, `ATHENA_AI_CONSENT=1`, or `"consent": true` in `.athena/local.json` or your user config. An Ollama endpoint that isn't `localhost`/`127.0.0.1`/`::1` counts as remote and needs consent too. `--dry-run` prints the provider, endpoint, documents and exact size first.
 - **Knowledge only, redacted.** Athena sends your `.athena` documents — never source code — after the secret redactor, and refuses to send anything that still looks like a secret.
 - **Output is INFERRED.** Suggestions land in `.athena/ai-suggestions.md` (gitignored), clearly labeled and attributed to the model. Nothing is added to your knowledge base automatically.
 

package/dist/activity-P4UUFHWV.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import {
+  listAgents
+} from "./chunk-JY6BFIJJ.js";
+import {
+  readRecentEvents,
+  summarizeSessions
+} from "./chunk-65TSRDQ3.js";
+import {
+  c,
+  dim,
+  heading,
+  isJson,
+  json,
+  line,
+  relativeTime,
+  sym
+} from "./chunk-Z6QWMJLK.js";
+import {
+  requireProjectRoot
+} from "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import "./chunk-JCGDR4UV.js";
+import "./chunk-2RS6TA3D.js";
+import "./chunk-GHFRQAYT.js";
+import "./chunk-673EPYYH.js";
+import "./chunk-FQEGEVLY.js";
+import "./chunk-2DY4PUR4.js";
+import "./chunk-IQQBAWSM.js";
+import "./chunk-AD4OZCU2.js";
+import "./chunk-INT3IGMQ.js";
+import "./chunk-XW3MLHI2.js";
+import "./chunk-EUPETUWA.js";
+
+// src/cli/commands/activity.ts
+var STATE_COLOR = {
+  ANALYZING: c.cyan,
+  PLANNING: c.magenta,
+  CODING: c.blue,
+  TESTING: c.yellow,
+  REVIEWING: c.cyan,
+  SUCCESS: c.green,
+  IDLE: c.dim
+};
+async function activityCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const limit = Math.min(Math.max(Number(opts.limit ?? 30) || 30, 1), 500);
+  const all = await readRecentEvents(root, 500);
+  const events = (opts.agent ? all.filter((e) => e.agent === opts.agent) : all).slice(-limit);
+  if (isJson()) {
+    json({ events, sessions: summarizeSessions(all) });
+    return;
+  }
+  heading("AI Agent Activity");
+  line();
+  if (!events.length) {
+    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, codex, copilot, gemini-cli) to record agent activity."));
+    return;
+  }
+  for (const e of events) {
+    const time = new Date(e.ts).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit", hour12: false });
+    const color = STATE_COLOR[e.state] ?? ((s) => s);
+    line(`${dim(time)}  ${color(sym.dot)} ${c.bold(e.agent)} ${dim("\xB7")} ${e.message}`);
+  }
+  line();
+  for (const s of summarizeSessions(all).slice(0, 5)) {
+    line(dim(`${s.agent} ${s.session ? `(${s.session.slice(0, 8)})` : ""}: ${s.events} events, last ${relativeTime(s.lastEventAt)}`));
+  }
+  line(dim("Only hook-reported tool use is shown. Athena cannot see agent reasoning."));
+}
+export {
+  activityCommand
+};
+//# sourceMappingURL=activity-P4UUFHWV.js.map

package/dist/agents-3HTSQGL2.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import {
+  configureAgents,
+  listAgents,
+  removeAgents
+} from "./chunk-JY6BFIJJ.js";
+import "./chunk-65TSRDQ3.js";
+import {
+  c,
+  dim,
+  heading,
+  isJson,
+  json,
+  line,
+  ok,
+  sym
+} from "./chunk-Z6QWMJLK.js";
+import {
+  requireProjectRoot
+} from "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import "./chunk-JCGDR4UV.js";
+import "./chunk-2RS6TA3D.js";
+import "./chunk-GHFRQAYT.js";
+import "./chunk-673EPYYH.js";
+import "./chunk-FQEGEVLY.js";
+import "./chunk-2DY4PUR4.js";
+import "./chunk-IQQBAWSM.js";
+import "./chunk-AD4OZCU2.js";
+import "./chunk-INT3IGMQ.js";
+import "./chunk-XW3MLHI2.js";
+import "./chunk-EUPETUWA.js";
+
+// src/cli/commands/agents.ts
+async function agentsListCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const rows = await listAgents(root);
+  if (isJson()) {
+    json(rows);
+    return;
+  }
+  heading("AI Agent Integrations");
+  line();
+  for (const r of rows) {
+    const icon = r.configured ? c.green(sym.dot) : c.dim(sym.ring);
+    line(`${icon} ${c.bold(r.name)} ${dim(`(${r.id})`)} \u2014 ${r.configured ? "configured" : "not configured"}${r.detectedInProject ? dim(` \xB7 detected: ${r.evidence.join(", ")}`) : ""}`);
+    line(`  ${dim(r.note)}`);
+  }
+  line();
+  line(dim('"Configured" means Athena instruction files are in place. Agents with hooks also report their tool use \u2014 see `athena activity`.'));
+}
+async function agentsAddCommand(names, opts) {
+  const root = await requireProjectRoot(opts);
+  const results = await configureAgents(root, names);
+  if (isJson()) json({ ok: true, agents: results });
+  else for (const r of results) ok(`${r.id}: ${r.files.map((f) => `${f.path} (${f.action})`).join(", ")}`);
+}
+async function agentsRemoveCommand(names, opts) {
+  const root = await requireProjectRoot(opts);
+  const removed = await removeAgents(root, names);
+  if (isJson()) json({ ok: true, removed });
+  else ok(removed.length ? `Removed Athena integration from ${removed.join(", ")}` : "Nothing to remove");
+}
+export {
+  agentsAddCommand,
+  agentsListCommand,
+  agentsRemoveCommand
+};
+//# sourceMappingURL=agents-3HTSQGL2.js.map

package/dist/ai-ASL4FFQ7.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import {
+  aiStatus,
+  buildEnrichPayload,
+  enrich
+} from "./chunk-RXNRMIZP.js";
+import {
+  c,
+  dim,
+  heading,
+  isJson,
+  json,
+  line,
+  spinner,
+  sym,
+  warn
+} from "./chunk-Z6QWMJLK.js";
+import {
+  requireProjectRoot
+} from "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import "./chunk-PVCIGUIT.js";
+import "./chunk-JCGDR4UV.js";
+import "./chunk-FQEGEVLY.js";
+import "./chunk-2DY4PUR4.js";
+import "./chunk-IQQBAWSM.js";
+import "./chunk-AD4OZCU2.js";
+import "./chunk-EUPETUWA.js";
+
+// src/cli/commands/ai.ts
+var CONSENT_SOURCE = { env: "ATHENA_AI_CONSENT", local: ".athena/local.json", user: "user config" };
+async function aiStatusCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const status = await aiStatus(root);
+  if (isJson()) {
+    json(status);
+    return;
+  }
+  heading("AI providers");
+  line();
+  for (const w of status.warnings) warn(c.yellow(w));
+  if (status.warnings.length) line();
+  for (const p of status.providers) {
+    const icon = p.availability.ok ? c.green(sym.ok) : c.dim(sym.ring);
+    line(`${icon} ${c.bold(p.name)}${p.selected ? c.cyan("  (selected)") : ""}`);
+    line(`    ${dim(`${p.remote ? "sends data to" : "runs locally at"} ${p.availability.endpoint} \xB7 default model ${p.defaultModel}`)}`);
+    if (!p.availability.ok) line(`    ${dim(p.availability.reason ?? "")}`);
+  }
+  line();
+  line(`Consent to send project knowledge: ${status.consent ? c.green(`granted (${CONSENT_SOURCE[status.consentSource ?? "env"]})`) : c.yellow("not granted")}`);
+  line(dim("Athena never needs AI: analysis, sync, context and MCP are deterministic. AI only produces INFERRED suggestions you review."));
+  line(dim('Configure in .athena/config.json \u2192 "ai": { "provider": "ollama" } for a fully local setup.'));
+  line(dim("Endpoint (baseUrl) and consent are machine-local only: ATHENA_AI_BASE_URL / ATHENA_AI_CONSENT=1, .athena/local.json, or ~/.config/athena/config.json."));
+}
+async function aiEnrichCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const docs = opts.docs?.split(",").map((d) => d.trim()).filter(Boolean);
+  const payload = await buildEnrichPayload(root, { docs });
+  if (!isJson()) {
+    heading("AI enrichment");
+    line();
+    for (const w of payload.warnings) warn(c.yellow(w));
+    if (payload.warnings.length) line();
+    line(`Provider:  ${c.bold(payload.provider.name)} ${dim(`(${payload.model})`)}`);
+    line(`Sends to:  ${payload.remote ? c.yellow(payload.endpoint) : c.green(`${payload.endpoint} (local)`)}`);
+    line(`Content:   ${payload.documents.join(", ")} ${dim(`(${payload.chars} characters, redacted knowledge only \u2014 no source code)`)}`);
+    line();
+  }
+  if (opts.dryRun) {
+    if (isJson()) json({ ...payload, provider: payload.provider.id });
+    else line(dim("Dry run \u2014 nothing was sent."));
+    return 0;
+  }
+  const sp = spinner(`Asking ${payload.provider.name}...`);
+  let result;
+  try {
+    result = await enrich(root, { docs, consent: opts.consent, signal: opts.signal });
+    sp.succeed(`Suggestions written to .athena/${result.file}`);
+  } catch (err) {
+    sp.stop();
+    throw err;
+  }
+  if (isJson()) json(result);
+  else {
+    line();
+    line(result.markdown.split("\n").slice(0, 40).join("\n"));
+    line();
+    line(dim(`Full suggestions: .athena/${result.file} (gitignored). These are INFERRED \u2014 nothing was added to your knowledge base.`));
+  }
+  return 0;
+}
+export {
+  aiEnrichCommand,
+  aiStatusCommand
+};
+//# sourceMappingURL=ai-ASL4FFQ7.js.map

package/dist/analyze-F3YOILNL.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import {
+  parseAgentsOption,
+  printSummary,
+  runWithProgress,
+  summarize
+} from "./chunk-DOQMAZL5.js";
+import {
+  printHeader
+} from "./chunk-SHKXELUX.js";
+import {
+  isJson,
+  json
+} from "./chunk-Z6QWMJLK.js";
+import {
+  requireProjectRoot
+} from "./chunk-XFN7UZCS.js";
+import "./chunk-KBO7XRBW.js";
+import "./chunk-SJOOXO34.js";
+import "./chunk-PANVPNYF.js";
+import "./chunk-ELKFRTZT.js";
+import "./chunk-2R6PXY6Z.js";
+import "./chunk-PVCIGUIT.js";
+import "./chunk-OLPSEQS5.js";
+import "./chunk-JCGDR4UV.js";
+import "./chunk-2RS6TA3D.js";
+import "./chunk-GHFRQAYT.js";
+import "./chunk-673EPYYH.js";
+import "./chunk-FQEGEVLY.js";
+import "./chunk-2DY4PUR4.js";
+import "./chunk-IQQBAWSM.js";
+import "./chunk-AD4OZCU2.js";
+import "./chunk-INT3IGMQ.js";
+import "./chunk-XW3MLHI2.js";
+import "./chunk-EUPETUWA.js";
+
+// src/cli/commands/analyze.ts
+async function analyzeCommand(opts) {
+  const root = await requireProjectRoot(opts);
+  const agents = parseAgentsOption(opts.agents, false);
+  printHeader();
+  const result = await runWithProgress(root, { mode: "analyze", force: opts.force, agents, signal: opts.signal });
+  if (isJson()) json(summarize(result, root, false));
+  else printSummary(result, false, "analyze");
+}
+export {
+  analyzeCommand
+};
+//# sourceMappingURL=analyze-F3YOILNL.js.map