v0.2.10

Full Changelog: v0.2.9...v0.2.10

v0.2.8

What's Changed

• Release v0.2.8 by @MuNeNiCK in #2
• test: write installed route fixtures as UTF-8 by @MuNeNiCK in #3
• test: identify installed route assertion failures by @MuNeNiCK in #4
• test: preserve release fixture newlines on Windows by @MuNeNiCK in #5

Full Changelog: v0.2.7...v0.2.8

v0.2.7

What's Changed

• Release v0.2.7 by @MuNeNiCK in #1

New Contributors

• @MuNeNiCK made their first contribution in #1

Full Changelog: v0.2.6...v0.2.7

v0.2.6

Full Changelog: v0.2.5...v0.2.6

v0.2.5

Full Changelog: v0.2.4...v0.2.5

v0.2.4

Agent Workbench v0.2.4

v0.2.4 replaces the prior workflow with a Lean-assisted project workflow.

• Capture caller-approved design separately from agent and reviewer proposals.
• Persist caller-owned Command Profiles as exact structured argv, cwd, scope,
  disposition, and immutable succession; bind required validation routes to
  Evidence and retain caller-authorized deviations without turning profiles
  into a command runner.
• Retain non-blocking Keep/Problem/Try project memory with stable authors,
  caller-owned adoption and supersession, exact project-language relations,
  and atomic instruction, Design-candidate, Command Profile, or reviewed
  Design-acceptance conclusions without bypassing ordinary Design Review.
• Require explicit necessity, simpler-alternative analysis, bounded scope, and
  maintenance cost before adopting an AI-proposed complexity increase.
• Select formal, external-evidence, mixed, or no assurance per accepted design
  statement.
• Acquire the pinned official Lean distribution during init without a
  separate user installation.
• Preview an unaccepted formal design, review its exact meaning, and only then
  let the caller adopt it.
• Show the concrete Lean-oracle observations, contract, tool, and exact
  artifacts that make up that review scope.
• Compare a Lean oracle with the real product boundary through input-only cases
  without putting Workbench concepts into product code.
• Preserve a checked counterexample when a corrected design disagrees with the
  unchanged product, review that meaning first, and require restored
  conformance only for Work completion.
• Reject unfinished Lean proofs, and distinguish a valid product
  counterexample from timeout, process, malformed-output, and output-limit
  execution failures.
• Reuse unaffected assurance after a local design correction and invalidate
  only the exact formal-result binding whose declared product surface changed,
  without blocking or clearing a same-key assurance for another Design.
• Let only the latest current result for an exact formal spec govern
  conformance and completion; a newer counterexample or execution failure
  cannot be masked by an older pass.
• Reconcile the selected exact stale binding inside the successful
  formal-check operation, so rebuilding an identical generated artifact
  reports restored completion in that same response.
• Select a same-key formal successor by its latest unaccepted DesignRef during
  preview while an accepted completion command remains bound to its exact
  accepted DesignRef, and disambiguate same-key Evidence obligations with an
  optional Design key while retaining basis-exact currentness.
• Bound oracle, adapter, and aggregate preview output while processes run, and
  transfer formal result files through the private runtime boundary instead of
  a potentially oversized command-line argument.
• Derive formal-result retry identity from bounded semantic file content rather
  than temporary paths, and transfer stale-currentness identities through a
  streamed private file instead of one environment value. Do not impose an
  aggregate stale-set cap below valid durable state; fail closed if the
  producer, inspection, sort, or finalization stage fails; and validate
  projection metadata before mutation so rendering cannot fail after commit
  and discard exact retry state.
• Replace completion members by semantic Design lineage across later Tasks:
  superseded versions are removed while unrelated same-key bases are retained.
  Render the exact Design selector required by formal-check, add-evidence,
  and record-evidence.
• Let finish-task follow the exact first missing Task member for any number of
  pending Tasks, and scope same-key Review and Evidence resolution to the
  focused Work and exact completion member.
• Encode retry intentions injectively: the Skill hashes NUL-delimited argument
  vectors and the runtime stores canonical JSON arrays, so control characters
  in free text cannot merge distinct operations.
• Distinguish resumed reviewer continuity from a fresh, context-independent
  reviewer execution in the installed Skill; a resumed remediation check
  cannot be reported as the required fresh Review.
• Keep Phase as optional display metadata and derive completion only from the
  current positive work boundary.
• Correct a mistaken review target without relinking history, and preserve the
  exact return point and caller decision across urgent interruptions. An
  unfinished interrupting Work cannot be abandoned through implicit return;
  only a reasoned caller replan-return can replace the saved plan.
• Retire accepted design as a caller correction, show its declared affected
  dependency paths, and preserve unrelated work.
• Install as one Agent Skill with a Linux x86_64 runtime.

v0.2.2

Agent Workbench v0.2.2

v0.2.2 makes remote publication and release attempts honor their prepared
preconditions before dispatch.

