boshu2__agentops/CHANGELOG.md

# Changelog

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [Unreleased]

## [3.7.0] - 2026-09-13

AgentOps 3.7 makes native coding the default: accepted intent, implementation
and checks, fresh independent judgment, then finish. No AgentOps skill,
bootstrap, hook or orchestration service is required. The optional skill menu
is consolidated from the 52 roots shipped in 3.6.0 to 34, and the CLI gains
recovery and exact-content evidence helpers. Upgrade guidance covers the
published command, skill and scripted workflow entry points that were removed.

See the [curated release notes](https://github.com/boshu2/agentops/blob/main/docs/releases/2026-09-13-v3.7.0-notes.md)
for upgrade instructions, the complete product-area summary and known limits.

### Added

- Native Go evidence helpers under `ao provenance`: immutable intent snapshots,
  subject manifests and digests, verdict storage, exact-subject verification,
  required native judgment receipts, and orphaned-evidence inspection. Storage
  uses an explicitly selected protected non-Git destination; mechanical
  verification does not issue a semantic verdict.
- `ao config context` resolves caller-owned external context routes, including
  recovery from a selected native BD maintenance anchor. `ao session read-source`
  returns explicitly bounded source spans and integrity facts for synthetic or
  already-cleared sources; restricted-source access remains unsupported.
- Bounded `ao provenance mine-session --view excerpts` extracts cited transcript
  evidence without writing a checkpoint. Optional Memory guidance covers recall,
  mining and reviewed topic curation; Skill Eval measures a named skill decision.
- Claude `bulk-reader` and `code-writer` subagents, pinned to Haiku, and parallel
  `bulk-read` / serial `code-write` workflows return compact findings or receipts
  while keeping source and generated code out of the parent context.
- Codex-native `bulk-reader` and `code-writer` roles pinned to `gpt-5.6-luna`,
  generated with the portable bundle, plus explicit project registrations and
  an opt-in personal/project installer that preserves existing configuration.
- Separate opt-in Claude and Codex read-budget guards refuse oversized unbounded
  file reads, suggest bounded slices or reader delegation, honor scoped waivers,
  and record hashed telemetry. The default line budget is 350; installing skills
  does not activate these hooks.

### Changed

- `ao quick-start`, `ao demo`, the README and runtime onboarding describe native
  execution with zero mandatory skills. `ao demo --rpi` retains the explicitly
  selected workflow; `ao init` remains optional. `ao skills link --skill NAME`
  supports a selected subset while no-selector linking still installs the menu.
- The 34-skill menu groups intent, implementation and judgment; engineering
  specialists; Memory; deliberate review strategies; and optional tool/runtime
  adapters. Consolidated names and replacements are documented in `docs/MIGRATION.md`.
- Plan uses existing conversation or tracker acceptance, Implement repairs known
  defects directly, and Validate judges exact content from a fresh author-distinct
  context. RPI is optional; final review is assigned once with every required leg
  preserved. Requested retrospectives follow the known outcome and judgment.
- Memory and instruction-improvement guidance uses authorized source episodes,
  bounded CASS/MS retrieval, protected drafts and independent support/disclosure
  review. Later work must demonstrate benefit; a generated lesson is not proof.
- The CLI and CI build with the Go 1.27.1 toolchain; CI Python moves to 3.14.
  Dependency and pinned GitHub Actions updates are included across the full
  3.6.0-to-3.7.0 interval.

### Fixed

- Full release security checks scan the whole repository and treat Python collection or runtime errors as blocking failures. Nightly checks install the declared evaluator dependencies; test collection supports duplicate source/projection module names.
- Claude writers capture a supplied check's status in its original invocation, avoiding the observed status-confirmation rerun. Native success, failing-check and direct-writer trials each ran the check once; the direct child returned plain JSON.
- Plugin conformance verifies exact skill membership and link destinations. Clean Claude and Codex plugin installs and upgrades are exercised separately from source linking; Codex metadata checks use the current Skills-only manifest contract.
- Doctor keeps unique per-action backups and preflights undo integrity before
  restoration. Session mining protects checkpoint paths and concurrent writers;
  handoffs preserve work/session associations and use correct newest-first ordering.
- Evidence status, skill search, changed-file gate routing, constraint checks,
  provenance graph validation and scenario-result publication handle previously
  missed corruption, path, matching and recovery cases.
- The read-budget parser preserves quoted paths, handles end-of-options and
  negative `head` limits, and avoids attributing uncertain shell constructs to
  the wrong file. Repeat refusals stay short; installers preserve unique backups.
- Context-budget workers count physical lines, preserve the caller's target
  identity, remove raw check output from returns and report unknown state after
  worker failure. Batch writers preflight distinct target identities.
- Codex role registration points to real source-owned TOML files instead of
  symlink paths rejected by the installed runtime.
- Generated skill projections, executable entry points, documentation checks,
  seeded-defect probes and contamination detection received conformance repairs.

### Removed

- The published `ao eval` command family and `ao redact`. Use a repository-selected
  evaluator and owner-authorized disclosure review; generic provenance can retain
  the resulting evidence.
- `workflows/rpi.js` and its scripted retry machinery. Invoke the optional RPI
  skill when selected, or execute natively. AgentOps does not own an aggregate
  retry controller, queue, work ownership, Git or delivery transition.
- Twenty skill roots published in 3.6.0, including `learn`, `swarm`,
  `codebase-recon`, `bootstrap`, `handoff`, `standards` and `workflow-builder`,
  after useful behavior moved to surviving owners or native work. `memory` and
  `skill-eval` are the two new roots relative to that tag.

## [3.6.0] - 2026-08-17

AgentOps 3.6 is the **operations-layer alignment** release, and most of the
alignment was deletion. The product is now stated one way on every surface that
reads it: AgentOps is the operations layer for agentic engineering, the topology
is a federated integration graph, the interoperability contract is the semantic
work-and-proof protocol, and the standard path is one RPI traversal (Plan,
Implement, fresh Validate, report and stop). The knowledge-flywheel product
surface is gone — command family, app package, build profile, gates, config
block — the seven-move operating-loop workflow is a tombstone, `.agents/`
writers are narrowed to declared destinations, and 25 skills plus every
generated projection were realigned against the operating contract.

Two enforcement layers ride on top. Anti-ceremony guardrails fail closed when a
process artifact cannot name its consumer, its decision, the observed defect,
and its retirement condition, and `rpi` runs that STOP/CONTINUE guard once
before Plan. The eval program gives the skill harness measurement instead of
self-report: a 12-decision eval architecture, a probe harness with a fail-closed
v3 evidence contract, routing probes, a tier-2 flawed-plan corpus with hidden
holdout scoring, and estate ablation sweeps whose predictions were registered
before the runs. That same evidence contract is why measured probe coverage now
reads an honest 0/12 — the earlier wave-1 classifications are retained as
`LEGACY-UNVERIFIED` rather than counted.

### Added

- The `anti-ceremony` skill: a clean-room, artifact-free STOP/CONTINUE guard
  over the creation gate — name the consumer, the decision it gates, the
  observed defect, and the retirement condition, or do not create it. `rpi`
  takes it as a hard dependency and invokes it exactly once before Plan. On STOP
  it dispatches no core phase and reports `NOT_PLANNED` with the guard's reason;
  on CONTINUE the full Plan, Implement, fresh Validate path runs unchanged.
  AgentOps now fails closed when process artifacts are manufactured, when GREEN
  comes from weakening the oracle, and when repeated control artifacts replace
  implementation evidence.
- `ao session prune-agents` applies `.agents` retention policies from Go. It is
  a read-only dry run by default; `--execute` mutates and `--quiet` prints only
  the summary. The global `--dry-run` seam always wins over `--execute`.
  `scripts/prune-agents.sh` becomes a compatibility wrapper.
- `ao gc prepare` pre-seeds Codex trust for materialized Gas City session homes.
  Codex persists two independent decisions in `$CODEX_HOME/config.toml` —
  workspace trust under `[projects."<dir>"]` and one Codex-owned content hash
  per hook under `[hooks.state."<hook-key>"]` — and trusting a parent directory
  does not trust a session home. Hook identities and hashes come from Codex's
  own `hooks/list` app-server method rather than being reimplemented. Without
  this, the first Codex process in a fresh home could sit on the interactive
  trust dialog with a live pane that can never take dispatched work. `ao gc
  prepare` and `ao gc check` take `--codex-bin` to name the Codex CLI; the
  default is `codex` on PATH.
- The eval program for the skill harness: a 12-decision eval architecture
  (`docs/architecture/eval-architecture.md`) and the probe harness that runs
  control-versus-treatment behavioral probes and records replayable scorecards
  (`bash scripts/probe-skill.sh --probe <id> --replay`).
- Routing probes measure P(skill loaded | applicable task), the multiplier every
  skill-efficacy number depends on. Committed scenarios are templates with
  dispatch-time instantiation so an agent cannot read the fixture off disk and
  contaminate the run. Task-noun skills route and judgment-posture skills do
  not; the Codex runtime routed 4/4 against 2/6 for Claude-in-repo, because
  `.claude/rules` auto-load already delivers the content without routing.
- A tier-2 task-embedded corpus of flawed-plan execution fixtures with hidden
  holdout tests injected only at scoring, across four live flaw classes (quiet
  edge, vacuous green, burned compatibility bridge, opaque sentinel errors). The
  scorer emits `visible_pass`, `hidden_pass`, `claimed_done`, `false_pass`, and
  `flagged_gap`, and its selftest against planted references caught a real
  scorer bug before any spend.
- Estate ablation sweeps that apply delete-everything-and-measure-what-returns
  to this repository's own estate, with predictions registered before results.
- A dual-case anti-ceremony behavior probe that separates a justified process
  artifact from an unjustified one, with its discriminator under test.
- Between-releases release-path smoke: `.github/workflows/release-path-smoke.yml`
  runs a full GoReleaser snapshot (`goreleaser release --snapshot --clean
  --skip=publish`) nightly and on every change to a release-plumbing input
  (`.goreleaser.yml`, `.github/workflows/release.yml`, `cli/go.mod`,
  `cli/Formula/**`). This closes the process commitment recorded in
  `docs/audits/release-readiness-v3.3.0.md`: the release path was previously
  executed only by a real `v*` tag push, which is how a retired
  `.goreleaser.yml` before-hook stayed broken for 20 days. The smoke and its
  negative witness share one script (`tests/scripts/lib/release-snapshot-smoke.sh`,
  proven able to fail by `tests/scripts/release-path-smoke.bats`).
- `reverse-engineer` ships an output validator and a self-test, so its artifacts
  are checked by an executable rather than by assertion.
- `docs/contracts/ubiquitous-language.md` gains the product-architecture
  vocabulary and four forbidden conflations, including that check success is not
  a semantic PASS and that runtime completion is not validation.
- `docs/reference/skill-system-evolution.md` traces the skill system across
  releases, names seven evolution regimes, diagrams the present authority graph,
  and records falsifiable predictions.
- The canonical bd project identity is tracked at `.beads/identity.toml`, so
  project identity travels with the repository instead of being reconstructed
  per checkout.

### Changed

- The core architecture page is `docs/architecture/rpi-traversal.md`, with a
  compatibility redirect left at the old operating-loop path.
- Skill contracts match the operating contract. `rpi` preserves a durable
  caller-owned intent source by reference and digest and snapshots bytes only
  when no durable source exists. `automation-shape-routing` is advisory-only and
  returns the chosen owner without copying or starting the delegated workflow.
  `bootstrap` creates durable verdict storage and project docs only when
  explicitly requested. `implement` and `swarm` return factual evidence instead
  of implicitly revising or declaring semantic verdicts.
- `ao init` scaffolds only the requested-proof stores that have declared
  consumers: `.agents/ao/intents/sha256` and `.agents/ao/verdicts/sha256`. The
  former session-transcript, search-index, provenance, and handoff directories
  had no declared consumer and are no longer minted. The managed `.gitignore`
  block now covers `.agents/scratch/`, `.agents/projections/`, and
  `__pycache__/` instead of the retired knowledge-store paths.
- `ao session handoff` writes JSON to `.agents/ao/handoff/` instead of
  `.agents/handoff/`. `ao session rehydrate` searches both roots and selects the
  newest lexical handoff id, with the canonical copy winning a filename tie. No
  command moves or deletes the legacy files.
- `codebase-recon` binds evidence to the exact Git commit its manifest declares.
  Citations must be safe repository-relative regular files at that commit, a
  supplied line number must exist in the committed blob, delta manifests must
  match Git's own prior-to-current changed-path diff rather than a self-reported
  boolean, and dirty tracked, staged, or untracked source outside `.agents/` is
  refused. New packs default to `.agents/scratch/codebase-recon/<run-id>/`;
  earlier packs stay where they are and remain discoverable.
- `agent-mail` requires one mailbox owner and access mode per storage root, so
  an HTTP/MCP daemon and the direct `am` CLI never contend for the same
  database. A busy activity lock or bounded read timeout is a degraded adapter
  result, not permission to restart the service or switch roots.
- `status`, `using-flywheel`, and `using-gc` keep the state classes separate.
  Factory-complete, checks-green, and AgentOps PASS are reported as three
  different facts, never blended into one health claim.
- The probe-coverage gate reads a hand-maintained ledger at
  `evals/skill-probes/LEDGER.md` instead of the generated
  `skills/SKILL-TIERS.md`, which a regeneration had silently wiped. A row counts
  only if it names exactly one v3 scorecard whose fixture manifest, bound
  inputs, prompt events, transcript hashes, canonical skill source,
  non-overrideable runtime identity, reps, treatment mode, and recomputed
  discriminator result all agree.
- Cathedral-cut conformance scans linked skill references for retired identity
  claims, with Markdown fence, raw-HTML, and percent-encoding handling so the
  scan cannot be evaded by formatting.
- `scripts/extract-release-notes.sh` reflows hard-wrapped curated notes into
  logical Markdown lines before publishing, leaving headings, tables, code,
  HTML, block quotes, and explicit hard breaks intact. GitHub's renderer
  preserves soft line breaks, so copying the hard-wrapped source byte-for-byte
  produced a narrow ragged column in the published release.
- Handoff publishing is descriptor-anchored: it opens `.agents/ao/handoff` one
  component at a time, refuses any component that is a symlink or not a real
  directory, re-verifies that each opened descriptor still identifies the
  component it inspected, and publishes by hard link rather than rename, so a
  parent-directory swap mid-write cannot redirect the write and an existing
  handoff id is never clobbered.
- Prune path confinement runs traversal inside an `os.Root` with a final
  current-path identity check immediately before each descriptor-rooted delete.
  The contract states its own boundary honestly: intermediate-directory
  traversal is bound, and it does not claim a final basename is immutable
  against an adversarial replacement.
- Portable Codex skill validation rejects duplicate YAML keys, enforces symlink
  containment, and applies the current optional-field rules.
- `AGENTS.md` is compressed against current-main evidence (about 10.5KB to
  8.3KB) while preserving the honest-work and anti-ceremony doctrine, federated
  source authority, the factory and concurrency boundaries, and the Triggered
  Sources links that `validate-agents-split` requires. The estate-ablation
  aggregate counts that motivated the trim are labeled legacy-unverified and
  non-promotable.
- ADR-0016 is amended for federated source authority and corrects an overclaim:
  the three-directory `.agents/` layout is a target, not a currently enforced
  closed set.
- The Homebrew formula and the Codex plugin manifest state the operations-layer
  identity instead of advertising a knowledge-flywheel CLI.
- Dependencies: Go toolchain directive 1.26.5 to 1.26.6, `golang.org/x/text`
  0.40.0 to 0.41.0, `github.com/santhosh-tekuri/jsonschema/v6` 6.0.2 to 6.0.3,
  `github.com/BurntSushi/toml` 1.6.0 added for Codex `config.toml` handling, and
  the pinned GitHub Actions digests refreshed.

### Fixed

- Generated Codex descriptions are compacted without dropping canonical trigger
  text, so a compacted projection cannot lose the phrases that activate the
  skill. All owned Codex projections and hashes were regenerated against that
  rule (portable conformance 52/52).
- Skill audit grades are evidence-honest: static readiness is scored and labeled
  separately from measured safety and effectiveness, so a static score can no
  longer be read as a behavioral one.
- `ao doctor` Git-root detection no longer gets redirected by an empty or
  otherwise invalid ancestor `.git` directory, which previously sent doctor
  artifacts to the wrong place.
- The eval command-surface fixture failed when it was actually executed: it
  asserted `#{3,4}` where the surface produces `#{3,5}`. The fixture now matches
  the real surface.
- The bats lane provisions Python with jsonschema and PyYAML once, instead of
  reinstalling PyYAML in a later job after `setup-python` shadowed the runner
  interpreter.

### Removed

- The `ao flywheel` command family (`status`, `compare`) and the whole live
  knowledge-flywheel product surface: `cli/internal/flywheelapp`, the
  flywheel-only metric helpers and types, the `flywheel` build-profile bit, the
  `flywheel-compounding` gate scripts, and the `flywheel:` config block
  (existing config files still parse; the key is ignored). AgentOps no longer
  computes or reports knowledge-compounding state (`COMPOUNDING`, `DECAYING`,
  escape velocity). Invoking `ao flywheel` now exits 1 as an unknown command and
  prints a migration pointer (see `docs/MIGRATION.md`). Learning remains an
  optional off-path consumer of durable verdicts via the `learn` skill. The
  compatibility baseline records the family as intentionally `retired` rather
  than freezing the old product claim.
- `plan` manifest mode, added in 3.5.0, along with its "plan manifest" trigger.
  `plan` shapes one active behavior in the existing intent source; a
  multi-behavior specification stays a document the caller owns.
- The seven-move operating-loop workflow is a tombstone that fails with a
  deterministic migration message instead of silently running retired doctrine.
- The consumer-free `dream:` config block (the retired overnight subsystem's
  settings; existing config files still parse and the key is ignored) and its
  exclusive helpers, the vacuous retrieval-quality canary and the nightly job
  that ran it (every Go test it named was already deleted; the
  retrieval-comparison contract is now explicitly dormant and the blocking
  manifest-paths gate remains the live retrieval guard), the dormant
  `check-pillar-coverage.sh` GOALS.yaml script, `check-thesis-stability.sh`, and
  `generate-index.sh`. Remaining scratch-tier writers (`mine-all-sessions.sh`,
  `team-runner.sh`, `bin/ralph`) now write under `.agents/scratch/`. `bin/ralph`
  still resumes legacy `.agents/ralph/` checkpoints, so the documented
  backwards-compatibility contract holds without a migration.
- The dated skill-quality audit report, which had no runtime consumer and bound
  a superseded audit snapshot; all functional skill-quality changes stayed.

## [3.5.0] - 2026-07-31

AgentOps 3.5 hardens the factory boundary 3.4 drew. The Gas City maintainer
operations ship in the Go CLI as the `ao gc` command family, the operating
doctrine for driving a factory through its coordinator is encoded in the
runtime surfaces (the Mayor authors workflow beads and dispatches; the
operator authors intent, mails, reads state, and judges), `plan` gains a
substrate-neutral manifest mode for multi-behavior handoffs, and the verdict
contract stops punishing honest scope disclosure.

### Added

- `ao gc` command family: `prepare`, read-only `check`, and
  dry-run-by-default `recover-affinity` port the Gas City maintainer
  operations into the CLI (ADR-0016); `scripts/gc-maintainer-ops.sh` remains
  as a thin wrapper.
- `plan` manifest mode: shape N bounded behaviors as one caller-owned
  specification manifest (stable slugs, dependency edges, per-child
  acceptance and write scopes, tracker IDs `TBD`) authoring zero beads; the
  executing substrate materializes tracker state.
- `using-gc` documents the supervisor's typed run-status API (run detail and
  census endpoints) and the five-verb tending loop (monitor, observe, nudge,
  redirect, rework) with one owner per verb.
