# Changelog

All notable changes to FVS (Formal Verification Skills) will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/).

## [Unreleased]

## [2.3.12] - 2026-11-16

### Added

- `/fvs:loop-me-in` writes a self-contained HTML walkthrough of the last chunk of work, so you can
  catch up after an automated run. It states what was established in terms of the mathematics or
  protocol rather than the files. It shows where that step sits on the topic roadmap, as a
  milestone track with every status quoted verbatim and this step and the next steps marked. It
  explains how the work was made as an argument in prose, with links to the declarations and
  statement-only excerpts, never proof scripts. It ends with a multiple-choice quiz whose
  collapsible answers cite the code. (#96, #120)
- The command is offered once after an interactive `/fvs:crypto-eval` ACCEPT. You can also run it
  on demand with a plain-language description, an exact `<topic> nN`, `--commit` or
  `--working-tree`; a bare call ranks the most recently active work and shows one correction screen
  before anything is written. (#96, #120)
- Audience, documentation and style references come from a new `loop_me_in` block in the FVS config
  or from flags. Every code and record link opens the file in your editor at the cited line through
  the editor's URL scheme (`--editor`, `loop_me_in.editor`, or detection from the terminal,
  `$VISUAL`/`$EDITOR`/`core.editor` and `PATH`, with VS Code as the stated fallback), so a browser
  never has to read project files. (#96, #120)
- Output goes under `.formalising/loop-me-in/<slug>/` and is never overwritten. The command runs in
  the current session with no subagent, and never commits, edits project files or changes a
  recorded decision. (#96, #120)
- `/fvs:loop-me-in --final [<topic>]` explains the whole work instead of a chunk, typically at the
  end of a formalisation. It is a tutorial at the level of the top-level theorems, with every idea
  stated mathematically and in prose, no Lean beyond a reading table and editor links, and a trust
  section whose "standard axioms only" claim is made only after a bounded `#print axioms` check.
  The work is the roadmap plus the branch against the branch it diverged from (pull-request base,
  then the reflog, then `main` as the stated default), shown with the other candidates and the
  top-level theorems for correction before anything is written. (#96, #120)
- A workflow guide, `docs/workflow.md`, follows a project from planning through the Rust, paper and
  crypto tracks, the review commands and the session commands, with a diagram for each flow. The
  README shows the functional-correctness and crypto-formalisation pipelines as two diagrams and
  links to the guide, and `/fvs:help` links to it too. The guide lives in the repository and is not
  part of the npm package. (#121, #125)

### Changed

- `/fvs:crypto-execute` names the executor's run report path explicitly,
  `.formalising/fv-plans/<topic>/IMPLEMENTATION_nN.md` next to `build.log` (where it already landed
  in practice), checks it after the run and writes the returned report there itself when missing.
  `/fvs:loop-me-in` reads it as the authoritative list of files an iteration touched. (#96, #120)
- `/fvs:crypto-eval` reads that same report by name, `.formalising/fv-plans/<topic>/IMPLEMENTATION_nN.md`,
  as its source for the files the iteration touched, and checks that the iteration argument is `n`
  followed by digits before it builds the path. When the report is missing, as for an iteration run
  before it was persisted, the eval says so and takes the files from `git diff --stat` and
  `git status --porcelain` instead of rebuilding the list from chat context. (#119)

### Fixed

- `/fvs:help` and the README no longer say that `/fvs:fc-plan` computes a bottom-up verification
  order or sorts functions into "ready now" and "blocked". They now say that it refreshes the graph
  and progress facts in `.formalising/CODEMAP.md`, writes qualitative complexity, leverage and risk
  notes to `.formalising/PLAN.md`, and lets you pick a target; the notes do not certify that a
  target's dependencies are proved. (#124, #125)
- The one-line `/fvs:fc-plan` summary in `/fvs:help`, "Pick next verification targets via dependency
  graph analysis.", now matches those bullets: "Choose a verification target, with qualitative
  notes on complexity, leverage and risk." (#124)

## [2.3.11] - 2026-11-03

### Fixed

- Direct installs resolve bundled script paths from the selected installation directory, including
  project-local installs invoked from a nested working directory. Shell examples quote those paths,
  so spaces and literal shell characters in direct-install paths do not split or expand them.
  Generated plugin examples keep the plugin root, and Pi examples keep package-relative resources.

## [2.3.10] - 2026-11-02

### Fixed

- Codex: crypto and other FVS commands now dispatch their sub-agents without a manual request. Codex
  only spawns sub-agents when the user or a skill explicitly asks; the Codex skill adapter now states
  that invoking an FVS skill is that request, discovers a deferred `spawn_agent` tool first, and stops
  with an explanation instead of silently doing a delegated role inline when sub-agents are
  unavailable (#114).
- Codex: FVS sub-agents start with fresh context on both spawn schemas. The adapter passes
  `fork_turns: "none"` (MultiAgentV2, used by most current models) or `fork_context: false` (V1)
  instead of an unconditional `fork_context: false` that V2 rejects or treats as a full-history fork,
  which also refused the confirmed model and effort (#114).
- Codex: the adapter no longer implies that a role's `sandbox_mode` is enforced. Codex children run
  in the parent session's sandbox; the effective sandbox is reported as the parent's, and a child is
  never called read-only when the parent can write.
- Loop commands that delegate a sub-agent per pass or round (lean-refactor, lean-verify, aeneas-extract,
  lean-specify repair passes, lean-formalise researcher re-dispatch, model-external revision rounds, and
  crypto-plan, crypto-followup and crypto-eval re-authoring or recheck) now state one uniform rule for
  Claude Code and Codex: a fresh child per pass with current inputs, no inline substitution by the parent,
  and a stop when a dispatch fails or ends in a terminal error, while valid results keep their routing.
  lean-refactor no longer starts another pass after a refactorer `## ERROR`. This is an instruction
  contract; it is not host enforcement of each pass (#114).

### Added

- `/fvs:crypto-eval` records a measured `Thinker wall time` in each eval: the `--codex` helper's
  measured process time, or the parent's clock from launch to the thinker's terminal response, or
  `not measured (<reason>)`. Failed or timed-out runs still persist no eval. This is timing
  instrumentation only, with no change to decisions or reviewer policy (#115).
- `/fvs:lean-refactor` works on any Lean file whose proofs already compile, an FVS spec or an ordinary
  Lean project file. Aeneas conventions apply only in Aeneas-extracted projects. Files with `sorry` or
  build errors go to `/fvs:lean-verify`; statements, signatures, attributes, definition meaning and the
  axiom policy stay unchanged, and new helpers stay as local as possible. A selected-file gate checks
  the chosen file with its imports at baseline and after every change (a default build may skip it),
  with real exit status. Outside configured library roots, `lake lean` rebuilds the actual imports,
  including non-default libraries, before each direct check. The Mathlib cache preflight runs only
  in projects that provide it. The argument label is now `<lean_file_path>`. Existing flags remain
  recognized; legacy mode mappings and pass budgets are described below.
  Credit: ideas from `/lean4:refactor` in Cameron Freer's
  lean4-skills (MIT, commit `83582df`), paraphrased.
- The protocol-prose guidance used by existing authoring calls adds a light plain-English wording pass
  after the exposition, guided by ASD-STE100 Simplified Technical English (Issue 9) but not
  STE-compliant. It freezes quotations, citations, code, Lean names, commands and formulas, keeps the
  mathematical register and house style, treats sentence lengths as soft guidance, and preserves
  every claim, quantifier and hedge. It adds no agent or review step.

### Changed

- Lean refactoring resolves the effective installed project toolchain, including overrides, and
  checks Lake's actual compiler path and binary hash before cache/proof work and at baseline/final
  capture. Targets, inspection, tactics and profiling use the project's available capabilities;
  unsupported capabilities use explicit project/review routes without upgrading a pin. Dependency-free
  checks cover Lean/Lake 4.25.2, 4.31.0 and 4.35.0; this is not universal compatibility qualification.
- Lean refactoring proposes a protected boundary and editable file/module/project scope before
  editing. It seeks net LoC reduction through reuse and shared lemmas, including new helper/import
  costs, while preserving useful prose. Broader scope and new public interfaces require proposals.
- Refactor acceptance records actual comparable build/elaboration samples and stops for an owner
  trade-off on a repeatable material performance regression. Tactic tiers, fixed reduction targets
  and unsupported speed guarantees are removed. Legacy mode flags remain explicit search hints
  warned when explicitly supplied; defaults need no migration prompt. Pass ceilings remain budgets.
- Parent-only serial compiler gates and a pristine printed-boundary comparison replace child builds.
  Net-code-LoC reporting excludes comment deletion and known formatting-only packing; operator
  counts are hints, not a hard acceptance limit or a complete Lean parser. Unsupported printed
  coverage or interpolation metrics use explicit reviewed comparisons; helper limitations do not
  block valid refactoring or waive compilation/axiom safeguards. Unavailable counts are not guessed.
  Printed comparisons support review; they are not kernel identity proofs.


## [2.3.9] - 2026-10-27

### Added

- `/fvs:ask-baif` orients users and agents to the current goal and evidence, routes one existing FVS
  command or bounded ordinary-task handoff, and reconciles/books existing issues when authorized.
  Within/between-batch checkpoints preserve ownership, goal acceptance and publication consent without another executor or scheduler.

- `/fvs:to-issues` breaks a roadmap or conversation into reviewable outcomes with blockers and
  acceptance evidence, exporting local markdown or publishing an approved, sanitized GitHub batch
  with explicit relationships and a recovery log.

- `/fvs:roadmap` turns the current conversation or a short prompt into a long-horizon verification
  roadmap (`ROADMAP.md`): the claims to establish, scope and exclusions, external boundaries,
  milestones that an existing FVS command or checker decides, and decisions and status logs that a
  rerun only appends to. It synthesizes facts first, clarifies lightly by default or in adaptive deep
  rounds for material uncertainty/disagreement, and confirms new or changed shared intent explicitly.
  Current owner-approved agreements are reused without redundant questions; unresolved owner choices
  stay blocked, including in autonomous use. It writes under `.formalising/fv-plans/<topic>/` after
  checking that git excludes the file, offers to add `.formalising/` to the repository's local
  `info/exclude` rather than any tracked ignore file, and records unknowns as blocked milestones.
  Approving a roadmap grants no execution, spending or publication authority.
- `/fvs:issues-setup` lets you choose where a project's issues live (GitHub, local markdown, or another
  tracker) and records the choice, with its label vocabulary, in `.formalising/fvs-config.json`. A
  roadmap can override it in its own frontmatter. It only records the choice: it never creates GitHub
  labels or issues, and never edits ignore files.

- `/fvs:protocol-prose <file-or-topic>` revises protocol explanations against the source paper and
  repository conventions while preserving formal content. Lean edits require before/after builds
  and a prose-only comparison. Existing crypto and paper authoring calls receive the same guidance.
- Optional `/fvs:crypto-eval <topic> nN --fix-prose` permits one qualified editorial correction in
  the parent seat, followed by a fresh eval of the corrected files and all findings. Immutable
  baseline/correction/recheck records preserve history; semantic followup remains available when
  current acceptance cannot be established. This does not change the thinker's role or tool rights.

### Changed

- Crypto executors use the host's precise editing tool for localized changes, with unique-preimage
  checks and readback. Dispatch first checks effective edit access; a missing tool or uncertain
  policy blocks instead of silently rewriting whole files. Native whole-file writes remain for
  new files and genuine full rewrites within the approved scope (#107).
- Crypto plan reviews read the cited context needed to settle a question rather than repeatedly
  rereading whole sources. Fresh review, source fidelity, reuse and statement/trust checks remain;
  this wording change does not establish a model speedup or complete the broader #101 work.
- The native inventory is 35 commands and 21 workflows. Setup and package discovery counts derive
  from canonical commands, with explicit inventory allowlists retained in tests.

## [2.3.8] - 2026-10-23

### Added

- Antigravity's `agy` CLI replaces the retired Gemini CLI. `npx fv-skills-baif --antigravity` (or
  `--agy`) installs FVS as a native agy plugin in `~/.gemini/config/plugins/fvs/`, or
  `.agents/plugins/fvs/` for a local install, and the model profiles add an Antigravity planner
  row (Argon 4). Installing or uninstalling for Antigravity removes FVS's own files left by an
  earlier Gemini install and leaves everything else in `~/.gemini` alone; `--gemini` now points to
  `--antigravity`. The plugin passes `agy plugin validate`; how agy uses the agents' tools and the
  update hook at runtime has not been verified yet (#93).
- Argon (`gemini-4-argon-*` through agy) can review Claude- or OpenAI-authored crypto plans,
  specifications and external models. agy runs sandboxed in a temporary copy of the project without
  proof-engineering memory, and the review stops if agy's settings allow access outside the
  workspace. An Argon review sends the review packet to Google under your own agy account terms; on
  consumer accounts Google may use that content (#93).
- Each reviewer process records its start, end and duration, and crypto review records show the
  reviewer's wall time, so slow rounds can be measured (#94).
- The verified probe-aeneas workflow also runs on Linux x86_64. Extraction is confined with
  bubblewrap and works on a separate copy of the project. You need native tools, `/usr/bin/xz`
  and `/usr/bin/bwrap` with working unprivileged namespaces and seccomp; FVS does not install
  them, and it stops if confinement is unavailable. Native Windows and Linux arm64 are still
  unsupported (#77).

### Changed

- `/fvs:lean-verify` proves on its own: it works through every `sorry`, checks compilation itself
  and no longer asks for approval at each step. `--budget` (for example `90m` or `2h`, default `4h`)
  replaces `--max-attempts`. It asks you only to change a theorem statement, when the budget runs
  out or it is stuck, or when the audit flags something. VERIFIED now requires a cheat audit:
  `#print axioms` shows only `propext`, `Classical.choice` and `Quot.sound`; theorem statements,
  the definitions they use and the other Lean sources are unchanged; and no axiom,
  `implemented_by`, `extern`, `@[csimp]`, `unsafe` or kernel-weakening option was added (#90).
- Plan and specification reviews spend less time on checks that add no assurance. Reviewers default
  to `xhigh` effort, with `max` as an explicit choice. They check that verification commands are
  runnable by reading them, not running them. The numeric probe budget is gone: a check the
  available tools could not run is recorded in coverage and is not by itself a finding or a
  BLOCKED reason. Plan-review checklist items are narrower, reviewers no longer re-confirm the
  branch, base or already verified source spans, and triage after a review is lighter (#94).
- The README and `fvs-setup` describe what a skills CLI install report contains and how to opt out,
  instead of telling every user to opt out (#89).

### Fixed

- A completed review is no longer thrown away when its findings are out of order, a suggested edit
  is long, or the reviewer reports a different model than requested; the record lists the warning
  or mismatch instead. Reviewer and planner deadlines default to 30 minutes (#94).

## [2.3.7] - 2026-10-15

### Added

- The GitHub repository has a self-contained `skills/fvs-setup` entry, so the skills CLI can
  discover FVS. It explains the native installation for Pi, Claude Code, Codex, OpenCode and Gemini
  and asks before running an installer. Copying it alone does not install the FVS workflows (#81).
- A practical Lake builds reference covers targeted checks, import artifacts and caches without
  changing your project's toolchain or dependency pins, and credits its source talk. The Lean
  writing commands load it (#79).

### Changed

- The README is shorter and organised around installation for each runtime, the two workflows,
  commands, and updates and removal (#70).
- Codex thinking stages for `/fvs:crypto-plan`, `/fvs:crypto-eval` and `/fvs:crypto-followup`
  receive the full crypto-thinker role and a complete context file, run read-only, and return their
  response. The parent command checks the response and writes the stage files (#63).
- Crypto stages record requested, resolved and observed model settings separately and report a real
  settings mismatch instead of completing the stage. Choosing OpenCode or Gemini as a statement
  reviewer now says that route is unavailable and offers Codex, Claude, a fresh Pi session or an
  acknowledged other reviewer, rather than substituting one (#63).

### Fixed

- Every Lean-writing specialist (executor, crypto executor, external modeler and Lean refactorer)
  is granted lean-lsp-mcp diagnostics and goal states, and the Gemini and OpenCode conversions keep
  those grants. Effective access inside each host has not been verified yet (#74).
- The README lists OpenCode's help command as `/fvs-help`, the name the installer creates.
- `npm run check:plugin`, which `npm publish` runs, no longer fails on macOS, where the default
  temporary directory is reached through a symlink.

## [2.3.6] - 2026-09-29

### Added

- `/fvs:map-code`, `/fvs:fc-plan`, and `/fvs:trust-audit` first check whether the project has a
  verified probe-aeneas: its Aeneas, Charon, and Lean versions must match a tested combination and
  every helper must report the tested version. On macOS arm64, FVS can install the pinned official
  probe-aeneas v0.20.0 into its own versioned directory after you agree, and it runs extraction in
  a sandbox with no network access and no writes outside the project's build directories, the
  output, and a private temporary directory. Without a verified probe you can set it up, continue
  without a graph (qualitative notes only, no counts or verdicts), or cancel. Linux support is
  tracked in #77 (#69).
- Crypto and Lean specification reviews report how many grounding signature lines they charge and
  the first reference that exceeds the budget. A read-only `preflight` checks a request without
  contacting a reviewer (#73).
- In Codex marketplace installs, a workflow that requests an unregistered FVS specialist now warns.
  It then runs a labeled generic agent, or stops before dispatch when the step depends on the
  specialist's settings. The README explains how to switch to the direct Codex installation, which
  registers the specialist roles (#71).

### Fixed

- Completed Claude and Codex reviews are no longer rejected when the reviewer writes one plain
  progress sentence before the required title (#72).
- Native reviewers run in their own process group with a 20-minute review deadline and a 30-second
  version and authentication deadline (`FVS_REVIEW_TIMEOUT_MS`, `FVS_REVIEW_AUTH_TIMEOUT_MS`). On
  timeout or interruption FVS stops the whole group, including descendants. Cleanup is tested on
  macOS and Linux; Windows refuses to launch native reviewers (#75).
- When its sync metadata is missing, `/fvs:sync-aeneas-verif` points only to `/fvs:update`, which
  updates the installation you already have, and no longer suggests the npm installer.

## [2.3.5] - 2026-09-21

### Added

- `/fvs:model-external` resolves one external Rust stub and its bounded dependency closure from
  locked registry, git, vendor, or rustc sysroot source. Candidate changes are reversible and must
  pass separate model-fidelity and specification reviews, completed proofs, a guarded build, and a
  clean trust audit (#33).
- The unified npm installer now installs and removes FVS through Pi's native package manager. It
  supports updateable or exact versions, user and project scopes, explicit conflict handling,
  Pi-first mixed-runtime preflight and installation, and matching Pi installation guidance (#67,
  #68).

### Fixed

- Aeneas guidance synchronization now uses frozen upstream revisions, hash-verified snapshots,
  proposal-before-write review, blocker reconciliation, and project-scoped `native_decide` policy
  without weakening generated-file boundaries (#57).
- Crypto workflows no longer depend on functional-correctness executor names, Aeneas analogies, or
  obsolete sorry-grind assumptions. The dedicated crypto executor and fail-closed bridge boundary
  remain explicit (#65).

## [2.3.4] - 2026-09-20

### Fixed

- Crypto evaluation now trusts Lean's kernel for checked proof terms and concentrates adversarial
  review on statement/source conformance and trust-boundary evidence. It reuses a current executor
  build log or runs one bounded fallback without retry, rather than repeating proof derivations,
  executor gates, or external numeric computations.

## [2.3.3] - 2026-09-20

### Added

- FVS is now a native Pi package with 29 generated skills, provider-qualified model handling,
  `/skill:fvs-*` invocation guidance, and direct `pi install npm:fv-skills-baif` support (#62).
- `/fvs:configure` and every delegated workflow now use stage-scoped, runtime-aware model profiles.
  Quality selects authority, execution, and scout tiers from the live runtime catalog; commands show
  one confirmable model/effort manifest and fail closed when a provider or dispatch cannot honor it
  (#64).

### Fixed

- Fresh local Codex installs create their configuration directory before patch discovery. Local
  patch metadata now separates immutable history from active pending patches, preserves real edits
  without treating unchanged generated TOML as custom, and retires resolved patches atomically
  (#60).
- FC and crypto reviews require explicit catalog-resolved model/effort selections, preserve raw and
  normalized responses separately, retain writable diagnostic scratch without exposing source
  writes, and enforce consistent verdict, severity, authority, and thread-count contracts (#60).

## [2.3.2] - 2026-09-10

### Fixed

- Updates preserve added and modified local FVS files in complete, versioned patch bundles,
  recover legacy unlisted backups, and track generated Codex agent/hook files. Failed backup
  validation stops installation before replacement (#55).
- Claude crypto and FC reviewers can run bounded diagnostic probes in native-sandboxed scratch
  space with explicit generated Lake output paths. Failed launches and invalid responses retain
  local evidence. Sources/plans remain protected; model/effort selection is unchanged (#58).

### Added

- Crypto and FC reviews receive bounded source/reuse inventories with verbatim signature spans
  and freshness checks. FC grounds behavior in implementation source and checks project/mathlib
  helper reuse. Review contracts cover scope economy, CONTENT/PROCESS findings, mathematical
  coverage, and explicit author dispositions. Complete finding validation and mechanical-only
  formatting repair preserve review substance; APPROVE-WITH-EDITS remains terminal (#56).

## [2.3.1] - 2026-09-09

### Added
- Crypto plan and follow-up review now support selected Codex, Claude, or external reviewers with
  explicit model/effort choices, read-only execution, honest provenance, immutable hash-bound
  packets, and a three-round author/reviewer loop. Automatic handoff stays interactive, while
  one-run Skip and `crypto_review.automatic: false` retain an explicit unreviewed trusted path.
  This resolves
  [GitHub issue #51](https://github.com/Beneficial-AI-Foundation/formal-verification-skills/issues/51).

### Changed
- Crypto and functional-correctness review now treat `APPROVE-WITH-EDITS` as terminal once the
  authoring seat applies the exhaustively named bounded edits and reruns its gates. Reviewer output
  remains immutable; only true `REJECT`, `REVISE`, or `BLOCKED` verdicts start a fresh review.
  This resolves
  [GitHub issue #52](https://github.com/Beneficial-AI-Foundation/formal-verification-skills/issues/52).

## [2.3.0] - 2026-09-07

### Added
- `/fvs:lean-spec-review` adversarially reviews a functional-correctness specification against
  its Rust implementation, extracted Lean definitions, and interpretation layer before proof work.
  Users choose the reviewer runtime, model, and effort: Codex offers GPT Sol and Astra, Claude
  offers Fable, cheaper or custom models remain available, and effort defaults to `max`.
- `/fvs:lean-specify` now offers the same review flow automatically after successful generation
  checks. Existing projects need no migration: a missing `spec_review.automatic` setting enables
  the menu, while `{"spec_review":{"automatic":false}}` disables only the automatic handoff.
- Review records preserve runtime/model provenance, source hashes, immutable history, validated
  `PASS | REVISE | BLOCKED` verdicts, and orchestrator triage. Other providers use an exported
  review packet and imported response rather than arbitrary command execution. This resolves
  [GitHub issue #46](https://github.com/Beneficial-AI-Foundation/formal-verification-skills/issues/46)
  and delivers the functional-correctness slice of
  [GitHub issue #32](https://github.com/Beneficial-AI-Foundation/formal-verification-skills/issues/32).

### Fixed
- Lean workflows now retrieve the project cache before build-capable work and cap Lake concurrency
  at four threads unless the caller overrides it. Crypto execution accepts IDE diagnostics when
  available and keeps a documented headless fallback. This resolves
  [GitHub issue #49](https://github.com/Beneficial-AI-Foundation/formal-verification-skills/issues/49)
  and [GitHub issue #50](https://github.com/Beneficial-AI-Foundation/formal-verification-skills/issues/50).

## [2.2.1] - 2026-08-28

### Fixed
- `/fvs:map-code`, `/fvs:fc-plan`, and `/fvs:trust-audit` now derive function membership,
  dependency endpoints, specification state, verification state, and progress totals from
  probe-aeneas output instead of model inference. Targeted runs retain project-wide endpoint truth,
  and public top-level functions are reported only when exact public-API extraction succeeds. This
  resolves [GitHub issue #39](https://github.com/Beneficial-AI-Foundation/formal-verification-skills/issues/39).

## [2.2.0] - 2026-08-24

### Added
- FVS is now packaged as a deterministic dual-runtime plugin payload for Claude Code and Codex,
  with 27 shared skills, 13 Claude agents, portable plugin-root paths, and runtime-specific update
  guidance.

### Changed
- Marketplace distribution now uses the organization-level
  `Beneficial-AI-Foundation/plugins` catalog and the `beneficial-ai-foundation` marketplace ID.
  The catalog pins the independently released FVS payload by immutable tag and full commit SHA;
  the FVS repository no longer publishes its own repository-level marketplace catalogs.
- Plugin installation documentation now distinguishes the BAIF Git catalog from OpenAI's separate
  universal public Plugins Directory.

## [2.1.2] - 2026-08-12

### Added
- Project-local proof engineering now uses an index-first store under
  `.formalising/proof-engineering/`, with one bounded Markdown record per FC, crypto, or shared
  lesson. Formalisation commands retrieve only the most relevant reviewed records and reconcile
  evidence-gated candidates after a run; crypto modeling decisions require source citations and
  remain provisional until adversarial evaluation or an explicit human ruling. Independent crypto
  plan review remains memory-blind. This resolves
  [GitHub issue #38](https://github.com/Beneficial-AI-Foundation/formal-verification-skills/issues/38).

### Fixed
- Codex installation now emits each FVS agent role exactly once in its standalone TOML and keeps
  `config.toml` limited to shared agent settings. Reinstall migrates legacy duplicate declarations
  without disturbing foreign GSD or user configuration. This resolves
  [GitHub issue #43](https://github.com/Beneficial-AI-Foundation/formal-verification-skills/issues/43).

## [2.1.1] - 2026-08-10

### Fixed
- `/fvs:lean-specify` now generates specification module docstrings in the requested style-guide
  form: a standalone opener, a lower-case theorem title, a concise description, and a plain quoted
  Rust source path. This resolves [GitHub issue #42](https://github.com/Beneficial-AI-Foundation/formal-verification-skills/issues/42).

## [2.1.0] - 2026-07-26

### Added
- `/fvs:crypto-review` sends an initial or follow-up crypto plan to authenticated Codex for an
  independent pre-execution adversarial review. Codex runs xhigh, effort-only, ephemeral, and
  read-only; the FVS wrapper persists one validated review artifact and the primary planning seat
  records its evidence-backed response. Codex-authored/unknown-provenance plans and non-APPROVE
  verdicts fail closed before execution.

### Changed
- `/fvs:lean-specify` and `/fvs:lean-verify` now discover and fully load the target repository's
  style guide (configurable with `project.style_guide_path`) into both research and execution
  prompts. A shipped post-write checker enforces the repository line limit (100-column fallback)
  and rejects new ordinary identifiers with three or more namespace dots; verification preserves
  legacy debt only through an explicit baseline and requires full compliance for statement edits.

### Fixed
- FVS installs now verify the shipped Aeneas `_sync-meta.json` mapping and the sync command reports
  real update/reinstall recovery instead of a nonexistent Aeneas installer option.
- The config template now uses the top-level model schema consumed by commands and defaults
  `fvs-crypto-thinker` to `inherit`.

## [2.0.3] - 2026-07-04

### Changed
- The crypto formalisation loop now drives a dedicated crypto executor with an `implement -> check -> complete -> escalate -> BLOCKED` discipline, replacing the borrowed functional-correctness one-sorry-at-a-time proof-attempt grind that did not fit crypto work.
- `/fvs:crypto-execute` gained a runtime-agnostic executor model/effort knob resolved at dispatch time (explicit flag, then a config `model_overrides` entry, then an interactive ask, then inherit the default) so the executor is never hard-pinned to one model.
- The crypto thinker's plan mode is fenced to producing statements rather than proofs, with an added escalate-to-user tier when a step exceeds its remit.
- Guidance now treats `lake build` as the style authority for crypto work, and isolation checks skip the package's own style linters to avoid contradictory signals.
- `/fvs:lean-verify` received a minimal refresh keeping proof-attempt behavior functional-correctness-scoped, decoupling it from the crypto executor without a rewrite.

### Fixed
- Codex `hooks.json` is now written in the nested `{ hooks: { ... } }` shape that current Codex expects; pre-existing flat hook files are migrated on reinstall while foreign entries are preserved.
- Corrected the crypto-plan knowledge-base invocation path so KB querying resolves the intended interpreter and script location.

## [2.0.2] - 2026-07-02

### Fixed
- Codex installs now enable hooks with `[features].hooks = true` instead of an invalid root-level `hooks = true`, which current Codex parses as the hooks config table and rejects at startup.

## [2.0.1] - 2026-07-01

Documentation polish. No code or behavior changes.

### Changed
- README "How It Works" now documents the Aeneas extraction repair loop, the trust audit, and the paper track's crypto loop -- previously only the v1.x five-stage functional-correctness flow was described; the tagline and Prerequisites now cover both the code and paper tracks
- `/fvs:help` documents the crypto loop's `--codex` single- vs dual-runtime flag (which stages accept it, what it swaps, and the no-silent-fallback behavior), and Quick Start / Core Workflow now surface the extraction and crypto-loop entry points
- Install screenshot (`assets/terminal.svg`) version label updated to the v2.0 line

## [2.0.0] - 2026-06-30

Structural cleanup and bundle architecture. Updating from v1.3 applies all renames, moves, and removals automatically (deleted and renamed commands/agents self-heal on install); the installer prints a one-time summary of the changes below.

### Added
- Five bundle router commands grouping the command surface by track: `/fvs:aeneas`, `/fvs:fc`, `/fvs:formalise`, `/fvs:context`, `/fvs:manage` -- each carries a `requires:` frontmatter list and a "User wants -> Invoke" routing table; invoked bare they print the table, invoked with a prompt they route to the matched member skill
- Aeneas extraction repair loop -- `/fvs:aeneas-extract` drives an extract -> classify -> fix -> document -> re-extract loop over a Rust crate, reached via the `/fvs:aeneas` router; six dedicated agents back it: `fvs-extract-classifier` (categorises each extraction blocker), `fvs-extract-applier` (applies the chosen fix), `fvs-extract-bisector` (isolates the failing construct), `fvs-equivalence-assessor` (independent semantic-equivalence review), `fvs-draft-investigator` (drafts upstream issues/PRs), and `fvs-doc-syncer` (reconciles docs)
- Reversible source-modification records for extraction -- every source change is captured as `src-modifications.diff` + a derived `src-modifications.json` and `src-assumptions.md` at the crate root; annotations are preferred over edits and generated files are never written into the source tree, so an extraction run is always reversible and auditable
- Orchestrator-fired Category-B equivalence gate -- an ungated source rewrite halts the loop with a reviewable 7-field gate packet rendered to disk; an independent assessor produces the review, and the loop does not re-extract until the `equivalence-ratified:` oracle token is stamped by hand (self-ratification is impossible)
- Extraction pin audit -- the Charon / Aeneas / Lean / Rust toolchain pins plus lakefile rev drift are checked with a warn-and-confirm prompt before extraction starts; the acknowledgment is stamped into the reversible records as `pin_context`
- Per-blocker attempt caps + no-progress escalation for the extraction loop -- a same-signature recurrence escalates after the attempt cap rather than looping indefinitely; minimal working/failing examples (MWE/MFE) and drafted Charon/Aeneas issues and PRs are written to disk as HTML+MD and never auto-opened
- `/fvs:sync-aeneas-verif` config-driven clone mining -- mines local Charon and Aeneas clones at configured paths and reports clone staleness gracefully when a clone lags upstream
- Crypto formalisation loop -- `/fvs:crypto-plan` / `/fvs:crypto-execute` / `/fvs:crypto-eval` / `/fvs:crypto-followup` drive a topic-based iteration loop laid out under `fv-plans/<topic>/{plans,reviews,sources,merge}`, reached via the new `/fvs:formalise` router; the executor plans are bounded and runtime-neutral, and the eval writes exactly one of ACCEPT / FOLLOWUP / HUMAN_RULING / BLOCKED per round
- `fvs-crypto-thinker` agent + dual-runtime Codex-thinker mode -- single-runtime mode pairs a high-effort `fvs-crypto-thinker` with `fvs-executor`; dual-runtime mode delegates the thinking step to an FVS-owned minimal Codex CLI invocation via `scripts/fvs-codex-think.mjs`, artifact-mediated with no live bridge; NotebookLM KB querying is intensive with a loud-fail-once contract, a labeled degraded mode when the KB is unconfigured, and on-disk answer caching
- `/fvs:trust-audit` + `fvs-axiom-auditor` agent -- a build-backed `#print axioms` audit of a Lean target that inventories only the target's own declarations in fully-qualified strict scope, classifies each as verified / sorry / axiom (treating any `sorryAx` dependence as a `sorry`), notes the classical trio (`propext` / `Classical.choice` / `Quot.sound`) as Lean/Mathlib-standard, and reports NOT-CLEAN while any project-custom axiom lacks a justification, in a dependency-ordered table
- `/fvs:pause-work [path] [note]` destination argument -- write a handoff to a chosen file (path ending `.md`) or directory (`<path>/.continue-here.md`), enabling per-topic handoffs without clobbering the default; every handoff carries an `fvs_handoff: true` frontmatter marker
- `/fvs:resume-work` discovers custom-named handoffs via the `fvs_handoff` marker scan in addition to the `.continue-here.md` glob, and presents a recency-sorted picker

### Changed
- Renamed `/fvs:plan` to `/fvs:fc-plan` (clean break, no alias stub); all cross-references, the underlying workflow, and tests updated in lockstep
- Superseded `/fvs:sync-aeneas` with `/fvs:sync-aeneas-verif` (clean break, no alias stub) -- the doc sync now fans out to two specialised agents: tactics/Lean-syntax sync (the existing `_sync-meta.json` mapping + tactic-rename machinery) and extraction-docs sync, which also reconciles the Aeneas extraction blocker catalog against live upstream (retire / update-signature / still-open, reconcile-not-append); mines the config-driven local Charon + Aeneas clones and reports clone staleness gracefully
- `help.md` and README regrouped by bundle (`lean-refactor` is dual-listed in both `fc` and `formalise`; `map-code` in `context`; `sync-aeneas` in `aeneas`); Quick Start and Core Workflow narrative kept up top
- Codex re-sync from upstream GSD -- the Codex install now follows an effort-only model policy (each agent carries a `model_reasoning_effort`, the `model` is inherited from Codex with no `model` line emitted); the Codex skill-adapter header was re-derived from GSD with a fail-closed execute mode and multi-select handling, dropping the old blanket `Task(` / `AskUserQuestion` word-replace
- Codex config strip is now TOML-section-aware -- it handles legacy `[[agents]]` tables and prunes orphaned per-agent `.toml` files; GSD and FVS coexist across both surfaces (`config.toml` `[agents.*]` / `[model]` tables and the `hooks.json` SessionStart entries), with full Codex hooks parity (the `fvs-check-update` SessionStart hook)

### Removed
- Cross-language port commands `lean-spec-port` and `lean-proof-port` and their workflows (Verus / F* / Coq / Dafny porting); v2.0 is Lean-focused
- The Verus framework-detection branch in `checkpoint` (no more `checkpoint(verus):` commit prefix)
- The four legacy v1.0 agents `fvs-dependency-analyzer`, `fvs-code-reader`, `fvs-lean-spec-generator`, `fvs-lean-prover`
- "Extensible to Verus" positioning from README and help

### Migration
- Updating from v1.3 applies all renames and removals automatically -- no orphaned commands, agents, or manifest entries
- If you locally edited `plan.md`, it is backed up under its old name in `fvs-local-patches/` and must be merged into `fc-plan.md` manually (there is no automatic rename-alias map)
- The Codex per-agent `.toml` cleanup for removed agents lands in a future release

## [1.3.1] - 2026-04-07

### Fixed
- Statusline not showing FVS state in GSD delegation mode -- now detects `.formalising/` as FVS project indicator
- Update/staleness indicators never shown when GSD statusline active -- `readFvsCache()` shared across both modes
- Local install skipping FVS statusline when GSD globally present -- now wraps GSD locally via project-level settings

## [1.3.0] - 2026-04-05

### Added
- `/fvs:lean-formalise` command -- paper track for formalising mathematical papers into Lean 4 specs, 4 interactive prompts, two-phase researcher→executor dispatch, KB integration
- `/fvs:kb-setup` command -- interactive NotebookLM knowledge base setup (venv, auth, KB registration)
- `fvs-kb-query.py` composable CLI tool -- ask/list/health subcommands for querying NotebookLM KBs with structured JSON output
- `fvs-researcher` formalise mode (6th mode) -- reads resources (PDF, images, LaTeX, text), queries KB with domain gating, extracts mathematical structure, proposes Lean file layout
- `/fvs:sync-aeneas` command and workflow for continuous Aeneas upstream integration
- Aeneas upstream documentation snapshot (`fv-skills/upstream/aeneas/`) with sync mapping (`_sync-meta.json`)
- Aeneas staleness detection in session start hook -- queries GitHub API, shows warning in statusline
- Protocol verification domain pattern (Spec_pro/Spec_sec/Spec_pro|=Spec_sec) in lean-formalise
- `knowledge_bases` array in config template for domain-gated KB entries
- Installer copies `scripts/` directory to target with manifest tracking and uninstall cleanup
- Acknowledgements section in README

### Changed
- `/fvs:lean-simplify` renamed to `/fvs:lean-refactor` with expanded refactoring corpus
- `fvs-lean-simplifier` agent renamed to `fvs-lean-refactorer`
- All tactic names migrated to current Aeneas conventions: `progress`→`step`, `@[progress]`→`@[step]`, `omega` BANNED, `agrind` as default
- References enriched from upstream: aeneas-patterns (+400 lines), tactic-usage (+260 lines), proof-strategies (+300 lines), lean-refactoring (+400 lines)
- Test suite expanded from 154 to 167 tests (scripts, new commands, updated counts)

## [1.2.0] - 2026-03-16

### Added
- `/fvs:lean-spec-port` command for porting formal verification specs from other languages (Verus, F*, Coq, Dafny) to Lean -- interactive prompts, cross-project Rust source comparison, semantic blueprint translation, `--scan` flag
- `/fvs:lean-proof-port` command for porting proofs from other languages to Lean -- source proof as strategy blueprint, iterative one-sorry-at-a-time dispatch, tactic mapping (grind, bvify+bv_decide)
- `/fvs:reapply-patches` command for merging backed-up local modifications after updates
- Local patches persistence in installer -- file manifest with SHA256 hashing, automatic backup of modified files before update, runtime-specific restore suggestions
- SVG terminal logo replacing static PNG screenshot

### Changed
- Update command and workflow now include `check_local_patches` step

## [1.1.5] - 2026-03-09

### Fixed
- Codex install uses `skills/fvs-*/SKILL.md` only (removed incorrect `commands/fvs/`), matching GSD pattern
- Codex launch message shows `$fvs-help` (skill invocation syntax)

## [1.1.3] - 2026-03-09

### Fixed
- Codex install now creates `commands/fvs/` for `/fvs:*` slash commands (previously only installed skills)
- Installer shows info when both global and local installs exist (local takes priority)
- Update version detection uses path canonicalization to handle CWD=$HOME edge case

## [1.1.2] - 2026-03-09

### Fixed
- Installer now shows interactive runtime menu when `--local` or `--global` is passed without a runtime flag (previously defaulted to Claude silently)

## [1.1.1] - 2026-03-09

### Fixed
- `/fvs:update` now fetches and displays changelog entries before updating (previously showed no changelog)
- Update workflow uses local-first version detection instead of hardcoded paths
- Update cache clearing covers all runtime directories

## [1.1.0] - 2026-03-09

### Added
- `/fvs:lean-refactor` command for post-verification proof cleanup (#17) -- three modes (safe/balanced/aggressive), tiered heuristics, one change per invocation with build verification
- `fvs-lean-refactorer` agent for iterative proof refactoring
- `lean-refactoring.md` reference with proof-fuel rule, refactoring ordering, layering strategy, target selection heuristics, and repo-specific lessons
- Codex runtime support in installer (#18) -- `npx fv-skills-baif --codex`
- `/fvs:pause-work` command for session context handoff (#10)
- `/fvs:resume-work` command for session context restoration (#10)
- `/fvs:checkpoint` command for structured verification commits (#12)
- `fvs-researcher` generic research subagent for two-phase command dispatch
- `fvs-executor` generic executor subagent with VS Code diff file writing
- Model profile system (quality/balanced/budget) in `fv-skills/references/model-profiles.md`
- `npm test` regression suite -- 132 tests covering frontmatter integrity, installer round-trip, help/README parity, and cross-reference validation

### Fixed
- NL stubs now written to `.formalising/stubs/` instead of project root `stubs/` (#6)
- Statusline delegates to GSD when installed, uses correct 16.5% autocompact buffer in standalone mode (#11)

### Changed
- `/fvs:map-code` refactored to agentic two-phase dispatch (research -> execute)
- `/fvs:plan` refactored to agentic two-phase dispatch (research -> execute)
- `/fvs:lean-specify` refactored to agentic two-phase dispatch (research -> execute)
- `/fvs:lean-verify` refactored to agentic two-phase dispatch with iterative one-sorry-at-a-time executor
- Installer description updated to include Codex

## [0.1.0] - 2026-02-07

### Added
- Initial release: 7 commands, 5 agents, 5 references, 6 workflows, 3 templates
- Multi-runtime installer (Claude Code, OpenCode, Gemini)
- Session hooks (update checker, statusline)
