# PROGRESS — Agenium Where Agenium stands, what has been verified and how, and what has not. The history below is kept as written; the first section is the state at 0.1.0 (2026-10-28). Later releases are in the [CHANGELOG](../CHANGELOG.md) and the evidence map. Plain-language overview: [README](../README.md); evidence map: [VERIFICATION.md](VERIFICATION.md); decisions: [adr/](adr/README.md). ## Release 0.1 (status 2026-10-28) Last full verification: 2026-10-28 on Windows 11 Pro (10 cores, 32 GB), Rust `x86_64-pc-windows-gnu`: fmt PASS, clippy `-D warnings` PASS (workspace and desktop app), `cargo test --workspace` **445 passed, 0 failed**, UI smoke test (30 checks on the real app) PASS. ### Post-0.1 work toward more team kinds (2026-10-28) The owner asked Agenium to fit teams of more kinds, not only coding, and reviewed it live; done and verified on a test root: - **The user answers the Lead, never a worker** (ADR-122). A question the Lead escalated to the user: the user's answer becomes a message to the Lead, who answers on the ticket; nothing of the user's lands on a worker's ticket. Solo agents unchanged. Verified: `route_user_answer` returns a Lead message, adds no comment; the Lead's answer resolves it and counts as the user's decision for later tickets (test `agenium-orchestrator::team`). - **Node works in the Windows sandbox** (ADR-122): the parents of a command's folders are listable (`enumerate_paths`), so `fs.realpathSync` no longer dies with `EPERM lstat 'C:'`; a file beside the worktree stays unreadable (test `agenium-sandbox::node_resolves_paths_inside_the_sandbox`). - **Free-form skill domain tags** (ADR-123): a skill's frontmatter may carry any tags (no fixed vocabulary; several per skill), so the fields a team covers are visible. Shown on the agent (SKILL / SELF-LEARNED SKILL / MCP counts + domain chips), on the agent page, and on the skill library with a tag filter. A team template can declare extra worker roles for a domain, and new library skills keep per-variant depth in `references/` (progressive disclosure) rather than splitting into near-duplicate skills. - **Skill evaluation surfaced in the app.** Three layers already existed (shape lint ADR-88, opposite-directive conflicts ADR-92, Jev calibrated quality read ADR-90) but ran only at import. Added an on-demand **Evaluate** action on every library skill. Verified with Jev's `skill_quality` run over the whole library (`agenium-eval --example skill_quality`): every library skill reads as one job with actionable steps, evidence-backed proof and no stale code; one that had bundled two jobs was reframed and rose from 54% to 81% on "one job". Evaluate works end-to-end in the app (shape "good" + the Jev scores). - Projects are coloured by run state like tickets; a team shows its current and past projects (one at a time); the Lead's delegations are a collapsible bar over the chat; a long chat paste shows as one label; popups open Apple-style, rendered on `
` so the backdrop blur covers the whole window. - **Memory past 100 000 facts: the ANN sidecar is wired** (ADR-50 implemented, amended by ADR-125). Exact search below `[memory] ann_threshold` facts per agent; the write that reaches it starts a background usearch build while exact serves, then searches switch. Deletes are tombstones (usearch's slot reuse after `remove` was measured to strand an untouched fact), compacted at 10 % churn; every write reaches the sidecar before it returns; a missing, corrupt, foreign or out-of-date sidecar (journal gap, restored older database) is detected and rebuilt. Verified: `agenium-store` `tests/ann.rs` (9) and 20 hard kills during writes with 0 self-hit misses (`tests/crash.rs`); numbers in `STORE-SCALE.md` §13. **Tuned for exact answers** (§14, ADR-125 §8): on 100 000 real sentences agents get exact search's top 8 99 % of the time (was 96 % with ADR-50's parameters) at 1.1 ms per KNN (exact: 32 ms); two per-recall costs that grew with memory (counting every fact, scanning for lessons) removed. - **Memory at 1 M facts, Windows and Linux** (STORE-SCALE §15): agents get exact search's top 8 in 99 % of recalls at 100 k–1 M; hybrid 52–55 ms at 1 M (exact: ~400 ms); a whole-ticket query embeds in 0.4 s instead of 1.6 s (own BERT encoder, ADR-125 §11). The Ubuntu VM (2 vCPU, 5 GB) runs a 1 M-fact agent (peak 2.9 GB). - **Jev, after studying jev-ultrafast and awesome-jev** (`docs/reference/JEV-OPPORTUNITIES.md`): client fixes (a rate limit no longer turns the judge off, 5 s deadline, one reused connection, malformed answers ignored; ADR-126), the done check and the output trimmer (both off by default), shadow mode, billed usage, an answer cache with the review prefetched at submit; the judge is now one file per use (ADR-127). Not yet measured on a real team. - **`find_code` and judge keys** (ADR-128): find code by what it does — on this repository the answering file in the top 3 and its code excerpted for 10/10 behavioural questions (real API, ≈ 3.4 s, $0.003 per search); whether it lowers a coding agent's own tokens is measured by `find_code_ab` (needs a model key; not run). Named Jev keys take turns; a key out of quota is set aside until the user re-enables it (told by name); a failing key rests 30–60 minutes; every judge use on by default, fail-open (`tests/judge_keys.rs`). - **Large files split, behaviour unchanged:** `runtime/mod.rs` 2 858 → 1 546 lines (+ `ticket_runs`, `lead_runs`, `scheduling`), the CLI's `main.rs` 2 768 → 915 (+ `args` and one module per command group). - **Every source file under 32 KB** (the file-size ratchet, `cargo xtask ratchet`; owner: "chia nhỏ code ra từng module nhỏ cho dễ maintain"). The 32 files over the limit were split along their features, behaviour unchanged, and the baseline `devtools/ratchet.json` is empty: production Rust (engine, runtime, agent store, ANN sidecar, graph, backups, MCP client and OAuth, CLI backend run, sandbox, agent loop, registry, effects, skill overlays, VCS, one file per work tool, the CLI's commands, the desktop IPC commands), the UI (strings per language and area, Organize, Capabilities, Live, Ticket, the pixel office), the integration tests (one folder per test binary, so no extra binaries are linked) and the memory dataset generator. Checked: the same test counts per binary before and after, the UI strings identical key for key, the generated datasets byte-identical, the UI smoke test on the real app 29/29. - **End-to-end on real models after the split**: Solo golden tasks 25/25 (DeepSeek over the API, Claude Code Haiku 5.5, Codex gpt-6-luna, Grok 4.7, agy Gemini 3.8 Flash) and the team task 4/4 (a DeepSeek Lead and planner, each CLI as the workers); the Ubuntu VM builds clean and its sandbox, CLI backend, MCP, tools, loop, VCS and store tests pass. - **Vendor CLIs work only through Agenium's tools** ([ADR-129](adr/ADR-129-cli-agenium-tools-only-background-shell.md)): own shells off, own file tools limited to their scratch folder, background commands (`shell` + `shell_output` / `shell_stop`) for every agent, a Solo agent's subagents labelled in the run page and the Live tab. Verified: 20/20 golden tasks and 4/4 team tasks on the four CLIs with no own tool doing the work; seven defects found on the way and fixed (ADR-129 §Verified). `find_code` A/B on pinned Flask 3.1.0: every agent spent fewer tokens and steps ([results](../quality/eval/results/find-code/README.md)). - **Every screen verified in the real app** (`apps/desktop/ui-tests/full.mjs`, 57 checks on a root with real work: the header, the board and a ticket's popup, runs and their memory lines, the live office, a real chat turn, agents, memory, providers, skills, audit, usage, settings, the palette, closing and reopening). Found and fixed on the way: a ticket opened as a page from 11 places while the board used a popup (now one popup everywhere, of the ticket's own project); `test_calc.py` and `__main__` rendered as italics (CommonMark's in-word underscore); the providers page blank until every CLI had been run; memory runs that said only `{"kind":"memory"}`; the theme buttons without a name; the project picker and search moved from the header to the pages that use them, theme and language kept in the header only. Projects close and reopen by the user only ([ADR-130](adr/ADR-130-closing-and-reopening-projects.md)), and a project made from a GitHub repository (an empty one) was built and pushed to it on close. - **End to end again on real models after the changes** ([VERIFICATION](VERIFICATION.md), runs of 2026-10-28): golden tasks 5/5 on each of DeepSeek over the API, Claude Code Haiku, Codex, Grok, agy and OpenCode, with no own CLI tool doing the work; the team task with Codex workers; the memory chain (a lesson learned from a failed merge, recalled and held in three more tickets); the learning loop on a fixed scenario (an agent updated a system skill as its own copy and wrote a new one; the system skill unchanged); MCP from an API and a CLI agent; each CLI probed for what reaches its run (none of the user's own configuration). Fixed on the way: the learning scenario that had stopped testing skill writing, closing a project during the Lead's chat turn, instructions naming tools a run did not have, Codex's and OpenCode's own skill and worktree tools, and the report fields models guess. - **Two agents on one MCP server with different keys** ([VERIFICATION](VERIFICATION.md), 2026-10-29): an admin's key and a member's on one HTTP server, the workers on the API, Claude Code and Codex: each reached the server with its own key and only the admin could delete; no key in any log. An own key pasted bare now keeps `Bearer ` (ADR-62). Settings describe the three command modes at once, with what each does on this computer. - **The stop and a used-up quota, end to end** (2026-10-29, ADR-131): the stop ends a running command at once; a worker out of quota mid-ticket keeps its work, and a new model frees it in one step. The CLI backend reviewed again and fixed (ADR-56): an unquoted Claude hook path, CLIs giving up on long tool calls, a dead OpenCode server waited for 45 minutes, and more. - **The agent stays, only its model changes** (2026-10-29, ADR-132 to ADR-134): no automatic move to an API model, a Resume button wherever an agent is set aside, the ticket kept with its agent (quota runs in Solo and team went on with DeepSeek, Claude Code and Codex as the new model); long commands as jobs the run waits for (an 80-second check on all five CLIs); every CLI resumes its own session of a ticket (all five, checked by a code word the second run knew without reading it again); logins kept in step across runs on one account; a review of crafted paths with seven fixes; the dead `Check::Command` removed; two files split under the size ratchet. Then (ADR-135): an agent out of quota goes back to work with the same model once the quota should be back; a turn refused for a login another run refreshed runs again; no read through a hard link; a closed ticket's kept CLI sessions end; checked on Windows and the Ubuntu VM. - **A team designer and a skill writer** (2026-11-01, ADR-151): the user describes a team in a chat on the model they pick (API or CLI) and gets roles, counts, library skills, scopes and models with why, opened in the template editor; a skill the library lacks is written by an agent from a request and documents, to Agenium's skill rules, and opened in the skill editor. Both checked on seven models (API and four CLIs, OpenCode Go's free models among them): 15/15. - **One skill library, documents, helper sessions** (2026-11-01, ADR-152): agents propose new skills (Needs you: by hand, discussed with the skill writer, or declined) and change only their own copy; the skill writer sees the whole library, finds close skills with the local embedding model and merges with a before/after diff; helper chats are sessions; models picked are remembered; documents (PDF, Office, EPUB…) read as Markdown by agents' `read_file` and as attachments in every chat; markitdown installed, self-tested, updated and removed from Settings; teams on each role's model; helper calls in Usage; skill quality on 12 local criteria with effectiveness from reopened tickets. Checked end to end in the real app on three API and five CLI models ([VERIFICATION](VERIFICATION.md)). - **Agent CLIs updated from the app; opencode made reliable** (2026-11-01, ADR-153): each CLI's version, the newest and the verified one, the CLI's own updater with a check after and the old version offered back; opencode runs get the model catalogue and no longer complete with an empty answer; every other CLI checked under load in fresh homes. - **The chat runs on a model it can change; an attachment opens again** (2026-11-02, ADR-149, ADR-152, ADR-153 and ADR-155 amended): the Lead's chat names vendor, model and effort and changes the model in place, warned first when the context outgrows the new window, and its gauge measures against the model now chosen. The model field is a readable list (whole names, price, free tag, window) filtered as typed; Claude Code is listed by full ids only, its aliases still running. `@` lists the conversation's documents; a message put back after a failed turn says why and offers "Send again". A document attached in the chat is kept whole in the project's `.agenium/attachments` (outside git) and named in the message, every run of the project may read it: asked to check the original, Codex called `read_file` on it and copied item 5. A Codex or Antigravity MCP call reads `server :: tool: argument` in the chat and the Live view, its arguments reaching the view (it read `mcp_tool_call`). The CLI page says what it knows: no button at the newest, "Run its updater" where the newest is unknown, an unchanged update says it is already the newest, a version that answered the check here reads "checked on this machine", and a failed newest check is shown with its reason (grok: `program not found`). Verified in the app on the owner's machine (codex gpt-6-luna; opencode 2.2.5, agy 1.4.12, grok 1.0.41, claude); tests for the check kept per version, the version that answered it and a call's arguments reaching the view; full local CI and the UI smoke test (35 checks). - **Learning without an API key; a ticket stays inside its item's scope; candle on zip 9** (2026-11-03, ADR-56 and ADR-132 amended): a CLI agent's lessons are drawn by its own CLI, one read-only answer per call kept as the agent's `Memory` run under the CLI's provider and model, unless `[cli] fallback_provider/fallback_model` names an API model (still an optional cheaper extractor); a user working through CLIs now keeps learning with no API key. A ticket may not name a path outside its plan item's `scope_paths`: the item's scope refuses it (a Lead created a README ticket for a notes-only item, QS-4) and a ticket that names no scope takes the item's. candle-core, candle-nn and candle-transformers moved to 0.11.1, which uses zip 9.3.0: the four zip 8 advisories left the tree and `deny.toml` ignores none. Verified: the embedding tests with the model (recall unchanged: EN recall@5 0.967, VI→EN 0.300), the scope rule's lifecycle test, a Codex worker's memory drawn by codex on the QA root (provider `codex`, a new fact from QS-5), and the full local CI. | Release item | Status | Evidence | |---|---|---| | Features for a first release | DONE | [CHANGELOG](../CHANGELOG.md) | | Strict Content Security Policy in the app window | DONE: only the app's own scripts, no remote content, workers and Monaco allowed; `freezePrototype` left off (it breaks Monaco) | `apps/desktop/tauri.conf.json`; release build checked on a test instance: inline script and external fetch blocked, all 16 views and the Monaco/xterm chunks load with no violation | | Real team run on a mixed team after the latest changes | DONE: Claude Opus Lead, Codex, Grok, agy, DeepSeek; 4/4 tickets merged, the delivered app's tests pass; 4 findings fixed (ADR-116) | [results/team-mixed-20261027.md](../quality/eval/results/team-mixed-20261027.md) | | Documentation for users | DONE: README (English, Vietnamese), Jev guide, changelog, NOTICE with bundled third-party licenses | [README](../README.md), [README.vi](../README.vi.md), [JEV.md](JEV.md) | | Windows installer, tested on a clean VM | DONE: NSIS (77 MB) and MSI (102 MB; the MSI was dropped later, ADR-154), per-user install, embedding model bundled. Clean Windows 11 23H2 VM: silent install, model copied at first start without a download, **28/28 UI smoke checks pass on the installed app**, silent uninstall leaves nothing. Found and fixed: the before-build paths, a language dialog that blocked `/S`, the first-start language, the missing-Git message. Found, not fixed: **MXC containers are not available on Windows 11 23H2**, so there every agent command waits for approval (decision pending) | `apps/desktop/tauri.bundle.json`; VM run 2026-10-27 | | Running without a sandbox (ADR-117), on the clean Windows 11 23H2 VM | DONE 2026-10-27 with the rebuilt installer: UI smoke 29/29; the Settings option appears only there, its confirmation works, the policy saves; a DeepSeek Solo agent (OpenCode Go key, kept in a throwaway root's vault, deleted after) built a 2-ticket request: 39 shell commands ran, 0 refused, 0 permission requests, both tickets closed. Found: the agent asked the same question (no Python) on both tickets, as an answer on one ticket does not reach its siblings | VM run 2026-10-27 | | Linux (Ubuntu) package, tested on a VM | DONE: `.deb` (93 MB; depends on git, bubblewrap, WebKitGTK 4.1) and AppImage (171 MB), built on the Ubuntu 25.10 VM. The `.deb` installs, the bundled model is copied at first start, setup and the overview render, **the bubblewrap sandbox works**; the AppImage starts too; `apt remove` leaves nothing in `/usr/lib/Agenium` | VM run 2026-10-27 (screens checked on a virtual display) | | macOS installer (`.dmg`), tested on macOS | DONE: `Agenium_0.1.0_aarch64.dmg` (96 MB), ad-hoc signed `.app` with the model, Apple silicon only; installed from the `.dmg` it starts, shows setup and copies its model (run 7, Devin cloud, 2026-11-01). Not notarized: Gatekeeper rejects it until it has a Developer ID | `docs/reference/bench-raw/macos-2026-11-01-run7` | | Upgrades keep the user's data | DONE 2026-11-01: 0.1.0 then 0.1.1 over it on clean Windows 11 (NSIS through its windows, MSI) and Ubuntu 25.10 (`apt`): projects, team, provider key and language kept; uninstall keeps the root | [VERIFICATION](VERIFICATION.md) | | Code signing, auto-update | NOT DONE: needs a certificate and an update host (owner decision) | | Known limits of 0.1.0: Anthropic, Gemini and OpenAI APIs contract-tested, not called with a real key; ADR-115's extra request fields for OpenAI-compatible endpoints only; Devin's CLI driven over ACP inside the sandbox (ADR-156; devin 3000.11.234 verified 2026-11-04), Linux and macOS not yet; the macOS installer is an ad-hoc signed `.dmg` for Apple silicon (run 7, 2026-11-01), not notarized: Gatekeeper asks the user to open it by hand until it is signed with a Developer ID. ## History Verification at M3: 2026-10-24 (Asia/Saigon) on Windows 11 Pro (10 cores, 32 GB), Rust 1.99.1 `x86_64-pc-windows-gnu`, git 2.45. After M3: fmt PASS, clippy `-D warnings` PASS, `cargo test --workspace` PASS (**210 passed**, 0 failed, 2 helpers ignored; run without `AGENIUM_TEST_MODELS`, the local embedding-model tests were last run with it after M1.5), `xtask schemas --check` PASS, scripted golden tasks **5/5** PASS. Decisions and deviations of this implementation: [`adr/ADR-52-fresh-implementation.md`](adr/ADR-52-fresh-implementation.md). Front-ends: the headless CLI `agenium` and the desktop app `apps/desktop` (Tauri 2, [ADR-60](adr/ADR-60-desktop-app.md)). ## Milestones ### M0 — scaffolding (backend): DONE | Item | Status | Evidence | |---|---|---| | M0-1 workspace, LICENSE/NOTICE, local CI | DONE | `Cargo.toml`, `devtools/scripts/ci-local.{ps1,sh}`; cargo-deny step since 2026-10-26 (`deny.toml`, ADR-99) | | M0-2 config (`resolve_root`, layout, `config.toml`) | DONE | `agenium-config` tests (3 priority branches, layout, round trip) | | M0-3 setup wizard backend + system requirements | DONE (backend) | `setup.rs`, `sysreq.rs`; `agenium setup`, `agenium doctor` | | M0-4 core: ids, ticket, state machine, `dep_satisfied` | DONE | `agenium-core`: permission table test + property tests (no illegal transition, terminal states, dep rule) | | M0-5 store: SQLite, migrations + pre-migrate backup, event log, idempotency | DONE | `agenium-store` tests; **20x hard-kill crash test** | | M0-6 secrets (hybrid vault, keyring timeout, redaction, secret scan) | DONE | `agenium-secrets` tests; real Windows Credential Manager probe | | M0-7 vcs (git CLI): worktree/branch per ticket, auto-commit with secret scan, rebase + ff merge queue, remote test | DONE | `agenium-vcs` tests (bare-repo remote; real GitHub/GitLab NOT RUN) | | M0-8 project (`agenium.toml`, layout, git init) | DONE | `App::create_project`, `agenium project create` | | M0-9 bus + resync from the log | DONE | `agenium-bus` tests | | M0-10 reconcile DB <-> git | DONE | 8 injection points heal (`orchestrator/tests/reconcile.rs`) | | M0-11 backup full/incremental, retention 24/7/4, restore into a new root | DONE | store + orchestrator backup tests (content hashes) | ### M1 — Solo agent: DONE except the UI parts | Item | Status | Evidence | |---|---|---| | M1-1 Provider trait + Anthropic, Gemini, OpenAI-compatible adapters | DONE | contract tests on a local HTTP server; **real run on OpenCode Go** (OpenAI-compatible, DeepSeek v4.1 Flash); Anthropic and Gemini real APIs NOT RUN (no keys) | | M1-1b Local / custom endpoint capability flags (ADR-31) | DONE: tools / vision / context length detected from LM Studio (`/api/v0/models`) and Ollama (`/api/show`), hand-set `[[providers.model_caps]]` win; `provider models` shows them; a run on a model without tool calling is refused with the reason; the known context window drives the checkpoint. (No "network allowlist" entry needed: Agenium does not filter its own provider traffic; agent commands have no network.) | `agent/llm/src/local.rs`, `adapters.rs` local tests, `runtime.rs::model_without_tool_calling_is_refused` | | M1-1c OpenAI Responses wire (OpenCode `gpt-*`, `grok-*`, `muse-spark*`) | DONE (contract tests on a local server; not run against the real relay: the owner's key is for DeepSeek models only) | `agent/llm/src/responses.rs`, `adapters.rs::opencode_router_picks_the_wire_per_model`, `responses_failure_is_a_stream_error` | | M1-2 retry / Offline / QuotaExhausted | DONE | retry unit tests, 529/429/drop/402 contract tests, runtime test | | M1-3 prompt caching order, effort mapping, prices | DONE | breakpoints asserted in contract tests; built-in Anthropic prices + `pricing.toml` | | M1-4 work tools | DONE | `agenium-tools/tests/tools.rs` | | M1-5 protocol tools (24, schemas generated), 3 invalid calls stop, nudge | DONE | core + backend loop tests, `schemas/tools/` | | M1-6 loop, `max_steps`, loop detection | DONE | `agenium-backend/tests/loop.rs` | | M1-7 approval mode before the sandbox (YOLO fail-closed) | DONE | `RunGate`, CLI terminal approver, denied-command runtime test | | M1-8 chat console / agent view | CLI only (UI later) | `agenium chat`, live text + tool calls on the terminal | | M1-9 tokens + estimated cost per run/ticket | DONE | runtime test (usage on ticket), price table test | | M1-10 eval: 5 golden tasks + runner + report | DONE | scripted 5/5; **real model 5/5** (DeepSeek v4.1 Flash via OpenCode Go, `quality/eval/results/`) | | M1-11 memory hook + `fact_usage` | DONE (hashing embedder stand-in) | `agenium-memory` test | | **Exit**: Solo agent: ticket -> worktree -> report -> self-review -> merge -> close | **MET** with a scripted model, and end-to-end through the CLI against a fake OpenAI-compatible HTTP server | `orchestrator/tests/runtime.rs`; CLI smoke (see below) | CLI end-to-end smoke (2026-10-23): `setup -> project create -> provider add (openai_compat, local fake server) -> agent solo -> chat "Hãy thêm file chào hỏi" -> run` produced spec v1, plan v1, AGN-1, a work run, a review run, merge into `main` (`AGN-1: Write the hello file`) and Closed. ### M1.5 — Agent registry: DONE except the UI forms (M15-6) | Item | Status | Evidence | |---|---|---| | M15-1 agent profile, model switch keeps memory/MCP/skills | DONE | `runtime.rs::vendor_switch_keeps_memory_skills_and_conversation` | | M15-2 local embedder + memory pipeline + hybrid retrieval | DONE | `bge-small-en-v1.5` via candle (pure Rust; ONNX Runtime has no GNU build); `agenium-memory/tests/{local_model,pipeline}.rs`; trigger test `runtime.rs::closing_a_ticket_teaches_the_assignee`; real model (below) | | M15-3 McpHub stdio + Streamable HTTP, credential binding | DONE (no OAuth, no legacy HTTP+SSE) | `agenium-mcp/tests/mcp.rs` (test server binary + HTTP stub), `runtime.rs::mcp_tools_reach_the_agent_with_its_credential`, `mcp_settings.rs`; manual: `@modelcontextprotocol/server-everything` 2.0.0 | | M15-4 SkillRegistry, `load_skill`, skills index | DONE (overlay updates = M4.5) | `agenium-skills/tests/skills.rs`, `runtime.rs::skills_are_indexed_loaded_and_readable` | | M15-5 export/import JSONL, delete agent | DONE | `orchestrator/tests/agent_io.rs` (byte-identical memory round trip, tamper/secret refusal, delete rules), core_002 migration test | | M15-6 Settings forms (MCP, skill) | CLI equivalents only (UI later) | `agenium mcp add/import/test`, `agenium skill import/validate/show` | | M15-7 graph memory core (agent_002 migration, entity/alias/edge/fact_entity, merge log, tombstones) | DONE | `agenium-store/tests/graph.rs` (v1 -> v2 migration with data, identity/aliases, merge rewiring + log, plan uses `edge_out`/`edge_in`, property test vs reference BFS), backup round trip, export/import, **20 hard kills** during graph writes: integrity, FKs, degree cache, merge chains consistent | | M15-8 extraction + entity resolution | DONE | `agenium-memory/src/{pipeline,resolve}.rs`; labelled set of 2 152 mentions run (`docs/memory-eval.md` §1: auto-merge precision 1.000, with the model 0.996–0.998 / recall 0.92) | | M15-9 graph channel + RRF + re-rank + scope hard filter | DONE | `agenium-memory/src/retrieve.rs`, GM-3 (graph finds what text misses), GM-2 (scope leak 0) | | M15-10 benchmark | DONE except a cold disk | traversal at 100 k / 1 M edges (STORE-SCALE §8.1); 112-question graph QA (`docs/memory-eval.md` §2: recall@8 0.99, 0 scope leaks); 4 readers + 1 writer and a cold page cache (STORE-SCALE §12: depth-2 p95 8.5 ms at 1 M edges under load); a cold OS file cache needs administrator rights, not measured | | M15-11 golden scenarios GM-1..5, GM-7 | DONE (scripted model) | `agenium-memory/tests/graph_memory.rs`; "second ticket >= 20 % fewer steps" seen on the real model in the skill/MCP run (11 -> 5), not as a GM task | ### M2.5 — CLI backend: ACCEPTANCE MET with codex and agy ([ADR-56](adr/ADR-56-cli-backend-headless.md)) | Item | Status | Evidence | |---|---|---| | Detect CLIs in PATH: version, login state, minimum version | DONE | `agent/cli-backend/src/detect.rs`, `agenium doctor` | | Headless JSON-stream drivers | DONE: codex (`exec --json`, resume per turn), agy (stream-json in/out) | `codex.rs`, `agy.rs`, `run.rs` | | Per-run home, the user's CLI configuration not used | DONE (codex: `CODEX_HOME`; agy: `USERPROFILE`/`HOME`) | `tests/stream_run.rs`, unit tests | | YOLO mode, permissions decided by Agenium | DONE: codex inside Agenium's sandbox (MXC/bubblewrap/Seatbelt, live stdio); agy via its `PreToolUse` hook -> Agenium's gate (fail-closed) | `security/sandbox/src/service.rs`, `tests/contained.rs`, `tests/stream_run.rs` | | Protocol tools through Agenium's MCP server | DONE | `agent/mcp/src/server.rs`, `tests/server.rs` | | Limits / mandatory report from the event stream | DONE | `tests/stream_run.rs` | | Golden tasks through a CLI | **codex gpt-6-luna 5/5**, **agy gemini-3.8-flash-low 5/5**, **claude haiku 5/5** | `quality/eval/results/20261024T055002Z-cli-codex-gpt-6-luna.json`, `20261024T060626Z-cli-agy-gemini-3.8-flash-low.json` | | ~~API fallback when the CLI cannot run~~ | WITHDRAWN (ADR-132): the agent is set aside for the user, who resumes it; `[cli] fallback_provider/fallback_model` is an optional API extractor for a CLI agent's lessons (its own CLI draws them when unset) | `orchestrator/tests/runtime/team.rs::a_cli_agent_whose_cli_cannot_run_waits_for_the_user` | | Contract per minimum version | DONE (stream parsing tested on lines captured from codex 0.163.0 / agy 1.4.4; older = not used) | `codex.rs`, `agy.rs` tests | | claude driver | DONE (hook control, per-run `CLAUDE_CONFIG_DIR`) | `agent/cli-backend/src/claude.rs`, `quality/eval/results/20261024T065834Z-cli-claude-haiku.json` | | opencode driver (OpenCode's free models) | DONE: `opencode serve` driven through its HTTP API, every permission decided by Agenium; **5/5** golden tasks with `deepseek-v4.1-flash-free` | [ADR-68](adr/ADR-68-opencode-cli-free-models.md), `quality/eval/results/20261025T050257Z-cli-opencode-deepseek-v4.1-flash-free.json` | Embedding model measured here (release build, `agent/memory/tests/local_model.rs`, own 60-fact fixture `tests/data/retrieval.json` because the S6 pair set is not in the pack): load 0.09 s; EN recall@1 0.733, **recall@5 0.967** (S6 pass >= 0.85); Vietnamese query -> English fact recall@5 0.30 (S6 measured 0.167: memory stays English, ADR-40); **46 facts/s single, 77 facts/s batched** (S6 pass >= 20; fastembed/ONNX in S6 was ~5x faster), query embedding + ranking ~22 ms. Debug builds are ~2x slower. ### M3 — Ticket system: DONE except the UI (Kanban drag and drop, S7 live path) Most of the ticket system was built with M1 (the Solo exit criterion needs it); M3 adds the user-side views, overrides and audit, and closes the gaps found with the CLI backends. | Item | Status | Evidence | |---|---|---| | M3-1 Discovery -> RequirementSpec (locked on approval) -> Plan with versions/approval, `revise_plan`; no ticket outside the plan | DONE | `lifecycle.rs`, `team.rs::team_spec_and_plan_wait_for_the_user`, `plan_revision_follows_the_newest_approved_spec`; CLI `agenium plan` (spec + plan versions, what waits for approval and the exact `approve` command, progress per plan item), `agenium approve spec|plan` | | M3-2 permission matrix of the state machine, user override | DONE | core table-driven permission test; overrides: `user_set_priority`, reassignment of an Assigned ticket by the user only (Lead cannot), user review/close/cancel/answer through the same intents (`Actor::User`, recorded as `user`) -> `views.rs` tests; CLI `ticket priority|assign|review|close|cancel` | | M3-3 every protocol tool + validation rules, structured forms, template per ticket kind | DONE | 24 tools, `schemas/tools/`; **every JSON example of the architecture page parses** (`protocol.rs::design_document_examples_parse`); report templates coding/pentest/research (`templates.rs`) | | M3-4 scheduler unlocks on `deps_satisfied` (Closed, or Resolved + approved (+ merged)) | DONE | `lifecycle.rs::dependencies_unlock_on_approve_and_merge_not_close`; priority then age (`sched.rs`) | | M3-5 Kanban, ticket view, audit trail | DONE headless: `App::board` (columns, blockers, open questions, flags), `ticket show`, `App::audit` = committed events (actor by name, originating intent) + refused protocol calls from the run logs; export `ticket audit --format md|jsonl --out`. **500 tickets: board in ~7 ms** (debug). UI = later | `orchestrator/tests/views.rs` | | Review in one run (approval reports the real merge result + next step; review runs nudged; failed git ops replayed every round) | DONE: claude haiku 5/5 with 2 runs per task (was 3) | `quality/eval/results/20261024T090226Z-cli-claude-haiku.json`, `runtime.rs` nudge regression, `reconcile.rs::failed_merge_is_retried_without_a_restart` | ### M4 — Team mode: IN PROGRESS ([ADR-57](adr/ADR-57-team-mode-lead-inbox.md)) | Item | Status | Evidence | |---|---|---| | Lead inbox (blocking questions, permissions inside the allowlist, plan items without tickets, tickets without a usable worker, non-blocking questions) + Lead inbox run each round | DONE | `orchestrator/src/inbox.rs`, `team.rs::lead_inbox_order_sla_and_escalation`; CLI `agenium inbox` | | SLA of blocking questions -> System comment + NeedsUser (once); Lead escalation (`answer_question.escalate`) | DONE | same test | | Team templates: coding, pentest, research, content (TOML, user overrides in `