project-athena 0.3.0 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,61 @@
 # Changelog
 
+## 0.5.0 — 2026-10-03
+
+Unified findings: every security check (secrets, dependency audits, review checks) now reports into one findings model with value-free fingerprints, an honest coverage record, and a quality gate driven by an optional committed policy, baseline and triage. New `athena scan` writes text, JSON, Markdown, GitHub annotations or SARIF 2.1.0 for code scanning, and `--policy-from <base>` keeps a pull request from quietly weakening the gate. Static analysis rules arrive in 0.6.0; until then reports say plainly that SAST and IaC are not covered.
+
+### `athena scan` and friends
+
+- New `athena scan`: runs the secret scanner and dependency audits over the whole project, or with `--base <ref>` / `--staged` / `--changed` over a change (adding the review checks), then applies the policy, baseline, triage and inline suppressions and evaluates the quality gate. Exit 1 when the gate fails (`--no-fail` to report only), 2 when Git can't compute the requested change. `--only secrets,deps,review`, `--format text|json|markdown|github|sarif`, `-o <file>`, gate overrides `--fail-on`, `--min-confidence`, `--unrated`, plus `--no-baseline`, `--policy-from <ref>` and `--offline` (audits are skipped and reported as skipped). Full-project scans are saved to `.athena/findings.json`.
+- New `athena baseline show|create|update|prune`, `athena findings list|show|triage` (fingerprint prefixes of 6+ characters; a reason is required and committed) and `athena explain <ruleId>` / `athena scan --list-rules`.
+- New MCP tool `findings`: a read-only summary of the last scan (gate, ratings, coverage gaps, active findings with fingerprints), fenced as untrusted data and never containing secret values. It never starts a scan.
+- `athena security` keeps its flags, output and `--json` shape; it now also writes `.athena/findings.json`.
+
+### Unified findings: secrets, dependencies and review checks
+
+- New `.athena/findings.json` (gitignored): every security check now reports into one findings model with stable, value-free fingerprints, severity (`critical`…`info`, plus `unrated`), confidence, a FACT/DETECTED/INFERRED label, CWE, location or package, the engine that reported it, and a coverage record per engine (files scanned and skipped, tools unavailable/failed/timed out/skipped offline).
+- Secrets: one `secret/<pattern>` finding per match with file, line and column. Private keys and AWS/GCP/Azure credentials are `critical`, other known token formats `high`, keyword heuristics `medium` and marked *potential* (low confidence). Fingerprints hash the line with the matched value masked, so they survive rotating the value and reveal nothing about it; no secret value is ever written.
+- Dependency audits: one `dependency/vulnerable-package` finding per package and advisory (FACT, attributed to `npm-audit`, `pnpm-audit`, `pip-audit`, `govulncheck`, `cargo-audit` or `composer-audit`), with version, lockfile/target, advisory ids, vulnerable range, fixed version and CWE where the tool reports them. `moderate` is now `medium`; a missing severity stays `unrated`. npm packages that are only vulnerable through another reported package are not counted twice.
+- `athena review --json` gains a `scan` object (`scan.findings`, `scan.coverage`) with the checks as `review/<check>` findings (blocker → high, warning → medium, info → info) and added secrets as `secret/*` findings at the exact line. The existing `findings` list, human output and exit codes are unchanged.
+- `athena security` runs on the new scanners and writes both `.athena/findings.json` and the legacy `.athena/security-scan.json` (still used by the web UI and `security.md`). Flags, output, `--fail-on` and `--unrated` behave as before; `--json` keeps the v1 shape — the unified shape will be `athena scan --format json`.
+- A project that only has a `security-scan.json` from an older version is read as findings (its secret count becomes a coverage note, since v1 recorded no lines).
+
+### Policy, baseline, triage and quality gate
+
+- `.athena/policy.json` (optional, committed; `schemaVersion: 1`): `gate` (`failOn` severity, default `high`; `minConfidence`, default `medium`; `unrated: fail|warn`, default `fail`; `scope: new|all`, default `new`; gated `categories`, default secret, dependency, sast, iac, review), per-rule `rules` (`"off"` or a `severity`/`confidence` override; exact ids or `family/*` prefixes), `paths.exclude`/`paths.tests` globs, `licenses.deny`/`warn`, and `external` engines (`semgrep`, `gitleaks`, `trivy`, `osv-scanner`: `auto|off`; `network: allow|deny`). A missing file means defaults. An invalid file, including an unknown key, is an error that names the offending path. It is never silently ignored.
+- `.athena/baseline.json` (committed): records findings that already exist so that only new ones fail the gate (scope `new`). Baselined findings stay visible and still count in ratings. Entries hold only value-free fingerprints, rule ids and files. Pruning needs a full scan and keeps entries of any category whose engine failed or did not run, because a broken engine reports nothing and that must not read as "fixed".
+- `.athena/triage.json` (committed): a reviewed decision per finding (`safe`, `false-positive`, `accepted-risk`, `fixed`, `to-review`), similar to SonarQube's hotspot review. Every decision needs a reason (at most 500 characters). A reason that looks like it contains a secret is refused, and the value is never echoed. `to-review` keeps the finding open.
+- Inline suppressions: `athena-ignore <ruleId> -- <reason>` in a `//`, `#`, `/* */`, `<!-- -->` or `--` comment on the finding's line or the line above. Each comment names one exact rule. A suppression without a reason is ignored and reported as an `info` finding (`review/suppression-without-reason`). A comment with no valid rule id is reported as `review/invalid-suppression`.
+- Every finding gets a status on each run (never stored): `open`, `baselined`, `suppressed`, `triaged:<safe|false-positive|accepted-risk|fixed>` or `excluded`.
+- Quality gate: fails on active findings in gated categories at or above `failOn` with at least `minConfidence` confidence. Unrated findings follow `gate.unrated`. With scope `new`, baselined findings are skipped. The gate also fails when an engine for a gated category failed or timed out, and the result says so explicitly, because an engine that broke checked nothing. Unavailable or skipped engines, and gated categories that nothing scanned, are listed as warnings.
+- Ratings A–E per category, based on the worst active finding: A none, B low/info, C medium, D high, E critical. Unrated counts as D, or C under `unrated: warn`. Each rating comes with a basis ("N rules across <languages>; X files not covered") and no numeric score. A category is not rated when no engine ran for it or one of its engines failed.
+- Anti-tamper for CI (`policyFrom: <ref>`): the gate uses the policy, baseline and triage committed at the base ref (missing there means defaults). Every change to them since `merge-base(ref, HEAD)`, and every added `athena-ignore` comment (tracked or untracked), is reported as `review/policy-weakened`. Severity is `high` when the change relaxes the gate (a higher `failOn` or `minConfidence`, rules turned off or downgraded, new excludes, fewer gated categories, engines turned off, added baseline entries, new closing triage decisions, added suppressions); other changes are `info`. A base-branch policy can downgrade this rule if a team prefers review notes over a failing check.
+
+## 0.4.0 — 2026-10-03
+
+Agent memory: coding agents can now record what they learn — decisions and why, gotchas, bug root causes, conventions — and later sessions recall it. Memory lives in `.athena/memory/` as plain Markdown you commit and review like code. Anything an agent writes is `unreviewed` (INFERRED) until you confirm it (`athena memory review`, or the Memory page in `athena open`); entries turn `stale` when the files they describe change. Secrets are refused, and text that looks like it is trying to instruct the agent is flagged and kept out of recall.
+
+After upgrading, run `athena analyze` (or `athena agents add <agent>`) so your agent instructions mention `recall` and `remember`.
+
+### Project memory
+
+- New `athena memory` commands for the project memory in `.athena/memory/`: `list` (`--kind`, `--status`, `--stale`), `show`, `add` (`--kind`, `--title`, `--details` or `--details -` for stdin, repeatable `--file`/`--tag`, `--evidence`, `--supersedes`), `search`, `recall <task…>` (`--file`, `--tag`, `--limit`; ranked hits with reasons), `confirm <id…>`, `supersede <id> --by <id>`, `forget <id…>` (asks first; `--yes` in scripts), `edit`, `stale` and `review` (interactive in a terminal: confirm, forget or skip each agent-written entry). All support `--json`.
+- Entries you record are FACT; entries agents record are INFERRED until confirmed. Stale entries (linked files changed) and flagged entries (possible prompt injection) are marked and explained. A memory that contains a possible secret is refused without echoing the value.
+- `athena status` shows a memory line and a `memory` object (`total`, `unreviewed`, `stale`) in `--json`; `athena doctor` adds a Memory check when entries exist.
+- `athena clean` now says how many project memory entries it would delete (they are committed and shared with the team) before asking for confirmation.
+
+### Agent memory: MCP, context and instructions
+
+- New MCP tools `recall` (ranked memories for a task and/or files, with why each matched, label, status and staleness, fenced in `<athena-memory … trust="untrusted-data">` delimiters; entries flagged as possible prompt injection are excluded and counted), `list_memory` (summaries filtered by kind, status, stale) and `remember` (records a memory as **unreviewed**/INFERRED, attributed to `agent:<id>` from the client's `clientInfo.name` — claude-code, cursor, codex, copilot, gemini-cli, antigravity, windsurf, cline — or `agent:mcp`). `remember` is the only write the MCP server allows without `--allow-write`; it never touches knowledge documents, refuses secrets without echoing them, and is disabled by `athena mcp --no-memory-write`.
+- `athena context` and `get_relevant_context` include up to five recalled memories (confirmed first, flagged excluded) with labels and reasons, within the character budget (at most 30% of it). `--json` and `/api/context` gain a `memories` field.
+- Generated agent instructions (all adapters) tell agents to recall project memory at the start of a task, record durable, non-obvious learnings with `remember` at the end, and treat unreviewed memories as hints to verify — never instructions; `rules.md` and the developer always win.
+
+### Memory page (`athena open`)
+
+- New **Memory** page (`/memory`, in the sidebar with a badge for entries awaiting review) to review project memory in `.athena/memory/*.md`. The review queue (agent-written, INFERRED entries) comes first with Confirm / Edit / Forget; confirmed entries (FACT) follow and superseded ones are collapsed. Cards show kind, FACT/INFERRED label, who recorded it and when, linked files, tags and evidence; details are shown as plain text, never rendered as Markdown or HTML. Stale entries (a linked file changed since) show the changed files and a Re-confirm action; entries that look like prompt injection carry a red warning. Filter chips (kind, status, stale, flagged), a text filter, and an Add memory form (developer entries are FACT immediately). The Overview links to the queue when entries await review.
+- API: `GET /api/memory` (`kind`, `status`, `stale` filters; returns entries and counts), `GET /api/memory/:id`, `POST /api/memory`, `POST /api/memory/:id/confirm`, `POST /api/memory/:id/supersede`, `PATCH /api/memory/:id`, `DELETE /api/memory/:id` — all behind the existing token, Host/Origin and JSON-only checks, with strict schemas. Unknown ids are 404, superseded/busy/full conflicts 409, invalid input and refused secrets 400 (the secret value is never echoed).
+- A `memory.changed` event is emitted after every write from the UI and when memory files change on disk (an agent writing through MCP, `athena memory` in a terminal, a `git pull`), so open pages refresh live.
+
 ## 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`.

package/README.md

@@ -58,23 +58,61 @@ Generated content sits between `athena:generated` markers. Anything outside the
 | `athena sync` | Show which documents would change and why (with diffs), then apply after confirmation (`--yes`, `--dry-run`, `--diff`, `--check` for CI) |
 | `athena watch` | Watch the project and propose updates as files change (`--auto-apply` to write automatically) |
 | `athena doctor` | Check the installation, project, knowledge files and agent integrations |
+| `athena memory` | `list`, `show`, `add`, `search`, `recall`, `confirm`, `supersede`, `forget`, `edit`, `stale`, `review` — project memory in `.athena/memory/` (see [Project memory](#project-memory)) |
 | `athena rules` | `list`, `add "<rule>" --section <name>`, `edit`, `enable`, `disable`, `remove` |
 | `athena agents` | `list`, `add <claude-code\|cursor\|codex\|copilot\|gemini-cli\|antigravity\|windsurf\|cline\|agents-md\|all>`, `remove` |
 | `athena activity` | Show AI agent activity observed through hooks (`-n`, `--agent`) |
+| `athena scan` | Unified scan: secrets, dependency audits and (on a change) review checks, with policy, baseline, triage and a quality gate (`--base`, `--staged`, `--changed`, `--only`, `-f text\|json\|markdown\|github\|sarif`, `-o`, `--fail-on`, `--policy-from`, `--offline`, `--list-rules`) |
+| `athena baseline` | `show`, `create`, `update`, `prune` — record existing findings so only new ones fail the gate |
+| `athena findings` | `list`, `show <fingerprint>`, `triage <fingerprint> <safe\|false-positive\|accepted-risk\|fixed\|to-review\|clear> --reason …` |
+| `athena explain <ruleId>` | What a rule detects and what to do about it |
 | `athena security` | Audit dependencies with the tools installed for this project, and report secret findings (`--fail-on`, `--last`, `--no-audit`) |
 | `athena review` | Check the current diff for facts worth reviewing, and list your rules and checklist (`--base`, `--no-fail`) |
 | `athena git-hook` | `install` (`--review`), `uninstall`, `status` — a Git pre-commit hook that blocks commits when knowledge is out of date |
 | `athena context <task>` | Show which knowledge an agent should read for a task (`--full`, `--json`) |
 | `athena graph` | Inspect the project graph (`--build`, `--search`, `--node`, `--kind`) |
-| `athena mcp` | Serve project intelligence to agents over MCP (stdio; `--allow-write`) |
+| `athena mcp` | Serve project intelligence to agents over MCP (stdio; `--allow-write`, `--no-memory-write`) |
 | `athena ai` | `status`, `enrich` — optional AI suggestions (`--consent`, `--dry-run`) |
 | `athena open` | Start (or reuse) the local web UI on `127.0.0.1`, watch for changes, and open it (`--port`, `--no-open`, `--no-watch`) |
-| `athena clean` | Remove `.athena/` and Athena integration blocks |
+| `athena clean` | Remove `.athena/` (including project memory) and Athena integration blocks |
 
 Global flags: `--json`, `--quiet`, `--cwd <dir>`, `--no-color`.
 
  They print *Not available yet* and exit with code 2. See [docs/ROADMAP.md](docs/ROADMAP.md).
 
+## Project memory
+
+Agents rediscover the same things every session: why the queue uses advisory locks, that tests need `TZ=UTC`, which bug the retry guard fixes. Athena keeps these as **project memory** in `.athena/memory/` — one Markdown file per kind (`decisions.md`, `gotchas.md`, `bugs.md`, `conventions.md`, `todos.md`, `facts.md`). Commit it: the team shares it and reviews changes in pull requests. Text you write outside the `athena:memory` markers is kept as written.
+
+- **Evidence labels.** An entry you record is `confirmed` (**FACT**). An entry an agent records is `unreviewed` (**INFERRED**) until you confirm it.
+- **Staleness.** Entries can link files. When a linked file changes, the entry is reported **stale** until you confirm it again (which re-anchors it), edit it or forget it.
+- **Safety.** Entries that look like a secret are refused (the value is never stored or printed). Entries that address the agent instead of describing the project (possible prompt injection) are flagged and never recalled automatically.
+
+```bash
+athena memory add --kind decision --title "Queue uses advisory locks" \
+  --file src/jobs/queue.ts --tag jobs --evidence "PR #412"
+git log -1 --format=%B | athena memory add --kind bug --title "Double refund on webhook retry" --details -
+athena memory list                 # --kind, --status unreviewed|confirmed|superseded, --stale
+athena memory review               # walk agent-written entries: [c]onfirm [e]dit later [f]orget [s]kip [q]uit
+athena memory recall "change the refund flow" --file src/api/refunds.ts
+athena memory stale                # entries whose linked files changed
+athena memory confirm m-1a2b3c m-4d5e6f
+athena memory supersede m-1a2b3c --by m-7a8b9c   # keep as history
+athena memory forget m-1a2b3c      # asks first; --yes in scripts
+```
+
+```text
+$ athena memory list
+ID        KIND       LABEL    STATUS             TITLE · SOURCE
+m-b74d24  gotcha     INFERRED unreviewed         Refund webhook retries twice · agent:claude-code
+m-815cd7  decision   FACT     confirmed  stale   Queue uses advisory locks · developer
+
+2 entries · 1 confirmed · 1 unreviewed · 1 stale · source: .athena/memory/
+1 entry written by agents is INFERRED until reviewed: run `athena memory review`.
+```
+
+Every command supports `--json`. `athena memory review` is interactive only in a terminal; elsewhere it lists the unreviewed entries and exits 0. `athena status` and `athena doctor` show how many entries are unreviewed or stale, and `athena clean` warns before deleting project memory.
+
 ## Keeping knowledge in sync
 
 ```text
@@ -136,6 +174,10 @@ $ athena activity
 ## Security and review
 
 ```bash
+athena scan                       # secrets + dependency audits, policy and quality gate
+athena scan --base origin/main -f sarif -o athena.sarif --policy-from origin/main   # in CI
+athena baseline create            # accept today's findings; only new ones fail the gate
+athena findings triage 5f65caf9 false-positive --reason "test fixture"
 athena security          # audit dependencies + report secret findings
 athena security --fail-on high   # exit 1 in CI
 athena review                     # check the current diff before you commit
@@ -143,6 +185,8 @@ athena review                     # check the current diff before you commit
 
 **`athena security`** runs the audit tools your project's ecosystems provide (`npm audit`, `pnpm audit`, `pip-audit`, `govulncheck`, `cargo audit`, `composer audit`) and reports what they find, attributed to the tool. Athena has no vulnerability database of its own: a tool that isn't installed is reported as **unknown**, never as "no problems". Results are stored in `.athena/security-scan.json` and recorded in `security.md` on the next `athena sync`.
 
+**`athena scan`** puts every check into one findings model. Each finding has a rule id, severity (`unrated` when the tool gave none — never treated as low), confidence, a FACT/DETECTED/INFERRED label, CWE, a location or package, and a fingerprint that never depends on a secret's value. Every report lists what was *not* covered (tools not installed, engines that failed, categories nothing scanned), and a failed engine fails the gate — it checked nothing. Optional committed files tune it: `.athena/policy.json` (gate thresholds, rule overrides, path excludes), `.athena/baseline.json`, `.athena/triage.json`, and inline `athena-ignore <ruleId> -- <reason>` comments (a reason is required). In CI, `--policy-from <base>` evaluates with the base branch's policy and reports any change to it on the branch as `review/policy-weakened`. Output formats: text, JSON, Markdown, GitHub annotations and SARIF 2.1.0 (for code scanning). Ratings A–E per category come with their basis; there is no numeric score.
+
 **`athena review`** checks facts about your current diff: secrets in added lines (a blocker, exit 1), committed env files, new dependencies, source changed without tests, API/schema/auth touchpoints, large files, debug leftovers, and whether Athena knowledge is stale. It then lists your enabled rules and the project's review checklist for you or your agent to apply — Athena does not claim to judge whether they are met, and it runs no AI.
 
 ## Use in CI and git hooks
@@ -249,11 +293,19 @@ Documents to read
 
 - **Deterministic.** The same task and project state always produce the same selection, with a stated reason for each document. No AI is involved.
 - **Sections, not whole files.** Only the relevant sections are returned, under a character budget, with your rules always included.
+- **Project memory.** Up to five recalled memories from `.athena/memory/` (confirmed ones first, possible prompt injections excluded) are included with their label (`FACT` once a developer confirmed them, `INFERRED` while unreviewed), whether they are stale, and why they matched. They share the character budget (at most 30% of it) and appear in `--full` output and as `memories` in `--json`.
 - **Project graph.** `athena graph --build` writes `.athena/graph.json`: packages, files, routes, entities, frameworks and commands, connected by `contains`, `imports`, `handles`, `defines` and `depends_on`. It comes from the analysis, so it never asserts more than DETECTED evidence.
 
-**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`.
+**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`, and the memory tools `recall`, `list_memory` and `remember`.
+
+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 one exception is `remember`: an agent may append a memory to `.athena/memory/`, but it is always stored **unreviewed** (`INFERRED`, attributed to the agent, e.g. `agent:claude-code`, or `agent:mcp` when the client is not recognized) and counts as a `FACT` only after a developer confirms it. It never touches knowledge documents and refuses anything that looks like a secret. Start the server with `--no-memory-write` to turn it off.
 
-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.
+| Memory tool | Input | Returns |
+| --- | --- | --- |
+| `recall` | `task?`, `files?`, `tags?`, `limit?` | Ranked memories with why each matched, label, status and staleness, each in `<athena-memory … trust="untrusted-data">` delimiters. Entries that look like instructions to an agent are excluded (the reply says how many). |
+| `list_memory` | `kind?`, `status?`, `stale?` | One-line summaries: id, kind, status, label, stale, title |
+| `remember` | `kind`, `title`, `details?`, `files?`, `tags?`, `evidence?`, `supersedes?` | The new id and label (`INFERRED`); a developer must confirm it |
+ Repository content it returns is passed through the secret redactor and wrapped in `<athena-document … trust="untrusted-data">` (or `<athena-memory …>`) delimiters, so agents can tell project data from instructions. The generated agent instructions tell agents to `recall` at the start of a task, `remember` durable learnings at the end, and treat unreviewed memories as hints to verify — `rules.md` and the developer always win.
 
 ## Optional AI
 

package/dist/{activity-P4UUFHWV.js → activity-XCHKBZTG.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   listAgents
-} from "./chunk-JY6BFIJJ.js";
+} from "./chunk-RQKGT2EK.js";
 import {
   readRecentEvents,
   summarizeSessions
-} from "./chunk-65TSRDQ3.js";
+} from "./chunk-P4TRQMES.js";
 import {
   c,
   dim,
@@ -20,15 +20,15 @@ import {
   requireProjectRoot
 } from "./chunk-XFN7UZCS.js";
 import "./chunk-KBO7XRBW.js";
-import "./chunk-JCGDR4UV.js";
-import "./chunk-2RS6TA3D.js";
+import "./chunk-WWQ5NKEC.js";
+import "./chunk-YRIS7ZS6.js";
 import "./chunk-GHFRQAYT.js";
+import "./chunk-INT3IGMQ.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";
 
@@ -74,4 +74,4 @@ async function activityCommand(opts) {
 export {
   activityCommand
 };
-//# sourceMappingURL=activity-P4UUFHWV.js.map
+//# sourceMappingURL=activity-XCHKBZTG.js.map

package/dist/{agents-3HTSQGL2.js → agents-HUJ4JXIB.js}

@@ -3,8 +3,8 @@ import {
   configureAgents,
   listAgents,
   removeAgents
-} from "./chunk-JY6BFIJJ.js";
-import "./chunk-65TSRDQ3.js";
+} from "./chunk-RQKGT2EK.js";
+import "./chunk-P4TRQMES.js";
 import {
   c,
   dim,
@@ -19,15 +19,15 @@ import {
   requireProjectRoot
 } from "./chunk-XFN7UZCS.js";
 import "./chunk-KBO7XRBW.js";
-import "./chunk-JCGDR4UV.js";
-import "./chunk-2RS6TA3D.js";
+import "./chunk-WWQ5NKEC.js";
+import "./chunk-YRIS7ZS6.js";
 import "./chunk-GHFRQAYT.js";
+import "./chunk-INT3IGMQ.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";
 
@@ -66,4 +66,4 @@ export {
   agentsListCommand,
   agentsRemoveCommand
 };
-//# sourceMappingURL=agents-3HTSQGL2.js.map
+//# sourceMappingURL=agents-HUJ4JXIB.js.map

package/dist/{ai-ASL4FFQ7.js → ai-LGTLQKL4.js}

@@ -3,7 +3,7 @@ import {
   aiStatus,
   buildEnrichPayload,
   enrich
-} from "./chunk-RXNRMIZP.js";
+} from "./chunk-WUIC65QO.js";
 import {
   c,
   dim,
@@ -20,7 +20,7 @@ import {
 } from "./chunk-XFN7UZCS.js";
 import "./chunk-KBO7XRBW.js";
 import "./chunk-PVCIGUIT.js";
-import "./chunk-JCGDR4UV.js";
+import "./chunk-WWQ5NKEC.js";
 import "./chunk-FQEGEVLY.js";
 import "./chunk-2DY4PUR4.js";
 import "./chunk-IQQBAWSM.js";
@@ -93,4 +93,4 @@ export {
   aiEnrichCommand,
   aiStatusCommand
 };
-//# sourceMappingURL=ai-ASL4FFQ7.js.map
+//# sourceMappingURL=ai-LGTLQKL4.js.map

package/dist/{analyze-F3YOILNL.js → analyze-AP4XJT7D.js}

@@ -4,7 +4,7 @@ import {
   printSummary,
   runWithProgress,
   summarize
-} from "./chunk-DOQMAZL5.js";
+} from "./chunk-R5AX7VST.js";
 import {
   printHeader
 } from "./chunk-SHKXELUX.js";
@@ -16,21 +16,22 @@ import {
   requireProjectRoot
 } from "./chunk-XFN7UZCS.js";
 import "./chunk-KBO7XRBW.js";
-import "./chunk-SJOOXO34.js";
-import "./chunk-PANVPNYF.js";
-import "./chunk-ELKFRTZT.js";
+import "./chunk-4FETKOY3.js";
 import "./chunk-2R6PXY6Z.js";
+import "./chunk-44EGCEB2.js";
 import "./chunk-PVCIGUIT.js";
-import "./chunk-OLPSEQS5.js";
-import "./chunk-JCGDR4UV.js";
-import "./chunk-2RS6TA3D.js";
+import "./chunk-ELKFRTZT.js";
+import "./chunk-AKOI4VTD.js";
+import "./chunk-QCC4VJUH.js";
+import "./chunk-WWQ5NKEC.js";
+import "./chunk-YRIS7ZS6.js";
 import "./chunk-GHFRQAYT.js";
+import "./chunk-INT3IGMQ.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";
 
@@ -46,4 +47,4 @@ async function analyzeCommand(opts) {
 export {
   analyzeCommand
 };
-//# sourceMappingURL=analyze-F3YOILNL.js.map
+//# sourceMappingURL=analyze-AP4XJT7D.js.map

package/dist/{chunk-ZB7LC6FP.js → chunk-3KFOI2X4.js}

@@ -13,7 +13,7 @@ import {
   git,
   statusV2,
   workingChanges
-} from "./chunk-OLPSEQS5.js";
+} from "./chunk-AKOI4VTD.js";
 import {
   isBlockModified,
   parseBlocks
@@ -218,4 +218,4 @@ async function buildStatus(root, signal, opts = {}) {
 export {
   buildStatus
 };
-//# sourceMappingURL=chunk-ZB7LC6FP.js.map
+//# sourceMappingURL=chunk-3KFOI2X4.js.map