- `ao init` scaffolds a marker-delimited `.gitignore` block covering
  machine-local loop scratch while leaving intents and verdicts trackable;
  idempotent across re-runs.

### Changed

- Factory operating doctrine in `using-gc` and `AGENTS.md`: work enters a city
  through the Mayor, which authors workflow beads and owns dispatch; direct
  `gc sling` is demoted to a no-live-Mayor debugging tool; the operator lane
  is a closed set and pack-owned session lifecycle belongs to the reconciler.
- `rpi` states that factory work enters through the factory's coordinator;
  RPI hands over intent and never dispatches factory runs itself.

### Fixed

- The verdict tool no longer pays validators to delete caveats: declared
  non-goals, bounded criterion proofs, and residual risks have documented
  disclosure homes; the PASS integrity finding names where each caveat
  belongs instead of failing silently; `store-verdict` errors name the
  allowed criteria fields.
- Loop skill docs work verbatim in installed trees: install-agnostic
  `validate.py` paths in `plan` and `validate`, real `manifest` flags
  documented, the `rpi` report shape inlined instead of linking an unshipped
  schema, and self-contained examples replace internal digests.
- `ao gate check` explains an unborn HEAD instead of surfacing a raw git
  exit-128; installed skill copies are excluded from user-repo gate scope;
  native-check repair hints no longer reference source-checkout paths.
- `ao doctor` gives installed users actionable advice without checkout-only
  commands, and the skill-link census is tri-state so only genuinely dangling
  links count as broken.

## [3.4.0] - 2026-07-30

AgentOps 3.4 is the **honest-contract release**. All 50 shipped skills went
through an eight-wave contract overhaul — declared real effects, honest output
contracts, closed artifact directories, authority claims stripped — and the
factory boundary is now explicit: AgentOps no longer carries its own
orchestration pack as the product path. The supported software factories are
the upstream Gas City build pack and the Agentic Coding Flywheel; AgentOps
supplies the skills and evidence discipline either factory executes.

### Added

- Negative-witness ratchet: every blocking gate must carry a test proving it
  fails on what it detects, with a shrink-only grandfather list.
- `ao gate check --dry-run`: a real plan-only mode that mutates nothing.
- `using-flywheel` skill: operating manual for the Agentic Coding Flywheel as
  a caller-selected external software factory, covering provisioning via the
  upstream wizard, AgentOps skill visibility across its worker runtimes, and
  the evidence boundary (factory convergence is never an AgentOps verdict).
  Gives the second supported factory an operating surface parallel to
  `using-gc`.
- `scripts/gc-maintainer-ops.sh`: a narrow operational adapter for stock Gas
  City rigs, with `prepare` (pin verification, contained runtime snapshot,
  skill linking), read-only `check`, and dry-run-by-default
  `recover-affinity`. It is not a pack, formula, role, daemon, or GC fork.

### Changed

- All 50 skill contracts overhauled across waves W2–W8: real effects, honest
  output contracts, scratch-tier artifact directories, authority grants
  stripped, fail-closed deadlines, corpus-level trigger separation.
- `goals` renamed to `fitness` with a compatibility alias; `shared` retired to
  a declared contract owner.
- Fresh validation persistence is optional: `verdict.v2` is written only for a
  caller request or a declared downstream consumer.
- The README and `using-gc` skill present the upstream Gas City build pack and
  the Agentic Coding Flywheel as the supported factory choices; `using-gc`
  teaches stock `gascity` workflows and roles.
- Gas City factory qualification pins and fail-closes on the checksummed
  v1.4.0 release and the registry-pinned `gascity` 0.1.6 workflows and roles
  used by Maintainer City, removes the v1.3 Mayor heartbeat workaround, and
  requires scope-local `core.control-dispatcher` propulsion.
- The eval subprocess runner is bounded and cancellable with process-group
  reaping; eval id containment hardened and temp directories owned by the run.
- ADR-0016 shipped-Python rule is enforced by a blocking gate.

### Fixed

- RPI and Validate no longer disagree on the intent-source digest.
- `handoff` schema matches what the command writes; `dcg` guidance corrected.
- The orchestration-skill-boundaries gate no longer references adapter files
  deleted by the 3.3 single-pass refactor.
- The negative-witness scan reads only git-tracked files under `tests/`, so
  ignored local logs can no longer flip its verdict between checkouts.
- Retired Gas City prototype wiring decayed to frozen bytes: the skill
  projection into the retired pack copy stopped, and the
  `adapter.gc-maintainer` gate replaces `adapter.gc-executor`.

### Deprecated

- The in-repo Gas City factory prototype (`deploy/gc/`) is retired in place;
  upstream factories are the supported path.

## [3.3.0] - 2026-07-23

AgentOps 3.3 is the **Cathedral Cut**: the deliberate subtraction of the
guardrail machinery built to steer weaker models. Strict verbose step contracts,
enforcement gates, injection hooks, one-release command tombstones, retired
lifecycle command surfaces, and the heavy out-of-session orchestration layer are
gone — that scaffolding does not help a frontier-class model and actively
degrades one, turning dense process into meta-work it spirals on. What remains is
the judgment-boundary membrane: shape one behavior, run one bounded experiment,
validate the exact result from a fresh independent context, persist a durable
verdict, and stop — caller-owned intent in, pinned provenance out. Git, CI,
retries, queues, work ownership, closure, release, and delivery stay caller-owned.