• Reject a remote predecessor that violates the prepared precondition, even
  when the target and artifact digest otherwise match.
• After an uncertain response, reconcile only the exact target and artifact
  digest that could represent the attempted successor.
• Cover precondition conflicts and adapter failure boundaries through the
  executable storage laws.
• Keep the one-Skill installation and static Linux x86_64 release contract from
  v0.2.1.

v0.1.35

Release history

v0.1.35 — 2026-07-27

• Keep closed work-unit history visible without letting its stale task
  derivations, checklists, validation gates, or coverage items block the
  current design's implementation-readiness gate.
• Preserve stale blocking and disposition behavior for open and blocked work,
  including validation gates whose owner is resolved through their task.

v0.1.34 — 2026-07-25

• Fix resume-check for a work unit with nested suspended activation history
  by selecting its latest suspended activation instead of rejecting the valid
  lifecycle state as ambiguous, while retaining the integrity error for
  malformed sibling or root histories.
• Add a regression that reconstructs nested suspended activation history and
  verifies the latest activation is selected, plus boundary regressions for
  invalid same-work siblings, malformed roots, and ambiguity across distinct
  work owners.

v0.1.33 — 2026-07-25

• Keep an active file-only source correction executable when an unrelated
  stale design record has higher global resolver precedence.
• Preserve closure, finding, correction-session, and transition guards while
  leaving the stale record available for its subsequent owner action.
• Report the exact missing and unexpected predecessor IDs when reconciliation
  mappings do not cover their required domain.
• Include selected validation-gate IDs in generated review contexts so those
  reconciliation diagnostics can be resolved through the public interface.
• Keep the printed decomposition-review recovery action authoritative by
  creating the required implementation-ready review plan.
• Route pending decomposition reconciliation through decomposition show so
  the next printed action resolves to the reviewed Plan and authorized preview.
• Allow a reconciliation closure to finish without fabricating a file edit
  when its applied transition already consumed that exact reviewed Plan;
  unchanged ordinary edit contracts remain rejected.

v0.1.32 — 2026-07-25

• Serialize identical concurrent release assembly requests so one process
  cannot remove another process's shared staging directory.
• Restore missing local candidate assets through an exact assembly retry after
  an interrupted post-commit directory publication.

v0.1.31 — 2026-07-25

• Preserve completed derivation repair inside an active aggregate checklist
  when the target checklist item and its task are both closed.
• Cover both active-aggregate and fully closed checklist repair routes through
  the complete public CLI lifecycle.

v0.1.30 — 2026-07-24

• Expose design-requirement identities through the public requirement inventory
  so requirement-scoped findings and derivation repairs can be completed
  without private state access.
• Exercise the complete public route from requirement discovery through
  finding targeting and completed derivation rebind.

v0.1.29 — 2026-07-24

• Keep source-correction guidance executable through the public CLI, including
  migrated adopter, closure supersession, and cross-design reconciliation
  routes.
• Enforce active correction exclusivity across every work owner even when
  stale recovery or required-review actions mask the selected resolver state.
• Preserve exact transition ordering, runtime-value matching, and idempotent
  replay without weakening correction lifecycle guards.

v0.1.28 — 2026-07-24

• Migrate existing generation 26 projects to the corrected source-correction
  trigger contract instead of treating them as current.
• Verify that required close-ready design findings accept typed source
  corrections after update, including closure creation and supersession.

v0.1.27 — 2026-07-24

• Preserve exact multi-target review findings and keep legacy single-target
  callers idempotent.
• Freeze the reviewed work boundary and release targets until an explicit
  reconciliation or supersession invalidates the affected review.
• Scope release assembly and revalidation readiness to the selected work unit,
  so unresolved review state in separate work does not block its release.
• Make review-target invalidation transactional and expose public recovery
  paths for completed work.
• Audit generation 26 migrations and retained trigger bodies so upgrades
  cannot silently omit release-integrity guards.

v0.1.26 — 2026-07-24

• Add an audited public path to rebind a completed task derivation to the
  correct checklist condition during scoped finding remediation.
• Let a typed source correction reconcile a generated checklist across design
  versions through its same-session alias.
• Keep remediation selection identical across status, next actions, mutation
  guards, closure operations, and database constraints, including mixed typed
  corrections, plan disposition, and terminal versus nonterminal acceptances.

v0.1.25 — 2026-07-23

• Let an ordinary structurally ready Decomposition Plan publish a reviewed
  replacement revision without treating its incomplete predecessor as an
  applied reconciliation source.

v0.1.24 — 2026-07-23

• v0.1.24 is withdrawn. Its Decomposition Plan fix distinguished ordinary
  ready revisions from reconciliation successors but did not permit the
  ordinary ready revision to publish its corrected successor. Use v0.1.25.
• Keep ordinary incomplete-to-ready Decomposition Plan revisions distinct from
  reconciliation successors, so their accepted ready plan can be applied.
