# Changelog

## 1.42.0 - 2026-07-02 - Priority-2 polish, and the external items prepared to one human action

The Priority-2 backlog items shipped for real, and the account/people/funding-gated items prepared so
each is a single human action away. The two heaviest architecture items are specced as ADRs rather than
half-built, because they need infrastructure to build and test honestly.

Built and tested (offline, real):
- **Searchable docs site (eval 09).** New mkdocs.yml (Material theme, search) builds the existing docs
  into a rendered, searchable site; the Pages workflow now deploys the landing page and the docs site
  together (mkdocs build --strict is clean). docs/requirements-docs.txt pins the toolchain.
- **Citation export (eval 04).** New tools/cite_export.py turns a refs.bib or a findings CSV into
  well-formed BibTeX or RIS, deterministically; it reformats and exports only, it does not fetch or verify
  (that stays paper_search plus the citations skill). Nine offline tests.
- **arXiv and PubMed in paper search (eval 04).** tools/paper_search.py now queries arXiv and PubMed
  alongside OpenAlex, Crossref, and Semantic Scholar, each degrading to a skip on network failure, with an
  offline injection seam and fixture tests. Tool budget bumped 120 to 121 for cite_export.
- **SECURITY.md contact fixed (eval 12).** The [your contact] placeholder is now a real private email; a
  vulnerability is reported privately, not in a public issue.
- **Windows encoding fix (caught by the new Windows CI matrix).** cambium_run.py now imports cambium_io so
  it prints UTF-8 glyphs safely on a cp1252 console instead of crashing; three test helpers decode subprocess
  output as UTF-8. Reproduced on Linux by forcing cp1252, fixed, and re-verified.

Prepared to one human action (external, honest about the gate):
- **PyPI publish (eval 04, 08, 12).** publish.yml builds the installable mcp_server package (cambium-mcp)
  and publishes via PyPI Trusted Publishing on a GitHub Release; python -m build plus twine check PASS
  locally. PUBLISHING.md gives the one-time trusted-publisher setup and the release steps. The account and
  the trusted-publisher config are the human actions; the rest is automated.
- **Efficacy study recruiting (eval 06).** evals/enforcement_study/RECRUITING.md adds a recruiting log and
  an ordered runbook over the already-built harness; the runs and the human raters remain the external step.
- **Maintainership (eval 12).** New GOVERNANCE.md states how the project is run and how a second maintainer
  joins, to reduce the single-maintainer bus-factor. New docs/paper/PREPRINT_OUTLINE.md is a systems-paper
  outline that invents no results and is publishable whichever way the study lands.

Specced, not built (need real infrastructure to verify):
- **ADR-0001 multi-tenancy and a database layer**, and **ADR-0002 LMS/LTI and SSO**, under
  docs/reference/adr/, record the intended design and the honest reason each is deferred until a consortium
  need or an identity provider makes it testable. Indexed from docs/reference/DECISIONS.md.

## 1.41.0 - 2026-07-02 - Priority 1: code-quality CI with a Windows matrix, and a full accessibility pass

The two Priority-1 items from the 12-evaluation backlog, built the Cambium way by parallel councils and
integrated behind one gauntlet.

- **Code-quality CI (eval 05, 08).** New .github/workflows/quality.yml adds a real quality gate. The pytest
  matrix now runs on ubuntu-latest AND windows-latest across Python 3.11 and 3.12, so a cross-platform bug
  like the Windows cross-drive relpath crash is caught in CI instead of on a push. ruff is GATING and passes
  at 0 issues on the current code (achieved by a pragmatic ruleset and per-file ignores, not by rewriting
  code). black --check, mypy, bandit, and pip-audit run ADVISORY (non-blocking) with their real numbers
  reported; coverage runs advisory at the observed 54.7 percent with a low non-failing floor. A
  .pre-commit-config.yaml wires ruff, black --check, whitespace fixers, and a no-em-dash guard for local
  use. What gates versus what is advisory, and why, is documented honestly in docs/reference/CODE_QUALITY.md.
- **Accessibility pass, WCAG 2.1 AA (eval 03, 10).** All five HTML surfaces (the gate card, both run boards,
  the generated dashboard, and the static dashboard.html) gained: a visually-hidden screen-reader summary,
  a prefers-reduced-motion reset so motion-sensitive users are respected (the static dashboard also gates
  its auto-advance on the media query), focus-visible outlines and keyboard operability on the
  Approve/Revise/Reject buttons and the interactive cards, list and region roles with aria-live="polite" on
  the live boards so streaming findings are announced, status conveyed by text not color alone, and small
  contrast nudges to meet AA. The v1.39 look is unchanged. New templates/ACCESSIBILITY_CHECKLIST.md is a
  standing, enforceable checklist and tests/test_accessibility.py (23 tests) guards every feature so it
  cannot silently regress.

## 1.40.0 - 2026-07-02 - Priority-0 security hardening + the run board is a frozen artifact

Executed the five Priority-0 items from the 12-evaluation backlog the Cambium way (parallel build
councils, disjoint file scopes, one integration gauntlet), plus froze the README run-board GIF so it
can no longer drift between what you build and what GitHub shows.

- **Web bridge: authentication, deny-by-default** (eval 01, 11). New web/server/security.py adds a
  require_key dependency: it reads CAMBIUM_API_KEY and checks X-API-Key or Authorization: Bearer with
  hmac.compare_digest. If the key is unset the protected endpoints return 503 (locked), never open, so an
  unconfigured deploy is closed by default. POST /api/run, the gate-decision endpoint, and the WebSocket
  stream now require the key; a single unauthenticated GET /health remains for probes.
- **Web bridge: rate limiting** (eval 01, 02). A zero-dependency in-process token bucket keyed by client
  IP plus key, sized by CAMBIUM_RATE_PER_MIN (default 60), returns 429 when exceeded. Auth runs before
  rate limiting, so unauthenticated floods cost no tokens.
- **Web bridge: non-root Docker + healthcheck** (eval 01). web/server/Dockerfile now creates and runs as a
  non-root user (uid 10001) and adds a HEALTHCHECK against /health.
- **provenance.py no longer uses a shell** (eval 01). The reproduce/check command now runs via
  shlex.split + shell=False, so a manifest command cannot inject through the shell (a ';' or '&&' becomes
  inert argv, proven by tests). Commands must be plain argv; the worked example still reproduces bit for bit.
- **Cross-drive relpath guards** (self-found during the v1.39 push). New cambium_io.safe_relpath falls back
  to the absolute path when os.path.relpath raises the Windows cross-drive ValueError; wired into
  budget_review, budget_narrative_match, checklist_builder, and solicitation_explainer so a user passing an
  input file on another drive no longer crashes.
- **The run-board GIF is a committed artifact now.** assets/run_board.gif is regenerated only by hand via
  assets/gen/gen_runboard_gif.py; the push script, the assets CI workflow, and gen_board_image.py no longer
  re-render it, so every push keeps the exact committed GIF and GitHub always shows the canonical v1.39
  live-board style (Up-next collapse, streaming findings, top decision bar). The generator gained a
  multi-OS font fallback so a hand-run renders cleanly on Linux, Windows, or macOS.

## 1.39.0 - 2026-07-02 - The board comes alive: one source of truth, findings that stream, a gate you never scroll for

A full UX pass driven by an end-to-end audit of the real first-run experience, then built and integrated
the Cambium way. The terminal always kept the promise the README GIF sells; now the in-chat visual board
keeps it too.

- **One plan, one state, every surface agrees.** run_state.json is the single source of truth: the routed
  plan (phases, groups, agents, gate per phase) is written once by task_router, and the text board plus both
  HTML boards render from it. For the same run they now report identical counts (22 specialists, 6 councils,
  3 gates for a software run), ending the old contradiction where two planners fed two faces different numbers.
- **Findings come alive.** Each agent's one-line finding surfaces the moment it reports (run_state.py finding
  and status subcommands write to a per-agent map; both boards merge it by agent id). A done agent shows a
  check and its finding, a working agent shows working, queued stays quiet. Findings are HTML-escaped.
- **The queued wall is gone.** Started phases render in full, then a compact "Up next: Execution (4) ->
  Verification (6)" strip stands in for not-yet-started councils, cutting the inline fragment from ~12KB to
  ~5KB and removing 18 identical queued cards.
- **Clean and de-duplicated.** The councils status strip uses a distinct not-started glyph so
  "Orchestration o . Labs o" never reads blank, and an agent that recurs across phases is not drawn twice in
  one view.
- **Quiet repaint.** run_state.py phase now prints a one-line nudge plus the exact repaint command instead of
  dumping a 16KB HTML fragment into the transcript; the fragment is opt-in with --emit.
- **The gate you never scroll for.** gen_gate_card.py gained a decision bar at the very top (Approve / Revise
  / Reject visible without scrolling), CSS-variable theming so it adapts to light and dark chat instead of a
  hard-coded dark slab, a coaching-voice contribution prompt aligned with FIRST_RUN's promise, and a
  plain-words glossary (gate, evidence tiers, P0/P1/P2, F&A). Empty sections are suppressed so a sparse gate
  stays short. User text stays escaped.
- **Per-run gate scope.** run_fidelity now scopes gate status to the current run, so a brand-new user's
  close-out no longer shows 60+ historical approvals from the project's own dev history as their run's gates.
- **Caught at the finish line, not after.** The first board build passed its unit tests but rendered no
  findings when driven end to end (a 0-based vs 1-based phase-cursor mismatch the hand-built test dicts hid).
  Rendering the real board caught it; the fix ships with new end-to-end tests that drive run_state.py the real
  way so it cannot regress.
- **Windows cross-drive fix (caught by the pre-push guard).** run_state.py's repaint reminder called
  os.path.relpath(state, repo), which raises ValueError on Windows when the temp state file is on C: and the
  repo is on D:. The Linux CI never hit it; the Windows pre-push test run did, exactly as designed. Guarded to
  fall back to the absolute path, with a regression test that forces the cross-drive ValueError so Linux CI
  guards it too.
- **The demo asset matches the product.** assets/run_board.gif was rebuilt to depict the v1.39 behavior:
  started councils show streaming findings, not-yet-started councils collapse into an Up-next strip, and the
  gate card leads with the Approve / Revise / Reject decision bar. Verified frame by frame. The assets CI
  workflow now regenerates the canonical README-quality GIF last so it can never be clobbered by the older
  PNG generator (both historically wrote the GIF). All generated diagrams (capabilities, org-chart, lifecycle)
  regenerated and confirmed at 46 agents, 11 councils, 120 tools, 40 skills, 8 gates.

## 1.38.0 - 2026-07-01 - Measurement becomes the boss: consolidation, golden routing, red-team, frozen budget

Everything from the frontier-lab gap assessment that needs no external help, built in one governed run
by four parallel councils and integrated behind the full gauntlet.

- **Consolidation gate executed.** Six near-duplicate tools retired to pointer stubs for one release
  (agent_scaffold, glossary_gen, flashcards, deadline_radar, plugin_lint, revision_matrix), every
  unique feature and its test coverage ported into the keepers first (new_agent/new_skill,
  glossary_builder, flashcards_export, award_calendar with VALARM + multi-source ics, plugin_smoke
  now 9 checks, rebuttal_matrix with reviewer sectioning). Three pairs kept deliberately as different
  jobs, documented in their docstrings.
- **Routing drift is now a red test.** tests/golden/routing/ freezes 15 canned plans across all 8
  task types; tests/test_routing_golden.py compares live route() output field by field and names the
  drift; tools/gen_routing_golden.py regenerates deliberately (--check for CI). Structural invariants
  included: routed agents must exist, the conductor is never a worker, writeups carry a release gate.
- **Untrusted text gets a guard and a red team.** tools/intake_guard.py (advisory pattern screen:
  instruction-override, script vectors, bidi/zero-width, base64 blobs; wrap() fences input as data,
  not commands; explicitly not a security boundary) plus tests/test_redteam_intakes.py firing an
  adversarial corpus at nine real intakes. Five real defects found and fixed: crash-to-traceback in
  solicitation_explainer and flashcards_export, UnicodeDecodeError in three readers, and an unbounded
  O(n*m) pairing in policy_diff now capped and noted.
- **The toolkit is frozen at 120.** tools/tool_budget.json + doctor check [9]: growing the count
  fails the health check unless the budget is bumped in the same commit, and CONTRIBUTING's new rule
  requires naming the eval or check a new tool moves. Deletion is celebrated.
- **ADR discipline.** templates/ADR.md + an advisory close-out signal when an architectural release
  ships without touching DECISIONS.md.
- **North-star scoreboard on the dashboard.** Five numbers, honest states: false-claim delta OPEN
  until the v1 study runs, routing fidelity PASS (measured live), minutes-to-first-value unmeasured,
  external groups 0, red pushes 0.

## 1.37.0 - 2026-07-01 - Audience power-up: 25 new tools, five for each of the five audiences

The Director approved a 25-item slate (5 net-new capabilities per audience) and a parallel build:
five build councils, one per audience, working simultaneously under strict conventions (advisory
language where compliance is involved, named and dated sources for every encoded external rule,
no invented rates or prices, offline deterministic tests). Orchestrator integrated and the full
gauntlet ran green before commit.

- **Researchers and PIs:** prereg_builder (pre-registration doc + completeness check), power_calc
  (deterministic power/sample-size, documented formulas), rebuttal_matrix (reviewer-response
  tracker, flags unaddressed points), venue_matcher (transparent lexical matcher, editable
  profiles), retraction_check (Crossref-backed retraction/correction flags on cited DOIs,
  degrades gracefully offline).
- **Research administrators:** common_forms_check (NIH/NSF Common Forms 2026 pre-flight: ORCID,
  5+5 products, certification; advisory, SciENcv remains the official instrument),
  effort_reconciler (person-months across projects, over-commitment flags, 2 CFR 200.430 as
  named motivation), subaward_consolidator (multi-site roll-up, every arithmetic step shown),
  award_calendar (deadline schedule + ics from award terms only), policy_diff (what changed
  between two solicitation versions, lexical not legal).
- **Developers:** new_agent and new_skill scaffolders (valid-by-construction frontmatter),
  plugin_smoke (packaging smoke test, green on this repo), api_stability (public CLI/MCP surface
  diff with semver advice), env_doctor (machine-side environment check complementing the repo
  doctor).
- **Institutions and funders:** audit_bundle (one-command evidence pack, calls the real hash-chain
  verify, plain-language INDEX.md), control_map (NIST AI RMF 1.0 self-assessment matrix with an
  honest gaps section), sod_report (separation-of-duties attestation over the gate ledger),
  archive_project (copy-only retention archive with hash continuity), cost_report (roll-ups from
  user-supplied rates only; refuses to invent prices).