The subtraction is concrete: the Go CLI shed 36 of its 79 internal packages
(79 -> 43), and the reference out-of-session orchestrator collapsed from a
~29k-line layer to a ~1,300-line thin pack (one commit removed 29,418 lines for
1,334). On that lean base the release keeps terse metadata-owned skill contracts
(48 skills, audited for concise executable contracts, not ceremonial length),
adds the Gas City factory pack as a labeled **preview**, and grounds plan and
premortem judgment in executable ground truth. This release removes public
command surfaces despite the minor version number; read
[docs/UPGRADING.md](https://github.com/boshu2/agentops/blob/main/docs/UPGRADING.md)
before upgrading.

### Added

- `subject-manifest.v1`, `revision-packet.v1`, and `verdict.v2` contracts for
  exact content identity, explicit fresh-context attestation, criterion-level
  judgment, and atomic content-addressed verdict storage.
- `ao skills link` and `ao skills unlink` as the source-linked install path
  across portable, Claude, Codex, Gemini, Cursor, and Pi skill roots.
- Structural conformance for the four-skill core, forbidden lifecycle authority,
  one-pass RPI sequencing, optional adapters, and inert command tombstones.
- A deterministic `toil-mining` extractor for recent human-origin Codex JSONL
  messages, with provenance, wrapper normalization, deduplication, exclusion
  accounting, and explicit checked/not-checked scope.
- Read-only `ao status` inventory for durable intent and verdict evidence,
  including newest-evidence recency without runtime-phase inference.
- One-shot MCP-backed `ms` search for environments without an attached MCP
  tool, plus multi-report synthesis guidance in Research.
- `ao eval` — deterministic local evaluation suites over locked tasks and
  holdout scenarios, wired as the Learn seat's measurement surface. It runs
  and reports; it holds no lifecycle authority (#921).
- A PreToolUse policy dispatcher (deterministic guard registry) under
  `cc-hooks`, shipped by default across every install path — automatic with
  the Claude Code plugin; one installer script for npx/skills.sh copies and
  source checkouts. Injection hooks remain absent (#932).
- A canonical top-level `workflows/` directory (sibling of `skills/`) holding
  the Claude Code workflow scripts as first-class tracked source, plus
  `ao workflows link`/`unlink` to install them as runtime links in the
  project-local `.claude/workflows/` registry — a Claude-only runtime adapter,
  same doctrine as `skills-codex/`, with the same refuse-foreign link
  semantics as `ao skills link`.
- An `rpi` workflow script (`workflows/rpi.js`) running the one-pass core loop
  as a conveyor: Plan snapshots exact intent bytes under SHA-256 identity,
  Implement runs one bounded RED->GREEN experiment inside its write scope, and
  a structurally separate fresh Validate context — receiving only derived
  facts, never the author's narrative — persists `verdict.v2` with distinct
  context ids. Any dead stage degrades to `NOT_PROVEN`; no retry, no
  lifecycle authority.
- Caller-selected cross-vendor validation for the `rpi` workflow: an optional
  `validator: { kind: 'spawned' | 'command', command? }` arg. With `command`,
  the fresh Validate context brokers the unchanged evidence packet to an
  opaque external judge command, captures its raw transcript under the run's
  `.agents/ao/` evidence area, and persists `verdict.v2` carrying the judge's
  own ruling — no verdict laundering (an ambiguous ruling is `NOT_PROVEN`),
  no silent fallback to the spawned judge, and the broker attests under its
  own context id, distinct from both the author and the external validator.
- **Gas City factory pack (preview)** — a thin AgentOps role pack over official
  Gas City that runs the one-loop factory (`deploy/gc/`, `packs/agentops-*`).
  `deploy/gc/materialize-toolchain.sh` fetches the official prebuilt
  gastownhall/gascity v1.3.5 and steveyegge/beads v1.1.0 release archives and
  verifies each through a fail-closed checksum chain (pinned sha256 of the
  official checksums asset -> archive digest -> installed-binary version/commit
  binding); no compiler, `git`, or `make` is required — only `curl`, `tar`,
  `python3`, and `shasum`. Gas City owns sessions/routing/formulas/OTEL, Beads
  owns work, Git owns candidate commits, GitHub owns PR/CI/merge, and AgentOps
  owns only the final semantic verdict — GC runtime state never enters an
  AgentOps verdict.
- **Mayor-driven door with a heartbeat shepherd.** The city runs one standing
  city-scoped Mayor that is a dispatch shepherd: it watches ready rig step beads
  and sling-nudges each to its run-target (workers claim; the Mayor never claims
  and never authors work), propelled by a scheduled heartbeat dispatch pass. Two
  doors reach the one session — a human attaches to the tmux session and drives
  interactively, or an orchestrating agent drives it by handing bead ids through
  native GC mail/sling (`mayor tell "dispatch <id>"`), with no keystroke
  injection.
- **`using-gc` mayor-orchestration skill** documents the drive loop (author
  intent as a bead -> feed -> dispatch by id -> read state from GC rather than
  prose -> completion is bead/verdict state, never pane output) and a four-layer
  visibility doctrine: robot/session state, the bead graph, tmux pane truth, and
  health machinery. Pack intake routes through rig-scoped dispatch per the stock
  Gas City mayor pattern, so the flow survives the upstream fix.
- The pack is labeled **preview** and discloses three Gas City v1.3.5 upstream
  defects it is built around: demand-driven worker spawn is broken for rig work
  (the shepherd nudge is the workaround; upstream #4586), a cross-store
  city-scoped claim returns `bead not found` (never exercised by the pack's
  rig-scoped flow; claim fix landed upstream after v1.3.5), and a rare tmux
  teardown hang under process churn (upstream PR gastownhall/gascity#3985).
  Preview is promoted to supported only after the next official Gas City release
  is pinned, deterministically qualified, and one clean mixed-provider canary
  passes.

### Changed

- RPI is now exactly `Plan -> Implement -> fresh Validate -> report and stop`.
  Plan absorbs Discovery, behavior-first planning, and goal design; Learn moves
  off-path as optional later analysis.
- The canonical corpus is 48 metadata-owned skills. Every skill passes the deep
  strict auditor, generated registry/graph/router/count projections agree, and
  Codex/Gemini artifacts regenerate from the canonical tree.
- The retained Go CLI is a deterministic repository-check and inspection tool.
  Its default public surface no longer controls semantic validation, retries,
  work lifecycle, Git, or delivery.
- Three supported install paths: `npx skills add` (universal across coding
  agents), runtime plugin marketplaces for Claude Code and Codex (managed
  bundles that update with the release), and one canonical checkout plus
  `ao skills link` for source-tracked installs. The 3.x curl installer
  scripts are refusing tombstones.
- `ao flywheel` knowledge metrics returned to the default build as optional
  read-side tooling (no more `-tags "flywheel legacy"`), carved into dedicated
  internal modules, and now read the canonical `.agents/ao/<section>` knowledge
  directories alongside the legacy `.agents/<section>` fallback.
- The post-Cathedral-Cut Go cleanup removed the retired 3.2 implementation
  (~88k lines). Removed verbs fail as unknown commands with a replacement
  hint; nothing forwards to old code.
- Published `ao demo` now presents the packet-free one-pass loop; active docs,
  templates, and smoke tests use caller-owned intent plus runtime-derived
  subject evidence. The old Plan, Candidate, and revision schemas are labeled
  deprecated compatibility formats.
- `scripts/ms-reindex.sh` derives completeness from live
  discovered/indexed/error accounting instead of a hard-coded corpus floor.
- CASS guidance distinguishes authoritative rebuild fallback and timed-out
  concurrent reads from empty results or source loss.
- Plan and premortem now route their judgment to executable ground truth: Plan
  binds acceptance to the real runnable check surface rather than a narrative
  restatement, and premortem adds a derivation-diff challenge that tests a
  proposed change against the diff it would actually produce — keeping planning
  and pre-mortem reasoning anchored to evidence, not prose.

### Removed

- Pawl admission, land/done/close, governor/converge/reconcile, claim/next-work,
  state/worktree, membrane, yield, constraint promotion, the 3.2 `ao verify`
  front door, semantic `ao validate`, and the Crank control plane. Major public
  names return one-release non-mutating tombstones; the full removed-surface
  map with replacements is in
  [docs/MIGRATION.md](https://github.com/boshu2/agentops/blob/main/docs/MIGRATION.md).
- Discovery, behavior-first-planning, goal-design, Crank, delivery/controller,
  tracker-wrapper, and noncanonical mortem skill roots after their useful
  behavior was folded or retired.
- The unreferenced `.agy-plugin` 3.x bundle, whose copied 12-skill corpus still
  exposed removed beads, Discovery, and Crank behavior. `images/gemini` remains
  the generated Gemini/Antigravity compatibility bundle.

### Fixed

- A from-source `ao` build whose version matches its checkout is no longer
  flagged by doctor: the dev-version detector reuses the Binary Freshness
  resolution and fires only on genuine drift, shadowed duplicate binaries,
  or (outside a checkout) an informational from-source note. `ao doctor
  diff --only <id>` scopes the fix-plan preview.
- The dead `ao config models` surface was removed (nothing consumed model
  tiers); existing `models:` config sections still parse and are ignored,
  and the removed subcommand points at the migration map.
- The remaining single-rooted knowledge readers follow the canonical
  `.agents/ao/<section>` directories alongside the legacy roots: the
  learning-coherence gate, constraint counting, and the eval sandbox
  corpus deny-list.
- The strict docs-link backstop's allowlist was refreshed (all 53 entries
  referenced Cathedral-Cut-deleted docs); ROADMAP, the documentation
  index generator, and the doc skill's references no longer point at
  files that don't exist.
- Onboarding docs name the one real prerequisite: the loop runs as skills
  inside a coding agent (Claude Code, Codex, Cursor, …) and `/rpi` is typed
  in that agent's chat. The README Quickstart leads with the universal npx
  install alone (beads is introduced as the optional tracker it is), and the
  Codex plugin uninstall uses `codex plugin remove` with the manual cache
  removal demoted to a fallback for older Codex.
- Doctor sub-surfaces agree with each other: remediation and the
  triage/next-steps recommendations instruct `--fix` only when a fixer can
  actually act (non-fixable findings name their real manual action),
  `ao doctor health` reports every severity bucket present, `ao doctor diff`
  renders an explicit read-only fix plan, and `ao doctor explain` is a
  superset of the finding's triage entry.
- `ao config --show` stops rendering configuration for removed subsystems
  (`rpi.*`, `dream.*`) and, during the legacy `~/.agentops` fallback, shows
  the actually-read path labeled as deprecated with correct value
  attribution. The unused `AGENTOPS_NO_SC` variable is no longer documented.
- The pruned 3.2 bookkeeping verbs (`ao beads`, `ao wiki`, `ao ratchet`, and
  family) now fail with a migration pointer like every other removed
  surface, instead of a bare unknown-command error.
- `ao gate check` in a repository other than agentops itself no longer fails
  with a wall of UNKNOWN rows for agentops-internal checks: those checks skip
  as first-class not-applicable, the human report aggregates them into one
  honest line, and the summary now counts UNKNOWN in its own bucket so it can
  never read all-clear while unknowns exist. Inside the agentops repo a
  missing backing script remains fail-closed UNKNOWN.
- `ao doctor` no longer reports a permanent false `fm-skills-missing` P1 for
  source-linked installs: the detector follows symlinked skill directories
  (dangling links still count as absent), matching the `ao skills link`
  install path.
- `ao doctor` no longer raises a P1 for benign PATH shadowing of a required
  CLI (e.g. Homebrew git alongside Apple's `/usr/bin/git`), and the
  missing-CLI remediation renders only when a CLI is actually missing —
  eliminating the empty "Install the missing CLI yourself — —" template.
- `ao init` creates the complete evidence layout — both loop-evidence stores
  `ao status` reads (intents, verdicts) and the sessions/index/provenance
  substructure `ao doctor` enforces — so a fresh init is never flagged
  incomplete by the CLI's own diagnostics.
- `ao doctor` is now a fast installation-health check over binary identity,
  exact source-skill links, optional provenance integrity, and host safety. It
  no longer implicitly runs the 3.2 plugin/tracker/reviewer/fixer diagnostics,
  and its JSON output represents the same bounded checks as human output.
- CLI tests no longer inherit the operator's `TMUX` server; test cleanup is
  isolated under its temporary tmux socket directory.
- Skill auditing now measures concise executable contracts instead of rewarding
  ceremonial length, optional directories, or invented lifecycle sections.
- Scenario coverage is a caller-supplied static evidence check and no longer
  depends on beads, admission, tracker lookup, or lifecycle state.

See [docs/3.3.md](https://github.com/boshu2/agentops/blob/main/docs/3.3.md) for
the release narrative and migration boundary.

## [3.2.0] - 2026-07-03

AgentOps 3.2 is the **verification-keystone** minor: the cross-family review loop became the product's front door. `ao verify` is the canonical verb over the pawl engine (with `init` making the pre-push verdict ratchet portable to any repo, `stats` pricing the cost of verified-done, and `receipts` rendering the proof), `ao done` makes bead closes verdict-referenced, and the reviewer hardened into a standing multi-model service with honest degradation — outage-only failover, REBOUND re-authorization for byte-identical rebases, and an opt-in strict two-family quorum that reports honest-UNAVAILABLE rather than fake redundancy. The membrane gained memory (`ao membrane catch/recall/triage`) and its escape→derived-check loop is proven end-to-end on the shipped binary, including constraint travel to CI. Around that core the CLI shed the cathedral: the default build is the verification + bookkeeping spine (corpus-flywheel and legacy families behind `-tags "flywheel legacy"`, ADR-0012), the `ao rpi` surface and v1 memory experiment are removed, the bd/Dolt tracker is retired for `br`+`bv`, and the skill catalog consolidated 105→63. See [docs/3.2.md](https://github.com/boshu2/agentops/blob/main/docs/3.2.md) for the release narrative.

### Added

- **`ao verify` — the verification front door** (age-wedge-all-in-dyr0, age-rk3r): `ao verify` reviews a change and binds the verdict to the provenance ledger; `ao verify init` installs the portable pre-push verdict ratchet + chain verify in any repo; `ao verify stats` reports dispositions, refute rate, rounds, duration, degraded share, and re-review waste from the ledger; `ao verify receipts` renders the proof page from the embedded bundle; per-repo config file + `--show-config`.
- **`ao done`** — verdict-referenced bead close with a warn-first close-rate gate, falling back to the origin/main ledger when the local one lags (age-wedge-all-in-dyr0.4, age-lw4c); **`ao provenance show`** (per-SHA/bead verdict lineage) and **`ao provenance mine-session`**.
- **Standing pawl service** (age-standing-pawl-service-ml8): `ao pawl up/down/health/route/metrics` with warm tri-model panes (Claude + Codex + AGY), capability-adaptive routing, self-healing respawn/reroute, p50/p95 + agreement SLOs; `ao pawl review` runs zero-config on a stranger's repo (age-a9iv).
- **Verdict-integrity layers** (age-rk3r): REBOUND patch-id verdicts authorize byte-identical rebases without a re-review (honored by the portable push-gate and CI with Go-side lineage+proof re-validation, plus a keep-ref so CI can re-verify an orphaned reviewed commit); opt-in strict two-family cold quorum that refuses to degrade (honest-UNAVAILABLE); outage-only cold reviewer failover chain with explicit degraded labels; evidence-quality floor for CONFIRMED; live-smoke verify mode; provenance v1.1 verdict-edge enrichment (reviewer_family, degraded, rounds, duration_s, evidence_path).
- **Membrane memory** (age-zpj5, age-membrane-memory-arch-tz2s): `ao membrane catch` records panel catches (class key + affected paths), `ao membrane recall --include-catches` retrieves them by domain into prompts, `ao membrane triage` reports honest two-axis recurrence; the escape→derived-check loop is proven end-to-end on the shipped binary (`scripts/em-loop-donetest.sh`) with learned constraints traveling to CI and clean clones.
- **`ao wiki`** — the OpenKB port (age-port-openkb-into-agentops-go-5qw): `init/use/add/remove/recompile/lint/status`, gold-wiki compilation from `.agents/` with sanitize+mine, and verdict-gated publish bound to a content digest; retrieval integration via `ao lookup --gold` and `--pointers` bounded retrieval with a cold-start ε-exploration floor.
- **Plan-pawl duel** (age-plan-pawl-9yib): `ao plan-pawl decide` deterministic duel decider; `/discovery` gains `--duel/--no-duel/--duel-rounds`; pre-mortem gains the duel checklist; ApprovalEdge records two judge panes.
- **Real token accounting + governor**: per-bead token capture kills the hardcoded zeros, `ao yield tokens` parses Claude and Codex transcripts (deduped by response id, loud on absent usage), and `ao governor budget` adds an SPC error-budget with a two-sided noise band (age-membrane-memory-arch-tz2s.3, .7).
- **Gate wave** (age-gate-the-ungated-egwt, age-push-equals-ci-0ua): full `-race` suite on push-to-main, provenance hash-chain gate at the pre-push boundary, `docs.cli-snippets` (live docs resolve against the cobra tree), `docs.skill-refs --all-docs`, `docs.demoted-claims` honesty lexicon, script-preamble ratchet, ADR-registry check, fail-closed pinned golangci-lint, static shell-portability gate, jsonl-scanner ratchet, and a report-only CI verdict backstop (age-wedge-all-in-dyr0.9).
- **Land pipeline** (agentops-2pl, age-genn, age-qeqv, age-tkxq): single-writer land lane with branch submit queue and default-deny gh shim, deterministic land wrapper, staged-scope pre-commit guard against concurrent-lane contamination, first-class per-item consumed markers in next-work.
- **Eval instruments** (age-cwo, age-7q7d, age-kf-s1-close-loop-0ly): verification-membrane eval (false-done catch rate over deterministic oracles + cross-family verifiers), real-false-done trap tasks, escape-harvest tooling, measured local-MLX eval membrane (100% per-task concordance vs codex; eval-path only), scenario-ab environment-level arm isolation (macOS sandbox-exec), deterministic answer-key grading, ceiling pre-screen, absolute task-success judging.
- **Codex runtime hardening** (ag-p273x, ag-codex-runtime-enhancement-o0nds): task-packet and run-receipt JSON Schemas enforced at runtime, `required_commands` executed and recorded, dispatch paths bounded to cwd/`allowed_paths`, packet-injected auth env rejected, dispatch receipts, image health doctor with per-check timeouts.
- **ms integration**: the `ms` skill (meta_skill search/load doctrine), session-bootstrap surfacing, `ms-reindex` wrapper + post-merge hook installer, and "ms search first" folded into discovery/plan/skill-builder (age-l6y3, age-22g0, age-50pr).
- **15-skill spine partition**: `spine: true` frontmatter with a behavioral GOALS gate, plus `flywheel`/`legacy` archive build tags — the default `ao` build omits archived families (age-focus-membrane-bookkeeper-m1wg.12/.23, ADR-0012).

### Changed

- **The ship path routes to the Go release authority** — `ao gate check` is the default gate on the ship path (age-fkps), `#trivial` waivers verify the diff is genuinely provenance-only (age-u43w), and non-trivial commits hidden behind a `#trivial` tip are gated individually (age-8ais).
- **The default pawl routes through the standing service** when it is up, with size-scaled review timeouts for large read-files packets (age-standing-pawl-service-ml8.7, age-wedge-all-in-dyr0.11).
- **Skill catalog consolidated hard**: the corpus prune folded 39 sources into 21 targets (105→65, ag-s43tg), then 70→63 with six skills folded into canonical owners (#889); six corpus-flywheel skills plus `evolve`/`autodev`/`acfs` demoted to a new experimental tier; substrate skills folded 13→5; `ao skills retire` makes retirement deterministic via the dispositions ledger; all 50 trigger-marker offenders cleared behind a new `skill.triggers` gate.
- **Codex twins are generated self-contained** from source with pointer exemptions, a byte-verify drift gate, and content-divergence gates extended to SKILL.md bodies and references; twin regeneration scoped to the spine set (~70% regen cut) (age-8wm, age-codex-twin-generator-qlj, age-k2ag, age-focus-membrane-bookkeeper-m1wg.18).
- **CLI consolidation**: session-continuity commands under `ao session`, eval-family commands under `ao eval`, an experimental help group for corpus/flywheel surfaces, and a quick-start that lands the first verdict in one command (age-focus-membrane-bookkeeper-m1wg.16/.17, age-h4y3, age-wedge-all-in-dyr0.5).
- **Storage discipline**: canonical `storage.AtomicWriteFile` (quest/llmwiki/doctor/wiki delegate), exported JSONL helpers with a loud-failure buffer policy, fsync-safe atomic writes + parent-dir fsync, and tar extraction containment (age-3azc, age-uja6, age-storage-hardening-roxg, age-y9jy).
- **Out-of-session substrate wording reconciled (Wave F).** Live multi-agent orchestration is documented as **NTM/ATM + Agent Mail**; Gas City remains an optional reference SDK, not the default operator substrate. Historical 3.0.0 CHANGELOG entries that name Gas City as primary orchestration are superseded by this note for current doctrine — see [`docs/3.0.md`](https://github.com/boshu2/agentops/blob/main/docs/3.0.md) and [`docs/architecture/codebase-overview.md`](https://github.com/boshu2/agentops/blob/main/docs/architecture/codebase-overview.md).
- **Doc-debt reconciliation waves A–F (2026-06-16)**: `cli/AGENTS.md` br pointer stub + `cli.agents-tracker` drift gate; RPI terminology glossary; `ports-and-adapters.md` + BC5 + hookless framing with a `docs.architecture-drift` gate; worktree disposition audit (dry-run); `skill-probe-i0.sh` + `check-provenance-orphans.sh` registered in the Go gate registry; skill-disposition triage checklist.
- **Root agent docs reconciled to executable truth** (age-2d8m) — source-of-truth precedence stated inline; stale hook-era/`bd` wording swept; README claims PMF-linted with evidence citations (age-ejk).

### Fixed

- **Pawl truthfulness arc**: each pane's ACTUAL verdict is recorded (no fabricated REFUTED from timeouts), all verdicts are collected (no first-REFUTE guillotine), cc/agy sends are delivery-based (the unreliable atm-wait engagement gate removed), cold codex reviews are echo-safe with a hardened shared `codex-exec` runner, a hijack guard refuses verdict binds when the worktree HEAD moved mid-review, and backgrounding-reap failures self-explain (age-pawl-good-bar, age-55qz.10/.11, age-sylz, age-wjp0, age-gate-the-ungated-egwt.8/.13).
- **Full-tier gate reds greened** (age-hl9q): the flywheel proof builds its sandbox `ao` with the ADR-0012 archive tags (`PROOF_BUILD_TAGS`), `heal.sh --strict` resolves skill CLI references against the full command surface via the shared snippet resolver (third instance of the archived-command escape class), and `computeVerifyStats` was split under the gocyclo budget.
- **macOS portability sweep**: bats suites and release scripts fixed for BSD `wc`/`stat`/`find`/`sed`/`touch` divergences; a static shell-portability gate guards regressions (age-qzvm, age-lz4b, age-m9rf, age-jtz0, age-i0ky, age-7jm6).
- **Test isolation hardening** in `cli/cmd/ao`: cobra flag/writer state restored via `t.Cleanup`, tmux socket isolation, deterministic process-group tests, os.Setenv ratchet, and the trustworthy cmd/ao test floor restored with the gate blindness that shipped it red closed.
- **Regen determinism**: `registry.json` drops wall-clock `generated_at` (age-9itj), the skill catalog regen folded into `regen-all`/`regen-check` (age-biop), and the catalog/registry inventory surfaces agree at 64 skills (age-61ci).
- **Provenance integrity**: strict bead-id extraction kills false edges from prose, post-land emit is race-proof via disposable worktrees, merge_sha is trunk-bound, and ledger appends serialize under a cross-process lock.

### Removed

- **The `ao rpi` command surface** — ADR-0009 executed; the operating loop + process skills are the navigation path, and the engine's live helpers were extracted to `internal/worktree`, `internal/runtimecmd`, and `internal/rpi` (age-tlj6, age-3pdt).
- **`ao recall` and `ao memory ingest-claude`** — the v1 unified-memory experiment retired; recall is consumed from the coexisting open-source tools (cass / cass-memory) rather than rebuilt in-tree (age-5nvy, age-7grl).
- **The bd/Dolt tracker lane** — `br` (beads_rust) + `bv` are canonical over a git-JSONL ledger; bd wrappers, docs, and workflow references swept with regression gates (ag-joto6, age-m44f, age-u1u6).
- **Archived command families** — `turn`, `harness`, `operator`, `harvest`, `refinery`, `mind`, and `curate` moved behind the `flywheel`/`legacy` build tags; the dead `ao cron` compat shim deleted (age-focus-membrane-bookkeeper-m1wg.13/.14/.15).
- **The unproven memory-moat machinery** — retired per ADR-0004 honesty; the membrane stays, the moat claims went (age-7grl).

### Security

- tar extraction containment (IsAbs reject, canonical path-inside assertion, typed rejects); fail-closed full-tree pre-push path guard for private artifacts; `ao corpus scan` deny/PII leak detector; cwd-relative script execution routed through the `aoBinaryInside` trust chokepoint; Codex dispatch rejects packet-injected auth env; the SDLC provenance ledger is tamper-evident with hash-chain verification at the pre-push boundary (age-storage-hardening-roxg.2, ag-ao0eo, ag-b0x50, age-gate-the-ungated-egwt.2/.9).

## [3.1.0] - 2026-06-08

AgentOps 3.1 is the **packaging-and-gate-discipline** minor on top of the hookless 3.0 core. The headline is not a new feature — it is that the release pipeline itself became the product. Three things hardened together: the **release gate moved native** (the inline bash checks were ported to a single Go gate that the pre-push hook runs as the release authority, with workflow-parity enforcement so a check can't pass locally while drifting in CI); **close-admission tightened** (the verdict gate now counts distinct validator *families* with author exclusion, so a self-graded "looks good" no longer admits a close); and the **skill corpus was canonicalized** (ghost skills materialized into the tree, registries/counts regenerated from one source, and bundled image copies forced back to byte identity with that source). On top of that discipline, the three IMAGE-CORE recipes (Claude / Codex / Gemini-AGY) ship as real, smoke-proven install paths. See [docs/3.1.md](https://github.com/boshu2/agentops/blob/main/docs/3.1.md) for the release narrative.

### Added

- **Installable image artifacts for the 3.1 runtime set.** Claude Code now has a dedicated marketplace installer wrapper, Codex keeps the native plugin curl installer, and Gemini/Antigravity now has a curl installer that validates and installs `images/gemini` through `agy plugin`. The three documented one-liners are in [README §Install](https://github.com/boshu2/agentops/blob/main/README.md#install); the recipes are materialized as `images/{claude,codex,gemini}/` (each with a manifest, `README.md`, and `verify.sh`).
- **Day-2 install operations are productized.** Added [docs/install-day2-ops.md](https://github.com/boshu2/agentops/blob/main/docs/install-day2-ops.md) — operator guidance for install, update, backup, permission repair, recovery, and escalation across Claude, Codex, and Gemini/AGY (the AT&O "make Day-2 part of the product, not an afterthought" doctrine).
- **Installer smoke proof covers all three image paths.** `tests/install/test-install-smoke.sh` checks the Claude, Codex, and Gemini/AGY one-liners without invoking vendor runtimes (measured: 45 passed, 0 failed).
- **Claude installer release-pinning.** `scripts/install-claude.sh` now accepts `--ref <ref>` (or `AGENTOPS_INSTALL_REF`) to pin the marketplace source to a tagged release (e.g. `v3.1.0`), reaching parity with `install-agy.sh`.
- **Claude image version guard.** `images/claude/verify.sh` now asserts `.claude-plugin/plugin.json` declares the expected release version (default `3.1.0`, override via `AGENTOPS_EXPECTED_VERSION`), so a stale-version drift in the marketplace manifest fails the gate.
- **`ao skills resolve` — MECE corpus audit** (`c9c3e2706`). Reports skill overlap and coverage gaps so the corpus can be kept mutually-exclusive / collectively-exhaustive.
- **`ao refinery` backstop daemon** (`cba058c6a`, ag-qidx) — a refinery surface for the gate/registry regen path, with a `cli-skills-map` regenerated for it.
- **Go gate workflow coverage + parity reporting** (`390695b65`, `281d46d34`, `283e60e78`) — the gate now reports which CI workflows back each check and *requires* workflow parity, so a locally-green check that has drifted out of CI fails the gate.

### Changed

- **Pre-push gate flipped to the native Go gate** (`c97efcc36` PB2, `efbcf7e90`, `ca9366ccb`) — the inline bash checks were ported to native Go checks (`643e7ade1`, `b720a72cd`, `bcaae4b02`, `5b93b4814`, `6814e377c` — PB1 batches) and the pre-push hook now runs `ao gate check` as the release authority. Local validation is the routine shipping path; GitHub Actions is an optional/manual backstop.
- **Push-to-main cockpit doctrine** (`d90ff1d09`, `0f501beae`, `a023dc4df`) — workflow rewritten for push-to-main with a concurrency-scoped push lock (`push-serial.sh`); dead merge-machinery scripts deleted.
- **Local validation is the release authority** (`3d4fc1299`, `ac5664c56`, ag-3l86) — local-CI made viable as a DSR fallback when GitHub Actions quota is exhausted.
- **Skill corpus canonicalized + triggers added.** 4 ghost `codebase-*` skills materialized into the tree and registered across catalog surfaces (`dd34f8688`, `584701af8`, `61421cdb9`, `0580f7303`, `cp-801l`); explicit "Use-when" triggers added to weak-trigger skills (`5cdd8e792`, `5895422cd`, `e0932310d`); `using-ntm` renamed to `using-atm` (`5c4e7f07a`); 2026-06-10 operational lessons encoded into 4 canonical skills (`d286a5fc2`).

### Fixed

- **Verdict gate now enforces distinct families + author exclusion** (`ef63eec78` (cherry-pick of 5f7120ff6), `d6576b359`, `94181cc89`, `9c1398671`) — `council_judge` counted files, not distinct validator families, and did not exclude the author; a self-graded verdict could admit a close (LAW-3 gap). `ef63eec78` adds `tickVerdictIdentity` (author, judge name, judge program, judge model family) and the `tickCouncilGate` family-count check to `tick.go`; `d6576b359`/`94181cc89`/`9c1398671` seal the skill-edit contract surfaces that the gate now audits.
- **Removed Claude `--print` probes from headless paths** (`267f378a0`, `dee7a3502`, ag-eli0) — the headless checks and the team-runner path no longer shell out to `claude --print` (LAW 0 compliance).
- **Distribution install contract aligned** (`29b919f92`) — the `agentops-core.distribution-install-update` canary was failing on main; the contract was realigned so `claude plugin update` and the install/update path stay green.
- **Gemini image bundle drift** (`3e0f8f4e8`, `0e5d07211`) — refreshed the bundled Gemini/AGY `SKILL.md` copies so `images/gemini/verify.sh` proves byte identity against the canonical source corpus. The residual `validate` and `vibing-with-ntm` drift left by the 2026-06-10 4-skill lesson encoding was resynced so both `images/gemini/verify.sh` and `scripts/validate-agy-plugin.sh` pass byte-identity.
- **Skill-auditor pass-1 gated on heal-strict** (`dbc2a6466`); post-merge skill lint drift repaired (`f784d2842`).

## [3.0.1] - 2026-05-25

Patch release. No runtime behavior change — it advances the plugin/marketplace version so existing `3.0.0` installs can `claude plugin update` cleanly (the `3.0.0` version label never moved across the 15 commits that landed the skill consolidation and doc reconciliation, so a plain update reported "already latest"). Also reconciles two release-engineering surfaces the per-PR gate did not exercise:

- **`claude plugin update` now works for early 3.0.0 installs.** Version bumped to 3.0.1 across `.claude-plugin/plugin.json`, `.claude-plugin/marketplace.json` (metadata + plugin), and the `install-ao.sh` pin.
- **Nightly Static Validation is green again.** Removed the Nightly step that ran the deleted `scripts/validate-hooks-doc-parity.sh` (hooks were removed in 3.0). Repointed/retired two stale `tests/docs/validate-skill-count.sh` extraction patterns that grepped PRODUCT.md for hook-era phrasing ("runtime hook event sections", the "### 1. Skills (N across 4 runtimes)" heading) that the 3.0 restructure removed.

## [3.0.0] - 2026-05-24

AgentOps 3.0 is the **hookless-first** major. The headline: AgentOps is what runs **in-session** — skills + the `ao` CLI + the RPI/evolve/crank/swarm loops + the context-compiler. Out-of-session orchestration (scheduling, daemons, autonomous dispatch) is delegated to Gas City (a reference City ships in this release) or Olympus. The default install registers **zero hooks**; the lifecycle is driven by skills and CI gates. See `docs/3.0.md` for the north star.

### ⚠️ Breaking Changes

- **Hookless by default** (`soc-57b7f`) — the default install registers no hooks. All 53 runtime hooks were audited and removed; capabilities that lived in hooks (standards injection, commit-review gating, noise injectors) are now CLI ports + CI gates. Opt back in with `--with-hooks` (`AGENTOPS_INSTALL_HOOKS=1`) or `ao hooks install --force`. **Migration:** if you relied on hook-driven behavior, switch to the CI gate or the equivalent `ao` subcommand.
- **Daemon carved out** (`soc-2rtm0`, daemon-carve wave 5) — `internal/daemon` + the `agentopsd` binary were deleted. AgentOps no longer ships an out-of-session daemon; Gas City is the orchestration substrate. Builder cores that previously ran as daemon jobs (wiki build, llmwiki loop) keep their in-process / GC-callable core but lose the daemon-job-executor wrapper.
- **Scheduling/plans/watch/overnight commands removed** (`soc-2rtm0`, kill-schedule-overnight) — `ao schedule`, `ao plans`, `ao watch`, and the overnight engines were deleted. Gas City owns scheduling. The phased RPI engine keeps its non-gc backends (`auto`/`direct`/`stream`/`tmux`); `runtime=gc` is no longer a valid mode.
- **`factory` command + contract corpus retired** (`soc-2rtm0`, cascade-rip) — the `ao factory` command and its contract corpus were removed.
- **Gas City (gc) bridge severed** (`soc-2rtm0`, wave 2) — the CLI gc-bridge glue (`gc_bridge.go`, `gc_events.go`, `rpi_phased_gc.go`) was deleted; the daemon-side GasCity client is a separate, retained surface.

### Added

- **AgentOps reference Gas City** — a turnkey City (`city.toml` + `agentops` pack + overlay) that demonstrates out-of-session orchestration on top of AgentOps skills.
- **`ao validate --gate`** — exit-code verdict for Gas City retry loops and CI; PASS/WARN/FAIL collapses to a process exit code.
- **Real hexagonal port adapters** — `corpus_fs` CorpusReader/Writer, a bd-backed TrackerPort, and a git-backed WorkspacePort, each wired to its core consumer. Port-realness audit in `docs/architecture/`.
- **BDD acceptance layer** — scenario→test linkage runner + CI gate (`soc-63xfx`); canonical `.feature` acceptance added across skills (research/plan/validation/trace/handoff/readme/autodev/flywheel/inject and more) and daemon-lifecycle Gherkin linked to tests.
- **`scripts/ship.sh`** (#346, `soc-33uy`) — single-command wrapper that auto-detects inventory-touching diffs and routes through the full pre-push gate (no `--fast` skip on skill/contract changes), preemptively running the regen sweep (sync-skill-counts, codex-hashes, domain-map, context-map, registry, sync-hooks). Mechanical fix for ship-loop anti-pattern #1.

### Changed

- **Honest 3.0 doctrine** — `docs/3.0.md` is the canonical north star: AgentOps is in-session; Gas City and Olympus own out-of-session. Doctrine, PRODUCT, and README were reconciled to the in-session core (skills + rpi + evolve + crank + swarm + context-compiler), with the out-of-session autonomous-dispatch gap explicitly labeled (`soc-5jwah`).
- **Version sync to 3.0.0** — `.claude-plugin/plugin.json`, `.claude-plugin/marketplace.json` (metadata + plugins[0]), and the City pack's pinned `AO_VERSION` (`packs/agentops/assets/scripts/install-ao.sh`) all bump to 3.0.0.
- **Coherent-arc PR rule** (#348, `soc-1lp1`) — replaces "one scenario per PR" default in `CLAUDE.md` + `AGENTS.md`. The unit of a PR is one closable bead (or small-epic slice) with a single rollback semantic. Small epics (≤5 child beads, same surface) ship as one PR with N commits; large epics ship as N PRs sliced by scenario or wave. Updates `ship-loop` skill (Claude + Codex twins). Derived from the 2026-05-19 8-PR merge-arc burn-through.
- **`skill-auditor` rubric scoring** (`soc-ads5v`) — adds a Pass 3 rubric-scoring stage.
- **Executable-spec-link-integrity promoted warn→blocking** (`soc-x7y9f`) — the scenario→test link gate is now a required CI check.

### Fixed

- **Daemon robustness hardening** — bounded idempotency key + request decode guards (`soc-scg3h`), heartbeat ledger-write timeout (`soc-15g9f`), heartbeat goroutine-lifecycle bound (`soc-yyrrq`), payload-shape validation before ledger append (`soc-qra05`), and executor-panic recovery in supervisor dispatch (`soc-as401`). (Hardening landed before the daemon carve-out for the GasCity-side client surface.)
- **`goals trace --orphans`** parser now rejects bead prose and matches real orphans.
- **6 pre-existing shellcheck warnings** (#349, `soc-j026`) cleaned across `validate-codex-api-conformance.sh`, `goal-failure-taxonomy.sh`, `purge-global-garbage.sh`, `nightly-pr-digest.sh`, `add-validate-job.sh`, `check-skill-size.sh`. All in scripts unchanged from base — atomic side-quest per anti-pattern #2.
- **Local pre-push gate eval-canary strictness mismatch** (#350, `soc-nmhp`) — full-mode eval-canaries now respect the same path filter as CI's `eval-workbench-verify` (`HAS_EVAL=1 || is_ci_env`). Previously `needs_check eval` short-circuited to true in full mode, producing 5 spurious FAILs on doc/script PRs against a baseline-less local env. Closes the "Local-vs-CI environment drift" learning (`docs/learnings/2026-05-07-ci-push-gate-toil-pattern.md`).
- **Eval fixtures referencing deleted hooks** (`soc-t40ai`) cleaned; stale deleted-hook copies removed from `cli/embedded/`.

## [2.41.1] - 2026-05-15

### Fixed

- **Release CI shipped red in v2.41.0** — the v2.41.0 tag was cut on a commit where three `Validate` checks were already failing; they were masked because the path-filtered CI marks untriggered jobs `skipped` (not `failed`). This patch clears all three: `registry.json` regenerated after the v2.41 arc added 10 `ao` subcommands; `skills/validation/SKILL.md` links `references/flags.md` with a real markdown link so `heal.sh --strict` passes; the `cli-command-surface-matrix` eval baseline + fixture updated to the current heading count (`top=70 sub=173 all=243`); and 7 `/skillname` slash-command references in `skills-codex/{evolve,validation}/SKILL.md` converted to Codex `$skillname` notation so the codex-native install canary passes.
- **`--oscillation-sweep` removal was incomplete in v2.41.0** — `soc-1q1x` deleted the `ao defrag --oscillation-sweep` flag but the cycle-181 audit only checked Go callers. Seven shell/YAML/doc callsites still referenced the removed flag, breaking the `validate-flywheel-proof` CI gate (`scripts/nightly-dream-cycle.sh` shelled the dead flag). Cleared from `.github/workflows/nightly.yml`, `scripts/nightly-dream-cycle.sh`, `scripts/check-compile-oscillation.sh`, `docs/contracts/dream-run-contract.md`, and the `compile` skill phase docs.
- **`extract-release-notes.sh` double-blank line** — the awk extractor captured the blank line after the `## [VERSION]` heading; wrapped in the `<details>` boilerplate it produced a double-blank between `<summary>` and the first subsection. Now strips leading/trailing blank lines from the changelog section.
- **`ci-local-release.sh` secret-scan false positive** — the secret-pattern scan recursively grepped the gitignored `_site/` MkDocs build directory, matching `password:!0` inside minified JS bundles. Added `_site` and `site` to the scan's `--exclude-dir` list.

## [2.41.0] - 2026-05-14

### Added

- **BC ports — 14/14 production-complete.** `FactoryAdmissionPort` (13th, `soc-2klg.1`) + `productionFactoryAdmission` (cycle 139–140) and `ClaimEvidencePort` (14th, `soc-2klg.2`) + `productionClaimEvidence` (cycle 141–142) land the last two BC4 ports, closing the 14-port BC inventory begun in the v2.40.0 cycle. Each port follows the `<port>.go` + `inmemory_<port>.go` + `inmemory_<port>_test.go` triplet plus a `productionX` production adapter, with compile-time interface assertions as drift guards.
- **10 typed-port-backed `ao` subcommands** — operator-facing CLI now exposes every BC port that needs a script-side surface: `ao loop history` (`productionLoopReader`, cycle 144, slice 1 of `soc-y5vh.5`), `ao ci latest`/`recent` (`productionCIStatus`, cycle 145, slice 2), `ao corpus inject` (`productionCorpusReader`, cycle 146, slice 3; closes `soc-y5vh.5`), `ao operator record`/`list` (cycle 147 — template-applied 1st of 7), `ao harness status` (cycle 148), `ao gate run` (cycle 149), `ao corpus capture` (cycle 150, BC1 R/W pair complete on CLI), `ao loop append` (cycle 151, BC3 R/W pair complete on CLI), `ao citation verify` (cycle 152, BC1 round-trip), `ao claim bind`/`list` (cycle 153, 10th adapter CLI-exposed). Establishes a reusable cycle-shape captured in `docs/learnings/2026-05-13-cli-wiring-cycle-shape.md`.
- **`ao loop verify`** — audits `.agents/evolve/cycle-history.jsonl` integrity via the typed BC3 `LoopReaderPort` (uses cycle-161 widening). Operator-facing health check on the loop ledger.
- **`CycleEntry.StartedAt` + `Title` fields** (`soc-ckc4`, ports widening at cycle 161 + writer-side round-trip at cycle 162). Enables the `ao loop verify` audit and richer downstream consumers of the cycle ledger.
- **BC3 LoopReaderPort operator wrapper** — `scripts/evolve-read-cycle-history.sh` provides `recent [N]` / `latest` / `range START END` modes around `ao loop history`, replacing inline `tail`/`awk`/`jq` shell-outs over the raw `.agents/evolve/cycle-history.jsonl` (`soc-y5vh.4`). Three migrated callsites: `skills/evolve/references/convergence-mechanics.md` Mechanism 1, `skills/evolve/references/oscillation.md` oscillation counter, and `skills/evolve/references/fitness-scoring.md` Oscillation Detection block (`soc-lghj`).
- **Supergate Gap 3 (loop-closure) bats coverage** — `tests/scripts/check-three-gap-supergate.bats` extended with three tests (happy-path PASS, `goals-validate` FAIL, `flywheel-proof` SKIP) using a PATH-shimmed `go` that produces a controlled `/tmp/ao-sg` (`soc-wxh5.3`). Suite goes 15 → 18 tests; closes the cycle-63 Gap 3 deferral.
- **Mandatory STEP 1.7.5 release-readiness gates** in `/validation` — auto-detects release context from branch name (`release/*`, `v*-prep`, `v*-evolve-run`, `v\d+\.\d+*`) or `--release-context` flag and requires `scripts/pre-push-gate.sh` (full, not `--fast`), `scripts/ci-local-release.sh`, and `scripts/generate-cli-reference.sh` cleanliness check when CLI surface changed. Validation refuses to recommend `/release` until all three pass. Codex parity synced.
- **`/evolve` teardown pre-release checklist** — when the loop runs on a release-shaped branch, the teardown report emits an explicit unchecked checklist (regen CLI docs, full pre-push, `ci-local-release.sh`, optional smoke run) instead of recommending `/release`. The handoff artifact carries the checklist verbatim; "ready to tag" means boxes checked, not cycles green.
- **Acceptance-Text vs Delivered Drift audit** in `/post-mortem` closure-integrity check — for each closed child, parses the bead `Acceptance:` section, extracts named gates, and WARNs when the close-note does not confirm the gate ran green. Catches the failure mode where a bead's acceptance language drifts from delivered evidence (origin: cycle 182 `soc-w6vh.4`).
- **`.agents/operator/` write-surface contract entry** — `docs/contracts/agents-write-surfaces.md` now documents the BC4 `OperatorPort` durable-intent log (allowlist + classification row, lifecycle=`rolling`, writer=`cli`).

### Changed

- **`/evolve` Step 0 prior-knowledge retrieval** now routes through the typed BC1 `CorpusReaderPort` (`cli/cmd/ao/corpus_reader_adapter.go`, cycle 112 `productionCorpusReader`) via `ao corpus inject` instead of the legacy `ao lookup` shell-out (`soc-y5vh.1`). Skill text in `skills/evolve/SKILL.md` and `skills-codex/evolve/SKILL.md` synced; codex hashes regenerated.
- **`/evolve` Step 1.5 healing-first classifier** now routes through the typed BC2 `CIStatusPort` (`cli/cmd/ao/ci_status_adapter.go`, cycle 117 `productionCIStatus`) via `ao ci recent --limit 1` instead of an inline `gh run list --workflow validate.yml --json conclusion` (`soc-y5vh.2`). Both callsites (`skills/evolve/SKILL.md` + `skills/evolve/references/convergence-mechanics.md`) updated in lockstep. Zero remaining inline `gh` shell-outs in `/evolve`'s hot read path.
- **`cli/cmd/ao` coverage floor** raised back to 76 % in `scripts/check-cmd-ao-coverage.sh` after real statement coverage climbed to 76.1 % (23553/30953) on the v2.41-evolve-run baseline (`soc-wxh5.1`). The cycle-60 recalibration to 75 % is reversed.
- **`/evolve` session-state refresh at Step 0** so the dormancy gate stays correct after long-running cycles harvest follow-ups (cycle 171 retrospective fix).
- **`/release` skill refactor** — moved Examples + Troubleshooting + the non-HEAD cut-version logic into `references/release-workflow-detail.md` to bring `SKILL.md` back under the `tier=execution` size limit. Behavioral surface unchanged; cycle 169 post-mortem restoration commit restored Examples and Troubleshooting after the initial extraction.

### Fixed

- **`three-gap-supergate` goals-validate sub-gate** — `scripts/check-three-gap-supergate.sh` now `rm -f /tmp/ao-sg` before `go build -o /tmp/ao-sg`. Go refuses to overwrite a non-object file at the build-output path, so any prior process that wrote a non-binary to `/tmp/ao-sg` (including the bats-test shim go) would otherwise wedge the gate. The bats teardown in `tests/scripts/check-three-gap-supergate.bats` also cleans `/tmp/ao-sg` to remove test pollution. Caught by `ao goals measure` (1 failing → 0 failing) — first validation that the new STEP 1.7.5 mechanical gate works on real drift.

### Removed

- **Dead `defrag.SweepOscillatingGoals` function** and all callers (`soc-1q1x` path 1). The function read `.agents/evolve/cycle-history.jsonl` for entries with a `target` field; zero entries have ever had one in production, so callers (`runCompileDefrag`, `runDefragPhases`, `runDreamDefragPreview`) always got empty results. Net removal: 6 files, 17 insertions / 465 deletions — `SweepOscillatingGoals` + 5 helpers + `CountAlternations` + `CycleRecord` + `OscillationResult` + `OscillatingGoal` types + `DefragReport.Oscillation` field + `defragOscillationSweep` flag + `--oscillation-sweep` CLI flag + 9 tests. Build green; 11924 tests pass.
- **43 dead-code findings swept from `cli/`** — across multiple cycles (156 cleared 10 `staticcheck` U1000 findings, 157 swept 18 more, 158 swept 10 more, 159 swept 5 more from `soc-k083`). Closes long-standing static-analysis backlog; `LoadCycleHistory` deletion (cycle 156) was the canonical example of the dead-code pattern that `soc-1q1x` later applied to oscillation-sweep.

### Internal

- **DDD/Hex architecture rescope arc — 13 cycles closed.** Phase-1 complete + phase-2 retrospective (`docs/rescope/2026-05-13-ddd-hex-architecture-rescope.md`); test-architecture-debt analysis reconciled to deletions; BC ports phase-2 narrowness post-mortem captured (`docs/learnings/2026-05-13-bc-ports-narrowness-postmortem.md`).
- **Learnings catalog hygiene** — README + when-to-add rubric (cycle 134), empirical /loop context-drift study over 87+ cycles (cycle 135), BC-ports wire-up arc retrospective (cycle 122), CLI-wiring cycle-shape template (cycles 144–146), substring sed-rename overreach warning.
- **Contract drift resolution** — `soc-5yuy` drift #5 resolved via audit; `cli-skills-map.md` refreshed to 70 generated CLI command headings for v2.41-prep BC-arc commands.

## [2.40.0] - 2026-05-13

### Added

- **Practice-citation derivation graph** — `PRACTICE-REGISTRY.md` becomes the derivation root for every primitive in the repo. A new `practice-citation derivation graph + advisory CI gate` enforces that every skill, hook, eval suite, CLI command, and schema declares its `practices:` lineage. Twelve backfill passes (`pass-1` through `pass-12`, four `pass-12` waves across `cli/`) reached **756/756 declared** primitives — full repo coverage. Touches `skills/`, `hooks/`, `schemas/`, `evals/agentops-core/`, and `cli/` via `// practice:` comment carriers.
- **Three-gap supergate (E5 epic)** — `scripts/check-three-gap-supergate.sh` consolidates three release-blocking gates into one entry point with Gap 1 `--strict-coverage` opt-in, wired into `scripts/pre-push-gate.sh` and the `validate-three-gap-supergate` CI workflow. Closes `soc-m47k` and three child gaps.
- **Contract enforcement gates** — `contracts-structural-floor` (covering all 38 contracts), plus dedicated CI-blocking gates for `factory-admission`, `finding-registry`, `factory-yield-ledger`, `flywheel-compounding-snapshot`, `wiring-closure`, `goals-validate`, `flywheel-proof`, `quarantine-empty`, and `contract-canaries` (`check 24e`). `feat(gate) --two-pass mode` and local-scope default added.
- **Behavioral eval workbench** — 12 eval tasks, first suite, three fixture components (Go CLI, Python FastAPI, DevOps scripts). Live-agent eval suite with 3 workbench cases, `scripts/eval-agent-harness.sh` wired into the eval CLI, and the suite expanded to all 12 workbench tasks.
- **Eval CI gates** — `eval-skill-delta` CI gate + nightly schedule template, `eval-workbench-verify` gate (GOALS.md Directive 10), head-to-head delta gate against the baseline scorecard (D10). Run records upload as CI artifacts for triage; Python venv bootstrapped in `agentops-eval-advisory`.
- **Eval harness primitives** — `context_comprehension` dimension, CDLC identity field, observability feedback loop, and industry-proven eval patterns added to the agent harness.
- **Unified registry** — Phase 1 added `scripts/generate-registry.sh` + `registry.json` source-of-truth. Phase 2 added a job type, CLI surface, and CI gate (`registry-check`).
- **Daemon factory-admission lane** — `feat(daemon): add factory admission job specs` + executor + lane validators, paired with `feat(gates): enforce factory-admission contract`.
- **Daemon RPI agent-update events** — `RPIRunExecutor` emits `agent_update.criterion_verdict` per wave checkpoint (`soc-awx8`) and phase-boundary `agent-update` events (`soc-y0ct.2`).
- **Daemon scheduling + executors** — wired skill schedules through the daemon, registered eval and planning job types, added a CLI fallback RPI executor.
- **Nightly automation upgrades** — admission-aware morning digest with durability; manual-PR-only landing policy for evolve; fail-closed execute preflight for source mutation; blocker matrix + main CI baseline artifacts; daemon-submitted dream runs; L3 rehearsal scenario + operator runbook; scheduler install helper + updated runbook; PR digest generator from structured run state.
- **Five-minute first-value install gate (PG1)** — first-time-user journey is now a release-blocking install proof.
- **Corpus snapshot/restore + freshness gate (D11)** — durable corpus state with a CI-blocking freshness check.
- **Hook commit guards** — `feat(hooks)` warns on commits with code-without-test (P2), missing sibling-pattern citation (P3), and missing fitness-delta (P4) in commit messages.
- **Goals additions** — `code-driven` vs `runtime-artifact` summary split; `SKIP` exit code 77 + flywheel-compounding dormant precondition; `AffectsFiles` sidecar for the open-PR blocker matrix.
- **New CLI surfaces** — `ao session spawn` (template-driven session launch) and `ao feedback-loop --drain` (clear unfed citation backlog, epic `soc-sx99` W3.1).
- **Skills framework expansions** — `skill-builder` + `skill-auditor` pair (epic `soc-9bak`, #237); `ao quickstart` + demo surface for `ao schedule` and `ao daemon` (epic `soc-sx99` W2.2); tracer-bullet shape for the `skills/domain` ubiquitous-language corpus; scoped evidence on `/crank` and `/implement` bead closures.
- **Schedule starter template** — tracked stock starter at `docs/templates/`.
- **Scripts** — `corpus-stats.sh` + derived `PRODUCT.md` evidence (epic `soc-sx99` W3.3); `evolve-update-session-state.sh` derives session-state from cycle-history tail.
- **`security` domain in eval-suite manifests** — `$defs/domain` enum in `schemas/eval-suite.v1.schema.json` now accepts `security` alongside the existing eight domains. Paired updates land in `cli/internal/eval/coverage.go` (`DefaultCoverageDomains`) and `cli/cmd/ao/cobra_commands_test.go` (`evalCoverageDomains`) so schema, production default, and test fixture stay in lock-step. `ao eval coverage` will report `security` as a missing required domain until a security-domain manifest is authored.

### Changed

- **Three-layer product model adopted across surfaces** — README, `PRODUCT.md`, `docs/index.md`, and downstream positioning docs aligned to the three-layer (substrate / assurance / bookkeeping) framing with the software-factory + TSMC + in/on-the-loop framing. Eight `docs(positioning)` commits cover the thesis polish, lineage cleanup, link to `vs-compound-engineer.md`, and the closure of `soc-yjzp.9` with empirical Δ=0.
- **`/release` skill refactored under the size limit + non-HEAD cut support** — `skills/release/SKILL.md` and the Codex twin shrank from 545 lines to a 141-line flow index, with the detail extracted to `references/release-workflow-detail.md`. A new `references/release-cut-and-bump.md` documents the `release/v<ver>` branch pattern for cutting at a non-HEAD SHA. (This is the commit that prepared the v2.40 cut itself.)
- **RPI lifecycle sharpened** — criterion contract + isolation enforcement + daemon executor swap (`soc-bcrn`, #255). The factory claim ledger reconciled via Wave 1A-D (`soc-e4ulx`, #264).
- **CI workflow path-filters** — added path-filter conditions to 28 CI jobs (the remaining tail); bats path-filter wired so `.bats` changes gate bats-test jobs; `bats` prints captured output on failure.
- **CI loop boundaries** — `feat(ci): enforce inner/middle/outer loop boundaries` (#230).
- **Codex parity drift** — `feat(ci): wire check-codex-parity-drift as CI-blocking + pre-push gate (D7)`.
- **Skill consolidation** — 12 standalone skills consolidated into `beads`, `review`, `doc`, and `research`; external-corpus quality playbook slices absorbed in two waves.
- **Documentation reorg** — `docs(claims)` introduced a public evidence manifest for v2.39 README claims (PG4); `docs(parity)` updated four times; `docs(cdlc)`, `docs(readme)`, `docs(eval)`, `docs(release)`, `docs(positioning)` swept across the catalog.
- **Dependencies bumped** — `chore(deps)` updates for `mkdocs-material` v9.7.6, `mkdocs-section-index` v0.3.12, `mkdocs-literate-nav` v0.6.3, `mkdocs-include-markdown-plugin` v7, `mkdocs-git-revision-date-localized-plugin` v1.5.1, `mkdocs-gen-files` v0.6.1, `linkchecker` v10.6.0, `pymdown-extensions` v10.21.2, Python 3.14, `dorny/paths-filter` v4. `deps(go)`: `pgregory.net/rapid` minor bump in `cli/` plus a go-minor-patch group bump (#268).

### Fixed

- **`fix(ci)`** — registry non-determinism + pre-push goals-validate fallback; structural CI failures from cycles 45-47; `registry.json` knowledge_stores and schedules must match gitignored-state regen (epic `soc-sx99`); refreshed registry generation; bumped CLI surface counts after `patterns repair-filenames` addition; close practice-provenance validator gaps; `--single-pass` on pre-push-gate tests broken by `--two-pass` default.
- **`fix(eval)`** — six fixes covering eval canary refresh, advisory job stabilization, run-record upload reliability, and miscellaneous workbench-suite drift.
- **`fix(hooks)`** — reconcile stale `.agents/.gitignore` deny-all with parent allowlist (`soc-rv5p`, #263); prove `pre-push` transmits refs (#254).
- **`fix(codex)`** — migrate deprecated hooks flag; remove dead Claude-specific references and runtime markers from the codex research skill.
- **`fix(cli/rpi)`** — three correctness fixes around RPI scoping and isolation enforcement.
- **`fix(daemon)`** — bound daemon RPI GasCity sessions; close unused-variable in `generate-registry.sh`; refresh CI registry after worker-spec additions.
- **`fix(flywheel-lifecycle)`** — survive sparse corpus in Stage 5.
- **`fix(next-work)`** — add `dream-degraded` to the source enum.
- **`fix(nightly)`**, **`fix(harvest)`**, **`fix(audit-truth)`**, **`fix(evolve)`**, **`fix(parity)`**, **`fix(worktree)`**, **`fix(coverage)`**, **`fix(skills)`**, **`fix(quickstart)`**, **`fix(scripts)`**, **`fix(docs)`**, **`fix(gates)`**, **`fix(pre-push)`**, **`fix(heal,lint)`**, **`fix(rpi)`** — a long tail of single-file fixes touching individual gates, scripts, and surfaces during the nightly close-loop cycles.
- **GitHub eval advisory setup** — the `agentops-eval-advisory` job now installs the deterministic canary toolchain (`jq`, `ripgrep`, `bats`, `bd`, and `gocyclo`) and initializes a disposable bd database before running `scripts/eval-agentops.sh --fast`, matching the local environment expected by the public canaries.

### Internal

- **RPI loop pass consumption** — 10 `chore(rpi)` consumption commits drove the practice-citation backfill epic through 12 passes, closing the `cli/` design pass and exhausting the schemas/hooks/evals pools en route to `756/756 declared`.
- **Tests** — `test(cmd/ao)`: beads citation-verify functions, beads human-formatter functions, `runBeads*` graceful-degradation paths, `TestSanitizeDaemonSkillInvokeArtifactName` 0%-coverage hole closed.
- **Refactors** — `refactor(daemon)` extracted routing-lane validators to drop cyclomatic complexity (two commits); `refactor(dream)` promoted probe shapes to the registry.
- **Codex artifact hashes** regenerated after enum updates and after merges.
- **Skill counts synced** to 71 after the consolidation passes.
- **Two nightly autonomous runs landed** — `Nightly 2026-05-06` (3 productive cycles, +1 code-driven goal, fitness 94.29 → 100.00, #235) and `Nightly 2026-05-07` (3 productive cycles, +0 code-driven goals already 100, 2 audit-truth regressions fixed).
- **Drain open `next-work.jsonl`** — six PRs bundled into one branch (epic `soc-xlw8`, #266).

## [2.39.0] - 2026-05-04

### Added

- **AgentOps daemon runtime** - landed opt-in `agentopsd` as the local control plane for durable jobs, queueing, worker execution, projections, health/readiness/status, event tailing, mutation tokens, and product soak proofs. New CLI surfaces include `ao daemon run`, `ready`, `status`, `events tail`, `jobs list/show/submit/wait/cancel`, `service install`, and `soak`.
- **Daemon-backed workflows and scheduling** - RPI, Dream, wiki/forge, and plans now have migration paths into the daemon via explicit daemon flags, `plans.projection`, worker policies, and projections. `.agents/schedule.yaml`, `ao schedule add/list/run/remove`, daemon `--schedule-file`, cron validation, backpressure controls, schedule mutation routes, and recurrence ledger events make recurring work a daemon-owned primitive.
- **Worker and factory substrate** - added AgentWorker contracts, GasCity API/SSE adapters, CLI fallback workers, process cleanup, quarantine, Linux cgroup caps, routing policy guardrails, scoped mutation tokens, factory lifecycle projections, worktree ownership contracts, validation state, manual merge disposition, and yield ledgers.
- **CLI command expansion** - added `ao agents inspect/lint/doctor`, `ao skills check`, `ao scope`, `ao eval task/cleanup/suite/coverage/baseline-audit`, `ao pool reindex`, `ao watch`, and daemon-backed plan synchronization surfaces.
- **Deterministic eval platform** - added eval runtime adapters, scorecards, coverage reports, baseline A/B, context-packet A/B, retrieval/file-backed backends, public canary suites, and contract canaries.
- **Dream and work-queue metadata** - added finding-generator sidecars, aggregation, external-watchlist output, end-user coverage fitness gates, and first-class next-work `status`, `requires`, `dedup_key`, and routing metadata.
- **`.agents/` write-surface governance** - catalogued repo memory write surfaces, added lint/smoke coverage, introduced the no-tracked-`.agents` policy, and added operator docs for working with runtime state.
- **Harvest and knowledge surfaces** - harvest now recurses into nested artifact directories, emits real rig metadata, and gained native Go extraction support.

### Changed

- **CLI architecture refactor** - reorganized large parts of the Go CLI around focused internal packages for daemon state, worker execution, GasCity, schedule parsing, eval, path resolution, lifecycle, harvest, OpenClaw, LLM wiki execution, safety, and quality checks.
- **Daemon migration model** - foreground RPI, Dream, plans, and wiki/forge paths remain compatible, while daemon submission/read paths move runtime ownership toward the durable ledger and rebuildable projections.
- **Hook runtime and context flow** - re-architected hooks around JIT context and a managed runtime backend, added Claude/Codex PreToolUse output parity checks, quieted Codex session-start behavior, and added edit/write hash-audit hooks.
- **Path resolution** - moved `.agents` and repo-state path logic toward shared Go/shell resolvers (`cli/internal/paths`, `lib/ao-paths.sh`) and migrated representative CLI commands and hooks to the new helpers.
- **Codex runtime packaging** - refreshed Codex skills for GPT-5.5, aligned native plugin metadata with the marketplace schema, regenerated manifests and hashes, converted remaining skill references to `$skill` notation, tightened native hook installation, and reduced skill-catalog context footprint.
- **Release and CI governance** - CI/local gates now cover daemon product proofs, contract canaries, eval baselines, command/test pairing, Codex runtime sections, pre-push wiring, release audit artifacts, Windows smoke, advisory policy, and nightly knowledge-cycle dedupe.
- **Docs and operator contracts** - added or expanded daemon, scheduling, control-plane, GasCity, OpenClaw, local compute routing, operator guide, and release governance documentation.
- **Bootstrap behavior** - `/bootstrap` now recommends installing `bd` instead of attempting automatic installation.

### Fixed

- **Daemon durability and state machines** - fixed fsync propagation, orphan temp sweeps, snapshot directory sync, idempotency-key dedupe, queue cancellation, recurrence recomputation, projection deep-copy/nil-safety, claimed job queue depth, terminal projection precedence, and store/reconcile context cancellation.
- **Daemon API and execution hardening** - capped request bodies, bounded event limits, normalized wait timeout errors, rejected bad cursors and malformed schedule payloads, hardened wiki source-path containment and schedule name traversal, tolerated oversized ledger lines, preserved Dream log permissions, and routed Dream/wiki execution through the foreground supervisor.
- **CLI hygiene** - fixed JSON output validity, UTF-8 truncation, schedule prompt behavior under tests, command catalog drift, Cobra docs conformance, hidden command surface checks, command/test pairing, and temp-directory walk-up behavior.
- **Hook/runtime drift** - repaired Codex skill chaining defaults, native hook manifest installation, noisy session-start output, hook output schema, intent-echo bypass for team runners, lifecycle guard coverage, and pre-push hook coverage.
- **Security and scanner false positives** - closed the harvest TOCTOU path with `os.OpenRoot`, excluded safe regexp literals from broad secret scans, split secret-regex construction so release gates do not flag their own patterns, and removed pipe-to-shell patterns from the ripgrep builder.
- **CI/nightly/release blockers** - repaired eval advisory fixtures, baseline-audit drift-only behavior, Windows smoke paths, shellcheck/pre-push gate regressions, knowledge-cycle dormant-corpus handling, release audit validation, and the canary count drift found during final v2.39.0 validation.

## [2.38.0] - 2026-04-22

### Added

- **Strict Delegation Contract** for `/rpi`, `/discovery`, and `/validation` — top-level orchestrator skills now declare strict sub-skill delegation as the default. Each skill points to the new canonical reference `skills/shared/references/strict-delegation-contract.md` which documents the contract, anti-pattern rationalizations, and supported compression escapes (`--quick`, `--fast-path`, `--no-retro`, `--no-forge`, `--skip-brainstorm`, `--no-scaffold`, `--no-behavioral`, `--allow-critical-deps`). There is no `--full` flag — strict delegation is always on.
- **Orchestrator Compression Anti-Pattern learning** at `docs/learnings/orchestrator-compression-anti-pattern.md`, surfaced through the orchestrator skill contracts. Includes detection phrases, corrective actions, and rationalizations to reject.
- **Orchestrator-owned step markers** in `skills/crank/SKILL.md` (STEP 3a.3, STEP 6.5 slop-scan, STEP 8.7) plus an "Inline Work Policy" footer documenting which steps are intentionally inline vs delegated.
- **MkDocs Material documentation site** — Pages site rebuilt on MkDocs Material (slate dark palette). Skill catalog and CLI reference are generated at build from `skills/*/SKILL.md` and `cli/docs/`. `mkdocs build --strict` wired into the pre-push gate (Check 25a). New dedicated pages for hooks, schemas, and upgrading, plus an expanded glossary. Theme tuned to the agentops-showcase terracotta-on-near-black palette; landing page leads with the primary use case and a headline skills table; flywheel diagram ASCII art realigned; doctrine back-links added to `12factoragentops.com`.
- **Shell completion for enumerated-value flags** — `ao <cmd> --<flag> <TAB>` now suggests the valid values instead of falling back to file completion. Covers `ao --output` (`json`/`table`/`yaml`), `ao seed --template`, `ao goals init --template`, `ao inject --format` and `--session-type`.
- **`ao doctor` stale-reference scan** now covers `skills-codex/*/SKILL.md` and `skills/*/references/*.md` in addition to the primary skill docs, catching drift in Codex mirrors and skill reference content.
- **Nightly close-loop throughput alarm** — the dream close-loop gate now fails loudly when `ingested > 0 && promoted == 0`, replacing the silent zero-throughput mode that previously masked citation-gate deadlocks.

### Removed

- Archived AO↔Olympus bridge integration: removed `docs/ol-bridge-contracts.md`, `docs/architecture/ao-olympus-ownership-matrix.md`, MemRL policy contracts, `skills/*/scripts/ol-*.sh`, `cli/cmd/ao/inject_ol_test.go`, and associated CLI types (`OLConstraint`, `gatherOLConstraints`, `.ol/` directory collector). Olympus predecessor's useful patterns live on inside `ao`.
- Lowercase `docs/index.md` duplicate removed after the MkDocs migration canonicalized the landing page.

### Changed

- **`--no-lifecycle` in `/discovery` renamed to `--no-scaffold`** for semantic clarity — the flag controls STEP 4.5 scaffold auto-invocation only, not broader lifecycle checks. `--no-lifecycle` is honored as a deprecated alias through v2.40.0; when both flags are passed, they are equivalent. Other skills (`/crank`, `/validation`, `/implement`, `/evolve`) retain `--no-lifecycle` with its existing lifecycle-skill-invocation semantics.
- **`/discovery` flags table** expanded: `--auto` is now explicitly documented (was transitively honored but undocumented); `--interactive` scope clarified ("research + plan gates, not pre-mortem").
- **`/validation` flags table** expanded: `--complexity=<level>` syntax formalized to match `/rpi` and `/discovery`; `--interactive` scope documented.
- **`/rpi` `--interactive` flag** scope note added: applies to discovery (research + plan) and validation (Gate 1, Gate 2); does NOT override pre-mortem or vibe council autonomy.
- **ASCII fast-path performance sweep** across rune-aware truncation call sites in `cli/` (`TruncateText`, `TruncateRunes`, `truncateForError`, plus goals/pool/search/rpi/parser call sites) — ASCII inputs now skip the full UTF-8 rune scan.
- **Compile and overnight internals refactored** — `runCompile` split into phase + preflight helpers; article scan, inbound count, and prune extracted from `repair`; dream packet corroboration split per source epic; dream yield emptiness guard extracted into a dedicated helper. No behavior change; lower cyclomatic complexity and tighter test surfaces.
- **Skills-codex DAG bodies converted to `$skill` notation** for the Codex runtime.
- **GitHub Actions bumped** — `actions/upload-pages-artifact 3→4`, `actions/deploy-pages 4→5`, `actions/configure-pages 5→6`, plus docs.yml workflow action versions aligned.
- **Precommit hook prefers local Go** when available.
- **Skills backfill pass** — docs, validators, and lint synced across all skills; Codex drift surface reset to no-op.

### Fixed

- **Orchestrator compression vulnerability** — a live compression was observed 2026-04-19 where `/rpi` was invoked but phases were inlined instead of delegated. This release **documents** the anti-pattern (forged learning + loud skill text), **scaffolds** future enforcement (shared contract reference used by all 6 orchestrator skills), and explicitly **defers** runtime hook enforcement to a follow-up initiative. It does not mechanically prevent compression yet — the durable fix depends on `ao inject` surfacing the forged learning on future session starts. See `.agents/research/2026-04-19-rpi-skill-dag-audit.md` for the audit and `.agents/plans/2026-04-19-rpi-dag-hardening.md` for the remediation plan.
- **Close-loop promotion deadlock** — `flywheel` close-loop auto-promotion and the loop-dominance signal are unblocked; citation-gate cycles no longer silently zero throughput.
- **Overnight findings router** now emits schema-compliant `next-work` v1.3 enums — valid `claim_status=available` (was `pending`), severity collapsed to `high` for `critical` and `blocker` inputs — with a build-time guard that fails on future drift.
- **Quality stale-refs scan** skips rename-doc lines so it no longer false-positives on deliberate rename notes.
- **Release and compile gates** — `go-complexity-ceiling` self-heals a missing `gocyclo`; `compile-*` gates fall back to Dream defrag preview when the primary path is unavailable.
- **Proof-run Phase 2** calls `pool ingest` before `close-loop` so the downstream stage has input to consume.
- **Hooks** — `git-worker-guard` narrowed to avoid false blocks on selective flags; test-hook harness tolerates environments without a locally built `ao`.
- **Scripts** — `goal-staleness`, `pillar-coverage`, `goal-quality`, and `bootstrap-maturity` now skip cleanly after the `GOALS.yaml → GOALS.md` migration and preserve existing JSONL maturity with compact output.
- **CI** — resolved 7 failures from the MkDocs rebuild, committed the forged-learning artifacts, and regenerated the codex shared hash.
- **Docs markdownlint** — unresolved `+ 9 findings).` continuation in the cross-disk harvest plan now reads as prose instead of tripping MD004.

## [2.37.2] - 2026-04-15

### Added

- **Swarm evidence validation** — AgentOps now ships a swarm-evidence schema and validator, and wires that proof surface into validation and release gates.
- **Lead-only worker git guard** — worker sessions now have an explicit lead-only git guard in the hook chain, reducing accidental write authority in multi-agent runs.
- **Compile and harvest operator controls** — `ao compile` adds runtime preference plus `--reset` and `--repair` controls, while harvest now reports excluded low-confidence candidates and top near-misses.

### Changed

- **Release and pre-push validation** — local release, pre-push, and command coverage gates now validate more of the hook, evidence, and Codex runtime surface before publish.
- **Codex/runtime artifacts and docs** — compile, evolve, post-mortem, swarm, and related runtime docs and artifacts were decomposed and synchronized to better match shipped behavior.
- **Flywheel backlog bookkeeping** — next-work aggregates, consumed markers, and enum normalization were cleaned up so carry-forward work is recorded consistently.

### Fixed

- **Pre-mortem gate ambiguity** — the crank pre-mortem gate now denies ambiguous state by default instead of failing open.
- **CLI and shell reliability edges** — `ao rpi serve --run-id` now accepts legacy 8-hex IDs, `ao mine --dry-run` emits a single clean JSON payload, and bash invocations are sanitized to bypass unsafe shell aliases.
- **Compile, harvest, and release drift** — compile repair defaults, malformed frontmatter salvage, YAML parse error surfacing, CI fixture drift, shellcheck drift, and Codex artifact metadata drift were corrected.

## [2.37.1] - 2026-04-15

### Added

- **Dream morning packets** — Dream can now emit ranked morning work packets with evidence, target files, exact follow-up commands, and queue/bead handoff metadata.
- **Dream yield telemetry and long-haul corroboration** — overnight reports now record packet-confidence telemetry and can trigger a bounded long-haul corroboration pass when the first pass produces weak morning output.

### Changed

- **Dream decision flow** — overnight runs now prefer cheaper evidence corroboration before slower council fan-out, so strong runs stay short and extended runtime is reserved for genuinely weak output.

### Fixed

- **Headless Claude Dream council** — Dream now uses Claude's working JSON output contract for headless council runs and normalizes the returned envelope before validation.
- **Dream close-loop and report surfaces** — overnight runs now write real close-loop callbacks and post-loop report artifacts instead of leaving placeholder `pending` steps.
- **Retrieval ratchet release gate fallback** — the retrieval-quality release check now falls back to checked-in eval data when a local manifest is absent.

## [2.37.0] - 2026-04-14

### Added

- **Windows install and smoke coverage** — `scripts/install-ao.ps1` adds a first-class Windows install path, and the blocking `windows-smoke` gate exercises PowerShell install, local `ao doctor`, and Windows-sensitive Go packages.
- **Compile command** — `ao compile` makes knowledge compilation a first-class CLI surface with docs and tests.
- **Local LLM forge pipeline** — `ao forge` can now redact, summarize, structurally review, and queue transcript-derived wiki pages with Dream worker integration.
- **Dream curator and evolve sub-cycle** — Dream gained a local curator adapter plus `ao evolve --dream-first|--dream-only`, allowing overnight knowledge passes to feed the daytime improvement loop.
- **`.agents` wiki surfaces** — INDEX, LOG, wiki directories, and search integration formalize `.agents/` as a Karpathy-style knowledge wiki with index-first navigation.
- **Operational quality surfaces** — beads audit/cluster commands, swarm preflight advice, status quality signals, retrieval eval queries, and a retrieval-quality CI ratchet broaden release-time proof.

### Changed

- **Knowledge scoring and search behavior** — inject now deduplicates by content hash, boosts indexed pages, weights stability, and search can pull Dream vault and wiki sources with stronger local recall.
- **Overnight and RPI internals** — overnight, lifecycle, search, inject, harvest, and RPI flows were decomposed into smaller helpers while tightening proof paths, mixed-mode provenance, and worktree cleanup.
- **Public framing and contributor docs** — README, philosophy, planning/post-mortem docs, and reference surfaces now better match the context-compiler and operational-layer story.

### Fixed

- **Windows overnight liveness** — Windows process checks no longer rely on Unix `signal(0)` semantics.
- **Dream RunLoop status invariants** — live-tree hash coverage now exercises every terminal RunLoop status, and `degraded` reflects the current rollback semantics.
- **Release retag safety** — release tooling now preserves annotated tags, validates audit artifact manifests and refs, and cancels stale reruns before duplicate publish attempts.
- **Post-mortem and closure audits** — metadata links, evidence-only closure packets, parser-path handling, and closure packet evidence modes were normalized.
- **Codex and runtime reliability** — same-thread lifecycle restart, root-scoped fallback reads, JSON config writes, bridge contract validation, and next-work proof-path handling were hardened.

## [2.36.0] - 2026-04-11

### Added

- **Evolve operator command** — `ao evolve` now exposes the v2 autonomous improvement loop directly in the CLI, including `--max-cycles`, `--queue`, `--beads-only`, `--quality`, `--compile`, and strict-quality passthrough flags.
- **Autodev program contract** — root `PROGRAM.md` gives evolve/autodev a repo-local operating contract with mutable and immutable scope, validation commands, escalation policy, and stop conditions.
- **Beads stale-scope tooling** — `ao beads verify|lint|harvest` adds first-class stale-citation checks for bead-driven planning and RPI recovery.
- **RPI discovery artifacts** — RPI can now persist and consume discovery artifacts, with tests and docs covering the `--discovery-artifact` path.
- **Dream RunLoop invariant coverage** — `TestRunLoop_LiveTreeHashInvariant_AllStatuses` locks the `IsCorpusCompounded()` and live-tree mutation invariant across deterministically reproducible terminal statuses.
- **Dream failed-summary contract coverage** — regression tests now lock the `finalizeOvernightSummary` contract for MEASURE consecutive-failure halts and persisted iteration history.
- **Dream operator mode** — `ao overnight start|run|report|setup` adds a private overnight lane with shared `dream.*` config, keep-awake defaults, scheduler/bootstrap guidance, council-ready runner packets, and DreamScape-style morning summaries
- **Nightly live retrieval proof** — the dream-cycle now runs `ao eval bench --live --json`, emits retrieval proof in nightly summaries, and keeps a visible artifact trail for flywheel health
- **Pattern-to-skill drafts** — repeated patterns can now generate review-only skill drafts under `.agents/skill-drafts/` during flywheel close-loop
- **Fresh-repo onboarding welcome** — new session-start routing helps first-time repos enter discovery, implementation, or validation without needing the full RPI lane first
- **Docs-site and contribution proof surfaces** — GitHub Pages navigation, comparison pages, behavioral-discipline guidance, strategic-doc validation patterns, and a first-skill guide expand the public proof surface

### Changed

- **RPI wave recovery integrated** — recovered RPI wave work landed across Dream, council, stale-scope planning, discovery artifacts, CI hardening, and Codex runtime surfaces.
- **Council `--mixed` strict contract documented** — `skills/council/references/cli-spawning.md` documents that `/council --mixed` requires Codex CLI and emits a hard error instead of silently falling back to Claude-only.
- **Plan and pre-mortem skill bodies decomposed** — focused reference files now carry the detailed pre-decomposition, scope-mode, mandatory-check, output, wave-matrix, and task-creation guidance while keeping the top-level skills within lint budgets.
- **Bead-input pre-flight wired into planning skills** — `/plan` and `/pre-mortem` invoke `ao beads verify <bead-id>` for full-complexity, aged, or prior-session bead inputs before decomposition or validation.
- **Operational-layer framing** — README, onboarding, docs, comparisons, and linked surfaces now consistently explain AgentOps as bookkeeping, validation, primitives, and flows for coding agents
- **Dream runtime positioning** — the public GitHub nightly is now documented as a proof harness, while `ao overnight` is documented as the private local compounding engine
- **Codex default path** — native hooks, install copy, runtime smoke coverage, and checked-in Codex artifacts are aligned around the native-plugin path on supported Codex versions
- **Validation guidance** — behavioral-discipline and strategic-doc review are now first-class references alongside code review and runtime validation

### Fixed

- **Windows Codex installer** — Codex installation now has a Windows path instead of assuming Unix shell behavior.
- **golangci-lint v2 contract** — the local lint wrapper and CI configuration now pin the v2 behavior expected by the repository.
- **security-toolchain-gate CI** — deterministic fixture generation in `cli/internal/overnight/fixture/gen_fixture.go` is annotated as a non-cryptographic seeded-random use, avoiding a false-positive semgrep blocker.
- **Recovered RPI validation blockers** — validation drift from the recovered RPI wave was cleared before retagging the release.
- **Stale-scope reference placement** — shared stale-scope validation guidance now lives under `skills/shared/references/` so `heal.sh --strict` can resolve it consistently.
- **Release and CI drift** — resolved docs-site Liquid/frontmatter issues, headless runtime smoke portability problems, pre-push shim test drift, and compile-skill headless command drift caught during release prep
- **Codex install and artifact drift** — fixed stale slash-command references, refreshed checked-in artifact metadata, added a Codex compile wrapper, and corrected plugin/marketplace mismatches exercised by smoke coverage
- **Runtime proof stability** — promoted Codex runtime smoke into the blocking smoke path and fixed related shellcheck and install-surface rough edges

### Removed

- **DevOps-rooted tagline** — public framing no longer leads with the old DevOps-layer tagline; the Three Ways lineage remains supporting doctrine instead of the category label

## [2.35.0] - 2026-04-07

### Added

- **Codex native hooks** — AgentOps hooks now install natively into Codex CLI v0.115.0+ via `~/.codex/hooks.json`; 8 hooks wired (session-start, inject, flywheel-close, prompt-nudge, quality-signals, go-test-precommit, commit-review, ratchet-advance); installer enables the `hooks` feature flag, migrates deprecated `codex_hooks` configs, and upgrades from hookless fallback to native hook runtime
- **Knowledge compiler skill** — renamed athena → `/compile` with Karpathy-style incremental compilation, pluggable LLM backend (`AGENTOPS_COMPILE_RUNTIME=ollama|claude`), interlinked markdown wiki output at `.agents/compiled/`
- **App struct dependency injection** — `App` struct carries `ExecCommand`, `LookPath`, `RandReader`, `Stdout`, `Stderr` seams; gc bridge, events, executor, context relevance, tracker health, and stream modules accept injected dependencies instead of mutable package-level vars
- **Test shuffle in CI** — `-shuffle=on` added to `validate.yml` and `Makefile` test targets, exposing and fixing 6 ordering-dependent tests (cobra flag leaks, maturity var leaks, env var leaks)

### Changed

- **CLI internal extraction (waves 5-13)** — business logic extracted from `cmd/ao` monolith into 15 `internal/` domain packages (`rpi`, `search`, `context`, `quality`, `goals`, `lifecycle`, `bridge`, `forge`, `mine`, `plans`, `knowledge`, `storage`, `pool`, `taxonomy`, `worker`) using Options struct pattern for dependency injection
- **Goals test migration** — 7 goals test files moved from `cmd/ao` to `internal/goals` as external test package (`goals_test`) with `t.Parallel()` and direct `goals.Run*()` calls replacing cobra command wiring
- **Test isolation** — `resetCommandState` now saves/restores 10 maturity globals; `resetFlagChangesRecursive` resets flag values to defaults; RPILoop and toolchain tests clear `AGENTOPS_RPI_RUNTIME*` env vars via `t.Setenv`

### Fixed

- **Defrag test flag leak** — `TestDefragOutputDirFlag` used `cmd.Flags().Lookup("output")` which matched the root persistent `--output` flag; changed to `cmd.LocalFlags().Lookup("output")`
- **Goroutine leak false positive** — `TestRunGoals_GoroutineLeak` used `goleak.VerifyNone` which caught goroutines from parallel tests; switched to `goleak.IgnoreCurrent()` to only detect leaks within the test itself
- **Secret scan false positives** — excluded `.gc/` directory and `Getenv`/`os.Environ` patterns from secret pattern scan
- **Codex skill validation** — added `output_contract` as valid schema key, `cross-vendor`/`knowledge` as valid tiers, fixed `$/` prefix in codex forge/post-mortem/scenario skills
- **Scenario CLI snippets** — replaced non-existent `--source`/`--scope` flags with valid `--status` variants

### Removed

- **Coverage percentage CI gates** — removed `coverage-ratchet` job, `check-cmdao-coverage-floor.sh`, `.coverage-baseline.json`, and associated BATS tests; percentage gates blocked CI during architectural refactors without catching bugs
- **`fire.go`** — FIRE loop (find-ignite-reap-escalate) superseded by gc sling + bead dispatch; `formatAge` helper moved to `inject_predecessor.go`
- **`rpi_workers.go`** — per-worker health display superseded by gc agent health patrol; `ao rpi workers` subcommand removed from CLI and docs

## [2.34.0] - 2026-04-05

### Added

- **Stage 4 Behavioral Validation** — new validation tier between council/vibe and production:
  - Holdout scenarios stored in `.agents/holdout/` with PreToolUse isolation hook preventing implementing agents from seeing evaluation criteria
  - Satisfaction scoring (0.0-1.0 probabilistic) in verdict schema v4, replacing boolean-only PASS/FAIL
  - Agent-built behavioral specs generated during `/implement` Step 5c
  - `/scenario` skill for authoring and managing holdout scenarios
  - `ao eval scenario init|list|validate` CLI commands (4 subcommands, 11 tests)
  - STEP 1.8 in `/validation` pipeline evaluating holdout scenarios + agent specs
  - `schemas/scenario.v1.schema.json` defining the holdout scenario format
- **Flywheel gate command** — `ao flywheel gate` checks readiness for retrieval-expansion work (research closure, rho threshold, holdout precision@K)
- **Citation confidence scoring** — `citationEventIsHighConfidence` with bucketed confidence (0/0.5/0.7/0.9) gates MemRL rewards on match quality
- **Retrieval bench refactor** — train/holdout splits, section-aware scoring (`scoreBenchSections`), manifest-based benchmark cases
- **Proof-backed next-work visibility** — `classifyNextWorkCompletionProof` unifies completed-run, execution-packet, and evidence-only-closure proof types; context explain and stigmergic packet now report proof-backed suppressions
- **Three-gap contract proof gates** — lifecycle gap mapping gates added to GOALS.md
- **Cross-vendor execution** — `--mixed` flag for Claude + Codex council judges
- **Gas City bridge** — gc as default executor for RPI phase execution with L1-L3 tests
- **149 L2 integration tests** — AI-native test shape ("L2 first, L1 always") validated at scale; coverage floor raised 78.8% → 81.0%
- **Test coverage hardening** — GPG commit-signing fixes, root-skip guards for containerized CI, 350+ lines of vibecheck detector/metrics tests, maturity.go empty-content bugfix

### Changed

- **Codex parity hook** — `codex-parity-warn.sh` now supports opt-in blocking mode via `AGENTOPS_CODEX_PARITY_BLOCK=1` (exit 2 instead of advisory)
- **12-factor doctrine** — compressed from 474 to 114 lines, reframed as supporting lens rather than product definition
- **Skill count** — 65 → 66 (added `/scenario`)
- **Research skill** — now persists reusable findings to `.agents/findings/registry.jsonl` with finding-compiler refresh
- **Closure integrity audit** — accepts durable closure packets without scoped-file sections as valid evidence
- **Proof-backed legacy entries** — `shouldSkipLegacyFailedEntry` uses `CompletionEvidence` field (proof-only, no heuristic fallback)
- **`readQueueEntries`** — returns all non-consumed entries; proof filtering is downstream via `shouldSkipLegacyFailedEntry`

### Fixed

- **6 CI failure categories** resolved in one commit (f1b83b25)
- **Cobra test registration** — `scenario` and `flywheel gate` added to expectedCmds
- **Citation feedback test** — assertion corrected for recorded confidence preference (0.5 not 0.7)
- **RPI hardening** — UAT version pre-flight, goals history filter, proof-backed suppression, fail-closed gates, cross-epic handoff contamination, bare ag- prefix guard
- **Branch consolidation** — 10 stale Codex branches analyzed, cherry-picked (9 commits, ~3,500 lines), and deleted; 25 orphaned worktrees pruned
- **git rerere enabled** — conflict resolution memory for future merges

## [2.33.0] - 2026-04-02

### Added

- **Backlog hygiene gates** — added `bd-audit.sh`, `bd-cluster.sh`, and Crank/Codex guidance for cleaning stale or mergeable beads before execution
- **Retrieval benchmarking and global scope** — added `ao eval bench`, benchmark corpora, `--live`, `--global`, and nightly IR regression coverage
- **`/red-team` adversarial validation** — added a persona-based validation skill plus checked-in Codex runtime artifacts
- **Software factory operator lane** — added a CLI/operator surface and Claude factory startup routing for software-factory workflows
- **Flywheel maintenance utilities** — added global garbage purge tooling and nightly retrieval benchmarking for knowledge quality tracking

### Changed

- **Release policy** — removed the enforced release cadence gate so releases no longer block on a minimum wait between tags
- **Knowledge operator surfaces** — plan and validation now wire knowledge operator surfaces directly into execution flow
- **Proof and runtime docs** — goals, RPI docs, and contributor guidance now reflect the expanded proof surfaces and hookless runtime behavior

### Fixed

- **Codex artifact parity** — restored checked-in Codex parity for red-team and cleaned Codex runtime metadata/frontmatter drift across crank, forge, post-mortem, release, and swarm artifacts
- **Retrieval quality** — replaced exact-substring filtering with token-level matching and tuned penalty, deduplication, and OR-fallback behavior
- **Harvest metadata preservation** — promotion now preserves source metadata and fills missing maturity, utility, and type fields safely
- **Release tooling** — release artifact directories are created safely and audit artifacts now resolve against release tag names
- **Documentation and link drift** — repaired the post-mortem Codex link and aligned runtime docs around the newer startup and lifecycle flows

## [2.32.0] - 2026-04-01

### Added

- **Knowledge activation skill** — new `/knowledge-activation` skill and CLI surfaces for activating cross-domain knowledge at runtime, with operator surface consumption and ranked intelligence context
- **Session intelligence engine** — complete runtime engine with explainability, ranked context assembly, and trust policy enforcement
- **Runtime selection for `ao rpi serve`** — serve now supports explicit runtime selection for Claude and Codex execution modes
- **Quality signals hook** — new `quality-signals.sh` hook with test coverage for session quality telemetry
- **Pre-push gate expansion** — 9 checks migrated from CI-only to the local pre-push gate for faster feedback
- **Inject stability warnings and status dashboard** — closed 3 harvest items with signal tests and dashboard improvements

### Changed

- **README refresh** — product-minded rewrite with gain-framing and Strunk-style prose fixes
- **Philosophy doc** — new `docs/philosophy.md` and observations section added to README
- **Documentation alignment** — repo front doors and codex artifact guidance unified across entry points
- **Claude Code architecture lessons** — retry budgets, stability flags, quality signals, and orchestration patterns applied to skills
- **Homebrew formula** — updated to v2.31.0 with pre-built binaries

### Fixed

- **Post-mortem closure integrity** — normalized file parsing for closure integrity audits
- **CI reliability** — resolved CI failures across codex refs, test pairing, hook coverage, worktree handling, docs parity, hook portability, and codex lifecycle
- **Lookup nested scanning** — `ao lookup` now scans nested global knowledge directories correctly
- **Pre-push test stubs** — added test stubs for new pre-push checks, skip non-shell in shellcheck

### Dependencies

- Bumped `codecov/codecov-action` from 5 to 6
- Bumped `DavidAnson/markdownlint-cli2-action` from 22 to 23

## [2.31.0] - 2026-03-30

### Added

- **9 lifecycle skills** — bootstrap, deps, design, harvest, perf, refactor, review, scaffold, and test skills wired into RPI with auto-invocation and mechanical gates
- **`ao harvest`** — cross-rig knowledge consolidation extracts and catalogs learnings from sibling crew workspaces
- **`ao context packet`** — inspect stigmergic context packets for debugging inter-session handoff state
- **Hook runtime contract** — formal Claude/Codex/manual event mapping with runtime-aware hook tooling
- **Evidence-driven skill enrichment** — production meta-knowledge, anti-patterns, flywheel metrics, and normalization defect detection baked into 9 skill reference files
- **Research provenance** — pending learnings now carry full research provenance for discoverability and citation tracking
- **Context declarations** — inject, provenance, and rpi skills declare their context requirements explicitly
- **Goals and product output templates** — `/goals` and `/product` produce evidence-backed structured output

### Changed

- **Three-gap context lifecycle contract** — README, PRODUCT.md, positioning docs, and operational guides reframed around the context lifecycle model
- **Dual-runtime hook documentation** — runtime modes table and troubleshooting updated for Claude + Codex hook coexistence

### Fixed

- **CI reliability** — resolved 4 pre-existing CI failures, restored headless runtime preflight, repaired codex parity drift checks
- **`ao lookup` retrieval** — fixed retrieval gaps that caused lookup to return no results
- **Embedded sync** — using-agentops SKILL.md and `.agents/.gitignore` now written correctly on first session start
- **Closure integrity** — 24h grace window for close-before-commit evidence, normalized file parsing
- **Skill lint compliance** — vibe, post-mortem, crank, and plan skills trimmed or restructured to stay under 800-line limit
- **Codex tool naming** — added CLAUDE_TOOL_NAMING rule and fixed 5 Claude-era tool references in codex skills
- **ASCII diagram consistency** — aligned box-drawing characters across 23 documentation files
- **Fork exhaustion prevention** — replaced jq with awk in validate-go-fast to prevent fork bombs on large repos

## [2.30.0] - 2026-03-24

### Added

- **Codex hookless lifecycle support** — `ao codex` runtime commands, lifecycle fallback, and Codex skill orchestration now cover hookless sessions end to end
- **PROGRAM.md autodev contract** — Added a first-class `PROGRAM.md` contract for autodev flows and taught `/evolve` and related RPI paths to use it
- **Long-running RPI artifact visibility** — Mission control now exposes run artifacts and evaluator output so long-running RPI sessions are replayable and easier to inspect

### Changed

- **Codex runtime maintenance flow** — Refreshed Codex bundle hashes, lifecycle guards, runtime docs, and release validation coverage around the expanded Codex execution path

### Fixed

- **Codex RPI scoping and closeout** — Tightened objective scope, epic scope, closeout ownership, and validation gaps in the Codex RPI lifecycle
- **Release gate reliability** — Restored headless runtime coverage, runtime-aware Claude inventory checks, and release-gate coherence validation
- **Reverse-engineer repo hygiene** — Repo-mode reverse engineer now ignores generated and temp trees when identifying CLI and module surfaces

## [2.29.0] - 2026-03-22

### Added

- **Model cost tiers and config writes** — `ao config` can now assign per-agent models by cost tier and persist repo configuration changes directly
- **Search brokerage over session history and repo knowledge** — `ao search` now wraps upstream `cass` results with repo-local AgentOps artifacts by default
- **Reviewer and post-mortem reference packs** — Added model-routing, iterative-retrieval, confidence-scoring, write-time-quality, and conflict-recovery guidance across council, research, swarm, vibe, compile, and related skills

### Changed

- **Competitive comparison and CLI docs** — Refreshed comparison docs, release smoke coverage, and command documentation around the expanded search/config surface

### Fixed

- **Flywheel proof and citation loop** — Added deterministic proof fixtures, preserved exact research provenance, and made citation feedback artifact-specific so flywheel health reflects real closure state
- **Search alignment with forged session history** — Search now stays aligned with forged session artifacts and fallback behavior
- **Hook-launched validation** — Pre-push and release gates now isolate inherited git env/stdin correctly and cover newer hook scripts in integration tests
- **Codex council profile parity** — Source and checked-in Codex council docs are back in sync for the shared profile contract

## [2.28.0] - 2026-03-21

### Added

- **Node repair operator** — Crank now classifies task failures as RETRY (transient), DECOMPOSE (too complex), or PRUNE (blocked) with budget-controlled recovery
- **Knowledge refresh auto-trigger** — Lightweight compile defrag runs automatically at session end via new SessionEnd hook
- **Configurable review agents** — Project-level `.agents/reviewer-config.md` controls which judge perspectives council and vibe spawn
- **Three-tier plan detail scaling** — Plan auto-selects Minimal, Standard, or Deep templates based on issue count and complexity
- **Adversarial ideation** — Brainstorm Phase 3b stress-tests each approach with four red-team questions before user selection

### Fixed

- **Crank SKILL.md line limit** — Consolidated duplicate References sections to stay under 800-line skill lint limit
- **Codex skill parity** — Synced all five competitive features to skills-codex with reference file copies

## [2.27.1] - 2026-03-20

### Fixed

- **Flywheel golden signals always shown** — Golden signals were gated behind `--golden` flag, causing `ao flywheel status` to report "COMPOUNDING" while the hidden golden signals analysis showed "accumulating". Golden signals now compute and display by default.

## [2.27.0] - 2026-03-20

### Added

- **Flywheel golden signals** — Four derived health indicators (velocity trend, citation pipeline, research closure, reuse concentration) that distinguish knowledge compounding from noise accumulation; accessible via `ao flywheel status --golden`
- **Forge-to-pool bridge** — Forge auto-writes pending learnings as markdown to `.agents/knowledge/pending/` for close-loop pool ingestion
- **SessionStart citation priming** — `ao lookup` wired into SessionStart hook to close the citation gap between inject and session context
- **Skill catalog quality** — Improved descriptions, extraction patterns, and reference linking across skill catalog

### Fixed

- **`.agents/.gitignore` scope** — Replaced broad `!*/` pattern with explicit subdirectory list to prevent accidental tracking
- **Codex runtime skill parity** — Hardened Codex runtime skill discovery and validation
- **Codex install smoke tests** — Fixed test assertions for install path edge cases

### Changed

- **CLI reference docs** — Regenerated with updated date stamps

## [2.26.1] - 2026-03-16

### Fixed

- **RPI stops after Phase 2** — Restructured rpi, discovery, and validation orchestrator skills as compact DAGs with execution sequence in a single code block; eliminates LLM stopping between phases due to `###` section headings acting as natural breakpoints
- **Test grep patterns for DAG headings** — Updated `test-tuning-defaults.sh` to match new complexity-scaled gate headings after DAG restructure

### Changed

- **Goals reimagined** — GOALS.md rebuilt from first principles with fitness gate fixes
- **README progressive disclosure** — Lead with moats, collapse detail into expandable sections
- **CLI reference docs** — Regenerated with updated date stamps
- **Doctor + findings helpers** — Added CLI test coverage for extracted helpers

## [2.26.0] - 2026-03-15

### Added

- **BF6–BF9 test pyramid levels** — Regression (bug-specific replay), Performance/Benchmark, Backward Compatibility, and Security (in-test) bug-finding levels with language-specific patterns for Go and Python
- **Test pyramid decision tree expansion** — 4 new routing questions for BF6–BF9 in the "When to Use" guide
- **RPI phase mapping for BF6–BF9** — Bug fix → BF6 mandatory, hot-path → BF7 benchmark, format change → BF8 compat fixture, secrets → BF9 redaction tests
- **`regen-codex-hashes.sh`** — Manifest hash regeneration script for Codex skill maintenance

### Changed

- **Go standards** — Added benchmark tests (BF7), backward compat with `testdata/compat/` (BF8), regression test naming convention (BF6), security tests for path traversal (BF9)
- **Python standards** — Added Hypothesis property-based testing (BF1), `pytest-benchmark` patterns (BF7), backward compat with parametrized fixtures (BF8), regression test naming (BF6), secrets redaction tests (BF9)
- **Coverage assessment template** — Extended BF pyramid table from BF1–BF5 to BF1–BF9

### Fixed

- **Codex skill audit** — 60+ findings fixed across all 54 Codex skills; removed orphaned `claude-code-latest-features.md` and `claude-cli-verified-commands.md` references
- **Skill lint warnings** — Resolved all warnings in crank, rpi, recover skills
- **README skill references** — Corrected broken references and linked orphaned templates
- **Skill linter refs** — Fixed directory reference and backtick formatting in reverse-engineer-rpi
- **CHANGELOG sync hook** — Replaced broken awk extraction with sed; awk failed on em-dash UTF-8 content producing header-only syncs
- **Plugin version parity** — Added pre-commit check that warns when `.claude-plugin/` manifest versions don't match the release version

## [2.25.1] - 2026-03-15

### Fixed

- **Codex BF pyramid parity** — Synced BF1/BF2/BF4 bug-finding level selection into skills-codex implement, post-mortem, and validation skills
- **Codex Claude backend cross-contamination** — Removed orphaned `backend-claude-teams.md` files (Claude primitives: TeamCreate, SendMessage) from 4 Codex skills (council, research, shared, swarm)
- **Dead converter rule** — Removed stale sed substitution for `backend-claude-teams.md` rename in converter script
- **Swarm reference integrity** — Added Reference Documents section to swarm SKILL.md; updated validate.sh to check only Codex-native backend references

## [2.25.0] - 2026-03-14

### Added

- **L0–L7 test pyramid standard** — Shared reference doc (`standards/references/test-pyramid.md`) defining 8 test levels, agent autonomy boundaries (L0–L3 autonomous, L4+ human-guided), and RPI phase mapping
- **Test pyramid integration across RPI lifecycle** — Discovery identifies test levels, plan classifies tests by level, pre-mortem validates coverage, implement selects TDD level, crank carries `test_levels` metadata, validation audits coverage, post-mortem reports gaps
- **RPI autonomous execution enforcement** — Three-Phase Rule mandates discovery → implementation → validation without human interruption; anti-patterns table documents 7 failure modes
- **Evolve autonomous execution enforcement** — Each cycle runs a complete 3-phase `/rpi --auto`; anti-patterns table documents 6 failure modes; large work decomposed into sub-RPI cycles
- **Codex skill standard** — New `standards/references/codex-skill.md` with tool mapping, prohibited primitives, two-phase validation, DAG-first traversal, and prompt constraint boundaries
- **Codex-native overrides** — Durable overrides for crank, swarm, council that survive regeneration
- **DAG-based Codex smoke test** — `scripts/smoke-test-codex-skills.sh` validates 54 skills with dependency-ordered traversal
- **Codex skill API contract** — `docs/contracts/codex-skill-api.md` with conformance validator
- **Output contract declarations** — `output_contract` field on council, vibe, pre-mortem, research skills with canonical finding-item schema

### Changed

- **Codex converter rewrite** — Strips Claude primitives instead of mapping to unavailable tools; rewrites reference files through `codex_rewrite_text`
- **CI pipeline** — Removed codex skill parity check (skills-codex/ now manually maintained); fixed shellcheck and embedded sync issues

### Fixed

- **Converter primitive stripping** — Task primitives (TaskCreate, TeamCreate, SendMessage) properly stripped instead of mapped to non-existent Codex equivalents
- **Embedded hook sync** — Added missing `test-pyramid.md` and `codex-skill.md` to CLI embedded references
- **ShellCheck SC1125** — Fixed em-dash in shellcheck disable directive in smoke test script
- **Skill line limits** — Moved verbose autonomy rules to reference files to stay under tier-specific line budgets

## [2.24.0] - 2026-03-12

### Added

- **Error & rescue map template** — Pre-mortem Step 2.5 with 3 worked examples (HTTP, database, LLM)
- **Scope mode selection** — Pre-mortem Step 1.6 with 3-mode framework (Expand/Hold/Reduce) and auto-detection
- **Temporal interrogation** — Pre-mortem Step 2.4 walks implementation timeline (hour 1/2/4/6+) for time-dependent risks
- **Prediction tracking** — Pre-mortem findings get unique IDs (`pm-YYYYMMDD-NNN`) correlated through vibe and post-mortem
- **Finding classification** — Vibe separates CRITICAL (blocks ship) from INFORMATIONAL findings
- **Suppression framework** — Vibe loads default + project-level suppression patterns for known false positives
- **Domain-specific checklists** — Standards skill extended with SQL safety, LLM trust boundary, and race condition checklists, auto-loaded by vibe
- **RPI session streak tracking** — Post-mortem Step 1.5 shows consecutive session days and verdict history
- **Persistent retro history** — Post-mortem Step 4.8 writes structured JSON summaries to `.agents/retro/` for cross-epic trend analysis
- **Prediction accuracy scoring** — Post-mortem Step 3.5 scores HIT/MISS/SURPRISE against pre-mortem predictions
- **Commit split advisor** — PR-prep Phase 4.5 suggests bisectable commit ordering (suggestion-only)
- **Council finding auto-extraction** — Significant findings from WARN/FAIL verdicts staged for flywheel consumption

### Changed

- **Post-mortem examples condensed** — Verbose examples replaced with concise 4-mode summary to stay under skill line limit

## [2.23.1] - 2026-03-12

### Fixed

- Resolved all golangci-lint quality findings
- Synced embedded standards after skill audit fixes
- Synced Codex bundle after skill audit fixes
- Resolved audit findings across council, vibe, standards skills

## [2.23.0] - 2026-03-11

### Added

- **Discovery and validation phase orchestrators** — New `/discovery` and
  `/validation` skills decompose the RPI lifecycle into independently
  invocable phases (research+plan+pre-mortem and vibe+post-mortem)
- **Stigmergic packet scorecard** — Ranked scoring for flywheel knowledge
  packets so higher-utility learnings surface first
- **Pinned work queue** — `/evolve` gains a pinned work queue with blocker
  auto-resolution for directed improvement loops
- **Per-package coverage ratchet** — Pre-push gate enforces per-package
  coverage baselines that only move upward
- **Fast pre-push mode** — `--fast` flag for diff-based conditional checks,
  skipping unchanged packages
- **Standards auto-loading** — Go and Python coding standards injected
  automatically into `/crank` and `/swarm` workers
- **271 test functions** — Four internal packages (`pool`, `ratchet`,
  `resolver`, `storage`) brought to 100% coverage

### Changed

- **README restructured** — Extracted reference material into dedicated docs,
  reducing README from 679 to 472 lines
- **RPI skill refactored** — `/rpi` now delegates to `/discovery` and
  `/validation` phase orchestrators instead of inlining all phases
- **Go and Python test conventions** — Canonical standards enriched with
  assertion quality rules, naming conventions, and table-driven test guidance
- **Documentation alignment** — Lifecycle, flywheel, primitive chain, and
  positioning docs updated to reflect current architecture

### Fixed

- **Goal runner deadlock** — Fixed goroutine deadlock in goal runner and added
  job timeouts to prevent stalls
- **17 CLI bugs from deep audit** — Addressed goroutine leaks, race
  conditions, panics, buffer overflows, and nil-check inconsistencies
- **Session close reliability** — Resolved pre-existing session_close issues
  surfaced by vibe council review
- **~50 zero-assertion tests** — Upgraded smoke tests from no-op to
  behavioral assertions across cmd/ao and internal packages
- **Test file hygiene** — Merged `_extra_test.go` and `cov*_test.go` files
  into canonical `<source>_test.go` names
- **CI stability** — FIFO test skip on Linux, embedded skill sync, coverage
  ceiling adjustments, crank SKILL.md trimmed below 800-line limit
- **Auto-extract quality gate** — Added quality gate to prevent low-fidelity
  auto-extracted learnings from entering the knowledge store

## [2.22.1] - 2026-03-10

### Added

- **Repo-native redteam harness** — Added a packaged redteam pack and prompt
  runner to `security-suite` for repeatable repository-local security
  exercises
- **Findings management commands** — Added CLI commands for listing and
  managing saved findings from the terminal

### Changed

- **Closed-loop prevention validation** — Completed the end-to-end finding
  compiler and prevention-ratchet validation path so saved findings feed back
  into earlier planning and task validation more reliably
- **Runtime contract parity** — Localized shared Claude runtime reference
  packs into the source skills and regenerated Codex artifacts so source and
  generated bundles stay aligned

### Fixed

- **Finding metadata injection** — Exposed finding metadata consistently in
  inject output and JSON integrations after the merged findings work landed
- **Release gate regressions** — Restored goals/package coverage, learning
  coherence, and hook-fixture isolation so the local release gate matches the
  shipped tree again

## [2.22.0] - 2026-03-09

### Added

- **Finding registry** — Council findings are saved to a persistent registry
  and automatically fed back into planning and validation, so the same class
  of bug is caught earlier next time
- **Repo execution profiles** — `.repo-execution-profile.json` lets skills
  and runtimes adapt to each repository's validation gates, startup reads,
  and done-criteria
- **Headless team backend** — Multi-agent workflows can run non-interactively
  (e.g. in CI) with structured JSON output and automated validation

### Changed

- **Codex and embedded artifacts** — Synced generated Codex bundles, embedded
  standards references, and install artifacts after merging branch work
- **Validation feedback capture** — Recorded validation-cycle feedback into
  `.agents` learnings so tracked patterns match the shipped tree

### Fixed

- **Lookup findings** — Fixed `ao lookup` and inject scoring so findings
  render, cite, and score correctly after the branch merge
- **23 CLI bug fixes** — Fixed goroutine leaks, race conditions, panics,
  buffer overflows, missing error handling, and nil-check inconsistencies
- **Post-mortem evidence hardening** — Staged changes and worktree evidence
  are now captured durably so proof isn't lost during compaction or cleanup

## [2.21.0] - 2026-03-09

### Added
- Codex-first skill rollout across the full catalog with override coverage, generated-artifact governance, and install/runtime parity validation
- Claim-aware next-work lifecycle handling with contract parity checks for `/rpi` and follow-on flows
- Headless runtime skill smoke coverage and Codex backbone prompt validation in the release gate stack

### Changed
- Codex maintenance guidance, override coverage docs, and CLI-to-skills mapping to match the generated runtime model
- Release-prep validation flows for runtime smoke, Codex artifact sync, and release note generation

### Fixed
- Next-work queue mutation races by making claim/update handling concurrency-safe and per-item
- Codex prompt parity drift by syncing generated prompts and tightening override coverage gates
- Worktree Git resolution and vibe-check runtime environment handling
- Push/pre-push validation regressions and nested pre-push wrappers
- Streamed phase timeout cancellation so phased runtime tests and release gating terminate promptly

## [2.20.1] - 2026-03-07

### Fixed
- Codex install workflow now uses `~/.agents/skills` as the single raw skill home and stops recreating an AgentOps mirror in `~/.codex/skills`
- Native Codex plugin refresh now archives overlapping legacy `~/.codex/skills` AgentOps folders instead of repopulating them
- Codex install docs now consistently describe the `~/.agents/skills` workflow and the need for a fresh Codex session after install
- Codex skill conversion now preserves multiline YAML `description` fields correctly, fixing malformed generated metadata for skills such as Compile
- `ao doctor` now treats plugin-cache plus `~/.agents/skills` as the supported Codex layout and reports manifest drift with accurate wording

## [2.20.0] - 2026-03-05

### Added
- Flywheel loop closure — `ao session close --auto-extract` produces lightweight learnings and auto-handoff at session boundary
- Handoff-to-learnings bridge — `ao session handoff` now extracts decisions into `.agents/learnings/` automatically
- Session-type scoring in `ao inject --session-type` — 30% boost for matching session context (career, debug, research, brainstorm)
- Identity artifact support — `ao inject --profile` surfaces `.agents/profile.md` in session context
- MEMORY.md auto-promotion in `ao flywheel close-loop` (Step 7) after maturity transitions
- Session-type detection in `ao forge` output metadata
- Production RPI orchestration engine — `ao rpi serve <goal>` with SSE streaming and auto mode
- Knowledge mining — `ao mine` and `ao defrag` commands for automated codebase intelligence
- Context declarations — `ao inject --for <skill>` reads skill frontmatter `context:` block for scoped retrieval
- Sections include allowlist and context artifact directories for skill-scoped injection
- `ao session handoff` command for structured session boundary isolation
- Behavioral guardrails — 3-layer hook defense-in-depth (intent-echo, research-loop-detector, task-validation-gate)
- Context enforcement hook and run-id namespaced artifact paths
- Headless invocation standards and RPI phase runner
- Nightly CI compile job for automated knowledge warmup
- Coverage ratchet gate with BATS integration tests for shell scripts
- Fuzz targets, property tests, and golden file contracts for CLI
- Git worker guard, embedded parity gate, and swarm evidence validation hooks
- Release cadence gate warns on releases within 7 days of previous

### Changed
- Coverage floor raised to 84% for `cmd/ao`, average floor to 95%
- Complexity ceiling tightened to 20 (from 25)
- Default session-start hook mode switched from manual to lean
- Hard quality gate on injection — maturity + utility filter
- Post-mortem redesigned as knowledge lifecycle processor
- RPI god-file split — 1,363 lines reduced to 203 with structured handoff schema
- Legacy RPI orchestrator retired — serve now uses phased engine (-1,121 lines)
- Council V2 findings synthesized into agent instructions and skill contracts
- 10k LOC of coverage-padding tests deleted; 72 stale tests quarantined
- Skill hardening — web security controls across 5 skills, CSRF protection, crank pre-flight
- Session-end hook wires `ao session close --auto-extract` before existing forge pipeline

### Fixed
- Flywheel signal chain — confidence decay, close-loop ordering, glob errors
- Path traversal in context enforcement hook and frontmatter parsing
- Race condition in handoff consumption at session boundary
- `ao mine` stabilized — dedup IDs, error propagation, `--since` window, empty output guard
- Hook test assertions aligned with warn-then-fail ratchet pattern (strict env required)
- Pre-mortem gate exit code corrected to 2 in strict mode (was 1)
- RPI serve event pipeline and coherence gate hardened
- jq injection via bare 8-hex run IDs in serve classifier
- Goals parser edge cases — paired backtick strip and rune-aware truncation
- UTF-8 truncation across six functions converted to rune-safe slicing
- CORS headers and stale doc references cleaned up
- Cross-wave worktree file collisions prevented
- hookEventName added to hookSpecificOutput JSON schema

## [2.19.3] - 2026-02-27

### Changed
- README highlights `ao search` (built on CASS) — indexes all chat sessions from every runtime unconditionally; adds Second Brain + Obsidian vault section with Smart Connections local/GPU embeddings and MCP semantic retrieval

## [2.19.2] - 2026-02-27

### Fixed
- CHANGELOG retrospectively updated to document all v2.19.1 post-tag commits (skills namespace fixes were shipped but not recorded)

## [2.19.1] - 2026-02-27

### Fixed
- Quickstart skill rewritten from 275 lines to 68 lines — removes 90-line ASCII diagram and 50-line intent router that caused 3+ minute runtime; now outputs ~8 lines and completes in under 30 seconds
- `truncateText` edge case: maxLen 1–3 now returns `"..."[:maxLen]` instead of the original string unchanged
- Dead anti-pattern promotion functions removed from `ao maturity` (`promoteAntiPatternsCmd`, `filterTransitionsByNewMaturity`, `displayAntiPatternCandidates`, ~99 LOC)
- Windows file-lock and signal support — replace no-op `filelock_windows.go` with real `LockFileEx`/`UnlockFileEx` via kernel32.dll; extract `syscall.Flock` and `syscall.Kill` into platform-specific helpers so the binary compiles on Windows without POSIX-only syscalls
- `heal.sh` Check 7 false positive — script reference integrity check now strips URLs before pattern matching, preventing remote `https://…/scripts/foo.sh` references from being validated as local files
- Security gate `BLOCKED_HIGH` — three persistent findings resolved: gosec G118 false positive (context cancel func returned to caller), golangci-lint nolint syntax (space in `// nolint:` directive), radon double-counting `reverse_engineer_rpi.py` from `skills-codex/` copy
- 71 stale `ao know *` and `ao quality *` namespace references replaced across 17 `skills-codex/` SKILL.md files — agents running rpi/evolve/crank were invoking non-existent commands from the pre-flatten CLI namespace
- Three HIGH-severity stale command references fixed across `skills/` and `skills-codex/`: `ao flywheel status` → `ao metrics flywheel status`, `ao settings notebook update` → `ao notebook update`, `ao start seed/init` → `ao seed`/`ao init`

### Added
- Spec-consistency gate (`scripts/spec-consistency-gate.sh`) validates contract files before crank spawns workers
- Command-surface parity gate (`scripts/check-cmdao-surface-parity.sh`) ensures all CLI leaf commands are tested
- `scripts/post-merge-check.sh` now validates `go mod tidy` sync and blocks on symlinks
- `scripts/merge-worktrees.sh` now propagates file deletions and preserves permissions
- Post-mortem preflight script checks reference file existence before council runs
- Hooks.json preflight validates script existence
- Windows binaries added to GoReleaser and SLSA attestation subject list

### Changed
- Coverage floor raised 78% → 80% with CI enforcement gate; Codecov threshold aligned to 75%
- Six truncation functions converted to rune-safe Unicode slicing
- `truncateID` in pool.go delegates to shared `truncateText`
- Crank skill invokes spec-consistency gate before spawning workers
- Vibe skill carries forward unconsumed high-severity next-work items as pre-flight context
- Release skill warns on unconsumed high-severity next-work items
- next-work JSONL schema formalized to v1.2
- Skills installation switched from `npx skills` to native curl installer (`bash <(curl -fsSL …/install.sh)`)
- README updated with 5-command summary, compound effect section, and `/vibe` breakdown

## [2.19.0] - 2026-02-27

### Added
- `ao mind` command for knowledge graph operations.
- New RPI operator surfaces: normalized C2/event plumbing plus `ao rpi stream`, `ao rpi workers`, and tmux worker nudge visibility.
- Codex install/bootstrap improvements, including native `~/.codex/skills` install and one-line installer flow.
- Windows binaries added to GoReleaser build outputs.

### Changed
- CLI namespace migration completed and aligned across hooks, docs, integration tests, and generated command references.
- Codex skill system moved to regenerated modular layout with codex-specific overrides and runtime prompt tailoring.
- CI/release gates hardened (codex runtime sections, release e2e validation, parity checks, stricter policy enforcement).
- High-complexity CLI paths refactored (`runRPIParallel`, `runDedup`, `parseGatesTable`) to lower cyclomatic complexity.

### Fixed
- Multiple post-mortem remediation waves landed for CLI/RPI/swarm reliability and edge-case handling.
- Hook delegation and integration behavior corrected for flat command namespace.
- `heal.sh` false-positive behavior reduced and doctor stale-path detection improved.
- Skill/doc parity and cross-reference drift issues corrected across codex and core skill catalogs.

### Removed
- Legacy inbox/mail command surface and stale/dead skill references from active catalogs.

## [2.18.2] - 2026-02-25

### Fixed
- `ao seed` now creates `.gitignore` and storage directories — reuses `setupGitProtection`, `ensureNestedAgentsGitignore`, and `initStorage` from `ao init`
- `ao seed` text updated from stale `ao inject`/`ao forge` to current MEMORY.md + session hooks paradigm
- MemRL feedback loop closed — `ao feedback-loop` command wired, `ao maturity --recalibrate` dry-run guard added
- Quickstart skill updated to reference `ao seed` and current flywheel docs
- CLI reference regenerated after `ao feedback-loop` and seed help text changes

### Changed
- `.agents/` session artifacts removed from git tracking
- PRODUCT.md updated — Olympus section removed, value props and skill tier counts corrected
- GOALS.md coverage directive updated to measured 78.8% (target 85%)

## [2.18.1] - 2026-02-25

### Changed
- SessionStart hook default mode changed from `manual` to `lean` — flywheel injection now fires every session
- Auto-prune enabled by default (`AGENTOPS_AUTO_PRUNE` defaults to `1`, opt-out via `=0`)
- Anti-pattern detection threshold lowered from `harmful_count >= 5` to `>= 3`
- Eviction confidence threshold relaxed from `< 0.2` to `< 0.3`
- Maturity promotion threshold in `--help` text synced with code (`0.7` → `0.55`)

### Fixed
- Empty learnings no longer inflate flywheel metrics — extract prompt skips empty files, pool ingest rejects "no significant learnings" stubs
- `ao pool ingest` now runs automatically in session-end hook after forge (was manual-only)
- 8 stale doc/comment references to old thresholds updated across hooks, ENV-VARS.md, HOOKS.md, using-agentops skill
- 13 empty stub learnings removed from `.agents/learnings/`

## [2.18.0] - 2026-02-25

### Added
- `ao notebook update` command — compound MEMORY.md loop that merges latest session insights into structured sections
- `ao session memory sync` command — sync session history to repo-root MEMORY.md with managed block markers for cross-runtime access (Codex, OpenCode)
- `ao seed` command — plant AgentOps in any repository with auto-detected templates (go-cli, python-lib, web-app, rust-cli, generic)
- `ao lookup` command — retrieve specific knowledge artifacts by ID or relevance query (two-phase complement to `ao inject --index-only`)
- `ao constraint` command family — manage compiled constraints (list, activate, retire, review)
- `ao curate` command family — curation pipeline operations (catalog, verify, status)
- `ao dedup` command — detect near-duplicate learnings with optional `--merge` auto-resolution
- `ao contradict` command — detect potentially contradictory learnings
- `ao metrics health` subcommand — flywheel health metrics (sigma, rho, delta, escape velocity)
- `ao context assemble` command — build 5-section context packet briefings for tasks
- Work-scoped knowledge injection: `ao inject --bead <id>` boosts learnings tagged with the active bead
- Predecessor context injection: `ao inject --predecessor <handoff-path>` surfaces structured handoff context
- Compact knowledge index: `ao inject --index-only` outputs ~200 token index table for JIT retrieval
- Learning schema extended with `source_bead` and `source_phase` fields for work-context tracking
- `ao extract --bead <id>` tags extracted learnings with the active bead ID
- Citation-to-utility feedback pipeline in flywheel close-loop (stage 5)
- Global `~/.agents/` knowledge tier for cross-repo learning sharing (0.8 weight penalty, deduped)
- Bead metadata resolver reads from env vars (`HOOK_BEAD_TITLE`, `HOOK_BEAD_LABELS`) or cache file
- Goal templates embedded in binary (go-cli, python-lib, web-app, rust-cli, generic) for `ao goals init --template` and `ao seed`
- Platform-specific process-group isolation for goal check timeouts (Unix: SIGKILL pgid, Windows: taskkill /T)
- SessionStart hook rewritten with 3 startup modes: lean (default), manual, legacy — via `AGENTOPS_STARTUP_CONTEXT_MODE`
- SessionEnd hook now gates notebook update and memory sync on successful forge
- Type 3 setup hook template: `hooks/examples/50-agentops-bootstrap.sh`
- Constraint compiler hook: `hooks/constraint-compiler.sh`
- Codex-native skill format (`skills-codex/`) with install and sync scripts for cross-runtime skill delivery
- Comprehensive cmd/ao test coverage push — 500+ tests across 5 waves reaching 79.2% statement coverage (13 untestable functions excluded)

### Changed
- SessionStart hook default mode changed from full inject to `lean` (extract + lean inject, shrinks when MEMORY.md is fresh)
- `ao flywheel close-loop` now applies ALL maturity transitions (not just anti-pattern)
- `ao hooks` generated config uses script-based commands instead of inline ao invocations
- `ao rpi` prefers epic-type issues before falling back to any open issue

### Fixed
- `truncateText` now uses rune-safe `[]rune` slicing to avoid breaking multi-byte UTF-8 characters
- `syncMemory` extracted from Cobra handler for testability
- `parseManagedBlock` detects duplicate markers and refuses to parse (prevents data loss)
- `readNLatestSessionEntries` warns on skipped unreadable session files
- `readSessionByID` detects ambiguous matches and returns error instead of first substring match
- `findMemoryFile` broad contains-fallback removed (was matching wrong projects)
- `pruneNotebook` iteration capped at 100 to prevent runaway loops
- `MEMORY_AGE_DAYS` sentinel initialized to -1 (was 0, causing false lean-mode activation when file missing)
- Lean-mode guard now requires `MEMORY_AGE_DAYS >= 0` before comparing freshness
- Memory sync moved inside forge success gate in session-end hook
- `ao search --json` returns `[]` (empty JSON array) when no results, instead of human-readable text
- `ao doctor` returns `DEGRADED` status for warnings without failures (previously only HEALTHY/UNHEALTHY)
- `ao rpi status` goroutine leak fix — signal channel properly cleaned up
- Inline rune truncation in `formatMemoryEntry` replaced with shared `truncateText`
- 6 new tests for dedup, ambiguity detection, iteration cap, duplicate markers
- Cobra pflag state pollution between test invocations — explicit flag reset in `executeCommand()` helper
- Goals validate.sh outdated checks and missing validate.sh for 7 skills
- 10 tech debt findings from ag-8km+ag-chm post-mortem (stale nudge, scanner, docs)
- ao binary codesigned with stable Mach-O identifier
- Hook integration tests updated — removed 8 stale standalone ao-* hook tests consolidated into session-end-maintenance.sh

## [2.17.0] - 2026-02-24

### Added
- GOALS.md (v4) OODA-driven intent layer — markdown-based goals format with mission, north/anti stars, and steerable directives
- `ao goals init` interactive GOALS.md bootstrap with `--non-interactive` mode
- `ao goals steer` command to add, remove, and prioritize directives
- `ao goals prune` command to remove stale gates referencing missing paths
- `ao goals migrate --to-md` converter from GOALS.yaml to GOALS.md format
- `ao goals measure --directives` JSON output of active directives
- `ao goals validate` reports format and directive count
- Format-aware `ao goals add` writeback (auto-detects md or yaml)
- Go markdown parser library with case-insensitive heading matching and round-trip rendering (26 tests)
- `/goals` skill rewritten with 5 OODA verbs (init/measure/steer/validate/prune)
- `/evolve` Step 3 rewritten with directive-based cascade for idle reduction

### Fixed
- `ao rpi` falls back to any open issue when no epic exists (#50)
- RPI phased processing tests added (~230 lines) for writePhaseResult, validatePriorPhaseResult, heartbeat, and registry directory

## [2.16.0] - 2026-02-23

### Added
- Evolve idle hardening — disk-derived stagnation detection, 60-minute circuit breaker, rolling fitness files, no idle commits
- Evolve `--quality` mode — findings-first priority cascade that prioritizes post-mortem findings over goals
- Evolve cycle-history.jsonl canonical schema standardization and artifact-only commit gating
- `heal-skill` checks 7-10 with `--strict` CI gate for automated skill maintenance
- 6-phase E2E validation test suite for RPI lifecycle (gate retries, complexity scaling, phase summaries, promise tags)
- Fixture-based CLI regression and parity tests
- `ao goals migrate` command for v1→v2 GOALS.yaml migration with deprecation warning (#48)
- Goal failure taxonomy script and tests

### Changed
- CLI taxonomy, shared resolver, skill versioning, and doctor dogfooding improvements (6 architecture concerns)
- GoReleaser action bumped from v6 to v7
- Evolve build detection generalized from hardcoded Go gate to multi-language detection

### Fixed
- `ao pool list --wide` flag and `pool show` prefix matching (#47)
- Consistent artifact counts across `doctor`, `badge`, and `metrics` (#46)
- Double multiplication in `vibe-check` score display (#45)
- Skills installed as symlinks now detected and checked in both directories (#44)
- Learnings resolved by frontmatter ID; `.md` file count in maturity scan (#43)
- JSON output truncated at clean object boundaries (#42)
- Misleading hook event count removed from display (#41)
- Post-mortem schema `model` field and resolver `DiscoverAll` migration
- 15+ missing skills added to catalog tables in `using-agentops`
- Handoff example filename format corrected to `YYYYMMDDTHHMMSSZ` spec
- Quickstart step numbering corrected (7 before 8)
- OpenAI docs skill: added Claude Code MCP alternative to Codex-only fallback
- Dead link to `conflict-resolution-algorithm.md` removed from post-mortem
- `ao forge search` → `ao search` in provenance and knowledge skills
- OSS docs: root-level doc path checks, removed golden-init reference
- Reverse-engineer-rpi fixture paths and contract refs corrected
- Crank: removed missing script refs, moved orphans to references
- Codex-team: removed vaporware Team Runner Backend section
- Security skill: bundled `security-gate.sh`, fixed `security-suite` path
- Evolve oscillation detection and TodoWrite→Task tools migration
- Wired `check-contract-compatibility.sh` into GOALS.yaml
- Synced embedded skills and regenerated CLI docs