• Require Phase-targeted review plans to derive clean state from exact Phase
  review contexts, and recover existing projects that recorded only an
  aggregate clean run before Phase closure.

v0.1.23 — 2026-07-22

• Make recovery selection preflight the complete staged transition so it never
  offers a checkpoint that cannot finish the update.
• Recover from the newest verified checkpoint in the formal update/restore
  lineage while preserving explicit owner selection for externally supplied
  ambiguous backups.
• Preserve and rebuild every dependent trigger when replacing a retained table
  during migration; existing generation 24 projects now reach generation 25
  without dropping review, finding, continuation, or owner-decision guards.
• Keep every verified backup discoverable in normal and recovery inspection,
  while running the complete staged update preflight only when a recovery
  source must be selected.
• Follow completed apply/restore direction and sequence when selecting a
  managed recovery checkpoint, reject symlink-substituted or sidecar-dependent
  restore sources, and preserve explicit owner selection for sequence-less or
  external history.
• Validate recovery transitions in memory so inspection never stages a private
  project ledger in shared operating-system temporary storage.
• Close every active or suspended activation epoch owned by a completed work
  unit, and keep release-asset verification hermetic under an external Cargo
  target directory.

v0.1.22 — 2026-07-22

• Make public-contract verification treat the project-local installed Skill
  copy as optional in clean source checkouts while still requiring exact
  equality when that copy exists.

v0.1.21 — 2026-07-22

• v0.1.20 was withdrawn. It is not a supported release and has no tag or GitHub
  Release because it removed established Agent Workbench workflows.
• Restore the complete work, Phase, Design Package, review, evidence,
  correction/KPT, repository, and record workflows after the withdrawn change.
• Add explicit update inspect, update apply, and reversible update restore
  commands. Ordinary status and lifecycle commands no longer update projects as
  a side effect.
• Make required Phase review recovery executable from both phase close-ready
  and the owner resolver, with an exact reasoned review plan waive command and
  no separate authority-event requirement.
• Let trace-aware resume retain the authority references captured at suspend
  while loading newer user directions, instead of blocking on every addition.
• Keep historical review plans, validation gates, and superseded Design Package
  approvals out of the current applicable-rule set.
• Add first-class Decomposition Plans that can be inspected, reviewed, applied,
  and reconciled while preserving checklists, Phases, and task membership. The
  existing decompose design workflow remains available as the automatic-plan
  path.
• Replace release-specific update handling with one stable update inspect /
  update apply / update restore flow that carries every supported project
  forward.
• Add the main binary's operator release lifecycle for candidate assembly,
  local inspection, annotated source publication, exact asset publication,
  downloaded remote verification, interruption reconciliation, idempotent retry,
  non-destructive withdrawal, and authority-backed supersession.
• Make release recovery detect partial publication, stale handles, and changed
  requests while preserving already-published assets.
• Retire the remaining signing-era owner and reviewer authority fields through
  the registered storage generation 25 transition. Exact accepted legacy
  results remain neutral migration provenance and no longer participate in the
  current review trust model.
• Validate every public command leaf at its parser and command-owner boundary,
  validate documented invocations against the live command tree, and repeat the
  registry checks against the extracted binary, Skill, and documentation
  release artifacts.

v0.1.19 — 2026-07-18

• Restore simple review claims and separate owner decisions without signatures,
  trust stores, grants, capabilities, or external administrator setup.
• Preserve existing signed decisions as read-only audit history while returning
  to the simple review workflow.
• Restore the v0.1.9-style review workflow and simplify the installed skill.

v0.1.18 — 2026-07-18

• Make supported existing projects update to the current workflow consistently.

v0.1.17 — 2...

v0.2.1

Agent Workbench v0.2.1

v0.2.1 makes the Linux x86_64 release independent of the host C runtime.

• Publish Agent Workbench as a static Linux x86_64 executable.
• Validate the packaged executable in clean musl and glibc environments.
• Keep ordinary source builds on the Lean toolchain selected by
  lean-toolchain.
• Preserve exact release commit, target, checksums, and version metadata.

v0.2.0

Agent Workbench v0.2.0

v0.2.0 makes the Lean implementation the default Agent Workbench product.

• Replace the Rust implementation with a Lean transition kernel, durable
  SQLite adapter, native CLI, and executable law suites.
• Keep review claims advisory and preserve separate, reasoned caller
  adjudication.
• Add ordered aggregate phases, dependencies, phase-scoped reviews, real
  rescope and split transitions, and exact external-operation identity.
• Preserve exact evidence, repository snapshot, artifact, and revision
  bindings through completion.
• Classify user feedback so considerations and rejected approaches do not
  silently become requirements or inverse absence tests.
• Validate required positive behavior without turning rejected approaches into
  permanent product requirements.
• Publish a Linux x86_64 binary, Agent Skill bundle, source archive, checksums,
  and versioned documentation.