- **Educators and learners:** flashcards_export (consumes the real Learning Lab format; 73 cards
  from the shipped academy in the live check), course_pack (syllabus from the run's own sources),
  glossary_builder (auto-extracted, review-before-teaching banner), transcript (hash-chained
  local learner record, not an accredited credential), gate_simulator (8 scenarios matching the
  real gate semantics, one per gate).
- Tool count 71 to 96; README, TOOL_INDEX, capabilities, and dashboard regenerated so every
  stated count is computed from the repo, not asserted.

## 1.36.0 - 2026-07-01 - Review closeout: every FABLE finding fixed and made unrepeatable; MCP surface grows to 10

An independent review by a different model family (FABLE_REVIEW.md, Claude Fable 5) graded the repo A- with
three P1 findings, each an instance of Cambium's own standards applied to itself. This release closes every
P1 and P2 from that review, extends the deterministic checks so each failure class cannot recur unseen, and
grows the MCP surface so external clients can drive the fidelity loop and the institute's memory.

- **Ledger repaired, and now machine-checked.** The two fused rows in governance/GATES.md (G-readme/G-landing,
  G-build/G-fit) are split, with truncation points marked in place; lost text was NOT reinvented. The approvals
  log is normalized to one canonical column order (Gate/Date/Approver/Decision/Notes). Doctor gained check [7]:
  any row without exactly 5 cells fails the health check, so a malformed audit row can never sit unnoticed
  again. Recorded as G-ledger-repair.
- **Dashboard drift: overclaim retracted, enforceable guarantee built.** G-dashboard-auto recorded "CI
  regenerates + git-diffs so the dashboard can never drift" while validate.yml said the opposite; carrying
  both was the one thing Cambium says it never does. The claim is retracted (G-dashboard-amend). The mechanism
  that IS enforceable everywhere: gen_dashboard stamps data-cambium-version into the HTML and doctor check [8]
  goes RED when the stamp does not match plugin.json, which forces a regenerate every release. Regenerated now.
- **Version drift can no longer hide.** Root pyproject.toml sat at 1.20.0 for fifteen releases because
  sync_version.py never covered it. It is in the sync list now (four manifests + README badge), doctor [8]
  cross-checks it, and CI's version step is `sync_version.py --check` over all of them at once.
- **Doctor sees the whole repo.** Python parse coverage extended from tools/ + governance/ to tests/, evals/,
  scripts/, and mcp_server/, with an explicit null-byte detector for truncated writes, the exact failure class
  that made the test suite uncollectable during the review (a doctor blind spot at the time). 161 files
  parsed, up from 80.
- **Reproducible CI.** New constraints.txt pins the test environment; CI installs with `-c constraints.txt`,
  so a green build means the same thing on every machine.
- **MCP surface: 6 to 10 tools.** cambium_dispatch (literal per-phase dispatch script), cambium_fidelity
  (close-out scorecard), cambium_recall (semantic memory over curated findings), and cambium_graph (multi-hop
  concept graph) join the original six. gen_readme now counts MCP tools from the @mcp.tool() decorators in the
  server itself instead of reading the README's own claim back to it.
- **knowledge-graph skill is now discoverable.** It was the one skill shipping without YAML frontmatter, so
  plugin clients showed an empty description. It has a proper name and description now.
- Verified on release (clean Linux sandbox, pinned env): pytest 644 passed + 1 skipped; doctor 163 ok /
  0 problems, self-grade A (100%), no risks; consistency check OK; sync_version --check clean across all
  manifests; enforcement gauntlet ALL CONTROLS PASS; 46 agents valid; dashboard regenerated and stamped.

## 1.35.0 - 2026-06-30 - Orchestrator fidelity: every agent has a job, and skips are visible

The recurring problem that the orchestrator does not always send the routed agents got its real fix, designed
and audited the Cambium way, then built and tested live.

- **No more orphan agents.** partnership-liaison is now dispatched in the grant path, and a new post-award
  `project` task type routes program-manager (work breakdown, milestones, subawards). Every roster agent
  except the orchestrator (the conductor) is now reachable by some route, checked by a test.
- **Execute a plan, do not invent one.** New `tools/dispatch_plan.py` turns `route(task)` into the literal
  agent calls to make per phase, with stop-at-gate lines.
- **Skips are visible.** New `tools/run_fidelity.py` prints a close-out scorecard comparing the routed plan
  against what actually happened (agent coverage, phase progress, gate recorded, learning delivered).
  Advisory and post-hoc; it never blocks, it puts the gap in front of the human.
- **Real enforcement for every task type.** `tools/cambium_run.py` can now build its phases from `route()`
  (`--from-router`, auto when no phases.yml), so the strict runner's unforgeable gate tokens cover software,
  review, data, report, and project runs, not just grants. The gate-token minting is untouched; only the
  phase source changed. The phases.yml path still works.
- **Honest two modes.** New `docs/concepts/RUN_MODES.md`: chat /cambium is convenient best-effort (helped by
  the dispatch plan and the scorecard); the programmatic runner is strict and guaranteed.
- Also fixed two bugs the live test run caught: a real HTML-escaping hole in the gate-card renderer (a
  script is now escaped, a safe table still passes) and a stale README tool count.
- Tests: new suites for the router orphan fix, dispatch_plan, run_fidelity, and the runner-to-router adapter,
  all passing here; resume and gate enforcement confirmed unbroken.

## 1.34.0 - 2026-06-30 - Run experience: a gate you can click, a board that stays live (gate G1)

A UX and orchestration-fidelity review (Verification and Faculty councils) found the real causes of the rough
spots the Director reported, and Execution fixed all five.

- **Clickable gate.** The dead, non-interactive gate buttons in `tools/gen_board_pro.py` are now real
  `<button onclick="sendPrompt(...)">` controls matching `gen_inline_board.py`, with a "you can also type it"
  fallback. Approve, Revise, and Reject now actually submit the decision.
- **Never a thin gate.** New `tools/gen_gate_card.py` renders the full eight-section gate one-pager with the
  working buttons, so a gate is never rendered empty.
- **Live board.** `tools/run_state.py phase N` now prints a repaint reminder and the current board fragment,
  so the board no longer freezes after Act I.
- **Learning delivered, not just filed.** `tools/learning_delivery.py` gains a `deliver` subcommand that
  prints the packet body, making delivery and the check a single action.
- **Fidelity.** New `tools/gen_tool_index.py` builds `tools/TOOL_INDEX.md`, an inventory of every tool, and
  `docs/concepts/PRESENTATION.md` now tells the Orchestrator to consult it and use the routed councils and
  existing tools before improvising. Wired into the push script.
- **Tests** added across the five. They run on the developer machine via the push hook; the sandbox folder
  was unmounted during the build, so the fixes were verified by inspection here.

## 1.33.0 - 2026-06-30 - Assets and README badge kept current automatically

The run-board GIF and the version badge had gone stale because nothing regenerated or stamped them on
release. Fixed so they self-heal for everyone.

- **push_cambium.bat** now regenerates the visual assets on every push: `tools/gen_lifecycle.py`
  (lifecycle.svg) and `assets/gen/gen_runboard_gif.py` (the current 7-frame run_board.gif). They can no
  longer ship stale. Non-fatal if Pillow or imageio is missing.
- **tools/sync_version.py** now also stamps the README version badge from the CHANGELOG, alongside
  plugin.json, marketplace.json, and mcp_server/pyproject.toml. The close-out review already flags this
  drift; now the release step prevents it.
- **README**: version badge refreshed to the current release, and a hand-written tool count that duplicated
  the auto-synced STATS block was reworded to avoid drift. architecture.svg (11 councils, 46 agents) and
  responsible-ai.svg verified current.

## 1.32.0 - 2026-06-30 - Four research-administration helper tools

Generic, advisory tools for any sponsored-programs office. Each one flags or assembles and then stops at a
human; none certifies, produces official figures, or acts as a system of record.

- **tools/budget_narrative_match.py**: flags where a proposal budget and its budget-justification narrative
  disagree (categories or amounts in the budget that are missing or inconsistent in the narrative), a common
  cause of desk rejects.
- **tools/checklist_builder.py**: turns a structured solicitation rules file into a submission checklist a
  human works through (required documents, budget sections, limits, cost share, deadline).
- **tools/proposal_timeline.py**: a backwards-planned deadline and task tracker for a proposal, with a
  built-in default task set and an optional .ics calendar export, all stdlib.
- **tools/solicitation_explainer.py**: renders a structured solicitation into a plain-language one-page
  summary for a new PI.
- **Tests**: 46 across the four tools. They run on the developer machine via the push hook; the sandbox mount
  dropped mid-run, so they were verified clean by inspection here (no em dashes, no program-specific naming).

## 1.31.0 - 2026-06-30 - One version, stamped everywhere (no more plugin-update drift)

The plugin version had drifted: `plugin.json` sat at 1.18.0 while the project moved to 1.30.0. So
`/plugin update` never saw a new version, and selecting a command failed with "unknown skill/plugin." Fixed
the drift and automated it so it cannot recur.

- **New `tools/sync_version.py`** reads the latest version from CHANGELOG.md and stamps it into the three
  manifests that must agree: `.claude-plugin/plugin.json`, `.claude-plugin/marketplace.json`, and
  `mcp_server/pyproject.toml`. Idempotent, targeted edits (no reformatting), with a `--check` mode for CI.
- **`push_cambium.bat`** now runs `sync_version.py` before committing, so every release advertises its new
  version number, `/plugin update` always registers it, and the CI version-consistency check passes.
- Guard test in `tests/test_sync_version.py`.

## 1.30.0 - 2026-06-30 - Assigned duties become structure, not enforcement (governance)

A run exposed two gaps: the orchestrator skipped the router's assigned toolsmith provision phase and the
Support README refresh, and the README drifted. The Director asked for a meaningful fix, not a rigid lock:
the orchestrator should reason from a clear structure and the human should see and own the outcome. So we
fixed the structure and added an honest mirror, not a gate.

- **Routing (structural).** `outreach` is now in `_closeout()` in `tools/task_router.py`, so refreshing the
  README is a named Support duty in every routed plan, not an afterthought.
- **Advisory review, not a gate.** `tools/closeout.py` is broadened into an honest close-out review: version
  badge versus the latest CHANGELOG, skills count, an undescribed-skill signal, plus the existing tool-count
  and CHANGELOG checks. It is clearly labeled advisory and informs the orchestrator's judgment; no new
  run-failing deterministic check was added.
- **Contract as principle.** `docs/concepts/PRESENTATION.md` (Act II and Act IV) now states the posture:
  the orchestrator consults the routed plan and dispatches the agents it names, reads the close-out review,
  decides with judgment, and states any deliberate deviation to the Director. Structure guides, the
  orchestrator reasons, the human owns the outcome. Also fixed a pre-existing truncated final sentence.
- **Tests:** `tests/test_closeout.py` extended (outreach in the close-out plan, version-badge drift, the
  undescribed-skill signal). Verified on the developer machine via the push hook; the sandbox mount could not
  run the freshly written file.

## 1.29.0 - 2026-06-30 - Full-stack AI engineer: nine engineering skills (gates G1, G4)

Run the Cambium way (Scouts + Faculty scoped it, Execution built it, Verification audited it, the Director
approved at G1 and G4). Cambium goes from 31 to 40 skills and can now act as a full-stack AI engineer.

- **Nine new skills** under the software-engineering set: `ai-application-engineering` (RAG, agents, evals,
  guardrails), `backend-api-design`, `databases-and-data-modeling`, `software-architecture`,
  `software-testing-qa`, `debugging-observability`, `devops-cicd`, `cloud-deployment`, and
  `security-engineering`. Each has trigger-rich frontmatter, an opinionated body, honest guardrails, and cited
  sources.
- **Honest boundaries, enforced by review.** Verification (integrity-officer + verify-domain) confirmed zero
  em dashes and that each skill states its limits: security guidance is not an audit, cloud never provisions or
  holds credentials, and AI features need evals plus a human. Fixes applied: python-jose replaced with PyJWT,
  destructive-DDL wording made precise, unsourced figures removed, star counts marked point-in-time.
- **Shared conventions.** New `docs/engineering_conventions.md`: progressive-disclosure authoring, a
  four-dimension definition-of-done scorecard (security, performance, tests, docs), architecture-first ADRs,
  and the shared honest boundary. Ideas adopted with credit from jeffallan/claude-skills (MIT),
  ui-ux-pro-max (MIT), and the senior full-stack engineer suite (idea only, no license found); see ATTRIBUTION.md.
- The skills count updates itself on the next generate. Note: three skills were briefly authored into the parent
  folder and moved into the repo; delete the stray copies under the parent `Cambium/skills/` on your machine.

## 1.28.0 - 2026-06-30 - UI/UX skill deepened from the best open design skills

Folded the durable, open ideas from the top UI/UX agent-skill repositories into `skills/ui-ux-design`, with
credit and no code copied.

- **DTCG design tokens.** The skill now recommends the Design Tokens Community Group JSON format so tokens
  are portable across Figma, Style Dictionary, and code, not hand-copied. (Idea from ux-ui-agent-skills.)
- **Design-system presets.** Start from an open, battle-tested system (Material 3, IBM Carbon, Adobe Spectrum,
  Shopify Polaris, GitHub Primer, GOV.UK) and override the brand layer, rather than inventing tokens per project.
- **Toolbelt additions.** `docs/web_ui_toolbelt.md` gains a "UI/UX design skills to learn from" table
  (ui-ux-pro-max, ux-ui-agent-skills, LibreUIUX, the official frontend-design skill) and a design-token
  standard and open-design-systems section.
- **Attribution.** `ATTRIBUTION.md` credits ux-ui-agent-skills (plugin87), LibreUIUX-Claude-Code (HermeticOrmus),
  ui-ux-pro-max-skill (nextlevelbuilder), and the DTCG. Ideas adopted, no files copied; verify each license
  before adapting any file.

## 1.27.0 - 2026-06-30 - Web development and UI/UX design skills

Cambium had one narrow front-end skill (cinematic-frontend, a 3D showcase) and no general web or design
skill. Added two, so the institute can build ordinary web work well, not just a "wow" scene.

- **New skill `web-development`.** Chooses the right stack instead of defaulting to a framework (plain HTML,
  Astro, React or Next.js, SvelteKit), sets up styling and components (Tailwind, shadcn/ui on Radix), holds
  a Core Web Vitals budget (LCP, INP, CLS), and tests with Vitest, Playwright, and axe. Honest about judging
  the result in a real browser and the Cowork artifact storage limits.
- **New skill `ui-ux-design`.** Accessibility-first (WCAG 2.2 AA, contrast, keyboard, focus, no bad ARIA),
  three-tier design tokens, mobile-first layout, the full set of interaction states, form usability, and
  Nielsen's 10 heuristics as a review checklist. Advises and flags; the human designer decides.
- Both skills name their sources (W3C/WCAG, MDN, web.dev, Nielsen Norman Group, and the tools' own docs) and
  pair with each other. The skills count updates itself on the next generate.
- **New `docs/web_ui_toolbelt.md`,** a curated shortlist of the proven, most-starred web and UI/UX
  repositories (frameworks, styling, component libraries, icons and animation, and the top learning and
  reference lists), with when-to-use notes and honest caveats. These are references to install per project,
  not Cambium dependencies; popularity is treated as a signal, not a reason.

## 1.26.0 - 2026-06-30 - Local PII screening

Their first pillar is Security: research administration handles confidential and personally identifiable
information. Added a local PII screener so sensitive data is flagged before a document is handled or shared.

- **New `tools/pii_screen.py`.** Screens text for likely PII and reports the entity type, character span,
  confidence, and a masked snippet. Uses Microsoft Presidio if installed (rich, multi-entity), otherwise a
  stdlib regex screener: email, US phone, US SSN, credit card (Luhn-checked), and IP address. Supports a
  `--redact` mode that writes a cleaned copy.
- **Security-critical invariant, tested:** the report and the redacted copy never echo the raw PII value.
- **Honest framing:** it is a screen, not a guarantee. It does not promise to catch everything, and a human
  must review before any document is shared.
- **`requirements-ai4ra.txt`** gains the optional, heavy `presidio-analyzer` (plus a spaCy model). Cambium stays
  stdlib-first: the regex fallback runs with zero new dependencies.
- **Tests:** `tests/test_pii_screen.py` (14 tests, run green in the sandbox), including the no-raw-leak invariant.

## 1.25.0 - 2026-06-30 - A research-administration toolkit: disclosure, FAIR catalog, rules handoff (gate G1)

Scoped against AI4RA's published framework (NSF award 2427549): their three objectives (FAIR open data,
trustworthy tested AI tools, a scalable community of practice), the Four Pillars (Security, Accuracy,
Reproducibility, Flexibility), and the TaMPER workflow (Task, Model, Prompt, Evaluation, Reporting). Cambium
already fits as the preparation-and-governance layer between an extractor (Vandalizer) and a system of record
(iRIS). This release adds the small pieces that make that fit legible to research administrators, and adopts a
few lightweight, optional, well-licensed libraries without giving up Cambium's stdlib-first stance.

- **New `tools/tamper_record.py`.** Emits a TaMPER record (Task, Model, Prompt, Evaluation, Reporting) plus a
  Four-Pillars self-check for any run, in Markdown, JSON, or W3C PROV (PROV is optional; it falls back to JSON
  and says so). Honest by design: it reports only what the run recorded, marks the rest "not recorded", and does
  not claim Cambium chose or hosted a model.
- **New `tools/fair_descriptor.py`.** Writes a Frictionless-style `datapackage.json` cataloging a run's outputs
  so they are Findable, Accessible, Interoperable, Reusable (their Objective 1). Validates with `frictionless`
  if installed, else writes a valid descriptor anyway.
- **New `tools/rules_handoff.py` and `examples/ai4ra/vandalizer_handoff.schema.json`.** A JSON Schema for the
  solicitation rules an extractor like Vandalizer hands over, plus a validator so a valid handoff drops straight
  into `budget_review.py` with no manual conversion (the Flexibility pillar). Uses `jsonschema` if present
  (newest available validator), else a stdlib check.
- **`tools/ai_disclosure.py` gains `--format json`,** a schema-aligned export of the AI-use disclosure for
  another system to consume (the TaMPER Reporting step).
- **`requirements-ai4ra.txt`** pins the optional extras (jsonschema, frictionless, prov, pip-tools). Every tool
  degrades gracefully without them and says which path it used.
- **Tests:** `tests/test_tamper_record.py`, `tests/test_fair_descriptor.py`, `tests/test_rules_handoff.py`,
  `tests/test_ai_disclosure_json.py`. Honest note: the first three (30 tests) were run green in the sandbox; the
  ai_disclosure JSON tests and the full suite run on the developer machine via the pre-push hook, because the
  sandbox file mount could not reliably serve the freshly edited file.
- **New `docs/ai4ra_alignment.md`** maps every objective, pillar, and TaMPER step to the Cambium file that
  serves it, with honest gaps.

## 1.24.0 - 2026-06-30 - A README that actually shows the work (gate G2)

A reviewer noted the README and assets undersold the week of engineering. Rebuilt the README the Cambium
way (outreach designed it, the integrity officer set the honesty guardrails) so the work is visible without
tipping into hype.

- **New README sections.** "Who it is for" (an audience map: researchers and PIs, research administrators,
  developers, institutions and funders, educators, one honest line each); "What we engineered" (the work by
  cluster, each naming its real file: the router, the gate and audit machinery, the evidence contract, memory
  and the knowledge graph, the learning system, the read-only-plugin data-home fix, the research-administration
  tools); "Skills and features, built and adopted" (built in-house vs adopted with attribution); and "Capacity
  and strength" (the auto-synced numbers).
- **Two new assets,** readable and brand-matched: `assets/capabilities.svg` (the engineering clusters and the
  capacity at a glance) and `assets/adopted-ideas.svg` (the ideas adopted from other work, with attribution,
  and where the heavy dependency was declined). The hero image is unchanged.
- **Removed** the unused `demo.gif` and `demo_example.gif` from the README (archived).
- **The showcase assets generate themselves now.** New `tools/gen_capabilities.py` rebuilds
  `assets/capabilities.svg` from the live repo counts (agents, councils, gates, tools, skills, tests) and
  `assets/adopted-ideas.svg` from `assets/adopted_ideas.json`, with a `--check` mode for drift. The push
  script runs it before every commit, so those numbers never go stale by hand again. +7 tests.
- Honesty guardrails held: every capability labeled enforced (with its mechanism) or partial / roadmap; the
  A/B study stays a reported null; the live web mode stays a simulation; no "best / guaranteed / autonomous /
  production-grade"; novelty framed as the integration; every number reproducible from the repo.

## 1.23.0 - 2026-06-30 - Two research-administration add-ons that sit above extraction (gate G2)

Tuned toward UIdaho's AI4RA program (AI for research administration). The scouts found AI4RA does document
EXTRACTION (Vandalizer); the open gaps are reasoning and governance ACROSS the award lifecycle, which is
Cambium's nature. An idea tournament and a research-administration faculty consult converged on two
complementary add-ons, built here, that sit above extraction rather than repeating it.

- **`tools/ai_disclosure.py`.** Assembles an AI-use disclosure plus an audit summary from records Cambium
  already keeps (gate decisions and approvers from GATES.md, the contribution and audit trail, which agents
  ran). Addresses the newly required AI-use disclosure (for example NIH NOT-OD-25-132). It documents what AI
  did and that a human signed off; it explicitly does NOT certify compliance. Skill: `skills/ai-disclosure`.
- **`tools/budget_review.py`.** A deterministic budget-to-solicitation REVIEW that FLAGS issues (F&A cap,
  cost ceiling, period, required sections, disallowed categories, cost-share) against a solicitation-rules
  file. Advisory only and honest by design: it says "review" and "flag," never "validate," and a human in
  sponsored programs makes the final call. Consumes the kind of structured rules AI4RA's Vandalizer extracts.
  Example inputs under `examples/ai4ra/`. Skill: `skills/budget-review`.
- +31 tests. budget_review verified live; ai_disclosure verified by inspection after verification caught and
  fixed two bugs (an agent_cards list-vs-dict crash, and a "validate" wording slip). Honest framing carried
  throughout: advisory, not a compliance determination; documents AI use, does not certify.

## 1.22.0 - 2026-06-29 - Run data is writable even when Cambium is an installed (read-only) plugin

When Cambium is installed as a plugin, its `tools/` folder is read-only, but several tools wrote run state,
boards, and caches back into the install directory and failed. This separates the read-only code from the
writable run data, so an installed plugin just works.

- **New `data_home()` in `tools/cambium_io.py`.** One resolver for where run data is written, with a
  backward-compatible precedence: the `CAMBIUM_HOME` env var if set; else the install root if it is writable
  (the dev, repo, and test case, so nothing changes there); else a per-project `.cambium/` directory under
  the current working directory, so run data stays with the user's project. Adds `run_state_path()`,
  `run_board_html_path()`, and `memory_cache_dir()` helpers.
- **The run-state, board, learning-delivery, and memory/graph cache tools now write through `data_home()`**
  (cambium_start, run_state, run_trace, gen_board_pro, gen_inline_board, learning_delivery, memory_recall,
  concept_graph). Read paths for committed repo content (templates, skills, agent cards) are unchanged; only
  writable run data moves.
- The invariant `data_home() == ROOT` whenever the install is writable keeps the whole existing test suite
  green. +7 tests in tests/test_data_home.py.
- Honest status: verified by inspection; the sandbox mount blocked a live pytest run here, so the tests
  confirm on a clean machine. Until the installed plugin is rebuilt from this fix, a read-only plugin run
  still needs the writable-copy workaround.

## 1.21.0 - 2026-06-29 - A lean local knowledge graph, the learn-first brain sized honestly (gate G-fit)

A reviewer suggested Cambium adopt a GraphRAG + Graphiti + Neo4j "learn first, then execute" brain. Run the
Cambium way (landscape / methods / prior-art scouts + faculty on knowledge graphs), the gate decided to build
a lean in-house increment, not the heavy stack: Cambium is solo and server-less, Neo4j and Graphiti need a
running database that breaks the git-auditable guarantee, Microsoft GraphRAG needs a cloud LLM call per query,
and Cambium already owned the OKF entity graph, the memory_recall tool, and a typed ledger. The one real gap
was a graph you can walk at query time.

- **New `tools/concept_graph.py`.** A fully-local knowledge graph over Cambium's own curated records.
  Structural extraction from typed ledger fields first (not LLM extraction, which can poison a graph). Nodes:
  findings, decisions / gates, agents, concepts. Typed edges: decided-by, supports, derived-from, cites,
  relates-to, contradicts. Multi-hop queries (neighbors, shortest path, what-supports, what-contradicts) that
  flat keyword recall cannot answer. Uses networkx when present, pure-stdlib adjacency fallback otherwise.
  Cache gitignored. Verified live: a 57-node graph with a working multi-hop demo.
- **Contradiction guardrail.** The graph FLAGS contradictions (edges marked UNRESOLVED, human gate required)
  and NEVER auto-resolves them. Resolution stays a human decision at a gate.
- **A thin `memory_recall` adapter** can expand a query with the graph's neighbors, behind an explicit call,
  existing behavior unchanged. New `skills/knowledge-graph/SKILL.md`. +12 tests. LightRAG is named as the
  optional future upgrade if a local model is ever wanted.
- **Readability:** the in-chat run board (`gen_inline_board.py`) now uses larger, less cramped type so every
  user's board reads cleanly.

## 1.20.0 - 2026-06-29 - AI assists, never replaces, in the words and in the code (gate G-fit)

Cambium's university AI and IT council asked for one thing: every claim should show AI assisting the
researcher, never replacing them or authoring the scholarship. We ran the audit the Cambium way
(integrity-officer, research-assistant, research-conduct-officer, outreach) and fixed both the message and
the mechanism.

- **Assistive-voice copy.** The README tagline, subhead, and feature rows; the USE_CAMBIUM and
  GETTING_STARTED opening lines; the document-office, proposal-writer, and lab-statistics agent cards; and the
  grant-writing, scientific-writing, and proposal skill descriptions now frame the AI as drafting options and
  running checks for a researcher who stays the author and the decider. The RFP example is the model: Cambium
  pulls the RFP, matches your expertise, asks your interests, finds gaps and needed sections, proposes topics,
  then you develop the proposal with it.
- **A human release gate on finished deliverables (`tools/task_router.py`).** The writeup path (paper,
  proposal, thesis) previously closed out with no human sign-off on the manuscript itself; G4 approves
  findings only. The new G-release gate fires after the deliverable is drafted and before closeout, so a
  person approves the finished work, not just the findings.
- **Researcher interests required before drafting.** New `require_researcher_profile()` guard plus
  `GENERATIVE_TYPES` and `NEEDS_RESEARCHER_INPUT`: on generative task types, an empty researcher profile
  stops the run and asks for the researcher's interests and expertise before anything is proposed. Enforced
  at the CLI. +29 tests.
- Honest status: code complete and verified by inspection; the live test run was deferred to a clean machine
  because the build sandbox mount blocked execution here. Follow-up: wire the profile guard into the Cowork
  run contract, and record G-release in the gate registry.

## 1.19.0 - 2026-06-29 - We asked whether to adopt MemPalace, and built our own instead (gate G-fit)

The Director asked whether to integrate MemPalace, an external memory-palace tool (a local MCP server over a
ChromaDB vector store). Run the Cambium way, Scouts plus Verification plus Faculty plus Governance reviewed
it, and the gate decision was no. MemPalace is about three months old with 875+ open issues, its headline
benchmarks were publicly contested and walked back, and it stores conversation text verbatim, which can index
pasted secrets. But the gap it pointed at was real: Cambium could not search its own past findings. So we
adopted the capability, not the dependency.

- **New `tools/memory_recall.py`.** A dependency-light semantic-recall layer that indexes only Cambium's
  already-committed curated records (the findings ledger, GATES.md, the contribution ledger, agent notes,
  docs) and ranks them with a pure-stdlib BM25 scorer. An optional local-embedding rerank engages only if
  sentence-transformers is installed, with a graceful fallback otherwise. Every result carries provenance:
  source file, line, and a snippet.
- Because it indexes only curated, committed records and never raw transcripts, there is no verbatim-secret
  risk. The index cache lives at `.cambium_memory/` and is gitignored, never committed.
- **New `skills/memory-recall/SKILL.md`** tells agents, the record-keeper especially, to query past findings
  before starting related work. +9 tests.
- Honest status: the code is complete and verified by inspection; the live recall run was deferred to a clean
  machine because the build sandbox's filesystem mount blocked execution. Reproduce with
  `python3 tools/memory_recall.py index` then `python3 tools/memory_recall.py query "..."`.

## 1.18.0 - 2026-06-29 — Three outside ideas, integrated honestly (gates G-integrate, G-build)

We took a Loop Engineering paper, Meta's V-JEPA, and Google's Open Knowledge Format and asked, the Cambium
way, what each could actually do for us. A faculty honesty pass cut two overclaims before we built.

- **Four-cost loop guard (`tools/loop_costs.py`)**, from the Loop Engineering paper. Names Cambium's defense
  against the paper's four silent costs and flags weak ones: verification debt, comprehension rot, cognitive
  surrender, token blowout. The sharp one: it reads the per-gate contribution score `learning_gate.py`
  already writes but nothing ever read, so a bare approval (cognitive surrender) is finally caught. Ships
  with a run-aborting budget cap and a `run_budget_usd` config key. Registered as a deterministic check.
- **OKF export (`tools/okf_export.py`)**, from Google's Open Knowledge Format. Turns a run's findings, gate
  decisions, and provenance into a portable bundle of markdown + YAML frontmatter, cross-linked, with a
  self-contained Cytoscape graph viewer. Cambium's knowledge becomes a standard, navigable artifact.
- **Run-outcome prior (`tools/run_outcome_prior.py`)**, the de-branded V-JEPA idea. Predicts a run's cost
  and risk from history before it runs. Honest by construction: it refuses to fabricate a risk rate on fewer
  than five gates and labels uncalibrated estimates as such. It is a heuristic prior, not a world model.
- Dropped, after review: a literal autonomous loop mode (no scheduler or worktree isolation to build it on).
  +59 tests. Honesty corrections applied: no hard budget cap existed before; V-JEPA de-branded; the OKF
  graph viewer is net-new, not pre-existing.
## 1.17.0 - 2026-06-28 — Teaching is now enforced, not optional (gate G-learn-enforce)

A user ran Cambium, something got built, and no learning happened until they complained. The pieces existed
(the teaching-assistant, the Academy, the lab generator) but nothing forced them to fire, so teaching was
reactive. This makes it load-bearing.

- **New `tools/learning_delivery.py`.** A deterministic check: a build or analysis run cannot close cleanly
  without delivering a real learning artifact. It reads the run plan, decides if the run is a build/analysis
  run, and requires either a filled `agent_outputs/learning_packet.md` or a generated lab. A stub still
  counts as missing. Registered in the deterministic-checks registry and called from `closeout.py`, the same
  pattern as the evidence and pace checks.
- **New `templates/LEARNING_PACKET.md`.** The lighter enforced default that ships on every build/analysis
  run: a plain explainer, a glossary, flashcards, and a short quiz. The full interactive Learning Lab is the
  offered next step, not the minimum.
- **Duty + contract updated.** The teaching-assistant must now produce the filled packet AND deliver it to
  the Director in chat, never just file it (`agents/17` + `.claude/agents/17`, and PRESENTATION.md Act IV).
- Proven live: a build run with no packet fails (exit 1), passes once delivered, a stub fails, a memo is
  exempt. +26 tests. Honest limit: the check guarantees a packet is produced and flagged if missing; warm
  in-chat delivery is enforced by duty, not by the checker.
## 1.16.0 - 2026-06-28 — Honest README + a README that keeps itself in sync (gate G-readme)

The README now reflects the Academy work without overselling it, and it no longer drifts out of date by hand.

- **Honest rewrite.** Fixed the leftover "spaced repetition" overclaim and added a short "Learn by doing"
  section that tells the Academy and Learning Lab story in plain prose, names the real external resources we
  link to, and states two honest limits (the Practitioner badge is not auto-minted yet; spacing is per
  browser). Zero em dashes, per house style.
- **Auto-sync (new `tools/gen_readme.py`).** Keeps the README's factual blocks current between marker
  comments: the counts line (live from disk, now 46 tools and 18 templates) and a "Recent updates" list
  built from the top of this changelog. Ships with a `--check` mode for CI and a standing outreach duty to
  run it at every close-out, so the README updates itself instead of going stale.
- Ran as a Cambium task (gate G-readme) with outreach, research-engineer, and an independent referee audit
  (accept). +4 tests. Verified: README check clean and idempotent, consistency OK.
## 1.15.0 - 2026-06-28 — Academy upgraded the Cambium way (gates G-plan, G-build)

The Academy was rebuilt as a real run, not a solo artifact: Scouts found verified outside resources, Faculty
and Labs designed the curriculum, Execution built it, and Verification checked it. Two honest fixes came out
of it, both flagged by our own agents.

- **Real external resources.** Each of the 5 modules now links 2-3 verified "Go deeper" resources (Coursera,
  University of Pisa, Utrecht, the Princeton leakage/reproducibility workshop, OHRP, NIH). We link out and do
  not copy their content. Links were checked live during verification.
- **Honest learning science.** The Faculty caught that the flashcards called themselves "spaced repetition"
  while only running within one sitting. Scheduling is now genuine cross-session spacing (1/3/7/16-day), and
  the mastery check is cumulative and interleaved across completed modules instead of re-asking the lesson.
  The "spaced repetition" phrasing is gone from the data and the rendered hub.
- **Curriculum structure.** Modules carry three pillars (research integrity / open science / responsible-AI
  reasoning), a Foundation tier, and a badge whose Practitioner level is earned on a real Learning Lab run.
- Process: ran as a full Cambium run with a live board and two human gates (G-plan, G-build). 8 named agents
  across Scouts, Faculty, Labs, Execution, Verification. +4 tests. Verified: engine JS clean, embedded data
  valid, consistency OK.

Honest limits: the Practitioner badge is designed but not yet wired to mint from run artifacts; spacing state
is per-browser, not per-account.
## 1.14.0 - 2026-06-28 — Cambium Academy + interactive Learning Lab (gate G-learn)

A research institute should also teach, and reading a brief is the floor, not the ceiling. This turns the
Learning Gate from a document into an experience built on how people actually learn and retain: active
recall, spaced repetition, dual coding, worked examples with faded practice, and self-explanation.

- **Cambium Academy** (new, `academy/`): five short, interactive courses for students, researchers, and
  faculty. The Cambium way, evidence tiers and honest claims, why human gates beat autonomy, verifying a
  result without fooling yourself, and research ethics and data stewardship. Each has lessons with
  predict-then-reveal questions, flip flashcards, a clickable architecture diagram, a "your turn" change,
  explain-it-back boxes, and a cold mastery check, with progress saved locally.
- **Per-run Learning Lab** (new, `tools/gen_learning_lab.py` + `templates/learning_lab_template.html`): the
  teaching-assistant now turns each build into the same active walkthrough, generated for the exact thing
  you made. `demo/learning_lab.html` ships as a worked sample.
- **Live AI tutor**: a Cowork artifact version answers follow-up questions in the context of the build via
  the in-app model, so learners get a tutor beside them, not just a page.
- Wired into the site (Academy section + nav + footer) and the teaching-assistant standing duty. One engine
  powers both labs, so the mechanics stay identical and reproducible. +4 tests; tools 44 to 45, templates
  16 to 17. Verified: engine JavaScript clean, both labs render valid self-contained data, consistency OK.
## 1.13.0 - 2026-06-28 — Learning by doing + no idle agents (gate G-fit)

An audit found three Support agents that never got dispatched in any run. This gives each a real, recurring
duty, and turns the Learning Gate into an actual teaching moment.

- **teaching-assistant** now fires on every build or analysis run via a new `learn` step, producing
  `templates/LEARNING_BRIEF.md` (new): a plain-language what-and-why, a real architecture diagram (mermaid),
  the key decisions and tradeoffs, the concepts to understand, a small "try it yourself" change, and an open
  invitation to ask follow-ups. The human leaves understanding the work, not just approving it.
- **office-manager** now compiles the run digest at every close-out; **feedback-router** now splits and
  routes Revise feedback. Both were idle before; both fire on every run now.
- Wired into `tools/task_router.py` and the run contract (`docs/concepts/PRESENTATION.md`); agent duties
  recorded in the three agent definitions. +4 tests; templates 15 to 16. Verified: consistency OK.
## 1.12.0 - 2026-06-28 — Toolsmith gets live MCP awareness

The toolsmith already finds the best existing tool, skill, or MCP instead of relying on the base model. This
makes its MCP discovery concrete and council-aware, the honest way.

- `tools/mcp_discovery.py` (new): reads the host's MCP config files plus a curated routing map and proposes
  which connected or available MCP each council should use (literature MCPs to Scouts and the Librarian, web
  search broadly, code to Execution). It NEVER connects or installs anything; the proposal goes to the
  provisioning gate for human approval. Honest ceiling stated in the tool: it reports a server as
  "configured" (found on disk) or "available to add", and does not claim a server is live, since runtime
  connection state is not visible to a standalone tool.
- `governance/mcp_map.yml` (new): the curated MCP-to-council routing (alphaXiv, PubMed, Consensus, Exa,
  Semantic Scholar, bioRxiv, Zotero, GitHub).
- The toolsmith agent now runs `mcp_discovery` at provisioning and includes the result in its manifest.
  Tools 43 to 44, +5 tests (216). Verified: tests pass, consistency OK, dashboard --check passes.
## 1.11.0 - 2026-06-28 — Brain step-up, first increment (gates G1, G-fit)

Answered an external "make Cambium the best research brain" evaluation the Cambium way: Scouts audited its
claims (7 of 10 verified; specific competitor benchmark numbers flagged as unverified), the Integrity
Officer tiered all 12 proposed upgrades honestly, and we built only what is real.

- `docs/reference/BRAIN_ROADMAP.md` (new): the 12 capabilities tiered as buildable-now (6), honest scaffold
  (4), or external-only (2), with hard guardrails (no stub ships as capability; the web bridge stays labeled
  simulation; "most capable" stays Asserted until a real benchmark is run).
- Reasoning tier (`tools/model_router.py`): an extended-thinking budget for the six hardest agents
  (verification boards, referee, theory, statistics), test-time scalable from low to max. The base
  strong/mid/light routing is unchanged and backward compatible. Honest: the router emits the
  recommendation; the runner must honor it.
- Literature depth (`tools/paper_search.py`): Semantic Scholar as the primary source, a citation-graph
  lookup for a DOI, and a lexical relevance rerank, all with graceful fallback to OpenAlex/Crossref. The
  rerank is lexical, not neural embeddings (embeddings remain a scaffolded item).
- verify-evidence audited both as honest; two low wording overclaims were fixed. +7 tests (211). Verified:
  consistency OK, dashboard --check passes.
## 1.10.0 - 2026-06-28 — Adopt agent-skills patterns + two new skills (gates G1, G-fit)

Evaluated integrating addyosmani/agent-skills (MIT) the Cambium way (Scouts investigated, then Faculty and
Governance designed the build, gated twice). Outcome: adopt the patterns, do not bulk-import.

- `ATTRIBUTION.md` (new, root): credits addyosmani/agent-skills (MIT) for the skill-anatomy patterns we
  adopted. We re-authored the structure in our own words, so no MIT notice is triggered; we credit anyway.
- `docs/concepts/SKILL_AUTHORING.md` (new): a tiered authoring standard. Full anatomy (when-to-use, numbered
  process, anti-rationalization table, exit criteria, red flags) for procedural skills; a light set for
  reference skills so short skills don't bloat.
- `skills/reproducibility/SKILL.md` upgraded as the worked exemplar (anti-rationalization table + explicit
  exit criteria, replacing the old Guardrails block).
- Two new attributed, research-oriented skills: `version-control-discipline` and `test-driven-research-code`,
  serving the research-engineer and reproducibility councils. `code-review` deliberately dropped (collides
  with the verification council). Skills 23 to 25; counts and dashboard updated; consistency and dashboard
  --check green.
## 1.9.3 - 2026-06-28 — Institutional on-ramp (the office can say yes)

Cambium spoke only to the solo researcher. The unit that actually adopts it is the research-computing and
sponsored-programs office, so this gives them something to set once and a committee something to sign.

- `governance/institution/PROFILE.example.yml`: a one-time institution profile (approved funders, IRB and
  export-control and FERPA data rules, allowed models, budget ceilings, named approver gates), plus a
  worked example for a fictional university.
- `tools/institution_profile.py`: a validator so the profile is a real, checked object, not a dead doc. It
  confirms each approved funder has a rule pack, the approver roster resolves, and prints a one-line summary.
- `governance/institution/APPROVAL_PACKET.md`: a one-meeting governance approval packet that maps each
  standard institutional concern to the Cambium control, marks enforced vs partial honestly, and has a
  sign-off block.
- `governance/institution/SPONSORED_PROGRAMS_MAPPING.md`: maps common funder requirements to the Cambium
  artifact that supports each. Tools 42 to 43, +5 tests (204). Verified green.

## 1.9.2 - 2026-06-28 — Deterministic checks: less "AI grading AI"

Cambium's weakest trust point was that verification is AI checking AI. This adds checks that need no trust
in any model, and it labels every check honestly.

- New `tools/deterministic_checks.py`: real, non-LLM checks. Budget line items that either sum to the
  claimed total or don't; a claimed number that either equals the reproduced one or doesn't; a DOI that
  either resolves at doi.org or doesn't (best-effort, needs network).
- A check registry that tags every Cambium verification as deterministic, external-source, or model-judged,
  and writes `governance/CHECKS.md`. Right now 10 of 16 checks are grounded (8 deterministic + 2
  external-source) and 6 are model-judged. We publish the split rather than implying everything is
  mechanically verified.
- Surfaced on the dashboard (a "Grounded checks" card) and in the README. Tools 41 → 42, +7 tests (199).
  Verified: tests pass, consistency OK, dashboard --check passes.

## 1.9.1 - 2026-06-28 — Documentation restructure (first-impression cleanup)

Cut the root from 38 markdown files to 7 (README, CHANGELOG, CONTRIBUTING, CODE_OF_CONDUCT, SECURITY,
LICENSE, and a new CITATION.cff). Everything else now lives under `docs/` in one reading path:
`start-here`, `concepts`, `governance`, `reference`, and an `archive/` for old process notes. Added
`docs/README.md` as the index. VISION, PHILOSOPHY, and POSITIONING were kept separate on purpose, since
POSITIONING is where the honest self-grading lives. Every internal link and every tool that reads a moved
doc (dashboard, closeout, doctor, the run contract, quickstart scripts) was repointed. Verified: consistency
OK, closeout green, dashboard --check passes, no broken links in README or docs.

## 1.9.0 - 2026-06-28 — Premium in-chat run board + clickable gates as the default UX

Brought the run-board experience back and made it the standing experience for current users (no web app —
that stays on the roadmap). Gate **G-runux**, APPROVED.

- **README rebuilt from scratch** around the responsible-AI-research-institute framing: a new hero, the centerpiece *concern → enforced control* diagram, refreshed architecture + lifecycle/8-gates diagrams, and regenerated run-board + brand GIFs (all under `assets/`, generators under `assets/gen/`, logo unchanged). Counts reconciled to truth across README + dashboard: 23 skills · 41 tools · 6 MCP tools · 15 templates (46 · 11 · 8 unchanged).

- **In-chat live board** (`tools/gen_inline_board.py`): renders the run as a claude-native
  `mcp__visualize__show_widget` fragment — agent boxes that read done / working / queued, a progress rail,
  each agent's finding, and the live gate card. Reads the same `agent_outputs/run_state.json` as the
  sidebar board, so re-running it each phase updates the board in place. The agent boxes now live *in chat*,
  not only the sidebar.
- **Upgraded clickable gate card** (`templates/INLINE_GATE_CARD.html`): icon-led Approve / Revise / Reject
  whose buttons post the decision to chat via `sendPrompt`.
- **Sidebar board polish** (`tools/gen_board_pro.py`): added a chronological findings feed and a completion
  summary; remains the reopenable standalone HTML artifact.
- **Contract wiring** (`PRESENTATION.md` + `commands/cambium.md`): every `/cambium` run now paints the
  in-chat board AND the reopenable sidebar artifact, refreshed each phase, with the clickable gate at every
  stop. Plain text remains only the last-resort fallback.
- Verified: both boards render from one run state; inline fragment is show_widget-safe (no html/body/doctype);
  HTML parses; gate card carries all three actions; consistency green (46 · 11 · 8).
- Close-out: tool count 40 → 41 (new `gen_inline_board.py`) updated across README; benchmark dashboard regenerated (41 tools, 192 tests) so the CI drift-guards stay green. Version → 1.9.0.

## 1.8.0 - 2026-06-28 — Enforcement A/B v1: executable study infrastructure

Executed everything in the v1 A/B design that lives in software (gate **G-study-v1**, APPROVED). The study
*result* stays **Open** — it needs live model runs + real human raters — but the entire machine to produce
that result is now built, verified, and independently audited (verify-evidence: PASS).

- **Task set 18 → 102** (`evals/enforcement_study/tasks/gen_tasks.py`): 20 per core defect category
  (citation_defect, number_defect, tier_defect, fabrication, overclaim) + 2 legacy mixed, schema-valid with
  objective ground truth. Plumbing check (not a generalization claim): synthetic honest/dishonest outputs
  score Stage-1 false-claim-rate 0.000 / 1.000 — the honest case is tautological by construction; the human
  panel remains the instrument. Open robustness item: a paraphrase control.
- **Blinding** (`blind.py`): seeded shuffle → arm-blind `rater_packet.json` + a SEALED `blind_manifest.json`
  (study lead only). Audited: zero arm leak in the packet.
- **Rater UI** (`rater_ui.html`): self-contained arm-blind console; raters mark each claim
  asserted/flagged/absent and export `ratings_<id>.json`.
- **Stage-2 human-panel analysis** (`analyze_stage2.py`): Cohen's κ (binary + 3-way), 3rd-rater
  adjudication, unblinding, pre-registered two-proportion one-sided z + Cohen's h + Wilson/Newcombe CIs +
  Bonferroni; κ<0.6 reliability FLAG. Reuses the validated stats in `analyze.py`.
- **Budget** (`BUDGET.md`): Opus 4.8 at $5/$25 per Mtok → model compute ≈ $3–$13; the real cost is
  ~31 rater-hours (≈ $0.8k–$1.5k at n=102). No compute barrier.
- **End-to-end check** (`verify_pipeline.py`): blinds the real pilot outputs, stands in synthetic raters,
  runs the whole Stage-2 chain — PASS, no leak; result stays SYNTHETIC/Open.
- `V1_DESIGN.md` updated: built-vs-needed re-scoped; the only genuine open items are the live runs and the
  human raters. Version → 1.8.0.

## 1.00.0 - 2026-06-26 — First stable public release (re-baseline)
- **Version re-baseline.** Cambium is re-baselined to **1.00.0** as its first stable public release. The
  1.0.0 → 3.18.0 entries below were rapid same-day development iterations and are retained as history under
  "Pre-1.0 development history" — they do not represent prior public releases.
- **Versioning scheme going forward:** standard **[SemVer 2.0.0](https://semver.org)** — `MAJOR.MINOR.PATCH`
  with **no leading zeros** in any field (so `1.0.0`, `1.1.0`, `1.2.0`, … and patches `1.0.1`, `1.0.2`, …).
  *(The earlier zero-padded form `1.00.0` is invalid SemVer — leading zeros are forbidden — and caused the
  Customize panel to hide the version badge. The `1.00.x` headings below are retained as history; the live
  manifest version is the SemVer-valid `1.0.28`.)*
- **What 1.00.0 contains** (state at re-baseline): the 46-agent / 11-council institute with 8 human gates;
  full pre-award + post-award lifecycle; CI-enforced evidence/claim-tier contract (`governance/validate.py`);
  MCP server; self-grading `doctor` (GRADE A); the enforcement-vs-soft-prompting A/B harness
  (`evals/enforcement_study/`, study result **Open**); the per-funder governance corpus
  (`governance/funders/`, NIH+NSF, source-verified, freshness-CI); and the execution + record-keeper
  build/verify contracts. Verified: consistency exit 0 · doctor GRADE A · 104 tests pass / 1 skipped.

---

## Pre-1.0 development history (archived — rapid same-day iterations, not public releases)

## 1.0.0 - Initial public release
- 34-agent, 9-council research institute (orchestration, pre-award, partnerships, faculty, scouts,
  labs, verification, execution, support, reporting).
- Full project lifecycle (RFP -> proposal -> development -> reports) with 6 human-in-the-loop gates.
- Output contract (severity + claim tiers), findings ledger, leaderboard, synthesis.
- Smart-Tier model profile (+ opus-max / lean).
- Template repo + installable plugin manifest + marketplace.json.
- Interactive dashboard; two fictional demo projects.

## 1.1.0 - Governance & self-audit
- Ran the Institute on itself (Project 003): 4 audit boards; objectives scorecard.
- Added AI_GOVERNANCE.md (research + teaching) and AI_USE_STATEMENT.md template.
- Added governance/GATES.md (recorded human approvals) and governance/validate.py (evidence-tier
  validator + provenance manifest; fails build on open P0). Added SECURITY.md, CODE_OF_CONDUCT.md.
- README/INSTITUTE/OUTPUT_CONTRACT updated to reference governance.

## 1.2.0 - Team roles & delegated human-in-the-loop
- Added ROLES.md: Director/PI, Co-PI/Area Lead, Project Manager(Admin), Researcher/Student, Engineer,
  independent Integrity/Data steward; human->agent mapping; separation of duties; worked team example.
- config.example.yml now defines the team roster + per-gate approver map (delegated approvals).
- GATES.md gains role + named-approver columns. Each PI/Co-PI is the human-in-the-loop for their sector.

## 1.3.0 - World-class release (Institute built by its own team)
- CI: tools/check_agents.py (frontmatter validator) + .github/workflows/validate.yml — the evidence
  contract is now enforced on every push/PR (green on a healthy repo, red on an open P0 or invalid agent).
- Demo: demo/tour.html — a 60-second self-running animated tour; README gets badges + above-the-fold value prop.
- Worked example: examples/full-lifecycle/ — a complete fictional RFP->proposal->development->verify->
  report artifact chain that PASSES validate.py (demonstrates the integration claim end to end).
- Team usability: tools/whoami.py (prints a person's desk + approvable gates) + TEAM_QUICKSTART.md.
- tools/quickstart.sh + quickstart.ps1 one-command setup.

## 1.4.0 - High-end release
- Landing site: index.html (polished one-pager) + .github/workflows/pages.yml (GitHub Pages deploy).
- Visuals: assets/org-chart.svg + assets/lifecycle.svg (render on GitHub); embedded in README "At a glance".
- Positioning: COMPARISON.md (honest, web-verified vs AI Scientist / Co-Scientist / Agent Lab / AutoGen),
  FAQ.md, ROADMAP.md, CITATION.cff (citable software).
- Field-agnostic proof: examples/demo-humanities + examples/demo-public-health (non-STEM).
- tools/new_project.py scaffolder. Test artifacts moved to tools/test_fixtures/; projects/REGISTRY.md reset.

## 2.0.0 - Deeper research capability (v2)
- Roster 34 -> 39 (all doers/referees): lab-statistics, exec-iteration, research-engineer, referee, idea-tournament.
- Adopted (verified) mechanisms: novelty gate (AI Scientist), Elo idea tournament + reflect/evolve
  (AI Co-Scientist), scored self-refinement + tree-search experiment loop (Agent Lab / AI Scientist),
  venue-rubric referee (AI Scientist), cross-project institutional memory (AutoGen).
- New triggers: run tournament, iterate experiment, referee, run verification debate.
- Upgraded record-keeper (institutional memory), scout-prior-art (novelty gate), ideation (feeds tournament).

## 3.0.0 - Full research lifecycle (v3)
- Roster 39 -> 45: rfp-radar, convener, budget-officer, grants-compliance, feedback-router, research-conduct-officer.
- End-to-end lifecycle (LIFECYCLE_V3.md): RFP radar -> idea inbox -> brainstorm/tournament -> team + pre-award
  (budget, biosketch, DMP, forms) -> award mobilize (assignments, scoped agent access, alerts) -> execute ->
  reports/meetings/scheduling -> feedback router. New gate G0 (Know the PI).
- Responsible-research governance at EVERY gate (RESEARCH_CONDUCT.md): IRB/IACUC, COI, FERPA, data
  sovereignty, dual-use, reproducibility - GO / CONDITIONS / STOP, alongside evidence + AI-use governance.
- Templates: USER_PROFILE, IDEA_INBOX, COLLAB_WORKSPACE, POST_AWARD_PLAN.
- New triggers: watch rfps, rfp in <file>, add idea, convene team, build budget, compliance check,
  assign work, route feedback, conduct check <gate>.

## 3.1.0 - Self-improvement run (Project 005: Cambium improves Cambium)
P0: v3 scaffolder now creates all v3 write-targets + copies templates (new_project.py); unified RFP
intake to one canonical 00_rfp_brief.md; hardened validate.py (dropped undocumented 'info' tier;
'Code-verified' now requires a command marker; fails on unresolved citations; won't clobber provenance
on empty runs); citation-resolution gate (15-librarian); reproducibility checklist (template + scored);
DATA_MANAGEMENT_PLAN template; policy currency (NIH NOT-OD-25-132, NSF PAPPG 2025, publisher/COPE,
zero-embargo public access, NIST AI RMF) in RESEARCH_CONDUCT/AI_GOVERNANCE/AI_USE_STATEMENT; G0 gate added.
P1: EVALS.md reliability floor; MCP_INTEGRATION.md; MODEL_ROUTER.md (needs your model access);
record-keeper memory service; ensemble referee + EQUATOR/TOP; budget-aware verification; stale 34->45
counts fixed (COMPARISON/FAQ/GETTING_STARTED/ROLES). Built BY Cambium; see cambium_imp/005-improve-cambium.

## 3.2.0 - P2 items (Project 005 cont.)
- A2A Agent Cards: tools/gen_agent_cards.py -> agent_cards.json (TESTED: 45 cards).
- Deep-research two-mode loop (quick scan / deep research) on scouts + triggers.
- EFFICIENCY.md: prompt-caching guardrails (never cache volatile facts) + per-vendor cost telemetry spec.
- MCP_INTEGRATION.md: A2A cards section. Triggers: quick scan, deep research, gen cards, cost report.

## 3.2.1 - Model router wired (Claude now, pluggable later)
- config.example.yml: model_router block (anthropic ON; google + openai_compatible scaffolded OFF).
- tools/model_router.py: agent -> tier -> concrete model from active provider; stdlib fallback to Claude.
  TESTED: 45 agents -> 12 opus / 31 sonnet / 2 haiku. Add free/other models later via config (no code change).

## 3.2.2 - Repo-wide consistency cleanup + enforcement
- Fixed every stale count across the repo: 34/39 -> 45 agents, 9/10 -> 11 councils (Governance added),
  "six gates" -> 8, in index.html, demo/tour.html, plugin/README, ROADMAP, CITATION, dashboard, README,
  INSTITUTE; rebuilt index.html council grid (all 11 councils, correct per-council counts).
- Regenerated assets from the live roster: assets/org-chart.svg (tools/gen_org_chart.py),
  assets/demo.gif (tools/gen_demo_gif.py), assets/social-preview.svg+png. Counts now generated, not hand-typed.
- NEW tools/consistency_check.py (canonical 45/11/8 from the live roster) wired into CI: the build now
  FAILS on any future count drift. Self-cleaning by construction.

## 3.3.0 - Auto-runner engine (specs -> running workers)
- tools/cambium_run.py + phases.yml: orchestrator that runs agents CONCURRENTLY within a phase
  (each call = one session), sequentially across phases, stopping at every human gate.
- Dry-run prints the parallel execution plan + model per agent (via the router); --live executes via
  the Anthropic API with a thread pool (needs ANTHROPIC_API_KEY). I/O-bound: concurrency, not cores.
- AUTORUN.md documents both execution paths + limits.

## 3.4.0 - Deployable app (Cambium Campus) — built by the engineering councils
- app/engine.py: hardened orchestrator — run-state on disk, retry/backoff LLM client + token cap,
  failures block their gate, gate stops + resume (addresses backend-audit P0s).
- app/server.py: stdlib HTTP server — serves the front-end + /api/health,/agents,/plan,/run,/approve.
- app/index.html: cinematic campus UI wired to the API with static-demo fallback.
- Packaging: requirements.txt, Dockerfile, Procfile, run.sh/run.bat, app/README.md (local + deploy).
- TESTED: server boots; all endpoints return correctly (health, 45 agents, 5-phase plan, dry-run run, static).
- Static front-end deploys free to Pages (demo mode); full live app via Docker/host + ANTHROPIC_API_KEY.

## 3.4.1 - App hardened after Cambium's own security review (project 008)
- 4 councils (engineer, verification, UX, referee) reviewed the app in parallel; fixes applied:
- SECURITY: server now serves ONLY app/ (no repo/.git disclosure), denies dotfiles+traversal,
  validates JSON (400 not 500), caps body size, regex-validates run-id, optional CAMBIUM_TOKEN auth,
  binds 127.0.0.1 by default. TESTED: /.git, /engine.py, traversal -> 404; junk body -> 400.
- ENGINE: phase order respects phases.yml (PI before parallel writers); collision-proof run IDs;
  real --resume; graceful missing-run handling.
- UX/A11y: AA contrast (--mut), reduced-motion keeps rooms visible, canvas aria-hidden + CDN-fail
  fallback, journey focus-trap, fetch timeouts. Dockerfile non-root USER; app/runs gitignored.

## 3.5.0 - Task Router (auto council selection for ANY task)
- tools/task_router.py: classifies a task (grant / software / review / research / report / data) and
  builds a custom phase plan — which councils activate, what runs in parallel, where the gates fall.
- engine.py + /api/plan now use the router, so council selection is Cambium's, not hand-picked.
  Verified: "review app" -> exec+verify+lab+gov (incl. the Governance council a human reviewer missed);
  "build app" -> lab+exec+verify+faculty+gov; "grant" -> full pre-award lifecycle.

## 3.6.0 - Toolsmith: provision existing tools (reuse beats rebuild)
- New agent 45-toolsmith (Support): discovers existing npm/pip packages, component libs (shadcn/21st.dev),
  MCP connectors, skills, datasets, free APIs for a task; returns a manifest + install commands;
  installs ONLY after human approval. tools/toolsmith.py registry + TOOL_POLICY.md (supply-chain policy).
- Task Router adds a provisioning gate (G-provision) at the start of software/research/data tasks.
- Roster 45 -> 46 (Toolsmith joins Support; still 11 councils). Counts synced repo-wide; org-chart +
  dashboard + social card regenerated. Dashboard rebuilt (was truncated by a sed on the mount).

## 3.6.1 - cambium doctor (one-command health check)  [← ECC's doctor/repair idea]
- tools/doctor.py: runs check_agents + consistency_check + validate + HTML-integrity (catches
  truncation / unbalanced <script>) + Python-parse + derived-sync (agent_cards, org-chart) in one pass.
  `--fix` regenerates derived files. Wired into CI so a truncated/stale file fails the build before merge.
- On first run it caught the dashboard.html truncation (Windows/Linux mount desync); rebuilt + verified.

## 3.7.0 - Local console: login + task box + account-based execution
- app/console.html: sign in (local passcode), type a task, preview the auto-selected councils, run,
  approve at each gate. Live agent outputs per agent.
- app/providers.py: execution backend auto-detect — Claude Code (your Anthropic login, no API key) >
  API key > dry-run. engine.call_model now delegates to providers.
- app/server.py: local login (session cookie, pbkdf2 passcode, CAMBIUM_PASSWORD), gated API, serves
  the console. .auth.json gitignored.
- Honest: no claude.ai-cookie backdoor; Claude Code is the sanctioned account path. TESTED end-to-end
  (login 401-gates, authed plan/run, dry-run) + doctor healthy.

## 3.8.0 - Self-grade + decision records (← ECC/ruflo metaharness idea)
- tools/doctor.py: added `--grade` — scores the institute A–F across roster, counts, evidence gate, HTML integrity,
  code, governance coverage, tooling, evals/tests, decision records, + a security risk scan.
- DECISIONS.md (living ADR log, seeded with ADR-001..005) + templates/DECISION_RECORD.md; wired into the playbook.

## 3.8.1 - Test suite (closes the grade's one gap)
- tests/test_framework.py: 15 pytest checks — Task Router selection, Toolsmith stack, Model Router tiers,
  validate.py blocks/passes correctly, doctor/consistency/check_agents exit clean, agent_cards in sync.
- Wired pytest into CI (validate.yml). All 15 pass.

## 3.8.2 - README + manifest rewrite
- Rewrote README around what Cambium actually is: a Claude PLUGIN + template (not a single skill, not an MCP),
  with clear goals, principles, install (plugin/template), lifecycle, governance + self-grade + tests, and
  multi-account continuity. Fixed stale plugin manifest counts (34/9 -> 46/11) + version 3.8.0.

## 3.9.0 - Cambium MCP server (built BY Cambium: Toolsmith provisioned, then built + verified)
- mcp_server/ : Python MCP server (official `mcp` SDK / FastMCP, stdio) exposing cambium_plan, cambium_provision,
  cambium_agents, cambium_doctor, cambium_grade, cambium_validate to any MCP client.
- pyproject (uvx entry `cambium-mcp`), README with Claude config snippets. tests/test_mcp.py (skips if SDK absent).
- TESTED: 6 tools register; plan/provision/agents/doctor/validate all return correctly. README/ADR updated.

## 3.10.0 - UX + transparency + one vocabulary
- Fresh "Living Layer" visual identity (evergreen + emerald + lime): logos, lifecycle, org-chart, social, demo.gif.
- templates/GATE_SUMMARY.md — one standard gate one-pager (Decision · Options · Risks · Evidence · Recommendation · APPROVE/REVISE/REJECT); mandated by the Orchestrator + OUTPUT_CONTRACT.
- USE_CAMBIUM.md — plain-language beginner guide (no jargon).
- tools/run_trace.py — shows the workflow as text / Mermaid / SVG + a LIVE status board (✓ done · ▶ now · ○ waiting), standardized to the 11 councils; wired into the Orchestrator and dashboard.html.
- Toolsmith design stack (brand-guidelines, canvas-design, theme-factory, ui-ux-pro-max…) so design tasks reuse real skills, not stats packages.
- Consistency sweep (Verification council): human role unified to Director (was President); "Provost"→Orchestrator; council names unified; "GATE" reserved for the canonical 8 (others are Checkpoints); plugin 3.8.0→3.9.0.
- Tests now 26; doctor --grade A.

## 3.10.1 - Fix roster-name drift (teaching/research-assistant)
- gen_org_chart.py + task_router.py referenced non-existent `teaching-asst`/`research-asst`; real names are
  `teaching-assistant`/`research-assistant`. Org-chart showed "(?)" and the router pointed at 2 phantom agents.
- Fixed both; regenerated org-chart.svg (0 unknowns). Added a generator guard (fails if a council member is not
  a real agent) + tests/test_roster_names.py (CI now catches CMAP↔roster drift).

## 3.10.2 - Fix plugin install (marketplace manifest location)
- `/plugin marketplace add` looks for `.claude-plugin/marketplace.json` at the REPO ROOT, but the manifests
  lived under `plugin/`. Result: clone succeeded but install failed with "Marketplace file not found."
- Added root `.claude-plugin/marketplace.json` + `.claude-plugin/plugin.json` (source "./", agents=.claude/agents).
  `/plugin marketplace add https://github.com/pkjaslam/Cambium_AI.git` + `/plugin install cambium-institute` now work.
- README: use the full HTTPS URL (short form can resolve to SSH and fail host-key checks); run the two commands separately.

## 3.10.3 - Make install actually work (lessons from real installs)
- Removed the redundant `plugin/` folder: the repo had TWO plugin.json (root + plugin/), which broke Cowork
  repackaging with "Zip must contain exactly one plugin.json. Found 2." Now exactly one manifest at root.
- Agents auto-discovered from `agents/` (no manifest `agents` field — the array/string forms were rejected).
- New INSTALL.md: tested steps for Cowork (Add-marketplace-from-repository AND /create-cowork-plugin), Claude Code
  (HTTPS URL, separate lines, user scope to avoid system32 EPERM), and the honest update story (manual Sync/Update;
  auto-sync is Team/Enterprise + private repo only). README quickstart points to it.

## 3.10.4 - Keep plugin agents/ auto-synced
- tools/sync_plugin_agents.py mirrors .claude/agents/ -> agents/ (the plugin's auto-discovery copy).
- Wired into push_cambium.bat (runs before git add), so the installable plugin never drifts from the roster.
- tests/test_plugin_sync.py fails CI if agents/ and .claude/agents/ ever diverge.

## 3.10.5 - Install docs: lead with the reliable path + document Claude-app quirks
- INSTALL.md now leads Cowork users with /create-cowork-plugin (bypasses the flaky "Add marketplace" menu),
  and a Troubleshooting table maps real Claude-app bugs (Personal-marketplace "+" only shows Anthropic catalog
  until a plugin is added once; installs lost on restart #40600; Windows empty marketplace #28853) to fixes.
- README quickstart updated to match. These are app quirks, not Cambium bugs.

## 3.11.1 - Council-labelled live agent cards
- Orchestrator now writes every sub-agent dispatch as "<Council> · <Role>" (e.g. "Verification · Referee",
  "Labs · Statistics"). Cowork's native "Running N agents" cards show that label verbatim, so the live UI now
  speaks the same council vocabulary as the run_trace status board — the two views finally agree.
- Clarified (docs/answers): the native "Running N agents" widget is Cowork's own and cannot be restyled by a
  plugin; the run_trace board (plan up front + ✓/▶/○ across all councils + gates) is the complementary map;
  dashboard.html is a static org reference, not a live run monitor.
ncils, stopping at a one-page
    gate card for APPROVE / REVISE / REJECT), then runs the chosen mode. Skips the question for trivial chat
    and quick lookups; honors "always Cambium"/"stay solo" for the session.
  - `commands/cambium.md` (`/cambium <task>`) and `commands/solo.md` (`/solo <task>`) — explicit manual
    override so the user can pick the mode per request without waiting to be asked.
- Version skipped 3.9.0 → 3.11.0 to clear the CHANGELOG's earlier 3.10.x headings (manifest had lagged at
  3.9.0 while the log ran ahead) so the marketplace version is unambiguously newest and the Cowork update
  button activates. Counts unchanged: 46 agents · 11 councils · 8 gates.

## 3.11.2 - Smart-default mode picker (Solo vs the Cambium way)
- cambium-mode skill rewritten to a SMART DEFAULT: trivial edits/lookups run Solo silently (no
  question); substantial tasks (evaluate, analyze, research, write, verify…) trigger a one-time
  Solo/Cambium-way choice that is then remembered for the session.
- Encodes the decision rule, session-memory, and an honest note that /solo and /cambium are the only
  100%-deterministic controls. USE_CAMBIUM.md documents the default so behavior is predictable even
  when the soft trigger doesn't fire.

## 3.11.3 - Routing coverage: Support close-out everywhere + write-up phase (ADR-016)
- Standard Support close-out (record-keeper, integrity-officer, janitor) now runs on EVERY task type
  (Support council coverage 3/6 -> 6/6) — the plan finally matches the "housekeeping every time" rule.
- document-office write-up phase added to research/report/data (Orchestration council 0 -> 3/6);
  librarian + figures routed into grant/research/report.
- New guard test (tests/test_router_coverage.py) fails CI if any council drops to zero routed agents,
  if close-out goes missing from a task type, or if document-office stops being routed. 32 tests pass.
- 7 agents remain intentionally on-demand (orchestrator, partnership-liaison, program-manager, outreach,
  office-manager, feedback-router, teaching-assistant) — excluded by design to avoid artificial over-use.

## 3.12.0 - Three built-in quantitative skills (mathematics, statistics, machine-learning)
- NEW skills/mathematics — deterministic symbolic + numeric math (SymPy/SciPy, optional Z3/Pint):
  compute exact answers, verify by back-substitution, tag Proved/Code-verified/Asserted.
- NEW skills/statistics — rigorous inference: tests, power/sample-size, GLM/mixed models, multiplicity
  correction, bootstrap, Bayesian basics (scipy/statsmodels/pingouin); reports effect size + CI, checks
  assumptions.
- NEW skills/machine-learning — leak-free predictive modeling: stratified/grouped/time splits, pipelines,
  CV, tuning off the test set, calibration, SHAP, model cards; explicit leakage checklist.
- SKILLS_MAP.md maps the three to the agents that wield them and notes optional curated web add-ons
  (frontend-design, frontend-excellence) — your installed UI/web skills already cover most of that.
- Smoke-tested: SymPy + scipy.stats patterns run and return correct values. 32 tests pass.

## 3.13.0 - Full council skill coverage (8 new skills)
- NEW skills covering every previously-uncovered council:
  optimization (lab-methods), reproducibility (research-engineer/verify-evidence), citations (librarian),
  data-management (data-steward), grant-writing (pre-award), research-ethics (governance),
  project-management (program-manager), scientific-writing (document-office/reporting-officer).
- Each emphasizes correctness + honesty: optimality status, rerun-and-verify, never-fabricate citations,
  PII screening, criteria alignment, GO/CONDITIONS/STOP ethics gates, claims<->evidence tiers.
- SKILLS_MAP.md maps all 11 built-in skills to the councils/agents that wield them. Deliberately did NOT
  duplicate UI/UX, web, software-eng, figures, decks, teaching — already covered by installed skills.
- Smoke-tested optimization (scipy linprog -> verified optimum). 32 tests pass; plugin.json clean.

## 3.14.0 - On-demand skill provisioning (skill-provisioner)
- NEW skills/skill-provisioner — instead of pre-stocking thousands of domain skills, Cambium now detects
  the field from a user's request, offers the few skills that help (existing to install + new to create),
  helps immediately via faculty-expert, and persists approved skills as reusable SKILL.md files.
- Two-tier delivery (instant faculty expertise now + reusable skill next session), detect-and-offer-once,
  human approval before any install or persist. Wires toolsmith + skill-creator + faculty-expert.
- USE_CAMBIUM.md tells users they can just ask "make a skill for X". 32 tests pass.

## 3.14.1 - Provisioner persistence policy (ADR-020, decided the Cambium way)
- skill-provisioner now states: the Cambium repo skills/ is the canonical home for created skills;
  local activation into a personal/project skills folder is an explicit, per-skill, opt-in step — never
  automatic, silent, or bulk. Solves "go live faster" without bypassing governance.

## 3.15.0 - The Cambium Way, made legendary (presentation layer + real-agent dispatch)
- New PRESENTATION.md — the canonical "Cambium way" contract: four acts (Opening run board · Live phases ·
  Gate · Close-out) so every Cambium run is unmistakable and identical, never the generic "Used N tools".
- run_trace.py upgraded: rich TEXT board (`--board`, alignment-proof left-bar header, council-grouped
  roster, per-agent findings, leaderboard, gate rail) and a self-contained LIVE HTML dashboard
  (`--html`, deep-forest + Cambium-lime theme, phase rail, agent cards showing `cambium-institute:<name>`,
  active-gate banner). Phase-level cursor (`--phase N`) + `--state state.json` overlay for live findings.
  Legacy `--text/--svg/--status/mermaid` preserved.
- commands/cambium.md + orchestrator (00) now MANDATE dispatching the REAL named sub-agents
  (`subagent_type: cambium-institute:<name>`, `description: "<Council> · Role"`) instead of working inline,
  and re-emitting the live board each phase — so the Director sees who is working, on what, and where the
  gates are. cambium-mode skill updated to point the smart-default at the same contract.
- templates/GATE_SUMMARY.md restyled with the branded gate header; ties to the dashboard gate banner.
- 34 tests pass; doctor healthy (23/0); agent_cards 46==46; source/plugin agents identical.

## 3.15.1 - Run-board imagery + auto-published dashboard
- New tools/gen_board_image.py renders the run board natively with PIL (no browser): assets/run_board.png
  (hero) + assets/run_board.gif (Opening → Scouts live → Gate → advancing). Data comes from
  run_trace.phases() so the picture never drifts from the real plan.
- README gains a "The Cambium way" section showcasing the live board + the four acts, linking PRESENTATION.md.
- cambium.md + orchestrator now make the Cowork dashboard explicit and automatic: publish once with
  create_artifact (Act I), update the same artifact id at the start of every phase (Act II).
- doctor 24/0, 34 tests pass, agents synced + identical.

## 3.16.0 - Auto-populated run board + asset CI
- New tools/run_state.py maintains agent_outputs/run_state.json (phase · finding · gate · lead · sync ·
  show · reset). `sync` AUTO-LIFTS each agent's headline from its own agent_outputs/<name>.md "## Decision"
  line, so the live board fills in as agents report — no hand-edited JSON.
- run_trace.py now AUTO-DISCOVERS agent_outputs/run_state.json (no --state flag needed); explicit --state
  still overrides. run_state.json is git-ignored (per-run, like findings_ledger).
- commands/cambium.md, orchestrator, and PRESENTATION.md now drive the board via run_state.py (phase →
  dispatch → sync → re-emit), with the Cowork dashboard published once (create_artifact) and updated each
  phase (update_artifact, same id).
- New .github/workflows/assets.yml regenerates assets/run_board.png + .gif on every published release (and
  on changes to the renderer/router) and commits them back, so the README board never goes stale.
- Synced mcp_server/pyproject.toml to the plugin version (was drifted 3.14.0 vs 3.15.1). doctor 25/0,
  34 tests pass, agents identical, counts consistent.

## 3.17.0 - Durable memory + guarded autonomy (Agentic-OS adoption, decided the Cambium way)
Ran the full Cambium way on the "Agentic OS" video (3 Scouts + Faculty + idea-tournament + Integrity audit,
real dispatched agents, gate G2 approved). Adopted the genuinely-missing ideas; rejected the app/deploy framing.
- **A · Pause/Resume handoff** (`tools/handoff.py` + `/cambium:pause` + `/cambium:resume`): writes a durable
  agent_outputs/HANDOFF.md from run_state + findings_ledger + synthesis (machine state embedded for lossless
  restore), restores on resume, archives consumed handoffs to archive/handoffs/. Durable memory across
  context windows instead of lossy auto-compaction. Folds in `loop_position` (run_state.py `loop`).
- **B · Context status line** (`tools/statusline.sh` + statusline.py): `⬢ Cambium · model · dir · ctx ~NN%`,
  flips to "⚠ run /cambium:pause" at ~85% so you pause before compaction. Documented in AUTORUN.md.
- **C · Guarded auto-loop** (`phases.yml → autoloop`): a phase may iterate its internal work until acceptance
  tests pass, then SURFACE its gate — fail-closed (max_iterations + budget_usd), integrity check each
  iteration, single-writer state, and it may ARM but NEVER clear a gate. Orchestrator + AUTORUN updated.
- Deferred: plan→task-graph deps (v3.3), Graphify/Obsidian brain. Rejected: /seed (redundant),
  Hermes/Railway deploy (Cambium isn't an app).
- New tests/test_handoff.py (pause/resume round-trip + autoloop guardrails). 36 tests pass, doctor 27/0,
  consistency clean. plugin.json + pyproject synced to 3.17.0. G2 approval logged in governance/GATES.md.

## 3.17.1 - End-to-end Cambium (no silent drop to solo)
- Fixes a contract gap the Director caught: when the Cambium way is chosen, the WHOLE task — including the
  BUILD/implementation AFTER an approval gate — must run Cambium (dispatch real Execution/Labs agents:
  research-engineer, exec-*, lab-methods). The Orchestrator must not quietly do the post-gate build inline.
  The only allowed alternative is to ASK the Director ("Cambium or solo for this build?") — never switch
  silently. Enforced in PRESENTATION.md (END-TO-END rule + 4th headline rule), commands/cambium.md,
  the Orchestrator agent, and the cambium-mode skill. 36 tests pass, doctor healthy.

## 3.17.2 - Consistency sweep (gate G-fix) + Execution build contract
- **Now-tier consistency sweep (gate G-fix, Director-approved):** repo-wide fixes verified against
  v3.17.1 source by the Verification council. Gate count "six lifecycle gates" → 8 (AI_GOVERNANCE.md,
  FAQ.md); "President" → "Director (PI)" regression fixed across AI_GOVERNANCE.md, FAQ.md,
  GETTING_STARTED.md, DEVELOPMENT_PLAYBOOK.md, COMPARISON.md, examples/demo-from-scratch/*,
  templates/project/README.md, config.example.yml; version "1.4" → 3.17.1 and "45 agents" → 46
  (ROADMAP.md, FAQ.md, CITATION.cff, tools/ci_ledger.csv).
- **CI guard hardened:** tools/consistency_check.py now catches the "<word> lifecycle gates" drift class
  that previously slipped through, and skips transient run artifacts (agent_outputs/, projects/ run boards).
- **Execution build contract (new):** research-engineer agent + run-lab skill now require chunked edits for
  files >40 lines (a truncated single-shot rewrite shipped a SyntaxError this run) and a verify-or-flag rule
  — run consistency_check/doctor/pytest and paste real output as Code-verified, or label results Asserted and
  hand verification to the Orchestrator. Never imply a green build you did not run.
- **Roster mirror re-synced:** agents/ was stale (27) vs canonical .claude/agents/ (46); ran
  tools/sync_plugin_agents.py → 46/46 in sync.
- Staged (not done): claim-tiered repositioning + Tier-A literature connectors (Next); enforcement-vs-soft-
  prompting A/B study + per-funder governance corpus with dating/owner/freshness-CI/non-certification
  guardrails (Later). Grants-discovery connectors dropped per ROADMAP non-goal.
- Verified: consistency_check exit 0 · doctor --grade A (100%) · 36 tests pass / 1 skipped · live roster 46.
  G-fix approval logged in governance/GATES.md.

## 3.17.3 - Record-keeper write discipline
- Folds the verify-or-flag discipline into the record-keeper agent (follow-through on ADR-025): APPEND-ONLY
  (never edit/reword an existing CHANGELOG block or ADR; new ADRs take the next unused number) and
  VERIFY-THE-WRITE (no shell → re-read the changed region, confirm the new entry landed and no prior line was
  modified, else report Asserted and hand to the Orchestrator). Prompted by a record-keeper run this session
  that claimed appends it never made and corrupted ADR-011's status line. Canonical + agents/ mirror in sync (46).
- Verified: consistency_check exit 0 · doctor --grade A · 36 tests pass / 1 skipped.

## 3.18.0 - Enforcement A/B harness + per-funder governance corpus (Later-tier)
- **Enforcement-vs-soft-prompting A/B harness** (`evals/enforcement_study/`): pre-registered PROTOCOL.md
  (TREATMENT = gates+validate.py enforcement vs BASELINE = soft-prompt; metrics defined as ratios against
  ground truth; blind GT-only judge to break the agent_eval circularity), a 12-item seeded-defect task set
  with locked ground truth, `metrics.py` (false-claim / over-claim / citation-integrity / reproducibility),
  and `run_study.py --demo` (runs end-to-end on fixtures). The study RESULT is **Open** — the harness ships;
  no "gates beat prompting" finding exists until real agent runs are done. Demo output is labeled
  FIXTURE/illustrative everywhere so it can't be mistaken for a result. Converts the report's central
  assertion into a measurable, continuously-runnable asset.
- **Per-funder governance corpus** (`governance/funders/`): machine-readable NIH + NSF entries mapping each
  funder's AI-use rules to Cambium gates, with all five mandated guardrails — dated, named owner (PI),
  quarterly cadence, `freshness_window_days`, and `DISCLAIMER.md` (non-certification: guidance, not legal/
  compliance certification; the human PI remains accountable; rules drift, re-verify at source).
  `tools/funder_freshness.py` HARD-FAILS on a stale or incomplete entry (warns at 75% of window) and is wired
  as a doctor check, so a drifting corpus can't silently ship false compliance assurance. NIH NOT-OD-25-132
  (6-app/PI/yr cap, "substantially developed by AI" rejection) and the NSF reviewer gen-AI prohibition were
  **source-verified** (2026-06-26) against the funders' own notices, not asserted.
- Tests: +68 (enforcement_study + funder_freshness). Verified: consistency_check exit 0 · doctor --grade A
  (100%) · pytest 104 passed / 1 skipped · funder_freshness OK · run_study --demo OK. Gates G-build + G-ship
  Director-pre-approved (AUTO) this run; logged in governance/GATES.md. Manifests bumped 3.17.1 → 3.18.0.

## 1.00.1 - 2026-06-26 — World-class README + landing-page overhaul
- **README rewrite** to a top-1% standard (Referee 9.3/10, Integrity PASS-WITH-FIXES): live GitHub-Actions
  CI badge, flat-square badge row, version badge, nav-anchor bar, demo.gif above all prose, GitHub Alerts
  ([!IMPORTANT]/[!TIP]/[!WARNING]/[!NOTE]), a new "Proving the claim" section surfacing the enforcement A/B
  harness (result Open — no overclaim) and the NIH/NSF governance corpus, GIF static-fallback, dated
  self-grade, COMPARISON hedge on the superlative, and the stale "26-test" → "104 passed / 1 skipped" fix.
- **Landing page (index.html) overhaul**: fixed a stale hero stat strip (34/9/6 → canonical 46/11/8) and a
  stale "Six human gates" → "Eight" (added G0); modernized the badge row (flat-square, live CI, version
  1.00.0); added a "Proving it — not just claiming it" governance box (enforcement harness + funder corpus,
  claim-tiered, dated grade, 104 tests). Recovered + rebuilt the file after a mount write-truncation;
  HTML integrity restored.
- Both audited by the Verification council; claims kept at/below their evidence tier (no "beats prompting").
- Verified: consistency exit 0 · doctor --grade A (100%, HTML integrity 100%) · 104 tests pass / 1 skipped.

## 1.00.2 - 2026-06-26 — Per-run state reset (board hygiene fix)
- **Root-cause fix for stale run boards.** Reusing one `agent_outputs/run_state.json` across runs leaked a
  previous run's phase/findings onto the next board (e.g. a README run's board showing a git-fix run's
  "## ADR-025 / 36 tests" findings). Fix: `tools/run_state.py reset` now stamps a `started_at` timestamp,
  and `sync` ignores any `agent_outputs/*.md` older than it — so stale prior-run files can't repopulate the
  board (important here because the working mount can't delete those files). The Cambium-way contract
  (`commands/cambium.md`, `PRESENTATION.md`) now calls `run_state.py reset` as the first action of Act I.
- Regression tests: `tests/test_run_state.py` (reset stamps started_at + clears; sync ignores stale files).
- Cleaned the older run-board artifacts (landscape-review, enforcement-governance) to show their own real
  findings instead of carried-over state.
- Verified: consistency exit 0 · doctor --grade A · 106 tests pass / 1 skipped.

## 1.00.3 - 2026-06-27 — World-class comprehensive README
- Full README rebuild from a deep discovery pass (research-assistant capability catalog, scout-landscape
  positioning, teaching-assistant how-to-use, outreach architecture — ~14k words of file-cited ground truth).
  The old README surfaced ~⅓ of the system; the new 400-line / 16-section README reflects the TRUE current
  Cambium: full 46-agent/11-council roster, 8 gates with approvers + separation of duties, the 21 skills,
  21 tools, 6 MCP tools, 13 templates, 5 examples, governance corpus, model routing (12/32/2), pause/resume,
  the guarded auto-loop, and the A/B harness — scannable via tables + <details>, with a how-to-use story +
  trigger reference and 6 standout pillars.
- Verified: Referee ACCEPT (9/9 across hero/completeness/scannability/usability/voice/structure; all nav
  anchors + asset/doc links checked). Integrity PASS-WITH-FIXES, all applied: hedged the "only open system"
  superlative at point of assertion; 14→13 templates; full claude-haiku-4-5-20251001 id; honestly relabeled
  the two pre-award example slices (dropped "proven"). A/B result kept Open; corpus = guidance not cert.
- Assets: assets/org-chart.svg regenerated from the live roster (46/11). All assets current.
- Green: consistency exit 0 · doctor --grade A (100%) · 113 tests pass / 1 skipped.

## 1.00.4 - 2026-06-27 — Brand asset redesign (logos, social card, favicon)
- Recreated the full brand-identity asset set at premium quality, rasterized SVG→PNG with cairosvg and the
  Inter typeface, from one reproducible source (`tools/gen_brand_assets.py`) — the repo's "regenerate from
  source" philosophy. Refined the "Living Layer" growth-ring mark (precise concentric emerald rings,
  layered lime active-node glow, radial spoke, faint org-satellite nodes, gradient tile + top sheen):
  - `logo-mark.svg` + `logo-mark.png` (512) + `logo-mark@2x.png` (1024) — the app-icon mark
  - `logo.svg` (light) + `logo-dark.svg` (dark) — wordmark lockups (Inter ExtraBold "Cambium." + lime dot + tracked subtitle), viewBox sized so nothing clips
  - `social-preview.svg` + `social-preview.png` (1280×640) — GitHub social card with a subtle org-constellation background, measured to fit (no text overflow)
  - `favicon.svg` + `favicon.png` (180) — new
- Wired `favicon` + Open Graph / Twitter-card meta (`og:image` → social card) into `index.html`.
- Brand tokens unchanged (BRAND.md "Living Layer" palette). All SVGs validate; PNG dimensions confirmed.
- Green: consistency exit 0 · doctor --grade A (100%, HTML integrity intact) · 113 tests pass.
- Action: re-upload the new `assets/social-preview.png` in GitHub Settings → Social preview (replaces the old card).

## 1.00.5 - 2026-06-27 — Logo v2: "Governed Growth Ring" identity
- Redesigned the brand mark from a richer, story-telling concept (inspired by reference directions): the
  mark now encodes Cambium itself — **8 gate-checkpoints** (amber keyhole+check = the 8 human gates) on the
  outer ring, concentric **emerald growth rings** (the cambium), the central **Director (PI)**, eight
  **council branch spokes** with leaf buds, a **lime radar sweep** to the active gate, and a single
  **red ✕ caught-error node** (the Verification board blocking a bad result). Clean flat vector, fully
  scalable — sharper and more meaningful than the references' raster art, on the "Living Layer" palette.
- Regenerated the whole set from `tools/gen_brand_assets.py` (v2): `logo-mark` (.svg + 512/1024 png),
  `logo`/`logo-dark` wordmarks (subtitle now "PORTABLE · GOVERNED · RESEARCH"), `social-preview` (1280×640),
  `favicon` (a simplified mini-mark for small sizes). BRAND.md motif section updated to match.
- Green: consistency exit 0 · doctor --grade A (100%) · all SVGs validate · PNG dims confirmed.
- Action: push, then re-upload the new `assets/social-preview.png` in GitHub Settings → Social preview.

## 1.00.6 - 2026-06-27 — Logo finalized: the "Living Tree" (blend)
- Final brand mark (supersedes the interim governance-ring in 1.00.5): a **tree of life** — symmetric
  canopy + roots with lime leaf clusters — rising from the concentric **growth rings** (the literal
  cambium), with the **8 gate-checkpoints** on the outer ring, a **lime radar sweep** to the active gate,
  a **red ✕ caught-error** node (Verification blocking a bad result), and the **Director (PI)** grounded at
  the roots. Blends the botanical + governance reference directions the Director chose. Clean flat vector.
- Regenerated the whole set from `tools/gen_brand_assets.py`: logo-mark (.svg + 512/1024), light/dark
  wordmarks (clean tier mark), social-preview (1280×640), favicon (mini tier). BRAND.md motif updated to
  "the Living Tree".
- Green: consistency exit 0 · doctor --grade A (100%) · all SVGs validate · social 1280×640.
- Action: push, then re-upload `assets/social-preview.png` in GitHub Settings → Social preview.

## 1.00.7 - 2026-06-27 — Logo: vector recreation of the "AI Research Institution" emblem (transparent)
- Recreated the Director's chosen emblem as clean vector with a **transparent background** (supersedes the
  Living-Tree mark): a wood-ring tree cross-section (deep green → teal → gold rings), a gold neural
  node-network branching through one quadrant, a glowing gold active blip, a thin open arc frame
  (emerald → gold), emerald leaves, and the **CAMBIUM AI · RESEARCH INSTITUTION** wordmark.
- Light + dark lockups (transparent, swap cleanly in GitHub's <picture>), emblem-only `logo-mark`,
  `social-preview` (1280×640, emblem + wordmark + tagline + stats on the brand dark bg), and `favicon`.
  All from `tools/gen_brand_assets.py` (regenerated); BRAND.md motif updated.
- Green: consistency exit 0 · doctor --grade A (100%) · all SVGs validate · social 1280×640.
- Action: push, then re-upload `assets/social-preview.png` in Settings → Social preview.

## 1.00.8 - 2026-06-27 — Adopt the official logo (assets/Cambium_logo.png)
- Replaced the generated marks with the Director's **official logo** (`assets/Cambium_logo.png`, transparent)
  and built all derivatives directly from it: `logo.png` (light), `logo-dark.png` (wordmark recolored to
  canvas for dark mode), `logo-mark.png` (cropped emblem), `favicon.png`, and the 1280×640 `social-preview.png`
  (the real emblem + white CAMBIUM AI wordmark + tagline + stats on the brand dark).
- README hero now uses the PNG logo via <picture> (light/dark); index.html favicon → favicon.png.
  BRAND.md points to Cambium_logo.png as the canonical source.
- Green: consistency exit 0 · doctor --grade A (100%, index.html intact) · README + index intact.
- Action: push, then re-upload `assets/social-preview.png` in Settings → Social preview.

## 1.00.9 - 2026-06-27 — Hi-res logo (background keyed out, all derivatives rebuilt)
- Adopted the Director's high-resolution official logo (`assets/cambium ai logo.png`, 1407×768). Keyed out
  the cream mockup background to transparent (feathered edges, no halo), tight-cropped, and rebuilt every
  derivative at full quality from it: `logo.png` (514×574, light), `logo-dark.png` (white wordmark for dark
  mode), `logo-mark.png` (1024² emblem), `favicon.png`, and the 1280×640 `social-preview.png` (crisp emblem +
  white CAMBIUM AI wordmark + tagline + stats). README hero + index favicon already point to these.
- Green: consistency exit 0 · doctor --grade A (100%) · README + index intact.
- Action: push, then re-upload `assets/social-preview.png` in Settings → Social preview.

## 1.00.10 - 2026-06-27 — OpenMontage integration (first slice, MIT-clean)
- Assessed (Cambium way: Toolsmith + Faculty/architecture + Research-Conduct-Officer) and designed the
  integration of **OpenMontage** (open-source agentic video production, **AGPLv3**) into Cambium, then built
  the MIT-clean first slice: `skills/render-video/` — a Reporting-council skill that produces video
  deliverables (video abstract, grant-pitch, results explainer) by **invoking a separately-installed
  OpenMontage as an external subprocess** + `video_contract.schema.json` (evidence-bound request/result,
  only Proved/Code-verified inputs) + `PROVISION.md` (separate install, zero-key free path, AGPL note).
  Recorded as ADR-028. **No OpenMontage code vendored** (process boundary = license boundary; Cambium stays MIT).
- Green: consistency exit 0 · doctor --grade A (100%) · 113 tests pass · JSON schema valid.

## 1.00.11 - 2026-06-27 — Wire render-video into routing + Reporting agents
- `tools/task_router.py`: new **video** task type — "make a video / video abstract / explainer / grant
  video / results explainer / teaser" now routes to **provision (G-provision) → produce (Reporting +
  figures/outreach, G5) → publish (G6) → close-out**, so the board and MCP `cambium_plan` mobilize the
  right council automatically. Guarded by the existing router-coverage test.
- Wired the `render-video` skill into SKILLS_MAP.md and the Relevant-skills line of `deck-builder`,
  `reporting-officer`, and `outreach` (canonical + agents/ mirror, 46/46).
- Green: router test passes · check_agents OK · consistency exit 0 · doctor --grade A · 113 tests pass.

## 1.00.12 - 2026-06-27 — Provenance manifest + e2e worked example + domain configs
- **Machine-checkable provenance manifest** (`tools/provenance.py`, ADR-029): `build` re-runs each
  Code-verified claim's recorded command, hashes command+script+output, and writes a manifest; `check`
  re-runs and fails on any output drift. Turns "Code-verified by convention" into reproduced-and-hashed.
- **End-to-end worked example** (`examples/e2e-worked-example/`): a full artifact chain RFP→aims→proposal→
  deterministic `code/analysis.py`→findings_ledger→provenance_manifest→report, with the headline number
  (3.06 bu/acre) reproduced + hashed (not asserted). Self-reproducing via `provenance.py check`.
- **2 non-ML domain configs** (`examples/configs/`: social-science survey, agricultural field trials).
- Tests +2 (`tests/test_provenance.py`, incl. drift-detection). Tool count 21→23; README corrected.
- Also: ran a full **Cambium self-evaluation** (Referee+Faculty+Scout) — `agent_outputs/EVALUATION.md`,
  overall B+, with prioritized suggestions (top: prove the enforcement A/B; wire a retrieval backend).
- Green: consistency exit 0 · doctor --grade A (100%) · 115 tests pass / 1 skipped · e2e manifest reproduces.

## 1.00.13 - 2026-06-27 — Grounded retrieval + speed/cost telemetry (eval #2, #4)
- **Deep search (#2):** `tools/paper_search.py` — grounded scholarly retrieval over OpenAlex + Crossref
  (no API key, offline-safe), returning structured citable records; wired into the 3 Scouts + Librarian.
  Fixes the "thin web-search wrapper" weakness (deep-search 5 → grounded corpus).
- **Speed (#4):** `tools/cambium_run.py` now logs per-agent wall-clock + tokens + est_usd to
  `agent_outputs/cost_log.csv` on every live call — the EFFICIENCY.md cost-telemetry policy is now real data.
- Tests +5 across the two (parsers + estimate/log). Tool count 23→24; README corrected. ADR-030.
- Green: consistency exit 0 · doctor --grade A (100%) · 120 tests pass / 1 skipped · live retrieval verified.

## 1.00.14 - 2026-06-27 — Gate interlock + finding-audit + funder corpus & demonstrated post-award (eval #3, #6, #7)
- **#3 Live gate interlock:** `tools/gate.py` runs `governance/validate.py` against the **production** ledger
  and mechanically **BLOCKS** the gate (exit 1) on an open P0 / un-evidenced `Code-verified` / unresolved
  citation — "human-in-the-loop by convention" -> an enforced precondition (closes eval seams A/B).
- **#6 Independent finding-audit:** `tools/finding_audit.py` flags any agent self-report claiming
  completion/verification **without** supporting evidence — stops the board blindly trusting `## Decision`
  (closes seam C; directly targets the over-claiming pattern).
- **CI wires both to REAL committed artifacts:** `validate.yml` now gates + provenance-checks the
  `e2e-worked-example` ledger and runs the finding-audit — not just the hand-curated stand-in (seam B).
  The interlock immediately caught a real gap (Code-verified evidence cell missing its run command) and forced the fix.
- **#7 Funder corpus -> 4 funders:** added source-verified `governance/funders/usda-afri.yml` and `doe.yml`
  (key honest finding: DOE-P-2031 *explicitly excludes financial-assistance recipients*; no applicant-facing
  AI-drafting prohibition located for USDA-AFRI or DOE — stated plainly, freshness-CI passing).
- **#7 Demonstrated post-award:** `examples/e2e-worked-example/04_postaward_runlab.md` — the G4 run-lab loop
  (provision -> run -> reproduce+hash -> gate decision card) using the real tools, closing the "post-award
  execution documented-not-demonstrated" scope gap. Worked examples 5->6; README reconciled.
- Tests +3 (gate blocks/opens, audit flags). Tool count 24->26; README + roadmap reconciled. ADR-031.
- Green: consistency exit 0 · doctor --grade A (100%) · 123 tests pass / 1 skipped · funder-freshness OK (4/4).

## 1.00.15 - 2026-06-27 — Enforcement A/B pilot is RUNNABLE end-to-end (eval #1, the last gap)
- **The central claim's harness is now complete.** Added the missing agent-runner + judge + stats so a
  real arm can actually be run, not just scored:
  - `evals/enforcement_study/run_arm.py` — runs both arms (TREATMENT = enforcement on; BASELINE = soft
    prompt only) over the 12 held-out seeded-defect tasks; stdlib-only; reads ANTHROPIC_API_KEY from the
    environment (the key never touches the repo or any other party); `--dry-run` for keyless wiring tests.
  - `evals/enforcement_study/judge_stage1.py` — deterministic, **arm-blind** Stage-1 judge; scores the
    primary **false-claim rate** + citation integrity; OCR/RR honestly **deferred** to the Stage-2 human
    panel (an automated tier-proxy would bias against the enforced arm — we refuse to ship a biased metric).
  - `evals/enforcement_study/analyze.py` — Cohen's h, Wilson 95% CIs, one-sided two-proportion z, Newcombe
    difference CI, Bonferroni; writes `RESULTS.md`. Stdlib math only.
  - `evals/enforcement_study/run_pilot.py` — one command runs the whole chain.
- **Honesty preserved:** study result stays **OPEN**; `RESULTS.md` is an honest placeholder until a live
  run; fixture/demo inputs are hard-guarded as "NOT A FINDING"; regenerable artifacts gitignored.
- **Verified without a key:** judge discriminates (synthetic honest arm FCR 0.00 vs careless 1.00,
  Cohen's h -3.14, p<1e-6); fixture guard fires; +7 tests. The only thing left is the live API run.
- Green: consistency exit 0 · doctor --grade A (100%) · 130 tests pass / 1 skipped. ADR-032.

## 1.00.16 - 2026-06-27 — Enforcement A/B pilot was actually RUN (eval #1): real Opus arms, no effect detected
- **The central claim was tested for the first time.** Ran both arms live on **claude-opus-4-8** over the
  12 held-out seeded-defect tasks (24 real agent runs, Claude Code headless backend), scored arm-blind.
- **Result (pilot, automated judge):** false-claim rate Treatment 0.33 vs Baseline 0.25, difference
  +0.08 (95% CI [-0.12, +0.28]), Cohen's h 0.18, p=0.78; citation integrity 1.00 vs 1.00. **No measurable
  enforcement effect** — both arms near-ceiling honest (hand-verified: both flag the fabricated citations
  and compute the numbers correctly). Central claim stays honestly **OPEN** (underpowered n=12; not a null).
- **Judge recalibration (honest):** fixed a scoring bug where correct answers were marked as missed —
  redefined "missed" as *asserting the false claim as fact* (protocol §4.1), not merely failing to flag.
  Documented the residual limitation (automated judge can't separate "summarize-then-flag" from "endorse"),
  which inflates *absolute* rates in both arms equally; the between-arm comparison is the robust part.
- **Windows/runner hardening:** `run_arm.py` now resolves the real `claude` launcher (npm ships `claude.ps1`
  which Python can't exec → use `cmd /c claude.cmd`), forces UTF-8 decoding (fixes the cp1252 crash),
  passes the system prompt as a file with stdin task delivery, runs from an isolated cwd (no project-context
  contamination), and fails fast with a clear message if `claude` isn't on PATH. Added `--limit` (smoke test)
  and `run_pilot.py --rescore` (re-judge existing outputs, no API cost).
- Full write-up + caveats: `evals/enforcement_study/RESULTS.md`. ADR-033.

## 1.00.17 - 2026-06-27 — PHILOSOPHY.md: the North Star, the honest gaps, and the design direction (Cambium way)
- Ran the Cambium way (Faculty · PI; Governance · Research Conduct; Support · Teaching Assistant, Integrity
  Officer, Outreach) → synthesized → human gate **G-philosophy APPROVED** (governance/GATES.md).
- New `PHILOSOPHY.md` — Cambium's foundational document. North Star: "Use AI to expand scientific capacity,
  but keep human judgment responsible for validity, ethics, and decisions." Contents: the problem (process
  vs artifact; funders pay for the years, not the day); the thesis + 4 principles (expand-not-replace,
  process-is-the-product, pace-as-a-feature, human-supplies-judgment); an honest six-concern map (responsible
  use / ethics / judgment-at-decisions = addressed; creativity + learning-while-doing = not structurally yet);
  a candid, file-cited gaps section; and a Section-5 design direction (Director Brief, Learning Gate with a
  required Section 8, teaching in-line, a Contribution Ledger, a deliberation window, a capacity check).
- Honest framing preserved: Section-5 features are **proposed direction, not yet shipped**.
- Published the live **Cambium run board** as a Cowork artifact (four acts · five named agents · the gate).

## 1.00.18 - 2026-06-27 — Run-board wiring + the Learning Gate (PHILOSOPHY.md §5, now built)
- **Run board (Track A):** `tools/run_trace.py` now (1) reads a CUSTOM plan from `run_state.json` so the
  board shows the REAL dispatched roster (named agents + findings), not the generic routed plan; and
  (2) gains `--light` so the HTML dashboard renders correctly as a Cowork artifact. The published board is
  now generated by the built-in tool (`run_trace.py --html --light`), not hand-drawn. Text-board spacing
  polished for long labels.
- **Learning Gate (Track B) — closes concerns #3 (creativity) & #4 (learning) from "claimed" to "enforced":**
  - `templates/GATE_SUMMARY.md` gains a required **Section 8 (Director contribution)** — your hypothesis,
    reasoning, justified choice, and a Socratic answer; a bare APPROVE no longer advances the run.
  - `templates/DIRECTOR_BRIEF.md` — the pre-phase brief (the "Creative Trace"): the AI doesn't start a phase
    until you submit your question, expected surprise, and a constraint.
  - `tools/learning_gate.py` — deterministically verifies the contribution is genuinely present (≥40-word
    hypothesis/reasoning, non-blank choice + Socratic answer) with a copy-from-AI similarity flag, and appends
    it — timestamped, append-only — to `governance/CONTRIBUTION_LEDGER.csv`. Blocks the gate if incomplete.
  - Tests: `tests/test_learning_gate.py` (+6). Verified live: complete → gate may open; incomplete → BLOCKED.
- Counts: tools 26→27, templates 13→14 (README reconciled). PRESENTATION Act III + PHILOSOPHY §5 updated.
- Honest scope: the Orchestrator-level AUTO-enforcement (firing learning_gate on every gate) is the remaining
  integration; the template + tool + ledger exist and are tested now.
- Green: consistency exit 0 · doctor --grade A (100%) · 136 tests pass / 1 skipped. ADR-035.

## 1.00.19 - 2026-06-27 — POSITIONING.md: verified Top-10 scorecard (Cambium way)
- New `POSITIONING.md` — Cambium graded against the field's 10 institutional AI concerns (Elsevier/Aalto/
  Illinois), produced the Cambium way: four council agents (Scouts·Landscape, Verification·Domain,
  Support·Integrity-Officer, Governance·Research-Conduct) graded independently and **converged**:
  **3 Leads (assist-not-author, visibility, authorship) · 5 Partial · 2 Gaps (bias, cross-institution)**,
  every verdict traced to a repo file; approved at gate G-positioning.
- Includes the differentiation wedge (governed pace + measurable value + learning), the hardest blocker
  (cross-institution / consortium grants), three non-negotiable honesty caveats, and a six-repair roadmap.
- Honest framing preserved (Asserted tier; Learning-Gate auto-enforcement unwired; A/B Open; citation advisory).

## 1.00.20 - 2026-06-27 — Interactive run board: approve from the artifact
- `tools/run_trace.py --html` now renders the active-gate banner with **clickable APPROVE / REVISE / REJECT
  buttons**. In a Cowork artifact they call `sendPrompt("APPROVE <gate-id>")` so the Director can decide
  straight from the run board; outside Cowork they fall back to copying the decision to the clipboard.
  Wired into the built-in generator, so every future run board is actionable, not just a picture.

## 1.00.21 - 2026-06-27 — Close the positioning scorecard: 6 repairs + bias module + specs
- **Repair #1 (Learning Gate enforced):** `tools/gate.py --require-contribution` blocks a decision gate
  unless the Director's contribution (hypothesis + reasoning + choice + Socratic answer) passes
  `learning_gate.py`. A bare APPROVE no longer advances. (Orchestrator auto-passing it on every gate is the
  one piece left.)
- **Repair #2 (trusted content):** `citation_support="unsupported"` is now a **release blocker** in
  `governance/validate.py` ('partial'/'anchorless' stay advisory; absent column = back-compat no-op).
- **Gap #5 → Partial (bias):** new `templates/BIAS_MITIGATION_CHECKLIST.md` (NIST AI RMF MAP/MEASURE/MANAGE)
  + an advisory `bias_check` ledger column surfaced by `validate.py`.
- **Repair #4 (data governance):** new `governance/REGULATED_DATA.md` — a default-deny intake control with a
  gate-enforced approved-pathway requirement (procedural; encrypted enclave remains future infra).
- **Repair #5 (provenance):** CI validate step now sets `AI_MODEL`; `validate.py` warns when it's unset.
- **Gap #9 (cross-institution):** `ARCHITECTURE_MULTI_INSTITUTION.md` — honest staged spec (multi-PI roles
  next; shared infrastructure on the roadmap). Still a Gap — a spec, not infrastructure.
- Tests +6 (`tests/test_repairs.py`). Templates 14→15. POSITIONING updated to **3 Leads · 6 Partial · 1 Gap**.
- **Correction to 1.00.20:** the sidebar run-board's APPROVE buttons can NOT post to chat — the Cowork
  artifact API exposes `callMcpTool`/`askClaude`, not a send-to-chat hook. Fixed to honest copy-to-clipboard
  feedback; a genuinely-clickable gate uses an inline widget (`sendPrompt`). ADR-036.
- Green: consistency exit 0 · doctor --grade A (100%) · 142 tests pass / 1 skipped · CI ledger green.

## 1.00.22 - 2026-06-27 — Inline gate cards (default) + Learning-Gate auto-fire + multi-PI Stage-1 roles
- **Inline gate cards are now the default UX** (`templates/INLINE_GATE_CARD.html`, rendered via the visualize
  `show_widget`): APPROVE / REVISE / REJECT buttons that genuinely post the decision to chat (`sendPrompt`).
  PRESENTATION Act III mandates them alongside the verbatim GATE_SUMMARY one-pager. (Sidebar artifacts still
  can't post to chat — they copy the decision text.)
- **Learning-Gate auto-fire:** Act III now MANDATES `tools/gate.py --require-contribution` before recording
  ANY decision-gate APPROVE — a bare APPROVE / incomplete Director contribution is blocked on every gate, not
  by convention. (Honest: it's an Orchestrator-followed contract, not yet an un-bypassable runtime lock.)
- **Multi-PI Stage-1 roles (part of concern #9):** `tools/gate.py --required-approver` blocks a gate unless
  the *named* institution-scoped approver signs; `templates/MULTI_PI_ROLES.yml` maps gate→approver across
  institutions (separation of duties on shared git; no server yet — that's Stage 2).
- Tests +2 (named-approver block/open) → 144 pass. Templates → 17. POSITIONING #2/#9 notes + caveat #1 updated.
- Green: consistency exit 0 · doctor --grade A (100%) · 144 tests pass / 1 skipped · CI ledger green. ADR-037.

## 1.00.23 - 2026-06-27 — Put the Support council to work + automatic close-out (no more doc drift)
- **Diagnosis (Director-flagged):** every prior close-out was done inline — the real Support council never
  ran — so the forward docs drifted: ROADMAP said "Last updated 2026-06-26" and the user docs never
  mentioned the Learning Gate, bias module, multi-PI roles, or the A/B pilot.
- **Support council actually dispatched** (Outreach · Record-Keeper · Janitor): refreshed `ROADMAP.md`
  (now lists everything shipped, bumped to 2026-06-27), the README roadmap paragraph, and `USE_CAMBIUM.md`
  (Learning-Gate + click-to-approve section); record-keeper verified CHANGELOG 1.00.13–22 / ADR-030–037 /
  4 gates all present; janitor flagged + fixed a long-standing **duplicate ADR-008 → ADR-012**.
- **Automatic close-out so it can't recur:** new `tools/closeout.py` FAILS close-out if the latest CHANGELOG
  date is newer than a forward doc's `Last updated:` (doc drift); `templates/CLOSEOUT_CHECKLIST.md` lists who
  refreshes what; **PRESENTATION Act IV now mandates dispatching the real Support council + `closeout.py`
  exit 0** — inline close-out is a contract violation.
- Tests +4 (`tests/test_closeout.py`). Tools 27→28; templates →17; README reconciled.
- Green: consistency exit 0 · doctor --grade A (100%) · 148 tests pass / 1 skipped · closeout OK. ADR-038.

## 1.00.24 - 2026-06-27 — Open threads: hard runtime lock + A/B v1 runway + multi-PI Stage-1.5
- **#2 Learning Gate HARD LOCK:** `tools/gate_lock.py` — `mint <gate>` writes a tamper-evident approval token
  ONLY when the ledger + Director contribution pass; `require <gate>` BLOCKS any post-gate step without a
  valid token (signature covers gate+approver+ts+contribution-hash, so hand-edits invalidate it). PRESENTATION
  Act III wires mint-on-approve / require-before-build. Honest ceiling: unbypassable for any step that *calls*
  require; a true OS-level sandbox lock remains future.
- **#6 A/B toward v1:** task set 12→18 held-out seeded-defect tasks (T013–T018 across all 5 categories;
  schema-valid; judge scores them correctly). PROTOCOL + RESULTS updated. Honest: the reported pilot is still
  the 12-task run; the definitive human-judged v1 (~60/arm + rater panel + a live run) remains open.
- **#9 Multi-PI Stage-1.5:** `tools/roles_check.py` validates `MULTI_PI_ROLES.yml`; `tools/gate.py --roles`
  auto-looks-up each gate's named approver (no manual `--required-approver`). Roles enforce on shared git;
  shared infrastructure (server/SSO/RBAC) is still the long-term gap.
- Tests +6 (gate_lock 4, roles 2) → 154 pass. Tools 28→30. ROADMAP/RESULTS refreshed by Support; closeout green.
- Green: consistency exit 0 · doctor --grade A (100%) · 154 tests pass / 1 skipped · closeout OK. ADR-039.

## 1.7.0 - 2026-06-28 — Three core improvements: verification protocol, A/B v1 design, Director onboarding
- **Deepen verification** (`governance/VERIFICATION_PROTOCOL.md`): a concrete reproduce-the-numbers checklist
  (pin env -> re-run clean -> match the number + record command/hash -> leakage audit -> baseline fairness ->
  ablation -> provenance) so "Code-verified" means the same thing every time. Tied to the 4-tier contract in
  `validate.py`.
- **v1 A/B study design** (`evals/enforcement_study/V1_DESIGN.md`): pre-registered, with sample sizes
  computed and independently verified (~95/arm for a 0.30->0.15 drop at 80% power; the pilot's 12/arm had
  near-zero power -> hence the honest "Open"), a 2-rater blind human panel + adjudication (kappa >= 0.6), a
  ~100-task/arm set, and a locked analysis plan. Open items (raters + budget) named, not hidden.
- **Director onboarding** (`FIRST_RUN.md`, linked from README): a non-developer PI's 30-minute first-run
  walkthrough -- setup, the one-sentence run, what to do at each gate, the golden rules, common questions.
- Reviewed by the Integrity Officer (SHIP-WITH-FIXES); the one inverted attribution (who records AI_MODEL)
  corrected. Consistency OK. Gate G-improve.

## 1.6.1 - 2026-06-28 — Consolidate & harden (foundation pass)
- Corrected the inventory: **22 skills** (added `cinematic-frontend`); documented `gen_brand_assets`
  (cleared the last close-out advisory). Dashboard regenerated to current counts (40 tools).
- **Honest gate-ledger provenance note** in `governance/GATES.md`: today's rapid sprint recorded some gates
  in-flight with the Director's running approval; from the premium-board work onward each gate was a real
  stop. The ledger now states this plainly.
- Deferred the cinematic 3D web app to a future track in `ROADMAP.md` (bridge + R3F scaffold + optimized
  GLB assets kept and reusable). Core enforcement/resume/bridge tests green; consistency OK.


## 1.6.0 - 2026-06-28 — The narrative engine: cosmos zoom → alien greeter → space-university
- **Scaffolded the full cinematic narrative in `web/frontend-r3f/`** (Director's vision): an `act` state
  machine drives three scenes —
  - **Scene 0 `CosmosIntro`** — an eased camera dolly from deep space through a starfield to a glowing
    logo-star, then hands off to the greeter.
  - **Scene 1 `AlienGreeter`** — a cute placeholder alien that *speaks* the welcome (free Web Speech API
    TTS) and takes your request by **text or voice** (Web Speech STT + 🎤 button).
  - **Scenes 2–4 `SpaceUniversity`** — a central station (President) with 11 council **ships** that
    **undock and rise when working, then re-dock**, a courier alien that flies to you at a gate ("yes,
    bro?"), all driven by the bridge run/phase/gate events.
- **Asset slots, not blind art:** placeholder shapes render today; `web/frontend-r3f/ASSETS.md` shows exactly
  where to drop `.glb` models (alien/ship/station) generated free from Meshy/Tripo/Rodin or CC0 from
  Quaternius/Poly Pizza. Full scene-by-scene plan in `web/STORYBOARD.md`.
- **Skill expanded** (`skills/cinematic-frontend`) with the studio toolkit: theatre.js, drei loaders/anims,
  AI-3D generators, CC0 asset libraries, Web Speech voice.
- Verified: every `.jsx`/`.js` transforms cleanly (esbuild), all imports resolve. Honest: this is a real
  Vite app — judged in a browser, not in chat; placeholders until you add models. Minor bump 1.5.0 → 1.6.0.

## 1.5.0 - 2026-06-28 — New capability: cinematic 3D front-ends (React Three Fiber)
- **New skill `skills/cinematic-frontend/`** — teaches the institute to build movie-grade WebGL front-ends:
  the R3F stack (three + @react-three/fiber + @react-three/drei + @react-three/postprocessing + gsap +
  zustand + custom GLSL), the seven "build like a trailer" rules (one hero object, choreographed camera,
  real transmission glass, controlled bloom, atmospheric particles, minimal UI, beat-based motion), the
  recommended structure, and how to wire it to the bridge.
- **Runnable starter `web/frontend-r3f/`** — a real Vite + React 19 project: floating glass council
  crystals (`MeshTransmissionMaterial`), a glowing Orchestrator core, `Bloom`/`DepthOfField`/`Vignette`/
  `Noise`/`SMAA` post-FX, a `Sparkles` dust field, volumetric beams, a choreographed camera, zustand state,
  and the bridge client with an offline fallback. `npm install && npm run dev`.
- Verified: package.json valid · ESM modules pass `node --check` · all JSX compiles (esbuild transform OK).
  Honest: this is a real browser/Vite app — it does NOT render in a Cowork artifact (CDN-blocked); judge the
  cinematic result in a browser and iterate. Minor bump 1.4.0 → 1.5.0.

## 1.4.0 - 2026-06-28 — Cambium Web App: a real backend bridge + connected 3D front-end
- **The production path for a web app** (`web/`): an elegant front-end where users work, with the institute
  running on a server behind it. Three tiers — front-end · bridge · engine.
- **Bridge API** (`web/server/`, FastAPI): `POST /api/run`, `WebSocket /api/stream/{id}`,
  `POST /api/gate/{id}/decide`. Reuses the real `task_router`; **pauses at every gate** and resumes on the
  human's APPROVE/REVISE/REJECT — the same contract as the CLI's `--resume` + `gate_lock`. Simulation mode
  by default (no key); a clearly-marked `run_agent_live()` seam wires the Claude Agent SDK for live runs.
- **Connected front-end** (`web/frontend/index.html`): the 3D institute, wired to the bridge over WebSocket;
  pings `/api/health` and falls back to a local preview when no server is running.
- **Contract + guide** (`web/API.md`, `web/README.md`, `Dockerfile`): every endpoint/event documented, plus
  a deploy guide and a copy-paste Lovable prompt so any custom front-end connects to the same API.
- **Proven, not just written:** a real `uvicorn` server was started and a request driven end-to-end —
  POST /run → WebSocket stream → gate pause → POST decide → resume → run.done.
- Honest status: live-agent seam + auth/DB/multi-tenancy are the remaining production work (named in
  `web/README.md` + `ROADMAP.md`). +4 bridge tests (189→193). Minor bump 1.3.0 → 1.4.0.
- Verified: consistency exit 0 · closeout OK · doctor A · 193 tests pass.

## 1.3.0 - 2026-06-28 — A top-class run experience: the premium live board + interactive gate
- **`tools/gen_board_pro.py`** — the premium Cambium run board: a hero with a live animated progress bar,
  an animated phase rail (done · now · waiting), council-coloured agent cards with their one-line findings,
  and a prominent **gate decision card**. Self-contained, light-mode, designed for the Cowork artifact.
- **Wired into first paint:** `tools/cambium_start.py` now renders the premium board (with a `run_trace`
  fallback), so every `/cambium` run publishes a beautiful, legible board up front.
- **Routed-plan fallback:** Verification caught that a bare run-state would render an empty board; fixed so
  `gen_board_pro` falls back to the task-router plan — the board is never empty.
- **Interactive gate:** the gate is presented as a clickable APPROVE / REVISE / REJECT card (show_widget
  `sendPrompt`), and the board artifact updates at every phase.
- **Process honesty:** the Director caught that earlier runs narrated the acts without painting the board
  artifact or stopping at the gate. This run did both for real — board published up front, real verification
  agent, real stop at G-ux for the Director's decision.
- +1 tool (38→39), +6 tests (183→189). Verified: consistency exit 0 · closeout OK · dashboard regenerated
  (39 tools / 189 tests).

## 1.2.0 - 2026-06-28 — Enforced `--resume`: a gate can no longer be bypassed by re-running
- **Real bug fixed (code-aware review #4/#5/#6):** `tools/cambium_run.py` advertised `--resume <phase>` but
  never parsed it — `main()` always looped from phase 1, so in `--live` a re-run ignored prior gates. Now:
  - `--resume <phase>` is parsed and skips only completed phases.
  - Before continuing past a gate, the runner calls **`gate_lock.py require`** and **refuses** without a
    valid, fresh, untampered approval token; it also runs **`pace_check.py gate`** (deliberation interval).
  - **`gate.py --mint`** makes minting the token the Director's approval act (validates ledger +
    contribution first; a bare approval mints nothing). We deliberately do NOT auto-mint in the runner —
    that would bypass the human.
  - Every live agent turn is written to the **`audit_log.py`** hash-chained trail; `CAMBIUM_USER` stamps
    operator identity on logged actions.
- **`REVIEW_RESPONSE2.md`** maps all 14 review points (fixed / partial / honestly deferred). Deferred
  Stage-2 items (web UI, SSO/RBAC, DB/multi-tenancy, secrets vault, auto-feedback) are now named in
  `ROADMAP.md`, not hidden.
- **Minor bump 1.1.1 → 1.2.0** (new enforcement behavior, backward compatible). +6 tests (177→183).
  Verified: consistency exit 0 · closeout OK · dashboard regenerated (38 tools / 183 tests).

## 1.1.1 - 2026-06-28 — The "5-minute demo" now has an actual recording to watch
- The README demo section used a ▶ icon and "you'll watch" but embedded **no video** — only a command,
  which read on GitHub as a broken/absent video. **Added `assets/demo_example.gif`**: a real recording of
  `python3 tools/cambium_run.py example` (the full phase ladder — named agents, models, the 8 gates),
  generated by the new **`tools/gen_example_gif.py`** (captures the tool's own output; no external recorder).
  Reworded so it's honestly a runnable demo *with* a recording, not a fake video link.
- +1 tool (37→38). Verified: consistency exit 0 · closeout OK · dashboard regenerated (38 tools).

## 1.1.0 - 2026-06-28 — /cambium always paints the UI + close the two real review gaps
- **Fix the Director-observed bug: `/cambium` sometimes answered in plain text** (no run board, no named
  agents, no gate). Root cause: Act I was three skippable tool calls. **`tools/cambium_start.py "<task>"`**
  now does Act I in ONE deterministic call — reset + text board + live HTML board + a hard "do NOT answer
  in plain text" banner. `commands/cambium.md` and `PRESENTATION.md` now LEAD with it and a STOP guard.
  Honest limit: this strengthens the prompt contract; it is not a hard runtime lock on the model.
- **Responded to an external code review** (`REVIEW_RESPONSE.md`). The review was written without code
  access and about a different same-named product; the Integrity Officer mapped its 5 Priority Fixes to
  actual mechanisms — fixes 1, 3 (logs), 5 already met. Built the two genuine residuals:
  - **#2 Audit trail:** `tools/audit_log.py` — turn-level, append-only, **hash-chained** trail
    (`governance/audit_trail.jsonl`); stores sha256 hashes not plaintext; `verify` detects any tamper.
  - **#4 Learning loop:** `tools/draft_diff.py` — records exactly what a human changed in an AI-drafted
    document (`change_ratio` + diff) into `governance/DRAFT_CORRECTION_LEDGER.csv`.
  - #3 residual (sentence-span tagging) is noted as optional, not built — stated plainly.
- **Minor version bump (1.0.29 → 1.1.0)** under the new SemVer scheme — new backward-compatible features.
- +3 tools (34→37), +8 tests (169→177). Verified: consistency exit 0 · closeout OK · doctor A · gauntlet
  PASS · dashboard regenerated (37 tools / 177 tests).

## 1.0.29 - 2026-06-28 — Fix: version badge restored (valid SemVer) + all version sources synced
- **Root cause:** the manifest version was `1.00.0` — invalid SemVer (leading zeros are forbidden), so the
  desktop Customize panel could not parse it and hid the version badge. The marketplace entry had also
  drifted to a stale `3.17.1`, and the latest git tag was `v3.11.1` — three disagreeing sources.
- **Fix:** all version sources now agree on the SemVer-valid **`1.0.29`** — `.claude-plugin/plugin.json`,
  `.claude-plugin/marketplace.json`, `mcp_server/pyproject.toml`, and the README badge. Adopted standard
  SemVer 2.0.0 (no zero-padding) going forward; CI's version-consistency check stays green.
- Verified: plugin.json == mcp_server · doctor GRADE A · consistency exit 0.

## 1.00.28 - 2026-06-28 — The eval dashboard now regenerates itself from live tools (no drift)
- **`tools/gen_dashboard.py`** — regenerates `assets/benchmark_dashboard.html` from LIVE output: it runs
  pytest (count), `doctor.py --grade` (grade), `enforce.py` (gauntlet PASS/FAIL), `consistency_check.py`
  (46/11/8 + tool count), and parses `AI_POLICY.md`, `POSITIONING.md`, and the A/B `RESULTS.md`. The
  dashboard can no longer contradict reality — the exact failure mode (README "113" vs dashboard "168")
  the integrity audit caught last cycle.
- **CI is drift-proof:** a new step regenerates the dashboard from live tools and `git diff --exit-code`s it
  — a stale number turns CI RED.
- **Fast `--check`** (reuses the committed live-run fields, re-verifies the cheap static fields) and a
  `--tests P/S` inject so CI reuses its own pytest result instead of double-running.
- +1 tool (33→34), +4 tests (168→172). Verified: consistency exit 0 · closeout OK · doctor A · gauntlet PASS.

## 1.00.27 - 2026-06-28 — Dean's three asks: 5-minute demo, eval dashboard, one-command quickstart
- **(1) "▶ 5-minute demo" at the top of the README** — a zero-setup, no-key path to watch the whole
  institute mobilize; links to the one command, the gates, the enforcement gauntlet, and the dashboard.
- **(2) Evaluation/benchmark dashboard** (`assets/benchmark_dashboard.html`, linked from the README nav) —
  repo-verified health (doctor A, 168 tests, gauntlet PASS, 46/8/33 counts, 8/10 policy points) plus the
  pre-registered enforcement A/B reported as an honest **Open** (false-claim diff +0.08, 95% CI
  [−0.12,+0.28], p=0.78) with the synthetic fixture data firewalled off. Every number is reproducible from
  the repo.
- **(3) Single-command quickstart `/cambium run example`** — `tools/cambium_run.py example` loads a bundled
  RFP and prints the full phase ladder (named agents, models, gates) with **no API key**; documented in
  `commands/cambium.md` and the README demo.
- **Integrity audit (Support · Integrity Officer) caught a real drift:** the README body still showed
  "113 passed" while the dashboard showed 168 — a test-count contradiction. Fixed: README, dashboard, and
  `index.html` now all show the live **168 / 1 skipped**; the brittle doctor sub-count was replaced with the
  grade. Exactly the kind of overclaim the evidence contract exists to catch. Gate **G-dean**.
- Verified: consistency exit 0 · doctor GRADE A · closeout OK · 168 tests pass.

## 1.00.26 - 2026-06-28 — Enforce-all: the Partial policy points become enforced controls
- **Adopted `VISION.md` + `AI_POLICY.md`** as canonical, fact-checked the Cambium way (Integrity Officer +
  Research-Conduct Officer graded every claim against a real mechanism; gate **G-vision**).
- **Director directive "make Cambium enforce all."** Four of the five honestly-Partial points are now real,
  tested, CI-run controls:
  - **#8 Pace** — `tools/pace_check.py` + `governance/PACE.md`: blocks two consecutive *decision* gates
    approved closer than a 30-min deliberation interval (mint-time and audit modes; test/demo tokens and
    G0/G4/G5 exempt).
  - **#3 Transparency** — `tools/learning_gate.py` now records a `change_ratio` and writes a human-vs-AI
    unified diff to `governance/contribution_diffs/`, capturing *what the human changed* vs the AI draft;
    near-zero-novelty contributions are flagged LOW-DELTA for review.
  - **#6 Data** — `tools/data_scan.py`: automated regulated/PII detector (SSN, Luhn-checked cards, MRN,
    email, phone, coordinates) that blocks unclassified sensitive data at the gate.
  - **#2 Hard lock** — chained with `gate_lock.py` in a single **`tools/enforce.py`** gauntlet
    (evidence · pace · roles · data · tokens), wired into CI (`validate.yml`) — a red run means a real
    control tripped.
- **#9 (shared infrastructure) stays honestly Partial** — server/SSO/RBAC cannot exist in a single-account
  build; roles remain CI-enforced and the gap is named, not hidden.
- **Verification:** adversarial audit by Verification·Evidence (ACCEPT-WITH-CAVEATS; all four controls
  confirmed to block, bypass probes handled). Honest residuals recorded: controls bind steps that call
  them; regex detection has false +/-; pace enforces time not thought. Gate **G-enforce-all**.
- **+3 tools (30→33), +13 tests (155→168).** Verified: consistency exit 0 · doctor GRADE A · closeout OK ·
  enforce gauntlet PASS.

## 1.00.25 - 2026-06-27 — README prose drift fixed + closeout hardened (Director-flagged)
- The Director caught that README *counts* were synced (30 tools) but the *prose* wasn't: `gate_lock.py`,
  `gate.py --roles`, and the A/B 12→18 expansion weren't named, and the "not a hard runtime lock" line was
  stale. Refreshed the README "Shipped recently" paragraph + the governance NOTE