# Changelog

All notable changes to CLike. Extension, orchestrator and gateway share one version.

## [Unreleased]

## [1.10.2] — 2026-11-16 — A promoted REQ reaches the default branch

### Fixed

- **The gate merge is retried on a transient git failure.** After a passing gate CLike switches to the default
  branch and merges the REQ's branch; when another git process holds the index for a moment (the editor's own
  git refreshing after a switch of thousands of files) the merge stopped with `fatal: stash failed` and the REQ,
  promoted on its branch, never reached the default branch. A merge failing on a lock or a failed stash is now
  retried (three times, short delays); a real failure (a conflict, an unknown branch) is reported at once.
- **/autopilot never builds a promoted REQ again.** After a gate it checks that the REQ reads `done` in the plan
  of the branch it goes on with; if not, the merge did not happen and the run stops and says how to merge,
  instead of picking the same REQ as open and starting a new KIT of it (lead-generation v3: REQ-026 promoted on
  `feature/req-026`, a new KIT of REQ-026 started on `main`). A REQ this run promoted is never picked again.
- **A developer's stash is never popped by the gate merge.** Before switching branch CLike stashes its session
  log; with nothing to stash git creates no entry, yet the stash was popped afterwards — the developer's newest
  stash. Nothing is popped now when nothing was stashed.

## [1.10.1] — 2026-11-16 — The eval after a good KIT

A KIT that passed its own checks went to an eval that failed for reasons a repair could not, or need not, fix
(lead-generation release 3: three repair cycles on one REQ, two of them caused by CLike).

### Fixed

- **/plan keeps what the release declared.** A /plan rewrite dropped the release fields /idea --extend had
  written for existing REQs (`change`, `amends`, `supersedes`, `regression_env`, `release`, `origin`, `retires`,
  `keeps`): the eval then blocked a change the release had allowed, and a repair had to work around it. They are
  now carried over from the plan before the run when the new plan omits them (a value the new plan sets is kept),
  cloud and local agents alike, and the chat says which ones.
- **A regression whose environment did not come up runs once more.** When a promoted REQ's setup fails (a
  database not created, dependencies not installed) and its checks do not run, CLike runs that REQ's regression
  again before any verdict; if it comes up the second time, it is noted as a sandbox setup failure, not a
  regression of the candidate, and no repair starts. A missing tool or container runtime is never re-run.
- **Sandbox databases under load.** Creating a REQ's test database is retried (four attempts, short backoff)
  when the server is slow or refuses connections while parallel regressions start.
- **A check run alone gets its setup.** `eval-check <check>` during a KIT or a repair also runs the setup checks
  the LTC runs before it (dependencies, install, virtualenv), so a single check no longer fails for a missing
  environment.
- **An interrupted eval runs again.** An eval call that breaks before any verdict (timeout, disconnection, the
  machine asleep, the stack restarting) is run once more in the same cycle instead of stopping the auto-eval and
  parking the REQ in /autopilot. The client now waits for an eval at least as long as the orchestrator waits on
  the sandbox (6 h), whatever the Harper phase timeout.

## [1.10.0] — 2026-11-16 — Where the time and the money go

### Added

- **Telemetry portal: requirements, drill-down, KPIs and estimate.** Clicking a phase in *Cost by Phase* shows
  the requirements behind it. A **Requirements** view ranks every REQ by cost, work time (agent/model and eval
  sandbox), elapsed time, KIT runs and repairs, evals and failures, first eval and gate outcome, and opens
  each one's breakdown per phase. A **KPIs & estimate** view gives cost and time per REQ (median, p90),
  repairs per REQ, eval first-pass and gate pass rates, prompt cache hit rate, agent share of time, the cost
  of the phases without a REQ, and an estimate for N more requirements from the project's own history.
  New endpoint `GET /v1/metrics/harper/reqs`. Cloud and local-agent runs alike (same telemetry rows).

## [1.9.11] — 2026-11-15 — The failed tests read from the whole output

### Fixed

- 1.9.10 looked for the failed tests' names in the excerpt of a check's output, which keeps the error lines
  but not the runner's list of failed tests: the same already failing test was still reported as a new
  error. They are now read from the whole output (verified on the pilot's report and baseline: 5 "new"
  errors before, none now).

## [1.9.10] — 2026-11-15 — An already broken test stays already broken

### Fixed

- A promoted REQ's check that already fails without the candidate is no longer a "new error" when the same
  tests fail with only other values in their messages. A pilot's release 1 test compared `.env.example` with
  its settings and already differed on the promoted tree; the candidate's one new variable lengthened the
  assertion message, the regression blocked, and the repair could only relax the test. Now: every test the
  runner names failed must have failed on the promoted tree too; another failing test, or an error with no
  named test, is still new.

## [1.9.9] — 2026-11-15 — A repair note that does not invite a relaxed test

### Fixed

- The note on a promoted REQ's failing check that names the shared files a candidate replaced ("Shared files
  changed") now says to start from the test's own error (a listed file is the cause only when that error
  points to it), and that reconciling the promoted REQ's test means extending it with every assertion as
  strict; otherwise the product satisfies the test as delivered, or the change is declared. Its old wording
  ("reconcile the test in the candidate test root") led a pilot's repair to copy a release 1 test and relax it.

## [1.9.8] — 2026-11-15 — The old default stays proven after promotion

### Fixed

- A `regression_env` declaration (1.9.6) held only while its REQ was the candidate: once promoted, the next
  release's evals would have run the release 1 suites on the new default again. Like `supersedes`, it now
  holds once promoted too, for the REQs delivered before it (plan order); the declaring REQ and the ones
  after it run without it, proving the new default.

## [1.9.7] — 2026-11-15 — Delivered tests are extended, never relaxed

### Added

- **A candidate cannot relax a promoted REQ's test.** A candidate's copy of a delivered test file replaces
  it in that REQ's regression (a shared test it extends); when an assertion of the delivered version is
  removed, loosened (`==` to `<=`, `toEqual` to `toContain`) or newly skipped in the copy, the regression blocks
  (`regression::<REQ>::reconciled-tests-assertions`) with the lines and the remedy, instead of a warning.
  A pilot's repair turned `set(env) == set(names)` into `set(names) <= set(env)` in a release 1 test and its
  regression passed. A changed value or a longer expected list stays strict (a warning, as before); a change declared with `supersedes` (or `/eval --supersede`)
  lifts the block for that file. Python, Jest/Vitest/Playwright, Go, JUnit/AssertJ, RSpec and PHPUnit
  assertion forms.

## [1.9.6] — 2026-11-15 — A new default, the old one still proven

### Added

- **Declared regression environment.** A MODIFIED REQ that changes a default behind a setting and keeps
  the old behavior selectable declares `regression_env` in plan.json (e.g. `{"LG_UI_THEME": "classic"}`):
  the promoted REQs' unchanged checks run under it, every one still blocking, and the new default is
  proven by the REQ's own checks. A pilot's v2 made a new UI theme the default: 12 release 1 browser
  suites, written for the classic UI, timed out on the new sign-in page though the requirement keeps them
  valid under `classic`. `/idea --extend` writes it (cloud and local agents); plain settings only, shown in
  the report (`env::regression-env`), part of the regression reuse key.

## [1.9.5] — 2026-11-15 — Faster evals after a repair, room on the disk

### Added

- **A promoted REQ's regression is reused when its workspace is byte-identical.** Each one is kept with
  the digest of its composed workspace and of the promoted state, CLike, environment and declared changes;
  the next eval reuses a result that did not block, marked as reused. An eval run again after an
  interruption resumes where it was, and a repair that touched only what the promoted REQs do not receive
  (the candidate's own tests, CI scripts, docs) skips their regression, most of an eval's time (a pilot: 56 minutes).
  A change to the candidate's source runs everything again; a blocking or unstable result (passed only
  on a re-run) is never reused.
- **Disk guard on the eval volume.** Below `CLIKE_EVAL_MIN_FREE_GB` (default 10, and at least 15%), the
  work directories of the project's other evals are removed, least recently used first (reports and caches
  stay); still below, the report warns `env::disk-space` with the remedy. A pilot's volume had reached 91%
  with the work directories of earlier REQs.

## [1.9.4] — 2026-11-15 — No eval cut short

### Fixed

- An eval is no longer cut by the orchestrator's wait for the eval sandbox. The wait was one hour: a pilot's
  regression of 23 promoted REQs, each installing the candidate's UI dependencies, was stopped at 56 minutes
  with `eval sandbox unavailable: ReadTimeout`, a few REQs from the end. The caller owns the deadline
  (`clike.harperTimeout`; closing the request stops the run); the orchestrator's wait is now a six-hour guard
  against a lost sandbox (`CLIKE_EVAL_SANDBOX_TIMEOUT_S`), and connecting to the sandbox still fails fast.

## [1.9.3] — 2026-11-15 — Regression after a new dependency

### Fixed

- The regression of promoted REQs installs the npm dependencies the candidate adds. A KIT that pins its harness
  dependencies in its own `package.json` built the current source with the packages of its own time: a candidate
  adding a UI library (shadcn/ui) failed every promoted REQ with "Cannot find module" though no assertion changed
  (a pilot's v2: 22 REQs). When the candidate's manifest at the same path holds every dependency of the promoted
  one at the same version, the promoted copy takes the candidate's manifest and lock — as the candidate's Python
  requirements already were; a version conflict keeps the promoted manifest.
- A test a MODIFIED REQ supersedes is recognised when the promoted REQ's harness runs it from another test root
  (`scope-tests/req_001/x.spec.ts` for the declared `test/req_001/x.spec.ts`): the four superseded tests of a
  pilot's REQ-001 blocked the regression instead of being reported as superseded.

## [1.9.2] — 2026-11-15 — Release deltas, read right

### Fixed

- `/idea --extend` no longer warns that a companion delta has no section when its sections are titled with the
  companion's path (`## docs/harper/ux/DESIGN.md`) instead of its file name: both count, and the rule asks for the
  path.
- The release commit of `/idea --extend` holds the UI references in `docs/harper/ux/` (prototypes, mockups, images —
  not the companions): the prototype a release's KIT builds from had stayed out of git.

## [1.9.1] — 2026-11-15 — A README that shows

### Fixed

- The extension README shown by VS Code, the Marketplace and Open VSX has working links and its logo: links to the
  repository documents and the logo are absolute (the packager rewrote the relative ones to paths that do not
  exist).

## [1.9.0] — 2026-11-15 — UIs worth showing

### Added

- UI design systems: a solution with a user interface is built with a design system, chosen in
  `TECH_CONSTRAINTS.yaml` (`tech_constraints.ui.design_system`): **shadcn/ui by default**, or Fluent 2, IBM Carbon,
  MUI, Ant Design, `none`, or the project's own (`.clike/design-systems/<id>.md`, which also overrides a bundled
  guide). `/plan` and `/idea --extend` get the rule (the first UI REQ sets it up and owns it as a seam; UI lane
  guides name it), and the KIT of every REQ with a UI gets the whole guide (setup, theme tokens, app shell,
  component by need, rules, verification) — the same text for the cloud and the local agents. `/idea` records the
  design system the sources name, else shadcn/ui as an assumption; the `/init` placeholder shows the key. Before,
  the design profiles said how a UI behaves but not how it looks, and a KIT wrote a few lines of CSS. See
  `docs/design-systems.md`.

## [1.8.5] — 2026-11-15 — No silent waits

### Fixed

- A question a run waits on is a dialog that stays on screen: the local check after a passing solution
  verification, the local setup offer, the release publication, the installation of a tool an eval needs and the
  KIT's unfinished dependencies. They were notifications that hide themselves after a few seconds: a
  `/finalize --verify` that passed waited 1 h 40 min on a question nobody saw. The local check also says in the chat
  that it is waiting for an answer.
- A local-agent run CLike rejects, or that fails after the agent worked, is in the telemetry with its outcome
  (`REJECTED` or `FAILED` and the reason) and its usage: only successful runs were recorded, so a finalize
  rejected after 35 minutes of agent work left no trace of its cost. The portal record of every agent run carries
  its outcome too.
- The solution eval no longer logs `eval verdict not recorded`: it has no gate, so no verdict is kept for reuse.

## [1.8.4] — 2026-11-15 — A finalize that delegates

### Fixed

- `/finalize` is no longer rejected for a cloud apply guard it has: the `CLIKE_ALLOW_CLOUD_MUTATION` check is
  looked for along the whole delegation chain of the apply wrappers (scripts run by path and Python modules they
  import, a few levels down), not only in the script the wrappers name. A pilot's finalize wrote wrappers that run
  `solution_local.py`, which imports `solution_ops`, the module that fails closed: the run was rejected
  (`finalize_cloud_apply_guard_missing`) and nothing was committed. A guard in a module the apply path never
  reaches still does not count.

## [1.8.3] — 2026-11-15 — Releases with their inputs

### Fixed

- `/idea --extend` reads the requirements of its release first. The phase budget went to the project inputs and
  to the sources of earlier releases in declaration order, and the new release came last: with the default budget
  its requirements reached the cloud model with 0 characters, and a converted document reached a local agent
  empty. The current release (its folders and the deltas written for it) now takes the budget first, the history
  last.
- `/idea --extend` keeps the project inputs current: it writes the release's delta
  `docs/harper/inputs/RELEASE_vN.md` (requirements, edge cases, journeys, test scenarios, decisions, coverage of
  the release's sources), with IDs that continue the numbering. Before, `docs/harper/inputs/` stayed at the first
  release while `/spec`, `/plan` and the next release read it first as the current truth.
- `/idea --extend` keeps the BMAD and UX companions current: one delta per companion folder
  (`docs/harper/bmad/releases/vN/`, `docs/harper/ux/releases/vN/UX.md`), read before the companions by every
  later phase. Before, the KIT of a new release read the product, architecture and screens of the previous one.
  CLike checks each delta (written, one section per companion, no earlier input ID reused) and ignores a rewrite
  of the base inputs or of a companion.
- Customer documents reach `/idea` whole. A `requirements` source is no longer cut at the per-file cap (60,000
  characters: a 100-page specification arrived for less than a third, silently); a source the phase budget cuts
  is said to the cloud model with the headings it did not get, and a local agent reads the converted document
  whole.
- Word documents are converted in reading order, with their headings (also short all-bold paragraphs, as many
  customer documents write them) and their tables as Markdown rows where they stand. Before, headings were lost
  and every table came at the end, one cell per line: the coverage could not name a section.
- The cascade's cloud answer may be as long as `/idea`'s (it returns IDEA, SPEC, PLAN, plan.json, the report and
  the deltas whole).

## [1.8.2] — 2026-11-14 — Clean runs, fewer repairs

### Fixed

- Processes a check starts and detaches into a group or session of their own (a test launcher's servers, a
  browser suite's webServer) are stopped with the check: they carry a per-check tag CLike kills by. Before,
  they kept their ports and the next check failed with "address already in use"; other REQs' checks running
  side by side are never touched.
- A local agent with no registry access gets its lockfiles from CLike: `eval-check.mjs --lock <KIT manifest>`
  resolves `uv.lock` or `package-lock.json` in the eval sandbox and writes it beside the manifest, without
  counting as an eval-check run (an agent spent four of six runs smuggling a lockfile out of a check). When the
  runs are used up after a locally checked fix, the criterion is done: partial only means work left in the code.
- A self review that denies gaps ("no implementation gap remains") is no longer read as an incomplete KIT.
- A regression check that finds its port taken by another promoted REQ's server runs again alone, like a timeout
  under load, and is a warning when it passes; KIT instructions: servers the tests start use a free port.
- A full Podman disk no longer builds up silently: before an eval CLike also removes, caches included, the
  eval directories of projects not evaluated for 7 days (`CLIKE_EVAL_PROJECT_RETENTION_DAYS`) and, when
  the volume is short, other projects whole after their REQ directories; `docker/rebuild.sh` warns when
  the disk is more than 80% full and prints what can be freed. Before, caches of projects evaluated days
  earlier and old images filled 98 of 100 GB and the autopilot stopped (`EVAL_SANDBOX_EXHAUSTED`).

## [1.8.1] — 2026-11-14 — A plan with its stack

### Changed

- `clike.plan.capacityProfile` defaults to `C2` (REQs sized as vertical slices for a coding agent),
  whatever executor runs `/plan`: `auto` followed the `/plan` executor, so a plan made in the cloud
  sized REQs for one cloud call although the KITs ran on an agent. Choose `C1` when the KITs run in the cloud.

### Fixed

- `/idea` always writes the Technology Constraints rooted at `tech_constraints:` (validated on every
  executor) and treats a stack the sources decide as a decision; the `TECH_CONSTRAINTS.yaml` that `/init`
  writes is a plain placeholder; `/spec` stops with a clear message when no technology decision exists.
  Before, the agent took the `/init` stub as an approved "no stack", `/spec` wrote nothing and `/plan`
  produced REQs with no lane and no lane guides.

## [1.8.0] — 2026-11-14 — Verified before the eval

### Changed

- `/idea` writes the project inputs next to IDEA.md (`docs/harper/inputs/`: requirements with IDs and
  sources, edge cases, journeys, test scenarios and fixtures, open decisions, a coverage map of every
  source section), on every executor with the same rules and checks; `/spec`, `/plan` and `/extend`
  read them before the raw documents, and a new `/idea` keeps their IDs. `/idea` also runs on the
  documents in `docs/inputs/` without an attachment. The cloud output budget of `/idea` is 64k tokens.
- Local agent KIT: the agent runs all the KIT's checks in the real eval sandbox
  before it finishes (databases, browsers, registry installs its own sandbox may lack) and writes the
  acceptance coverage from that run, so the first eval passes instead of starting a repair. Up to
  `clike.kit.agentEvalChecks` runs (default 6, 0 = off); the full eval still decides.
  Once its checks first pass, the regression of the promoted REQs runs in that same run, whatever
  runs the agent has left, and two runs beyond the limit are kept for it: a change that breaks a
  promoted REQ (a shared file, a contract, a migration, a new dependency's warnings) is fixed in the
  KIT, not in a repair after the eval.
- KIT instructions: a REQ's test helpers, fake servers and support modules go in its own test
  directories, never in one that holds a promoted REQ's tests (a file there changes how those tests
  are collected after promotion).
- Telemetry: evals (full, targeted, check re-runs) and gates are recorded in `.clike/telemetry` and in
  the telemetry portal with their duration, status, check counts and sandbox timings; the portal sums
  their time per phase and per REQ, outside providers and models. An agent's own runs while it writes a
  KIT stay part of the KIT's time.
- A chat reopened while a run goes on (an `/autopilot`, an `--fix` loop started in a chat closed
  since) follows it live: it says the run is going on, receives its messages and run card, stays busy
  until it ends and can stop it from the card.
- KIT instructions, all executors: a check the agent's own environment cannot run does not make a
  criterion partial (the eval runs it), and install commands of the checks work on a clean machine
  with registry access (no offline-only flags: the eval starts with empty package caches).
- KIT and repair instructions: tests assert what their REQ delivers, never a state later REQs change
  on purpose (the head migration by name, an exact total of routes, tables or registry entries); a
  repair reconciling such a promoted test makes it hold for the REQs that follow instead of pinning
  its own value, which failed the regression again at every REQ adding a migration.
- Eval regression: `CLIKE_EVAL_REGRESSION_WORKERS` defaults to `auto`, the promoted REQs the
  sandbox's memory and CPUs sustain side by side (about 2 GB and 2 CPUs each, at most 4): a 4 GB
  sandbox keeps 2, a 10 GB / 7 CPU one runs 3. A number still sets it.
- KIT instructions: a frontend package anywhere under src/ (not only src/frontend) is declared as
  the LTC's `package_json`, so CLike installs it once per lockfile and reuses it in every check and
  in later REQs' regression; check commands run the package scripts and never `npm ci` themselves.
- Eval and gate reports carry `timings`: setup, the REQ's checks, the regression and each promoted
  REQ in it, with the workers used.

### Fixed

- Closing the CLike chat no longer stops a running `/autopilot` or `--fix` loop: the run goes on
  (before, "Webview is disposed" parked the REQ right after its KIT).
- An eval after a rebuild of the eval sandbox no longer blocks on a work tree the previous container
  left: a file it built under its private security label could not be deleted by the new one
  (`env::prepare-workspace`: Permission denied); what cannot be removed is moved aside. A regression
  workspace CLike could not prepare now stops the `--fix` loop with no repair, like the REQ's own.
- A promoted REQ's check that failed on the promoted tree before is called unstable only when it
  now fails with the same errors: a new error is the candidate's regression and blocks. Before, a
  REQ-002 test broken by a later REQ's name collision passed as "nondeterministic" and stayed broken in
  the product. KIT self-check: synthetic entries a test registers take names no real one will take.
- Review of the release's changes, end to end on every executor: the launcher/manifest of the
  promoted application is looked for only in the canonical `src/` and the project root (not in other
  KITs, `node_modules` or venvs); cloud `/idea` accepts further files in `docs/harper/inputs/` like the
  local agents; the project inputs never take the context budget of a release's requirements or of
  `/idea`'s own sources, and `/idea` reads its previous inputs REQUIREMENTS first; the bridge warns
  when an acceptance-first KIT relies on changes to its locked tests; the orchestrator and the
  extension wait for the gateway as long as a `/idea` or a KIT may run; `DECISIONS.md` with no open
  decision is valid; `/eval --accept` releases a REQ also from a running `/autopilot`; an
  out-of-range `clike.kit.agentEvalChecks` no longer breaks `/kit`; an agent's eval-sandbox run is
  marked partial; docx, pdf, xlsx and pptx project documents reach the RAG, indexed in the background.
- A REQ that extends an application already promoted no longer needs a copy of its launcher and
  runtime manifest in the KIT: the canonical tree has them (repairs dropped the copy and a cycle went
  to putting it back).
- The regression of a promoted REQ runs the promoted version of its tests also in a project with no
  commit yet or when one first commit recorded both copies: the modification times decide then, so a test a later REQ
  reconciled and promoted no longer loses to the stale copy in the REQ's KIT (every later candidate
  had to reconcile it again).
- `/eval REQ --accept` releases the REQ from the autopilot's parked REQs: its files do not change, so
  the next `/autopilot` kept it parked although the developer had resolved it.
- The checks a local agent runs in the eval sandbox while it writes a KIT no longer take the
  acceptance lock nor count as a verdict: the first eval did, and stopped the REQ as "changed after
  the lock" when the agent improved its own tests afterwards. Only the bridge marks its runs; the
  adoption baseline and the finalize verification are unchanged.
- BMAD `/plan`: the architect (default role) writes the plan; the pm is now a companion-only role
  that reads `PLAN.md` and `plan.json` and writes stories, story map and implementation readiness.
  Before, both roles regenerated the plan and the second run discarded the first. `/plan --agent pm`
  stops before any run when the plan is missing or older than the SPEC. Native `/plan` is unchanged.
- Mandatory BMAD companion outputs are called mandatory in the instructions too (they said "when
  useful", and the spec pm skipped them). Companion-only roles no longer receive the plan-sizing and
  scenario block meant for the canonical documents.
- The project RAG gets every Harper artifact a phase writes or reads: IDEA, TECH_CONSTRAINTS and the
  inputs after /idea; SPEC, UX and BMAD spec companions after /spec; PLAN, lane guides and BMAD
  architecture/plan companions after /plan; all of them after /extend; the finalize documents after
  /finalize. Before, only the lane guides were indexed. Unchanged files are not re-embedded.

## [1.7.1] — 2026-11-09 — Proof that holds on the first repairs

### Fixed

- `acceptance::coverage`: a criterion id written short (`A01`) or with its REQ (`REQ-009-A01`) is
  the same criterion — the plan numbers bullets one way and the KIT instructions showed the other,
  so declared criteria were reported missing; another REQ's id never counts. The KIT text and
  `eval-contract-writer` now show the id as the plan numbers it.
- `eval-contract-writer` says what the eval reads: `cases[]`, or a project's `commands[]` /
  `checks[]` read the same way; only fields outside them (`requires_external_infra`, `gate_policy`,
  `pass_criteria`) are ignored.
- The repair may fix a test-support file (a conftest, no test in it) that the regression lists among
  the shared files a promoted REQ also delivers, as the eval's diagnosis asks; tests and assertions
  stay identical. Before, the lock restored the fix and the regression came back.

## [1.7.0] — 2026-11-08 — Complete requirements, sized for the executor

### Added

- **Journey scenarios from SPEC to the gate.** Eight journey skills shipped by `/init` (identity and
  access, data lifecycle, UI states, async jobs, integration, files and export, industrial control,
  API contract): 85 scenarios with stable ids and EARS statements, test idioms per lane. SPEC
  includes or excludes every scenario a use case implies (`## Scenarios`); PLAN gives each included
  scenario to one REQ (`reqs[].scenarios`); the KIT proves each with a blocking check and a test that
  names it; `acceptance::coverage` blocks the REQ otherwise. After `/plan` the chat reports included
  scenarios no REQ owns and exclusions without a reason.
- **REQ capacity profile** (`clike.plan.capacityProfile`): C1 cloud single call, C2 agent vertical
  slice, C3 epic with an internal feature list; shared seams so later REQs add files instead of
  rewriting composition files. The same quality context reaches the cloud prompt and the local
  agents.
- **Epics (C3)**: `FEATURES.json` and `PROGRESS.md`, one eval case per feature not delivered
  (`acceptance::features::<id>`), the repair loop continues the epic feature by feature.
- **Skills on every executor**: `.clike/skills` installed as native skills of the local agents (open
  Agent Skills format), a CLike block of rules in the agent instruction files, a guard hook that
  locks tests and CI during `/eval`; command **CLike: Sync agent skills**, `clike.agentSkills.autoSync`.
- **Vendored skills, pinned and maintainable**: `vendor/<vendor>/<skill>` with `VENDORED.json`
  (pinned commit, license, review date, digests) and `tools/skills_vendor.py` (`verify`,
  `check-updates`, `update --apply` with diff and review findings). First: two open-source
  engineering-discipline skills (test-driven development, verification before completion).
- **web-e2e-harness** skill: deterministic frontend checks in the eval sandbox.
- **Skill catalog reviewed (quality and size)**: fifteen journeys and 175 scenarios — new journeys for
  runtime configuration and secrets, tenancy, AI guardrails, mobile offline, ML reproducibility,
  notifications and payments; security and correctness scenarios the models tend to skip (account
  enumeration, CSRF, session fixation, refresh-token reuse, object-level authorization, server-owned
  fields, spreadsheet formula injection, boundary values, transactional outbox, watchdog, alarm
  flood). Test idioms corrected and extended (Rust, PLC sandbox fallback, test naming per runner)
  and sent with the KIT prompt for the REQ's lane, so the cloud gets what the agents read.
  `eval-contract-writer` is now the proof contract (the exact `ci/LTC.json` fields the eval reads,
  ACCEPTANCE.json, scenario ids in test names); skills folded into journeys keep working through
  aliases; gate-only skills stay out of the KIT; vendored skills come with a CLike overlay per
  executor. The KIT's skill context is 55–65% smaller with no skill truncated.
- **Repairs in the KIT's session** (`clike.localAgent.resumeRepairs`): an auto-eval repair resumes,
  forked, the local-agent session that wrote the REQ's KIT.
- **Telemetry per REQ**: every Harper call records its REQ and duration; the portal sums calls,
  cost, tokens and time per REQ.
- **KITs sized on the model**: the cloud KIT asks the model's own output budget (within
  `CLIKE_KIT_MAX_OUTPUT_TOKENS`, default 64000) at a deeper reasoning effort (`CLIKE_KIT_EFFORT`,
  default high); the C1 profile names the KIT model, its budget and what fits one answer; local agents
  run Harper phases at a set effort (`clike.localAgent.codex.reasoningEffort`, `clike.claudeCode.effort`).
- **Epics delivered end to end and stronger eval guards from the pilots**: a KIT never replaces a
  promoted shared file with a much shorter one or drops its dependencies; the regression of promoted
  REQs runs with the candidate's dependencies; a shared test conftest reading the KIT's files is
  diagnosed (and may be fixed by the repair); acceptance bookkeeping accepts done synonyms and lists
  the checks a criterion can name.
- **[Estimating with CLike](docs/estimation-example.md)**: a worked enterprise estimate, classic vs CLike.

### Changed

- `acceptance::coverage`: a scenario is proved by a test whose name or title carries its id; a line
  that lists many ids (a comment, a table) proves none of them.
- `PASS_WITH_WARNINGS` promotes (unless strict warnings are on): skills and packs now say what the
  gate does.
- BMAD skills are not installed as native agent skills; they reach the agents and the cloud through
  the methodology loader when a run selects BMAD.

### Fixed

- A disposable eval database is the project's own (a sandbox variable of another project no longer
  stands in for it), with the driver its value named; the capacity profile chosen in the extension
  reaches the orchestrator; extension.js loads again (a test now parses every module).
- Selected skills reach the KIT whole: the enforcement layer several skills share is said once (it
  pushed seven skills past the preview cap and cut their test sections); the cloud KIT no longer
  repeats the selected capability context in the user message.

## [1.6.9] — 2026-10-31 — An existing project adopted, area by area

### Added

- **`/adopt` — an existing project brought into CLike**. First, with no model (the same for cloud
  and local agents): it surveys the areas (the services of a monorepo), their stack, source and test
  roots, the commands the team runs (Makefile, scripts, CI setup), the runtime versions they require,
  the documentation, the agent context files and git; writes the areas to `.clike/project.json`
  (corrections kept); runs the **baseline** — each area's own setup and check, on a copy of the
  project in the eval sandbox, on its runtime — indexes the documentation into the **project
  memory**; writes `docs/harper/ADOPT_<date>.md`. `--area <name>` adopts one area first,
  `--dry-run` writes only the report. It writes the **code map** `docs/harper/CODEMAP.md` (per area:
  modules and public symbols, entry points, routes, calls to the other areas, contracts, tests),
  the **git history per area** in the report, and indexes the source code of the areas adopted into
  the project memory with the documentation. Then the **analysis**, by the model the chat uses (a local agent
  reads the repository, a cloud model gets the survey, the READMEs, the agent context files and the
  project memory): IDEA, SPEC with use cases, TECH_CONSTRAINTS and lane guides of the project as it
  is, every statement marked observed, declared or open, `docs/harper/HOWTO_RUN.md` (each area's
  setup, run and test commands) and the root **README.md integrated** in CLike's release style
  (every existing section kept, else restored); one **baseline REQ** per area (done, its
  LTC runs the area's own checks, locked; a check already failing is reported, not blocking) and the
  **capability REQs** — done only when the area's baseline covers them, open otherwise, the backlog
  as open REQs. CLike checks the plan, appends its verification to the report and commits the Harper
  documents; a rejected analysis restores them. Areas can be adopted one at a time. Help, completion
  and the cockpit propose it after `/init` on an existing project. Of the project's own files only the
  root README is updated, every existing section and line kept word for word (else restored). The
  project memory gets every document of the repository (Markdown, text, reStructuredText, AsciiDoc,
  OpenAPI/AsyncAPI — module READMEs, examples and prompts included), not only `docs/` and the main
  READMEs. A file the model returns outside `docs/harper/` and the root README is ignored, and CLike
  never writes a project file: in a git repository the files that changed while the run went (an
  editor, another agent at work in the project) are named in the chat and left as they are.

- **`/idea --extend` in a project of areas**: the model gets the areas of `.clike/project.json`; every
  new REQ names its `area` (or `areas` for a journey across modules), a new module is declared once
  with `new_area` (folder, source, tests, commands) and registered in `.clike/project.json` with the
  release commit. A REQ without an area, an unknown area or a new area inside an existing one rejects
  the plan. A project without areas works as before. The same rules on cloud and local agents.

- **Language runtimes newer than the sandbox image**: an LTC that declares `"environment":
  {"python": "3.14"}` or `{"node": ">=24"}` gets that runtime (`python3.13`, `python3.14`,
  `nodejs24` in the tools catalog) without a question and for its own checks only — the venv and
  `uv` on the declared Python, the declared Node first on the PATH. A version the image satisfies
  installs nothing.

- **Projects of areas** (a monorepo of services): `.clike/project.json` `"areas"` declares each area
  with its roots and commands. The area roots are repository folders a KIT delivers through
  `runs/kit/<REQ>/root/<repository path>`; a check with `cwd` an area runs in its composed copy in
  the eval workspace (never in the project's own folder) with the area's own `src/` / `tests/`
  paths; the area tests are locked like `test/`; promotion and regression are unchanged. Local
  agents and cloud models get the same areas (`repository.areas`, *Repository areas*). A project
  without areas is unchanged.

### Fixed

- **`/adopt`, reviewed**:
  - **Write filter:** a returned path is checked as it is written, so `docs/harper/../src/x` is never
    written.
  - **Backlog:** a backlog item the first area imported no longer blocks the next area.
  - **Cloud model:** it gets the root README and the run guide whole, so their integration no longer
    loses their tail.
  - **README:** a README a local agent deletes is put back. The team's README is found in git, with no
    copy in `.clike/`, and the lines the team adds later to its own sections are kept.
  - **Areas:** the areas of `.clike/project.json` are used as you corrected or declared them.
  - **Mount:** a project opened through a symlink is recognised, and an MCP run is never asked to mount.
  - **The adoption commit leaves out:** CLike's local state, your documents in `docs/inputs/` and
    `docs/reference/`, a `.gitignore` change that is not CLike's, and any file naming a folder of this
    machine.
  - **Next step:** the cockpit and the outcome no longer propose `/finalize` in a project only adopted.
    They propose the next area, the analysis to run again, or the next release.

- **`/adopt` checks**: a journey across areas may name areas of the project not adopted yet, without a
  warning. Every adopted REQ lists the SPEC use-case steps it realizes (`covers`), so the coverage check
  no longer reports every step as uncovered.

- **A project outside `CLIKE_PROJECTS_DIR` gets its tests run**: when eval, gate or the `/adopt`
  baseline start on such a project, CLike asks to mount it. On confirmation, `docker/mount-project.sh`
  mounts that folder only, read-only (a CLike project, never a parent), and recreates the containers.
  `GET /v1/eval/roots` lists the folders eval reads, and the new setting `clike.stackDir` gives the
  stack folder.

- **`/adopt` with a local agent finishes**: the run guide (`docs/harper/HOWTO_RUN.md`) is accepted (only in the adoption: `/idea --extend` never writes it) as
  an output, and the survey report and code map CLike writes just before the analysis are no longer
  taken for the agent's output. The run is no longer stopped before its check and commit. If the run
  changes them, CLike puts them back.
- **`/adopt --area` of a second area adds to the first**: the earlier areas' sections, REQs, lane guides
  and run guide stay, and TECH_CONSTRAINTS only grows. Replacements are listed in the report, and a lost
  section is put back. The README keeps every line of the team's README as it was before CLike, while
  CLike's own sections are updated (cloud and local agents).

- **`/adopt` runs its analysis**: it was sent to the `/eval` and `/gate` handler and stopped after the
  survey, leaving the `/init` templates. An adoption that stopped before its analysis runs again for
  the same area (its baseline REQ written anew). A nested area is named by its path
  (`events/python` → `events-python`).
- **A project keeps its own default branch**: when the configured default branch does not exist in a
  repository that already has history (`develop`, `master`, `trunk`), CLike commits on the
  repository's own (`origin/HEAD`, then the current branch) instead of creating a new one.
- **A profile of the whole project runs on a copy of it**: the adoption baseline and the solution
  profile of a project without `src/` at its root (a project of areas) ran in the project folder,
  which the sandbox mounts read-only; their setup steps in an area run in its copy too.
- **`uv` projects run in the sandbox**: every REQ gets a writable `uv` project environment of its
  own. Before, the image's `UV_PROJECT_ENVIRONMENT` pointed at CLike's own read-only environment, so
  a project's `uv sync` / `uv run` failed.
- **The cloud KIT has the same root rules as the local agents**: env examples, `.gitignore`, the
  solution profile and runbooks under `root/`, never a staging folder.

- **The finalize commit closes the release**: the Harper documents left out of earlier commits
  (`docs/inputs/`, `docs/reference/`, `docs/harper/`, lane guides included) go with it; other files
  of the developer never do. Before, a release input and its lane guides stayed uncommitted.
- **The local check fails when the run leaves files git does not ignore** (local configuration,
  generated secrets, an identity provider's import, caches): the repair adds them to `.gitignore`.
  Before, a realm import with the local passwords could end up in a commit.
- **Configuration examples are usable**: the finalize writes a minimal valid example for every
  structured variable (JSON, YAML), one example file per mode, and the verification loads them with
  the solution's own loader; private files are ignored for every start option. Before, ten JSON
  settings of a live mode had only their names.

### Security

- **Extension build tools without known vulnerabilities**: `@azure/msal-node` 7.1.2 (an override
  under the packaging tool, GHSA-xcx6-jx8p-x3h5) and `qs` 6.17.0 (GHSA-6pq8-jhm2-2vcw); both were
  build-time dependencies of `.vsix` packaging, not of the extension that runs in VS Code.
  `npm audit`: 0 vulnerabilities; packaging verified.

## [1.6.8] — 2026-10-28 — An existing project, kept as it is

### Added

- **`/init` with no parameters initializes the folder open in VS Code**, in place, as
  `/init <name> <parent folder> --force` (which works as before). The cockpit proposes it, and says
  when the folder is an existing project not built with CLike.
- **`/init` keeps a team's own process**: in a repository that already has a CI workflow, a
  code-owners file or a PR template, CLike's `.github/CODEOWNERS`, PR template and workflow go to
  `.clike/proposals/.github/` instead of the repository, and the chat says so. A new folder gets them
  as before.
- **Bringing an existing project into CLike** ([docs/adopt.md](docs/adopt.md)), linked from the
  README: what does not change for the team, every step from `/init` in place to `/adopt` and
  `/idea --extend`, monorepos as areas.

## [1.6.7] — 2026-10-28 — A finalize that runs once

### Fixed

- **A finalize sent twice does not run twice**: a `/finalize` or `/finalize --verify` while the
  solution verification runs is refused with a message, and the eval sandbox runs one request at a
  time per eval workspace. Before, a `--verify` sent twice composed the same workspace at once (a
  FAIL with no check run), and a full agent run followed.
- **The local smoke check is repeatable**: the finalize rules ask a smoke journey to create what it
  needs under new names every run and never assume an empty database. Before, a journey that passed
  on an empty database failed with a 409 on the developer's database holding demo data.

## [1.6.6] — 2026-10-26 — Promoted when delivered

### Added

- **`/finalize --verify`**: the solution verification again — the sandbox profile, the local check on
  the developer's machine, the outcome, the release tag — without a new agent run. No tokens when it
  passes; the repair agent runs only on a failure, as in a full `/finalize`. For a finalize stopped
  before its end, or a fix made by hand (a busy port, a configuration value).

- **Use cases from the release to the finalize**: `/idea --extend` writes every journey the release
  adds or changes as a SPEC use case, as `/spec` does (`UC-nn` with steps, errors and prerequisites;
  the section is created when the SPEC has none), and its new REQs cover the steps. The report's
  CLike verification counts the use cases and warns when the release adds REQs without one.
  `/finalize`, cloud or local agent, follows the use cases: one check per journey that can run, and
  a `## Use cases` table in FINALIZE_REPORT.md with the status of each (verified in the sandbox, on
  the developer machine, needs the developer, not covered).

### Fixed

- **Root deliverables reach the repository**: a KIT's `root/` now also delivers the example of each
  private env file (`.env.<name>.example`), `.gitignore` / `.dockerignore`, `ci/SOLUTION_LTC.json`
  and project docs (`docs/<runbook>.md`, never `docs/harper/`, `docs/inputs/`, `docs/reference/`).
  The eval blocks root deliverables left in a staging folder (`ci/shared/…`) or a staging map of the
  KIT, saying where each belongs, and `/finalize` receives those that delivered REQs left there, to
  bring them to the root. Before, these files had no legal place: the KITs staged scripts, env
  examples, the solution profile and runbooks under `ci/shared/`, the gate promoted `src/` and
  `test/` only, and the solution lacked `--oidc` / `--live`.

- **A REQ is promoted only when its acceptance criteria are delivered**: every KIT writes
  `docs/ACCEPTANCE.json` (each criterion `done` with the blocking checks that verify it, `partial`,
  `missing`, or `developer_evidence`), and the eval's blocking check `acceptance::coverage` sends a
  criterion not delivered to the repair. A self review that declares the KIT incomplete blocks too.
  Before, every check could pass while criteria were not implemented: the KIT's own SELF_REVIEW said
  "not promotable", and CLike read only the checks.
- **The dependencies of a declared `package_json` are installed whatever the LTC's main runtime**:
  a Python LTC with a web frontend that names `src/web/package.json` (or requires a Node version)
  gets `npm install` before its frontend checks. Before, they ran without `node_modules`.

## [1.6.5] — 2026-10-26 — Declared changes that hold

### Added

- **A change the cascade did not name is declared in one command**: `/eval <REQ> --supersede
  REQ-x#<check | path::test> "<why>"` checks the reference, writes it to the plan (`supersedes`,
  `amends`), records it with the author in `runs/extend/declared-supersedes.jsonl` and runs the eval.
  A failing delivered test of a REQ the candidate amends gets a note with that exact command, and a
  stopped `--fix` loop repeats it: a repair may not change the plan. Before, the only way was to edit
  `plan.json` by hand while the repair kept failing on a test it could not change.

### Fixed

- **Superseded checks and tests hold in the regression**: a superseded check is dropped in whatever
  section of the delivered REQ's LTC declares it (`commands`, `steps`, not only `checks`), and a
  superseded test (`REQ-x#path::name`) is recognised in the output of any check that runs it,
  whichever promoted REQ owns the check: when all its failed tests are superseded the check holds,
  otherwise the note names them so the repair leaves them alone. Failed tests are read in the formats
  of the common runners of any language. Before, test references were never applied: a test the
  release replaced on purpose failed the regression and went to a repair.
- **A timeout under parallel load is not a regression**: a blocking regression failure that ran out
  of time while promoted REQs ran side by side runs again alone; passing alone, it is a warning,
  never repaired. Before, a 30 s test, a database connection and a 300 s suite slowed by the load
  were diagnosed as shared-file changes, and the repair changed correct code.
- **The end of `/kit`, `/eval` and `/gate` keeps what changed in the plan meanwhile**: the status is
  written on `plan.json` as it is on disk, not on the copy read when the run started. Before, a
  `supersedes` entry added during a 25-minute repair was erased when the repair ended.
- **`/idea --extend` names the delivered tests that pin a list the release extends** (the last
  migration or schema version, the set of routes, services or files): they are superseded, and the
  REQ that extends them is MODIFIED.

## [1.6.4] — 2026-10-26 — Script checks with nothing to install

### Fixed

- **PowerShell and shellcheck are in the eval sandbox by default**: `powershell` (`pwsh`) joins the
  tools catalog, and both script linters are default tools, installed by the eval-tools service at
  its start for every project, with no `/tools add` and no question; a check that runs
  `pwsh -NoProfile …` is found before the eval. Before, `pwsh: not found` was outside the catalog
  and `--fix` sent it to the repair agent twice.
- **`--fix` does not repair a missing program**: when every failing check stopped because its own
  command is not in the sandbox (exit 127), the loop stops and says how to add it; other
  environment blocks still go to a repair. The eval's advice says the same instead of
  `/kit --repair`: `/tools add <tool>` for a catalog tool, `/tools search <program>` (or `custom:` in
  `.clike/eval-tools.yaml`) for a program outside the catalog.
- **`/autopilot` retries a parked REQ when the environment changed**: a REQ parked by an earlier
  run is released when CLike's version or the sandbox tools changed, not only when its own files
  did. Before, a REQ parked on a missing program stayed parked after the program was installed, and
  `/autopilot` ended at once with "no REQ can go on".

## [1.6.3] — 2026-10-26 — An extend that keeps its work

### Fixed

- **`/idea --extend` no longer discards a cascade for a reference it can complete**: every check
  section of a delivered REQ's eval profile counts (`commands` and `external_checks` too: a valid
  `REQ-032#keycloak` was refused as unknown); a superseded test named without its REQ gets the
  amended REQ that owns it (its number in the path, its KIT tests, or the only one amended); a
  rejected cascade keeps its documents under `runs/extend/rejected/<time>/` instead of losing them.
- **A rejected `/idea --extend` leaves nothing of its own in the workspace**: with a local agent, the
  lane guides it changed are restored and the EXTEND report it wrote is removed (both kept under
  `runs/extend/rejected/<time>/`); before, they stayed and a later run took them as the release's
  own, so they were never committed.
- **The commit of `/idea --extend` holds the whole release**: the lane guides and the release's own
  inputs and references (`docs/inputs/vN/`, `docs/reference/vN/`) are committed with the documents,
  under a message that names the release and its new REQs
  (`docs(harper): release v3 from v2 — REQ-037 MODIFIED, …`). Before, only the files the run
  returned were committed: up-to-date lane guides and the inputs stayed out of git.

## [1.6.2] — 2026-10-25 — Releases from /finalize, the local start verified, a memory that answers

### Added

- **Ask in the Memory panel**: the panel answers instead of listing files. The model writes a short
  answer only from the numbered passages it gets (project, CLike guide or both), in the language of
  the question: sources cited, steps with the exact CLike command to copy, confidence and why, next
  questions, "not in the memory" when the sources do not answer. The project as it is now (next
  action, last run and its blocking failures, a test patch to review) and the date of each source
  come with it, so an outdated note does not win over the state. **NOW** questions come from the
  same state. Cloud model or local agent (read-only, no session), as the chat is set. Only the words
  that tell results apart are highlighted, matched as whole words.

- **A passing `/finalize` delivers the release**: the finalize commit names the release and its
  REQs, the annotated tag `vN` marks it, and the release notes are built from the documents (REQs
  with their gate merge commits, what changed, how to start, missing information, verification,
  limitations, full changelog). The release on the repository host is published only on
  confirmation, with every field and the reports attached; **CLike: Publish release** publishes the
  last passing `/finalize` later. `/idea --extend` takes `vN` as the baseline.

- **`/finalize` checks the local start on your machine**: after the verification passes in the
  sandbox (which runs the solution natively), CLike runs `scripts/check_solution_local` on your
  machine, the start you use (containers when a runtime is installed); a failure starts a repair
  cycle with its output (`clike.finalize.localCheck`: ask, always, off). The finalize rules ask for
  checks that do not depend on the address a server listens on, web services listening on every
  interface in the profile, and generated local values that renew when they expire.

### Fixed

- **After the last gate of a new release the cockpit proposes `/finalize` again**: the finalize
  report of the earlier release made it show FINALIZE done and "Delivered" (the autopilot already
  said `/finalize`). A finalize counts only when it is newer than the last gate promotion.
- **An empty release folder made in advance is no target**: `docs/reference/v4/` created empty
  for later made `/idea --extend` and the cockpit target v4 instead of the v3 with its inputs.
- **`/finalize` no longer rejects a correct cloud deploy**: a script named after the secret
  references it creates (`04_secrets.sh`) is code, not a secret store; the
  `CLIKE_ALLOW_CLOUD_MUTATION` guard counts in the implementation the apply wrappers delegate to.

- **A check that says a tool is missing no longer starts repairs of correct code**: a check that
  printed `shellcheck missing` and exited (instead of the shell's `command not found`) was taken for
  a code failure, and three repair cycles ran on code that had no defect. A check whose wording says
  a catalog program is missing — and that program is indeed absent from the sandbox — is now a
  missing tool: CLike offers to install it and runs the check again, or stops and says how.
  The BMAD eval advice says the same (`/tools add <program>`) instead of suggesting a KIT repair.

### Performance

- **A repair stops when its checks pass**: an agent's eval-check result no longer reads `FAIL` for
  failures the eval marks non-blocking (already failing without the candidate, unstable, warnings);
  they are shown as `WARN … not yours to fix`, and when every check given to the repair passes the
  result says to finish. On a real project the two checks of a repair passed at its second run and
  the agent went on for 25 minutes (about 14M tokens, mostly cached context re-read at every turn)
  chasing non-blocking coverage. The prompt names a promoted REQ's regression as `regression::<REQ>`.
- **The full eval that confirms a targeted re-eval no longer runs again what just passed**: on the
  same inputs (same files, plan and CLike version) it takes the REQ's checks and the regression of the
  promoted REQs from the targeted run (marked *Reused*) and runs the rest — about a quarter of the
  confirmation on a real project.

## [1.6.1] — 2026-10-25 — A memory you can ask, repairs that write the test fix, eval loops that stop

### Added

- **Memory panel**: **CLike: Memory**, or **🧠 Memory** in the chat (every layout, also while a
  command runs), opens a panel of its own next to the chat. Ask in natural language, in any
  language, what the project holds — Harper documents, REQ KITs, eval and gate reports, chat
  attachments — or how CLike works: CLike's documentation ships inside the extension and is in the
  memory from the start (checked at every start: indexed when missing or changed, left alone
  otherwise). Each result is a file with the lines that answer, the question's words highlighted,
  and opens it; the semantic ranking is refined by the question's exact words, weighted by their
  rarity, so `--accept` finds its section first in any language. **Contents** lists what each memory
  holds, **Recent searches** repeats one. The chat and the panel only open each other. New
  `POST /v1/rag/sources`; `POST /v1/rag/purge` accepts exact `paths`.
- **A successful `/finalize` opens the README in reading mode**, as the gate opens its promotion
  report. The settings that change the UI are documented in the chat UI page and the extension
  README.

### Fixed

- **A repair sure that a locked test is wrong writes the correction**: when the SPEC and the PLAN
  show that the code's behaviour is the required one, the repair writes the smallest change to this
  REQ's test (every expected value kept) instead of describing it; CLike restores the locked test,
  saves the change as a patch and stops. `/eval REQ --accept "<why>"` now applies the latest patch,
  records the reason and runs the eval (the patch is undone if the governance still refuses it).
- **A repair loop without progress stops even when a failure prints random values**: a session
  token printed by a failing browser test changed the failure fingerprint at every cycle, so the
  loop never saw that nothing improved. Random-looking tokens no longer count.
- **`/finalize` accepts a database boundary that already exists**: unchanged sources of the
  promoted code are sent as read-only evidence, and a database variable named after the project
  counts; a finalize that reused them was rejected.
- **A failed `/finalize` is no longer shown as done**: the cockpit keeps it as the next action with
  its reason, and the project stays below 100% until a `/finalize` passes.
- **The eval advice of an edited locked test points to `--accept`** with the files changed, instead
  of a repair.
- **A window running an outdated CLike says so**: a reinstalled extension changes the files, not the
  open windows; before a run CLike warns once and offers **Reload Window**. A window opened the day
  before had run a day of fixes without them.
- **The project memory no longer fills with temporary copies**: KIT indexing skipped no hidden
  folder, and a real project's memory held thousands of `ci/.tmp` copies (72% of its chunks). Hidden
  folders are skipped, and after a REQ is indexed its files gone from the KIT, and hidden-folder files
  of any KIT, leave the memory.
- **A repair that finds a wrong locked test no longer loses its work, and the loop stops for you**:
  on a test project the local agent found three defects in a locked browser test and fixed them
  (every assertion identical); the lock rejected the change, as it must without proof, restored the
  test and the loop went on repairing the code. Now the proposed change is saved as a patch
  (`runs/eval/<REQ>/proposed_test_fix_<ts>.patch`, with the reasons) and `/eval --fix` / `/gate --fix`
  stop: you review it and `/eval REQ --accept "<why>"` applies it (audited), or give a hint for the
  code. The lock is unchanged. Same for cloud repairs (the orchestrator returns the rejected test
  contents) and local agents. During a repair the eval-check helper warns when its result uses
  changes to tests that existed before the repair. The KIT prompt asks tests that hold or fail a
  network call to use the framework's interception, scoped and removed, and to run every test once
  against the code.
- **Checks that wait for a person, and tests that reach a name that never resolves, no longer stall
  `/eval --fix`**: on a test project a blocking manual check ("missing … observation") and a browser
  test following a redirect to `example.test` failed at every cycle, and no repair could change
  them. The eval runner now names both causes; a repair may make a check that waits for a person
  non-blocking (audited, like one needing a container runtime) and may fix a test that contacts a
  reserved host (every assertion identical, review required at the gate). The KIT prompt (cloud and
  local agents, same sentence) asks for neither in the first place.

## [1.6.0] — 2026-10-24 — Eval that converges on a real project, autopilot, chat cockpit, SPEC that decides

### Performance

- **Targeted re-eval in `/eval --fix` cycles**: after a repair of regression failures, the next eval
  runs every check of the REQ and the regression of the promoted REQs that failed only
  (`regression_reqs` on `/v1/eval/run`); when it passes, a full eval confirms it in the same cycle.
  On B2B every repair cycle re-ran ~20 min of regression over 25 REQs to re-check 1–7 failures. A
  targeted eval is never a verdict (`partial`, not promotable, not reused by the gate).

- **The regression no longer repeats a promoted REQ's own regression checks**: a check named
  `regression` / `…-regression` of a promoted REQ re-runs tests of earlier REQs, which CLike's
  regression already runs on their promoted tests (`regression-checks::not-run` lists the skipped
  ones). The KIT prompt asks not to copy other REQs' tests into a KIT. On the B2B project this
  removes about 4 of the 25 minutes of an eval.
- **The run without the candidate is done once per promoted state**: whether a failing check of a
  promoted REQ also fails without the candidate depends on the promoted tree only, so its result is
  kept (eval sandbox volume, digest of the promoted state, 24 h) and reused by the next repair
  cycles, the gate and the next REQs; a check known to fail there is not retried. On the B2B project
  six pre-existing failures were retried and re-run without the candidate at every eval.
- **Promoted REQs are regressed side by side**: `CLIKE_EVAL_REGRESSION_WORKERS` (docker/.env,
  default 2, `1` restores one after the other) of them at a time; shared installs (venvs, npm
  store) and service ports are guarded, and the report keeps the plan order.

### Added

- **SPEC decides, PLAN says what is KIT-ready, the autopilot stops before a KIT that cannot be
  built**: SPEC decides the ordinary choices the IDEA leaves open (simplest reasonable option, in
  Assumptions) and keeps open only the owner's questions (`OPEN-nn`); every REQ of `plan.json` has
  `kit_ready` and `blockers` (owner questions only); the KIT never stops on an open detail. After
  `/plan` CLike lists the REQs that wait (`⚠ KIT READINESS`), `/autopilot` parks them before `/kit`
  with their questions, a manual `/kit` warns. Same rules for the cloud model and the local
  agents. On a ShortLink test project SPEC left 8 decisions open (URL policy, code alphabet, API
  shapes…), PLAN marked both REQs not ready and the KIT wrote no code; the autopilot reported only
  "required roots missing".

- **Cockpit layout of the chat (`clike.chat.theme: cockpit`, the new default)**: the chat on the
  left; on the right the mode (Free · Coding · Harper), execution, cloud model, the local agent and
  its model, history scope, layout, and in Harper the methodology (Harper native or BMAD, with the
  role per phase where BMAD allows more than one), the project (release, REQs done / in progress /
  open, phases IDEA → FINALIZE), the next action with **Run** (the autopilot's rules) and
  **▶ Autopilot**, the REQs with what each waits for (a click puts its next command in the prompt),
  the last eval or gate and who writes. Free and Coding show the Harper project in one line. The
  output tabs (Text · Diffs · Files) become a drawer that opens by itself when there is something to
  read. It adapts to the panel: two columns, a compact side panel, then (beside the editor) one
  column with the cockpit as a drawer and a strip with the phases and the next action; icons only
  for the secondary buttons in very narrow panels. The other layouts (classic, pro, studio, paper)
  keep every feature and switch from the settings or the new **Layout** selector in the chat. With
  BMAD on, a Harper command typed without methodology runs with it (never `/gate`, `/eval --accept`),
  and the bubble shows the command that ran.
- **Run card and status bar for every command in flight (every layout)**: the real steps of the
  command — KIT, EVAL 1, REPAIR 1, EVAL 2, GATE, the steps of each REQ in `/autopilot` — with their
  outcome, counts and duration, the cycle of a `--fix` loop, the elapsed time and an estimate from
  the same step's previous duration, what is happening now (the handlers' messages, the tool a local
  agent is using), the cost of the run and of the session. The VS Code status bar shows the same
  line and opens the chat.
- **Live progress of an eval or gate**: the eval runner records its phase (setup, checks, regression),
  the checks done of total and the one running, the promoted REQs being regressed (thread-safe with
  the parallel regression workers); the sandbox serves it on `GET /progress`, the orchestrator on
  `GET /v1/eval/progress?req_id=…` (same confinement as `/v1/eval/run`); the chat polls it every 2 s.
- **Smart stop**: *After this step* lets the step in flight finish (an eval keeps its report) and
  starts nothing new — `/eval --fix`, `/gate --fix`, the finalize verification and the auto-eval
  after a KIT stop at the next step boundary and say how to go on; `/autopilot` stops after its
  current kit / eval / gate, or *after this REQ*. *Stop now* (or Esc) first says what it loses for
  the step running (agent, cloud model or sandbox) and suggests waiting when the step is about to end;
  after a stop the card lists what was done and what was cut, with the command to resume and the
  changes to review.
- **Local agents in Harper phases stream what they do**: their event streams feed the run card;
  the final result is kept as the run's output, as before, so tool outputs never reach the
  blocked/failed/interrupted checks.
- **History of conversations per mode**: **＋ New chat** (every layout) keeps the current
  conversation in `.clike/sessions/archive/<mode>/` instead of deleting it and, with an agent, starts
  a new agent session in that mode too; the cockpit's **History** lists the earlier conversations of
  the mode (title, when, how many messages): a click reopens one (the current one goes to the
  history), × deletes one after asking. Clear Session is unchanged.
- **Chat answers as cards (every layout)**: what CLike says while a command runs is one log card — a
  line per message with its time, coloured by outcome (✔ ✖ ⚠ ▶ ⏹), the span of the run, older lines
  folded, copy of the whole log, a line removable from the history; a model's answer shows code
  blocks, inline code, bold and titles (the text is escaped first: nothing it contains runs).
- **The cockpit proposes `/idea --extend`** when every REQ is done and the next release has its
  inputs (a `docs/inputs/vN/` above the plan's release, with files — the detection the command runs):
  next to `/finalize`, then as the next action; without inputs it says where to put them. With BMAD,
  each next action that admits more than one role offers the roles not run yet as choices.
- **Slash-command autocompletion in every layout**: commands with their syntax, REQs ranked for the
  command (`/kit` the ready ones, `/eval` those with a KIT, `/gate` those whose eval passed on the
  current files) with a warning when one cannot run yet, flags not yet used and their values
  (BMAD roles allowed for the phase, `--executor`, `--release`, `--phases=`, `/tools add` from the
  catalog, `/agent-model` models), the signature with the part being typed, and the error the
  parser would give before sending, with its fix (Tab). ↑ in an empty prompt recalls the commands
  already used. ↵ sends as before unless a suggestion is being chosen.

### Fixed

- **A failed eval or gate is no longer shown with ✔** in the chat summary (`✔ … EVAL FAIL`): ✖ unless
  the status is PASS or PASS_WITH_WARNINGS.
- **`/eval --fix` stops before a repair when the plan says the REQ waits for your answers**
  (`kit_ready: false`): a repair without them writes no code either (ShortLink: the readiness handoff
  failed the same checks at every cycle). It says what to answer; `/eval REQ --fix "<your decisions>"`
  gives the answers to the repair and goes on.
- **A status update of PLAN.md no longer deletes the REQ sections after the REQ table**: when a
  REQ changed status (open → in_progress at its KIT, done at the gate) CLike rewrote the table up to
  the first `### Acceptance` heading, deleting a `## REQ-001 — …` section in between with all its
  scopes (ShortLink test project: 82 lines of REQ-001 gone). The table now ends at the next heading;
  the snapshot no longer stops at a letter `Z` (`\Z` is not an end-of-text anchor in JavaScript).

- **`/agent-model list` shows the models the local agent accepts**: it listed ids of the cloud
  catalog the agent refuses and hid some it accepts. The list now comes from the agent's own login;
  `(cloud too)` marks the models the cloud selector has as well.

- **The bubble of `/eval` / `/gate` shows the command as typed** also when it contains an `s` in a
  flag (`--ask`): the webview split the text on the letter `s` instead of on spaces.

- **Copy icon on every chat bubble**, next to the bin: copies the message text to the clipboard
  (through the extension, so it works in every webview), usable during a run too.

- **Use cases in `/spec`, their coverage checked after `/plan`**: SPEC gets a `## Use Cases`
  section — every production journey end to end with numbered steps (`UC-01.1`…), error flows, the
  production data path and the prerequisites each journey implies (an authenticated API implies
  sign-in, session expiry, roles, authorization per resource, audit…), in scope or provided by
  someone named. Each REQ lists the steps it implements (`covers`); after `/plan` and
  `/idea --extend` CLike reports every step no REQ covers, the same for cloud and local agents. A
  requirement taken for granted (an authenticated API with no sign-in) no longer goes unplanned.

- **`/autopilot [N] | stop | status`**: the REQs of the plan unattended, in dependency order —
  `/kit`, `/eval --fix`, `/gate` each, through the chat handlers, so with the configured executor
  (cloud or local agent) and the same locks, gate and audit. A fixed rule, not a model, drives
  it: a REQ that needs the developer is parked with its reason and the independent REQs go on; a
  provider quota or rate limit waits and retries (`clike.autopilot.quotaWaitMinutes`,
  `clike.autopilot.quotaRetries`); an in-progress REQ with its KIT resumes from the eval.
  `--executor cloud|codex|claude` and `--methodology bmad` choose them for the run (chat, MCP, scripts).
  It knows where it is: a REQ resumes at `/kit` (no KIT), `/gate` (last eval passed on the current
  files) or `/eval --fix`; a parked REQ stays parked until its files change. Its state
  (`runs/autopilot/state.json`) makes an interrupted run resume by itself when VS Code opens again
  (`clike.autopilot.resumeOnStartup`); CLike services not answering wait and retry like a quota. Report in
  `runs/autopilot/report.md`. It stops before `/finalize`.
- **`harper_autopilot` MCP tool and `scripts/clike-autopilot.sh` / `.ps1`**: `/autopilot` from a local
  agent or a terminal — `start` returns at once, `status` / `stop` steer it; the scripts start it
  directly or through a local agent and wait by polling the server (no tokens).
- **`harper_init` MCP tool**: `/init` of the folder open in VS Code, in place (existing files kept),
  so an agent can run a project from `/init` to `/finalize` through MCP.
- **`docs/howto-mcp-bmad-claude.md`**: the sequence `/init` → IDEA (analyst) → SPEC (pm, ux) → PLAN
  (architect) → KIT (developer) / EVAL --fix / GATE → FINALIZE (tech-writer) driven by a local agent,
  with one ready instruction and a human check after PLAN.
- **`docs/clike-at-a-glance.md`**: the overview picture with a description area by area; the
  README gets a *Highlights* section linking to it (the picture is no longer embedded there).
- **Community files**: `CONTRIBUTING.md`, `CODE_OF_CONDUCT.md` (Contributor Covenant 2.1),
  `SUPPORT.md`, `NOTICE`, issue forms (bug, feature request) and a pull request template.

### Changed

- **`LICENSE` is now the verbatim Apache License 2.0 text**, so it is recognised as Apache-2.0
  (the previous file was a reformatted copy with a modified section 9). Copyright moves to
  `NOTICE`; both `pyproject.toml` declare `license = "Apache-2.0"`, the extension declares its
  issue tracker.
- **Chat sessions are no longer tracked**: `.clike/sessions/` is ignored as a whole and the
  hygiene check rejects it.

### Fixed

- **Cancel stops every Harper phase, not only `/eval` and `/gate`**: a cloud `/kit` (or `/spec`,
  `/plan`…) went on after Cancel and its response was written, committed and auto-evaluated; with
  "prefer agent", stopping the agent started the same phase in the cloud; the auto-eval after a KIT
  and the `/finalize` verification started after a Cancel. The phase requests now carry the cancel
  signal (`Harper <phase> cancelled`), the response is discarded, a stopped agent never falls back
  to the cloud, and no follow-up step starts. Same for cloud and local agents.

- **An eval sandbox out of memory is recognised, not repaired**: under memory pressure the kernel
  slows the checks to time-outs and kills processes without any `ENOMEM` in their output; on B2B
  REQ-026 the 3 GB sandbox hit its limit 9 million times, two processes were OOM-killed, and the
  repair chased the resulting time-outs for several cycles. A check that fails while the cgroup
  counters show OOM kills or the limit held is now `EVAL_SANDBOX_EXHAUSTED`: `--fix` stops and the
  report says how to give the sandbox more memory.

- **The KIT acts as a senior engineer of the REQ's lane, for every stack and every executor**: the
  cloud prompt named only Python / TypeScript / SQL / Infra, and the local agents got no role at
  all. One sentence (shared text, checked by a test) now covers any lane — Go, Ruby, Java/Kotlin,
  .NET, PHP, Rust, mobile (Swift/iOS, Kotlin/Android, Flutter, React Native), PLC (IEC 61131-3),
  low-code (Mendix) — and says that checks whose toolchain is not in the eval sandbox (Xcode, Flutter,
  PLC IDEs, Mendix Studio Pro) are listed in `ci/HOWTO.md` as run on the developer's machine.

- **A local agent can verify a regression repair before it finishes**: `eval-check` accepted only
  the REQ's own checks, so on B2B REQ-025/026 the agent "verified" its repair without seeing the
  promoted REQ it was fixing. `node .clike/bin/eval-check.mjs regression::REQ-014` now re-runs that
  REQ's checks with the candidate overlaid (`/v1/eval/run` accepts `checks` with `regression_reqs`).

- **A reformatted shared file is no longer named as the cause of a regression**: on B2B REQ-026 the
  only difference in `worker.py` was a wrapped line, yet `Shared files changed` named it on REQ-014's
  failure and the repair spent two cycles there while the cause was elsewhere. Changes that are only
  whitespace are not listed.

- **Saved eval and gate reports keep each failed check's error excerpt**: `runs/eval|gate/<REQ>/report_*.json`
  kept only the last 4000 characters of a check's output; on B2B REQ-026 that tail was a pytest
  assertion diff (`++++…`), so a later `/kit --repair`, the intermittent-failure diagnosis and the
  autopilot read no error at all. The `excerpt` and `fingerprint` are now saved too.

- **KIT rule: tests assert what the REQ adds to an append-only list, never that it is the last**:
  a migration chain (this REQ's revision is in the chain after its predecessor, not the head), a
  version list, an API or event catalog, a navigation (its entries, not their count). B2B
  REQ-017's head-migration test broke at every REQ with a migration (REQ-019, REQ-025, REQ-026).
- **Three KIT rules reached the prompts as Python dicts**: an unquoted `word: ` made YAML read them
  as mappings (`{'Checks and tests …': 'later REQs …'}`), for cloud and local agents. Quoted; a
  test checks that no phase-text rule is parsed as a mapping.

- **A check known to be unstable no longer blocks another candidate**: B2B REQ-014's integration
  and REQ-016's e2e fail intermittently across REQs; one that passed on a re-run in one eval blocked
  the next REQ when it failed twice. CLike now remembers (7 days) the checks that failed and then
  passed on a re-run, with their error lines: failing again only with those errors, while passing
  on the promoted tree alone, is a warning. A new error, or none to compare, still blocks.

- **A KIT's own `regression` check no longer fails for tests it does not have**: on B2B REQ-025 and
  REQ-026 the KIT's `regression` check re-ran earlier REQs' tests (`file or directory not found`),
  and the repair, unable to drop a locked check, copied those tests into the KIT. When the eval
  includes CLike's regression, the candidate's regression checks are not run
  (`regression-checks::not-run`), as for promoted REQs: CLike's regression runs those tests itself.
  The helpers of a promoted test that imports the test tree as a package (`test.x.y`) are found.

- **An interrupted agent run is no longer a finished KIT**: on B2B REQ-026 the local agent stopped
  mid-run (model at capacity) and CLike committed its partial files as the KIT and ran the eval. An
  agent that exits with an error after writing files is now `LOCAL_AGENT_INTERRUPTED`: files kept,
  nothing committed or evaluated. `/autopilot` waits and retries on a model at capacity. A KIT
  without `ci/LTC.json` is incomplete for every executor (cloud or local agent), not committed.

- **A gate no longer reuses a verdict of an older eval engine**: the reusable eval verdict and the
  regression baseline were keyed on CLike's version number, unchanged between fixes; B2B REQ-025's
  gate reused an eval made before the fix that would have blocked it. The key now includes a digest
  of the eval engine code.

- **A test-layout file added next to the promoted tests fails the first eval**
  (`structure::test-layout::<root>`): a package marker, conftest, runner or build config (Python,
  JS/TS, Go, Java, .NET) a KIT adds in a test directory of the promoted tree changes how those tests
  are collected and import their helpers. B2B REQ-025 added `__init__.py` files under `test/`; the
  regression showed REQ-003 broken only three evals later.

- **"Already failing without this candidate" no longer hides new errors**: a promoted check that
  fails on the promoted tree too is a warning only when the candidate adds no error lines of its
  own (B2B REQ-025: REQ-003 missed the coverage threshold there, the candidate broke its imports).
  The baseline keeps the error lines; one kept before them is computed again.
- The files the candidate adds in a promoted REQ's test directories no longer include the
  candidate's own tests.

- **`/eval --fix` no longer stops when the regression first shows up**: the regression of the
  promoted REQs runs only once the REQ's own checks pass, so on B2B REQ-025 its 4 failures appeared
  at the last cycle and the loop stopped (4 failures, "up" from 2). Fewer failing checks of the REQ
  itself now count as progress: extra cycles (`clike.autoEval.extraCyclesOnProgress`) repair them.
- **An unstable check of a promoted REQ no longer blocks**: one that failed on the promoted tree
  without any candidate on a recent promoted state (7 days) and passes there now, while it fails
  with the candidate, is a nondeterministic warning (B2B REQ-014's browser integration).
- **Files the candidate adds in a promoted REQ's test directories are named** on its failing
  regression check (`Shared files changed`): on B2B REQ-025 a repair added `__init__.py` files and
  REQ-003's tests no longer imported their helpers. Two repair rules (cloud and agents): fix a test
  helper's import path the way the promoted tests do, never add package markers / conftest / runner
  config to test directories this REQ does not own; a promoted test that pins the latest state (the
  head migration, a full list) and this REQ extends on purpose is reconciled in the candidate test
  root, keeping every existing entry.

- **A missing module that is a file of the project is a code defect, not the environment**: `No
  module named 'x'` / `Cannot find module 'x'` was classified environment-blocked even when `x` is a
  test helper or package of the project (B2B REQ-025: `req019_support`, imported by a bare name the
  check's path did not include). It is now an ordinary failure for the repair; a missing dependency
  (not a project file, or only under `node_modules` / a venv) stays environment-blocked.

- **`/eval REQ --fix --methodology bmad` keeps BMAD in its repair cycles**: the repair KIT ran as
  plain CLike and the re-eval lost the QA advisory; now each repair is a BMAD developer KIT and each
  re-eval keeps the chosen role (also under `/autopilot --methodology bmad`). The `▶ KIT` / `▶ EVAL`
  lines show `methodology=bmad/<role>`, and the chat echoes `/eval` and `/gate` as typed instead of
  dropping `--methodology` / `--agent`.

- **Promotion resolves a spot the REQ only rewrote, and `conflicts.md` reads line by line**: when
  the gate ran the candidate with the regression of the promoted REQs, a spot where it rewrote
  `src/` lines without losing any (each has its new form, none of its words is gone from the
  candidate file) is kept from the candidate and listed in the report for review — B2B REQ-024's
  two conflicts (`LaunchForm.tsx`, `server-api.ts`) resolve this way. A line whose words are gone
  stays a conflict. `conflicts.md` now says, per spot, what the REQ rewrote, what it would drop
  (with the missing words) and what it adds, what to do, and the exact commands.
- **A shared test-support file keeps the names the promoted tests use, in any language**: a KIT that
  replaces a helper or fixture module of the promoted tree (B2B: `test/fixtures.ts`, shared by
  REQ-002/005/008/012) and drops a name their tests use now fails the eval at once
  (`structure::shared-test-support::…`, blocking) with the names and the tests that use them —
  Python, JS/TS, Java/C#, Kotlin, Go — instead of a regression failing late. Python's root
  `conftest.py` keeps its own check.
- **A reconciled JS/TS test gets the modules it imports in the regression**: a candidate that changes
  a shared test helper of promoted REQs (B2B REQ-024: `test/fixtures.ts`, used by REQ-002/005/008/012)
  and makes it import a new file (`./v2/req-024.fixtures`) had that file left out of their regression
  — only Python imports were followed — so their suites failed to load (`Cannot find module`) and
  the repair chased a regression that promotion would not cause. Relative JS/TS imports
  (`from`, `export … from`, `require`, `import()`) are followed now.
- **A repair can correct a test API misuse on an assertion line**: when the eval proves it — an
  option or keyword argument reported unknown on that line (TypeScript, mypy, pyright, Python), or
  a regex-shaped string a pattern matcher compared literally — the locked test may drop that option
  or pass the pattern as a regex literal, its expected values unchanged; the orchestrator checks
  that these are the only changes and the gate asks the developer to review them. Before, the
  repair stopped because the fix touched an assertion line (REQ-024: `getByRole(…, { exact: true })`
  and `toMatch('Senza limite.*scelta esplicita')`).
- **A REQ phase run from another branch is committed on the REQ branch**: `/kit REQ-021` run on
  `main` (after the gate of REQ-020 merged and left you there) wrote `runs/kit/REQ-021/` files that
  `feature/req-021` tracks, the switch was refused and the KIT stayed uncommitted. Those files are
  now carried onto the REQ branch and committed there; the same holds for the handoff documents of
  `/finalize` and `/spec` run from a REQ branch, carried onto `main`. Any other blocking file still
  stops the sync and loses nothing.
- **A deliberate edit of a REQ's locked tests / LTC no longer needs a new `/kit`**: `/eval <REQ>
  --accept "reason"` (`POST /v1/acceptance/accept`) accepts edits that weaken nothing into the
  lock, with author and reason in the audit log. The stop message of `/eval --fix` / `/gate --fix`
  now names the REQ whose surface changed — often a promoted REQ run by the regression, not the
  candidate — and its files, instead of always suggesting `/kit` of the candidate.
- **A service broken by the candidate is explained**: when a promoted REQ's service starts without
  the candidate but not with it, the repair is told the candidate made a configuration mandatory
  (keep it optional with a safe default, or declare the change), instead of only "service failed".
- **A promoted REQ already broken blocked every new REQ**: a regression failure that the candidate
  did not cause (B2B: REQ-002's service lacks `LEADINTEL_EXECUTION_CONFIG`, required since
  REQ-003) blocked REQ-020 and went to its repair. A remaining failure is now re-run on the
  promoted tree without the candidate; failing there too, it is a warning naming the REQ to fix.
- **The promoted version of a test missed its helpers, and services ran stale code**: a promoted
  reconciled test now gets the support files it imports from the canonical test tree (B2B:
  `req017_support.py`, `identity/__init__.py`); a service of another promoted REQ runs its
  promoted code with the candidate's source (B2B REQ-005's REQ-004 service imported an older
  `ports.py`).
- **Cancel did not stop an eval**: the chat's Cancel aborted only chat requests, so `/eval`,
  `/gate` and their `--fix` loops went on (also with VS Code closed, the eval kept running in the
  sandbox). Cancel (and MCP `cancel_run`) now closes the eval/gate request, which stops the eval
  in the sandbox, stops every local agent CLike started, and ends the repair loop; a cancelled
  agent's files are not sent to the orchestrator.
- **Reconciliations did not last**: the regression of a promoted REQ ran the original tests of its
  KIT, not the version a later REQ had reconciled and promoted, so every following REQ had to
  reconcile the same tests again (B2B: the migration head pinned by REQ-015/017/018 failed at
  each new migration). The promoted version now runs when it is newer in git; the shared root
  `conftest.py` stays the REQ's own.
- **A candidate carrying a promoted file replaced every REQ's copy**: B2B REQ-020 shipped the
  canonical `test/conftest.py` unchanged and the regression put it in place of the root
  `conftest.py` of eight promoted REQs (missing fixtures). A file identical to its promoted copy
  is no longer a reconciliation.
- **A promoted dependency without a promotion record brought old files back**: a REQ done before
  gate promotion records existed (B2B REQ-003) had its KIT overlaid over the canonical tree, so an
  older `ports.py` replaced the one later REQs had changed, and REQ-019 failed on names that were
  already promoted. Such a KIT file now wins only when its canonical copy is not newer in git.
- **Local agent timeouts**: the per-agent timeout settings were ignored (the common
  `clike.localAgent.timeoutMinutes` always won); now the executor's own timeout applies when set. A run that times out is no
  longer thrown away: CLike checks the files the agent wrote and, if the required outputs are
  there, the phase continues (normalization, eval); otherwise the error names the setting to raise.
- **Regression ran the old test after a reconciliation**: when a candidate reconciles a promoted
  REQ's test in its own test root (as the *Shared files changed* diagnosis asks), the regression of
  that REQ now runs the candidate's version, which is what promotion delivers. It is reported as
  the warning `regression::<REQ>::reconciled-tests`. Before, the repair could never converge.
- **A reconciled test could not import its new neighbours**: the candidate's new support files next
  to the promoted REQ's tests (`__init__.py`, `conftest`, helpers; never tests, by name or content)
  now come with the reconciled test. Before, a relative import (`from .conftest import …`) failed in
  the regression only.
- **A reconciled test could not import a helper outside its directory**: a reconciled test in
  `test/v2/` importing a helper the candidate put at the test root failed with
  `ModuleNotFoundError` in the regression only, and the repair could not fix it. A reconciled test
  now gets the support modules it imports (also through another helper) from anywhere in the
  candidate's test tree, plus a package marker or `conftest` beside it; a `conftest` elsewhere stays
  out, since the test runner would load it into the promoted REQ's own tests.
- **A repair of an unlocked test was undone**: governance rejected any change to a `test/` file
  without a digest in the acceptance lock, so a test added after the lock (a reconciled test of a
  promoted REQ) could not be fixed by a later repair, and the extension restored it. Such files
  are not locked acceptance: they are kept (returned as `unlocked`), for cloud repairs as for
  local agents.
- **`clike.localAgent.allowEval: false` was ignored**: `/eval` ran the local-agent pre-pass whenever
  a local executor was selected. The setting now skips it and the eval goes straight to the sandbox.
- **Merge-on-gate blocked by a KIT file of the REQ**: a tracked file of `runs/kit/<REQ>/` changed
  after its phase (e.g. `ci/HOWTO.md` updated by an eval pre-pass) was left out of the gate commit,
  and the switch to the default branch failed ("Your local changes … would be overwritten"). Every
  tracked change of the REQ's own KIT is now committed with the KIT, eval and gate phases.

## [1.5.1] — 2026-10-18 — CLike from Claude Code and Codex: MCP hardened, eval repairs that converge

### Added

- **`docs/howto-mcp-project.md`**: run a whole CLike project from Claude Code or Codex through MCP —
  setup (`.mcp.json` with `${CLIKE_API_TOKEN}`, Codex, the extension server), the phase loop with
  the tool calls, the next release, what MCP does not do, troubleshooting.
- **`harper_run_phase` takes `attachments`** (workspace-relative files, as *Attach → Workspace
  files*): `/idea` and `/idea --extend` can run fully through MCP.
- **`docs/images/clike-overview.svg`**: CLike at a glance (lifecycle, release loop, who writes,
  governance, runtime, MCP, outputs), in the README.

### Fixed (MCP)

- **Run reports of other locations could be read through the orchestrator MCP**: `runs_read`,
  `eval_read_summary` and `gate_read_decision` accepted any `run_id` (`..` left the runs
  directory). A run id is now a run directory name only, CLike's `state/` is never a run, and with
  `project_root` + `req_id` the eval/gate tools read that project's latest report.
- **Claude Code reported "Dynamic Client Registration rejected (HTTP 401)"** when the
  `Authorization` header was missing: OAuth discovery and `/register` answered 401, so the client
  attempted OAuth. They answer 404 now (orchestrator and extension), and the docs show the
  `.mcp.json` with `${CLIKE_API_TOKEN}` and `localhost`.
- **Extension operational MCP**: streamable HTTP as clients expect (202 for notifications, 405 for
  GET, `ping`, negotiated protocol version); one phase at a time, locked before the run starts;
  every run gets a `run_id` (also `harper_kit_next`, `harper_continue_loop`, `await: false`), the
  registry is bounded, `cancel_run` stops a run; a run that stops early says why, and confirmations
  are answered with `confirm: true` instead of a modal nobody sees; `harper_run_phase` takes `text`,
  `methodology`, `agent` and `extend` / `release` / `dry_run` (`/idea --extend`);
  `harper_next_action` follows `dependsOn` and finishes an in-progress REQ first.
- CLike's own Claude Harper runs load no MCP server (`--strict-mcp-config`). The orchestrator MCP
  states that its `rag_reindex_*` tools write the RAG index.

### Fixed

- **`/eval --fix` could not remove a root conftest it was asked to remove.** The repair moved the
  REQ's fixtures into its package and deleted the KIT root `test/conftest.py` that
  `structure::shared-conftest` flagged, but CLike restored every deleted locked file: the same
  failures came back at every cycle. A test-support file that defines no test and that the eval
  itself named can now be removed (audited, out of the lock); a test file never.
- The eval reports saved by the extension keep each check's `duration_s`.

## [1.5.0] — 2026-10-18 — Release after release: /idea --extend, faster eval and gate, cloud context parity

### Added

- **`/idea --extend` — the next release of a delivered project.** One command runs the cascade
  IDEA → SPEC → PLAN in continuity with what exists. The release inputs live in versioned folders,
  `docs/inputs/vN/` (requirements) and `docs/reference/vN/` (background), plus any attached file (an
  attachment is required only when `docs/inputs/vN/` is empty); earlier
  releases are read as history, never as new requirements. IDEA, SPEC and TECH_CONSTRAINTS are
  merged, not regenerated (a document that drops a section of the earlier release is restored);
  the PLAN gets new REQs typed `ADDED`, `MODIFIED` (`amends`, `supersedes` the checks it replaces,
  `unchanged`) or `REMOVED` (`retires`), with `release` and `origin`, while delivered REQs stay
  read-only. CLike checks the baseline is delivered, tags it `harper/v<N-1>`, validates the delta
  and appends its own verification to the EXTEND report; `--dry-run` writes only the report. Then
  `/kit`, `/eval --fix`, `/gate` and `/finalize` as usual. BMAD works on it:
  `--methodology bmad --agent analyst|pm|architect|ux` (default `pm`), also on `/extend`.
- **The regression follows declared changes.** Checks a `MODIFIED` REQ supersedes are not run for
  the REQ it amends (reported as `superseded`, with the reason); a REQ retired by a `REMOVED` REQ
  leaves the regression set. Every other check of delivered REQs keeps running.

### Changed (cloud context = local agent context)

- **A cloud KIT now receives what a local agent reads**: the REQ's slice of PLAN.md, the code its
  dependencies delivered (dependency surface, chosen deterministically from the promotion reports,
  interfaces first, with their HOWTOs), the repository and promotion manifests, the locked tests of
  acceptance-first, the REQ and BMAD companion documents — before, the KIT message kept only their
  names. The KIT follow-ups get the REQ's slice of PLAN.md and plan.json instead of the whole files.
- **Dependency sources via RAG were mostly missed**: the prefix lookup scanned only the first 200
  points of the collection; it now scans the whole collection.
- **Cloud FINALIZE** receives IDEA, SPEC, TECH_CONSTRAINTS, a PLAN digest, a plan.json index and the
  solution surface (it used to get their names and 12 chunks of `src/`); **`/idea --extend`** sees the
  IDEA it merges into; **PLAN** gets IDEA; companion documents go with their content.
- The acceptance stage of an acceptance-first KIT reads the context sources and the dependency
  sources; a manual `/kit --repair` carries the latest failures and files; the local KIT and
  FINALIZE packages receive the attachments; cloud `/idea` accepts the project's context sources.
- The repair receives the head and the tail of a long check output (CLike's diagnosis is at the
  head, the runner's error at the end; only the tail was kept). Lane guides are indexed again after
  `/extend` and `/idea --extend`, and the KIT `root/` files are indexed with the candidate. The
  selected-capability guidance reaches the cloud KIT up to 20k chars (8k before).
- **A cloud run that cannot fit is refused with its size** (`cloud_context_too_large`,
  `CLIKE_CLOUD_MAX_PROMPT_CHARS`, `CLIKE_CLOUD_MAX_OUTPUT_CHARS`) instead of overflowing the model.

### Changed (speed, same verdicts)

- **The gate does not run the eval again when nothing changed.** A full `/eval` records its
  verdict with a digest of its inputs computed by the orchestrator (canonical code, root
  deliverables, the REQ's KIT, every LTC, `plan.json`, CLike version); `/gate` on the same inputs
  reuses a passing verdict and still checks acceptance integrity and required outputs. Any change
  runs it again.
- **The regression runs only what guards behaviour.** Lint, types, security scans, coverage,
  syntax and SBOM checks of promoted REQs (non-blocking there, passed at their own gate) are not
  run; tests, installs and builds are. On B2B this is about two thirds of the regression cases.
- **Installed `node_modules` are shared** across work copies by package.json + lockfile digest
  (hard links), instead of an npm install per REQ and per eval.
- **Each check reports its duration** (`duration_s`).

### Added (KIT)

- **A KIT can deliver repository-root files.** Run and setup scripts, deployment scripts,
  infrastructure and root manifests go under `runs/kit/<REQ>/root/<path>`; the gate promotes them
  to `<path>` with the same 3-way merge and report, the eval and the regression see them at the
  workspace root, and the regression names them when a promoted check fails on them. Allowed:
  `scripts/`, `deploy/`, `infra/`, `ops/`, `config(s)/`, `migrations/`, `db/`, `.env.example`, compose
  files, `Dockerfile`, `Makefile`, `Procfile`, plus `root_folders` / `root_files` in
  `.clike/project.json`; never `.git`, `.clike`, `runs`, `docs`, `src`, `test`, `ci` or private files.

### Fixed

- **A KIT that rewrote the shared root `conftest.py` passed the gate and then stopped the
  promotion on a conflict** (B2B REQ-015 replaced `test/conftest.py` and dropped 15 fixtures of the
  delivered REQs). The eval now checks it (`structure::shared-conftest::test`, blocking): a root
  conftest of a KIT keeps every fixture and helper of the canonical one; the REQ's own fixtures go in
  its package conftest. `/eval --fix` repairs it before the gate.
- **Cloud KITs could not deliver repository-root files**: the gateway accepted only
  `runs/kit/<REQ>/{src,test,docs,ci}` file blocks, so `root/` deliverables were dropped on the cloud
  path; cloud, Codex and Claude Code now share the same KIT roots.
- **A document phase run from a REQ branch hid the KIT.** `/spec` (and the other document
  phases) committed on the default branch and stayed there: the REQ's KIT disappeared from the
  working tree. CLike now switches back to the REQ branch and merges the documents into it.
- **`/spec --methodology bmad --agent ux` overwrote TECH_CONSTRAINTS.yaml** from the IDEA block,
  dropping the release additions of `/idea --extend`, and its prompt told the agent to regenerate
  SPEC.md without reading it. The UX role is companion-only: it reads the canonical SPEC and never
  writes SPEC or TECH_CONSTRAINTS; `/spec` no longer derives TECH_CONSTRAINTS once the project has
  releases. Its commit names the UX documents.
- After `/idea --extend`, the PLAN.md sections that index every REQ (REQ-IDs table, dependency
  graph, per-REQ test strategy and KIT readiness) did not list the new REQs when the agent put them
  only in the `## Release vN` section: CLike now adds them (table rebuilt from plan.json, pointers to
  the REQ's own subsections) and says so in its verification.
- The chat could not send any message (Enter or Send) after the previous fix: the webview copy of
  the command parser missed a constant; it is now included and tested by running that copy.
- A command pasted with a terminal border or a quote marker in front (`│ /idea --extend`) was sent
  as plain chat text to the agent; decoration before the `/` is now ignored.

### Changed

- Context sources: release folders (`docs/inputs/vN/`, `docs/reference/vN/`) split the current
  release from history (role `previous_release`); `docs/reference/**` is part of the default
  convention. `/extend` never changes TECH_CONSTRAINTS, and its cloud prompt now carries the
  request of the command (anchor, REQ id, text).

## [1.4.4] — 2026-10-18 — The solution running and configured on the developer's machine

### Changed

- **The README written by `/finalize` says it is a CLike project**: CLike, Harper and Finalize
  badges linked to the CLike repository, its Harper lifecycle and `FINALIZE_REPORT.md`, and a
  closing *Made with CLike* section with links to the Harper documents, the report and the
  solution evidence (cloud and local agents). A README without it fails the solution
  verification (`structure::readme-clike`) and the repair adds it.
- **`/finalize` brings the solution to running and configured, without running the tests
  again.** Every REQ passed its tests at its gate: the solution profile now installs, builds,
  configures and starts the solution and smoke-checks it while it runs (health, one real request
  per main capability, the main pages). The repair looks for configuration causes first
  (variables, URLs, ports, services, migrations), then tools, wiring and code. `/finalize` writes
  `docs/harper/FINALIZE_REPORT.md` for the developer — how to start and see the solution, every
  variable, the information only the developer can give, every change and why, the problems met
  and how they were solved — and `scripts/setup_local` / `start_solution_local`; after a passing
  verification CLike offers to configure and start it on the developer's machine.
  `docs/harper/SOLUTION_EVAL.md` also lists the verification cycles and the last gate of every
  REQ.

### Fixed

- **The solution started by `/finalize` could not start on the developer's machine when a host
  port was taken** (the CLike gateway listens on 8000): the setup script now picks a free port
  and updates the values derived from it, the start script names the busy port and its variable,
  and the report lists the ports.
- **The chat stayed busy after a passing `/finalize`** until the developer answered the offer to
  configure and start the solution locally; the offer no longer holds the chat.
- **`/finalize` committed only part of the solution it verified.** Files in a new directory were
  missed (`git status` listed only the directory), and the work of an earlier `/finalize` run that
  ended before its commit was taken for the developer's own changes. The developer's changes are
  now recorded once per round (`runs/finalize/DIRTY_BEFORE.json`, by content) and the record is
  dropped only after a finalize commit succeeds; the developer report accumulates the changes and
  problems of every run.
- **A local-agent `/finalize` was rejected for writing the solution.** The extension checked its
  files with the KIT rule (no `src/`, no `docs/harper/`): `/finalize` writes exactly there. It is
  now checked against the write roots and forbidden paths of its own package (never `test/`,
  `runs/`, `.git`, `.env` or caches). The finalize run scripts detect `docker compose`,
  `podman compose` or `podman-compose`, and offer the native run when no container runtime is
  installed.
- **A solution's services started before it was installed.** The eval starts the services before
  the checks, so an install written as a check came too late (the frontend could not find its
  framework). Eval profiles get a `setup` step that runs before the variables and the services;
  the `/finalize` profile installs and builds there.
- **A REQ promoted by its gate was not merged into `main`, without a word.** A CLike agent file
  of the REQ (`runs/kit/<REQ>/docs/AGENT_*`, rewritten at every eval) was modified and blocked
  the switch; it is now committed with the phase, and a failed merge-on-gate shows the cause and
  the commands. `/finalize` warns when REQ branches are not merged into the default branch it
  commits on. Git status paths no longer lose their first character in the log.
- **`/finalize` left its verification uncommitted.** `ci/SOLUTION_LTC.json`, the smoke scripts,
  the evidence and the report are committed when the verification ends; compose files are
  finalize outputs too. Changes the developer had in the working tree before `/finalize`, and that
  it did not touch, stay out of its commits. `/finalize` lists the REQs not promoted yet and asks
  before it runs; a repair cycle that cannot run says so.
- **Promotion repeated code at every gate.** Where both sides only added lines, auto-merge kept
  both even when `src/` already had the candidate's additions (an earlier REQ promoted them, or
  the same REQ was gated again, against a KIT base older than `src/`): composition files such as
  `app.py`, `conftest.py`, CSS tokens and `.env.example` grew a copy per promotion, up to code
  that no longer compiled — unseen by the gates, which run the KIT copy. Now the side that
  contains the other wins, overlapping additions are a conflict, a merge that would repeat lines
  both sides added is a conflict, and merged Python/JSON/JS files are checked before they are
  written. Promoting the same REQ twice changes nothing.
- **A resolved promotion conflict came back at every gate.** After the developer writes the
  right content into `src/` and deletes the `.conflict-…` file, the next gate keeps `src/` for that
  file (while the KIT file is the one that conflicted). KIT rules: a shared file several REQs
  extend keeps what the others put there, and REQ-specific test fixtures go in the REQ's own
  test package, not in the root conftest.
- **A REQ that broke an earlier REQ through a shared file had to guess why.** When a promoted
  REQ's check fails in the regression, the eval now names the files of that REQ the candidate
  replaced, with a short diff, and the repair notes list them (any language: test runner configs
  whose selectors no longer find the earlier tests, compose files and manifests, changed
  components). KIT rules: test runner configs, infrastructure and build manifests are shared
  files that keep the earlier entries; checks assert what their REQ adds, never an exact set.
- **A REQ with promotion conflicts was merged into `main`.** Merge-on-gate now runs only for a
  promoted REQ; otherwise CLike says it stays on its branch until the conflicts are resolved.

## [1.4.3] — 2026-10-17 — A sandbox that stays healthy, tools when an eval needs them

### Added

- **Eval tools stay current, on purpose.** `/tools update` and `./rebuild.sh --update-tools`
  rebuild every installed tool at its latest version (the image's PostgreSQL client too) and show
  `old → new`; a failed rebuild keeps the previous version. Versions are otherwise locked: each
  tool records an exact lock (micromamba explicit spec, `pip freeze`, archive digest), the
  orchestrator keeps a copy and the rebuild restores a new volume identically. `/tools` and the
  rebuild remind you after 30 days. Eval and gate reports record the tool versions they ran with.
- **One environment per tool**, so two tools never change each other's versions (`jdk@17` and
  `maven`), and two new kinds of catalog entry: `pip` for CLIs published on PyPI (`azure-cli`,
  whose conda-forge package does not resolve) and `download` for vendor archives, https only,
  verified by sha256 before they are unpacked. All catalog entries checked on conda-forge for
  linux-64 and linux-aarch64.

- **Native tools in the eval sandbox, installed when an eval needs them.** A catalog of clients
  and toolchains (databases, messaging, AWS/Azure/GCP CLIs, Kubernetes/IaC, quality scanners, JDK,
  Maven/Gradle, .NET, Go, Rust — conda-forge, both architectures). Before an eval CLike finds
  what the REQ declares (`environment.tools`) or runs and the sandbox lacks, asks the developer
  (`clike.evalTools.install`: ask | always | never) and installs it into a volume the sandbox
  mounts read-only; a check that stops on a missing program is installed for and run again, never
  repaired. `.clike/eval-tools.yaml` approves tools for a project and adds its own conda-forge
  packages. `/tools` lists, searches, adds and removes.

### Improved

- **Eval disk under control.** One npm cache per project instead of one per eval directory (40
  copies, 7.6 GB on a real project), and stale eval directories are pruned before an eval (the
  3 REQs used last kept; least recently used removed when the volume runs low; no eval below 2 GB).

### Fixed

- **A flaky test of a promoted REQ blocked the gate of another REQ.** A blocking regression test
  that fails is run once more; passing then, it is a nondeterministic warning naming its REQ, not
  a regression, and is not sent to the candidate's repair.
- **A cache a local agent wrote inside the KIT broke the eval.** The KIT copy now skips scratch and
  caches (`.tmp`, `.cache`, `.npm-cache`, `.next`, `local-eval-workspaces`) like the overlay copy,
  skips files removed during the copy, retries the preparation once, and a workspace CLike cannot
  compose is environment-blocked: `--fix` stops instead of "repairing" it. KIT and repair rules ask
  agents to keep their caches outside `runs/kit/<REQ>/`.
- **`/eval --fix` repeated the same errors when a locked test was wrong for the type checker.** A
  mypy/pyright error reported on a test file (`test_a.py:286: error: … [arg-type]`) now counts as
  evidence that the test is wrong, like a TypeScript error: the fix, with every assertion
  unchanged, is accepted for review instead of being reverted at every cycle.
- **A local agent's rejected test change was committed.** The phase commit ran before the
  governance restored the file: `HEAD` held the rejected change, the working tree the locked test.
  The governance now runs before the commit.
- **Backup/restore checks failed for a missing `pg_dump`.** The eval sandbox image has the
  PostgreSQL client tools (`psql`, `pg_dump`, `pg_restore`, major 18 from PGDG).
- **A blocking check that needs Docker could never pass.** The sandbox has no container runtime:
  such a failure is recognised (`docker: not found`, `Docker Compose … required`, daemon not
  reachable), the repair is told to make the check non-blocking and the governance accepts that one
  change; non-blocking, it is a warning. The KIT rules list what the sandbox has and lacks.
- **Acceptance governance ignored LTC files written with `commands`.** Checks are read in every
  shape the runner accepts, so removing or relaxing a check is detected there too.

- **`/gate --fix` repaired correct code for a broken sandbox.** The eval sandbox ran with uvicorn
  as PID 1, which never reaps the processes the checks orphan (servers, browsers, esbuild): their
  zombies filled `pids_limit` within a day of evals, and every check then failed with
  `spawn EAGAIN`, `pthread_create: Resource temporarily unavailable`, a closing browser or a web
  server that "exited early". Those failures were treated as code defects and sent to the repair,
  with the note "the failure most likely comes from that change". Now:
  - the sandbox runs with an init (`init: true`) and what a check or a service leaves in its
    process group is stopped when it ends;
  - the OS refusing a process, thread, memory or disk is environment-blocked, the report says
    `EVAL_SANDBOX_EXHAUSTED` / `GATE_BLOCKED_SANDBOX_EXHAUSTED` and `--fix` (eval, gate, finalize
    verification) stops with how to recover; a local agent's `eval-check` answers `BLOCKED`;
  - an eval does not start in a sandbox already at 60% of its process limit;
  - environment-blocked failures get no "passed in earlier runs" note;
  - the sandbox `/health` shows processes in use, zombies and PID 1.

## [1.4.2] — 2026-10-15 — Conflicts you can read, plans that stay intact

### Added

- **`conflicts.md` in the promotion report**: every spot still in conflict, readable without
  conflict markers: what `src/` has now, what the REQ wants, the diff between the two, the base,
  and what to do. The report and the chat point to it.

### Improved

- **Fewer promotion conflicts**: a spot where the candidate holds the whole canonical side plus
  its own additions (a later KIT rewrote a line an earlier REQ had already promoted) now merges,
  keeping the candidate: nothing of `src/` is lost and it is what the gate tested. A file with
  both kinds of spot is merged where it can be; its `.conflict-…` file holds only the rest.
- **The "nondeterministic failure" diagnosis needs the same code**: each eval/gate report stores
  `inputs_fingerprint` (canonical roots + KIT); a check is called nondeterministic only when it
  passed earlier on the same code. Otherwise the repair is told the failure most likely comes from
  what changed since.

### Fixed

- **Eval and regression ran on stale code of promoted REQs.** The eval workspace overlaid the KIT
  of every dependency, and the regression of a promoted REQ its own KIT, over the canonical tree:
  a file a later promoted REQ had changed came back in its old version (a candidate using it
  failed, a regression ran on code that does not exist). A REQ that is done with a successful
  auto-merge promotion is now taken from the canonical tree only; REQs without a promotion record
  are composed as before.
- **`/extend` could change existing REQs**: the append-only rule was only in the prompt. The
  extension now checks the returned plan.json: changed or removed existing REQs are restored,
  broken ids/sequence/anchor/dependencies reject the result (a local agent's plan is put back).
- **`/init --force` overwrote an existing project** (README, docs, every template file) and
  replaced `.gitignore`. `--force` now only allows a non-empty folder: missing template files are
  added, existing ones kept, `.gitignore` gets the CLike rules it lacks.
- **Context sources skipped source code** (`.py`, `.java`, `.go`, … were "unsupported format").
  They are read now, with the new role `existing_code`.
- **A `.conflict-…` file left in `src/` failed the gate**: the eval workspace copied CLike's
  promotion leftovers (`.conflict-…`, `.incoming-…`, `.bak-…`) and a format check read them
  (`trailing whitespace`). They are never copied now.

## [1.4.1] — 2026-10-13 — The gate repairs what it finds

### Added

- **`/gate REQ --fix ["hint"]`: the gate repairs what it finds.** A gate re-runs every check and
  the regression, so it can fail where the eval passed. With `--fix` a failing gate gets the same
  KIT repair as `/eval --fix` (tests locked, governed test/ci changes, same cycle limits and stop
  rules), then a full gate again: only a gate run on the repaired candidate promotes it. Missing
  required outputs reach the repair as failures; a tampered acceptance surface and promotion
  conflicts are not repaired.
- **Intermittent failures are diagnosed without a hint.** Before a repair (`/eval --fix`,
  `/gate --fix`) CLike reads the earlier eval/gate reports of the REQ; a failing check (or test)
  that passed before reaches the repair flagged as nondeterministic: make the code deterministic,
  do not change the asserted value. Found on a test whose count depended on jobs ordered by random
  UUIDs: it passed in 3 of 5 runs.
- **What each repair received is written next to the report**:
  `runs/<eval|gate>/<REQ>/repair_<REQ>_<ts>.md` (the developer hint, if any, CLike's diagnosis,
  the failing checks).

### Improved

- **`/eval --fix` repairs from all the errors, in both modes.** Measured on a Next.js REQ, three
  defects hid the errors from the model:
  - the cloud repair prompt filled its 160k-character file budget alphabetically with CLike's own
    context files, so **no `src/` or `test/` file** reached the model; the files named in the
    errors now come first, then tests, sources, CI and docs, and CLike context files and lockfiles
    are listed, not shown;
  - a failed check carried only the **tail** of its output, with ANSI codes and DOM dumps (the
    first failing test was lost), and the local-agent prompt cut it to 1500 characters on one line;
    the eval runner now extracts the error blocks of the whole output (`excerpt`, `fingerprint` in
    the report) and both prompts get them whole;
  - a test that ran and failed (`element(s) not found`, a missing module of the candidate) was
    classified **environment-blocked**, i.e. "the sandbox, do not change code".
  Checks with the same errors are listed once, non-blocking regression warnings of other REQs are
  left out, the repair rules ask to group the failures by root cause and fix them all, and "no
  progress" now means the same errors, not only the same check names.
- **The local agent re-runs the failed checks in the real eval sandbox while it repairs**
  (`node .clike/bin/eval-check.mjs <check>…`, served by the extension; `clike.autoEval.agentEvalChecks`,
  default 8 runs): it iterates until they pass in one session instead of one attempt per cycle. The
  agent gets neither the orchestrator token nor network access; a partial run (`/v1/eval/run`
  `checks`) is never a verdict.

- **`/finalize` verifies that the integrated solution runs end to end, and repairs it** (no flag;
  `clike.finalize.verify`, `clike.finalize.verifyMaxCycles`). `/finalize` writes
  `ci/SOLUTION_LTC.json`, the eval profile of the whole solution (install, the promoted test
  suites on the canonical tree, build, the solution started as services, e2e), derived from the
  REQs' eval profiles it now receives; CLike runs it in the sandbox against the canonical tree
  (without `runs/`, `.git`, `.clike/`) and, while it fails, runs `/finalize` again with its errors.
  A local agent checks the profile in the sandbox while it works and runs the local scripts on the
  developer's machine. On-prem: the local run is the target; cloud: guarded, non-mutating deploy
  checks. Evidence in `docs/harper/SOLUTION_EVAL.md`.
- The eval-check helper resumes the same run when an agent's command timeout stops it (Claude
  Code stops shell commands after 2 minutes by default); Claude Code gets `--allowedTools` for it.

### Fixed

- **Extension dev dependencies: 0 known vulnerabilities.** `@vscode/vsce` 3.9.2 → 4.0.0 (packaging
  tool only, not in the VSIX): its `secretlint → globby → fast-glob → micromatch → braces` chain had a
  high-severity DoS (`braces`, no patched version). Requires Node ≥ 22 to build the VSIX.
- **Merge-on-gate left `main` unpushed when the remote `main` had moved** (e.g. a PR merged on
  GitHub): the push was rejected as non-fast-forward and only logged, so the REQ branch reached
  the remote and `main` did not. CLike now fetches and merges `origin/main` before merging the
  REQ, then pushes; a conflict or a failed push is shown as a warning with the command to run.

- **Git: the KIT of an `/eval --fix` repair (and every eval report) was staged but never committed.**
  The phase files included paths the project ignores (`runs/eval/…`, `runs/kit/<REQ>/reports`,
  `ci/reports`): one ignored path makes `git add` fail, and the phase commit was skipped. Ignored
  paths are now left out (logged) and the rest of the phase is committed.
- **`/gate` auto-merge: a new file under a Next.js dynamic route (`app/runs/[run_id]/page.tsx`) was
  a false conflict** ("removed from the canonical root after the KIT", no marker file): for a path
  with `[ ]` that is not in the base commit `git show rev:path` exits 0 with no output, so the base
  looked like an empty file. The base is read with `git cat-file blob`, which fails on a missing path.
- **`/eval --fix`: the eval pre-pass undid a verified repair, and every cycle took ~15 minutes.**
  On a Next.js REQ the local-agent pre-pass of the eval after a repair rewrote the fix the repair
  had just verified in the sandbox (unit tests 37/37 → the same failures again). The eval after a
  repair now runs without the pre-pass, and the regression of the promoted REQs runs only once the
  REQ's own blocking checks pass (~4 of ~6 minutes saved per failing cycle). A local agent's run
  timeout is extended by the eval checks it may wait for.

- **A local-agent KIT failed with `LOCAL_AGENT_REQUIRED_OUTPUTS_MISSING` although it wrote `src/`
  and `test/`.** The artifacts sent to the orchestrator are capped (500 files, 8 MB) and were kept
  in discovery order: an agent's scratch in `ci/.tmp` (27 MB of tool installs) filled the budget
  and the code and tests were dropped. Scratch (`.tmp`, `.npm-cache`, `.npm`,
  `local-eval-workspaces`) is never sent, and within the budget `src/` and `test/` come first, then
  the CI profile and the docs; dropped files are logged.

- **`/kit` failed with `CLIKE_SELECTED_CAPABILITIES_MISSING` on a REQ run again.** The selected
  capability context was read from the first blob named like it: a copy left in the REQ's KIT by an
  earlier run, sent back truncated, was not valid JSON and the context the orchestrator had just
  built was ignored. This run's context now comes first, then the REQ's copy, and unreadable copies
  are skipped (context envelope and cloud prompt).

- **`/init`: the project CI workflow failed on every project** (it installed a root
  `requirements.txt` and ran a CLike-internal module). It now runs repository checks that fit any
  Harper project: `plan.json` valid, no `.env`/local state committed, no promotion leftovers or
  conflict markers in `src/`/`test/`. The generated `.gitignore` also ignores eval reports
  (`runs/**/ci/reports/`, `runs/**/reports/`), which, tracked, kept the tree dirty and blocked the
  switch to the next REQ branch.

- **Eval: `CLIKE_EVAL_TEMP_ROOT` is exported to the checks.** The KIT prompts tell CI scripts
  that CLike provides it, but it was only in the internal path map: scripts that require it
  failed (`build`, `e2e`, `integration` of a Next.js KIT).
- **Regressions no longer receive the candidate's installed dependencies.** The candidate's
  source overlaid into the workspaces of promoted REQs included `node_modules` (and `.next`,
  `.venv`, caches): another REQ's tests loaded the wrong Vitest ("cannot be imported in a CommonJS
  module") and its secret scans flagged files inside `node_modules`. Overlays skip installed and
  generated directories.
- Context files CLike writes for the local agent end with a newline (KIT format checks).
- `ci/FILE_REQUIREMENTS.json`, `ci/TARGET_CONTRACT.json` and `ci/REQ_PROMOTION_MANIFEST.md` are
  written by CLike from the plan at every package: they are not part of the acceptance lock (a
  rewrite reported `ACCEPTANCE_TAMPERED`).

## [1.4.0] — 2026-10-11 — Autonomous eval and gate

### Added

- **Test infrastructure for the eval sandbox** (`docker/eval.env`, git-ignored, template
  `docker/eval.env.example`): variables the projects' tests need, such as a real PostgreSQL test
  database URL, reach the sandbox only. Credential-like names are still refused.
- **Eval environment provisioning** (`orchestrator/eval_environment.py`): CLike creates what the
  checks declare in `ci/LTC.json` instead of asking the developer: `environment.required_variables`
  with `provision` `token` / `uuid` / `timestamp` / `template` (generated per run),
  `postgres_database` (a disposable database per REQ, recreated every run, on the server of
  `CLIKE_EVAL_POSTGRES_URL` in `docker/eval.env`), `service` or `external`; and
  `services: [{name, req, cwd, setup, start, env, port_env, ready, exports}]`, started before the
  checks from the composed source and dependencies of another REQ (e.g. the API of REQ-001 for the
  integration tests of REQ-002) or of the candidate, on a free loopback port, and stopped after.
  Values set in `docker/eval.env` win. KIT prompts (cloud and local agent) and `ci/HOWTO.md`
  follow the contract.
- **`/eval --fix` repairs a missing environment** when a repair can declare it (`BLOCKED` with
  `environment_repairable`): the repair completes the LTC `environment` / `services` (an audited,
  non-weakening amendment). Only values marked `external` or the database server stop it without
  spending tokens.
- **Locked JS/TS tests can be fixed when the eval shows the test itself is wrong** (a TypeScript
  error reported on the test file, a TypeError/ReferenceError raised in it, an unresolvable
  import), with every test title and assertion unchanged and no skip/only/todo added; flagged
  `review_required` at the gate. Until now only Python tests had this, so a correct repair of a
  TS fixture was reverted and `--fix` kept failing on it. The eval pre-pass now receives the
  previous failures as evidence too.
- **`/gate` promotes by auto-merge, without prompts** (`clike.gate.autoPromote`, default `merge`):
  a 3-way merge per file of `runs/kit/<REQ>/{src,test,tests}` into the canonical roots (base =
  the canonical state before the KIT), conflicting files never written (a `.conflict-<REQ>-<ts>`
  file holds the markers and the REQ stays in progress), installed/generated content never
  promoted, and a report with per-file outcome and unified diff in
  `runs/kit/<REQ>/promotion/<ts>/` (`report.md`, `report.json`, `promotion.diff`), opened at the
  end and summarized in the chat. `/gate --ask` / `--no-promote` override it for one run.
- **Auto-merge base = what the KIT started from**: per file, the last direct dependency KIT
  (`plan.json` `dependsOn`, the same composition the eval uses) that has it, else the canonical
  file at the KIT commit, else at the last commit before the KIT was generated (KIT never
  committed). Lines added at the same place by both sides (e.g. new `.env.example` entries) are
  kept both; changes to the same existing lines stay a conflict. Conflict files show the base
  (`|||||||`).
- **Git: a new REQ branch no longer fails on an unmerged previous REQ.** With merge-on-gate off,
  `feature/req-<n+1>` was created from `main`; local changes (plan, reports) made the switch fail
  and every phase of the REQ stayed uncommitted, silently. The new branch is stacked on the
  current branch when it is not merged into the default branch (it carries the code it depends
  on; creating it never conflicts with local changes), and Git failures are shown as warnings.
- **`/eval --fix` keeps going while it improves**: after `clike.autoEval.maxCycles`, up to
  `clike.autoEval.extraCyclesOnProgress` (default 3) more cycles as long as each one leaves fewer
  failing checks.
- **RAG indexing is batched and incremental.** The orchestrator embedded one chunk per gateway
  call (a project re-index took 5 minutes inside every `--fix` cycle); it now sends batches
  (`RAG_EMBED_BATCH_SIZE`, default 64, `RAG_EMBED_CONCURRENCY` 4) and skips files whose content
  is already indexed (point ids derive from path + content). The gateway `/v1/embeddings` accepts
  a list input and returns one vector per item in one provider call (it joined the items before).
- **`/eval` checks the required variables first.** The KIT declares them in `ci/LTC.json`
  (`environment.required_variables: [{name, purpose, example}]`; the free-form
  `environment: {NAME: "Required ..."}` of earlier KITs is understood too). When one is missing
  from the sandbox, the eval reports `BLOCKED` (`reason_code: EVAL_ENVIRONMENT_MISSING`) with the
  variable names and the `docker/eval.env` line to add, runs no check, and `/eval --fix` stops
  without a repair (no tokens spent on code that is not at fault).
- KIT (cloud and local agent): `ci/HOWTO.md` gets a mandatory `## Run with CLike /eval` section
  (required variables, `docker/eval.env` lines, one-time setup, rebuild, `/eval` and `--fix`).

### Fixed

- **`/eval` failed with `ACCEPTANCE_TAMPERED` from the second run on.** The acceptance lock hashed
  the files the eval itself writes (`ci/reports/**`: test/coverage/bandit reports, built wheels),
  so every later run found them "modified". Eval outputs (`reports/`, coverage files, `dist/`,
  `build/`, caches, `*.whl`, `*.pyc`, `*.log`) are no longer part of the acceptance surface, and
  locks written by earlier versions ignore their entries for those paths, without re-locking.
- **`/eval` with a local agent failed with `ACCEPTANCE_TAMPERED` after its own pre-pass.** The
  eval pre-pass agent repairs the candidate and could edit locked files under `test/` and `ci/`
  (e.g. add a test, rewrite a CI record) with no governance, so the canonical eval that follows
  found the surface changed. The acceptance surface is now locked before the pre-pass and the
  pre-pass changes go through the same audited amendment as the `--fix` repair: accepted ones are
  recorded, the others are restored. The eval agent is told that `test/` and `ci/` are locked and
  that evidence goes under `reports/`.
- **Telemetry: prompt-cache tokens priced** (cloud and local-agent runs). OpenAI cached input was
  charged at the full input price and Anthropic cache reads/writes were not charged at all; costs
  now use the list prices of `configs/models.yaml` (`cached_input_per_1k`, and for Anthropic
  `cache_write_per_1k` / `cache_write_1h_per_1k`, added from the Anthropic price page), rows
  recorded before are recomputed when shown, and the portal shows the cached tokens.
- Files CLike writes as JSON (promotion manifest, contexts, state) end with a newline: a KIT
  format check failed on the promotion manifest of a promoted REQ.
- **Telemetry portal: cost always 0 for Codex runs.** Codex reports tokens but no cost, so its
  rows had an empty `pricing`. The portal now estimates the API-equivalent cost from
  `configs/models.yaml` (new optional `cached_input_per_1k`; set for `gpt-6.1-sol`), also for the
  rows already recorded, marked `pricing.estimated`.
- **Eval sandbox OOM-killed on large JavaScript installs** (`503 eval sandbox unavailable`, then
  `npm install` exit 137 and every check `ENOENT`). Its work dirs (venvs, `node_modules`, npm
  cache) lived on the tmpfs `/tmp`, which counts against the container memory limit. They now live
  on the `eval_work` disk volume (`CLIKE_EVAL_BASE_DIR=/var/clike-eval`); `/tmp` is 1 GB. The image
  ships Node.js 22 LTS instead of 20 (current Next/Vitest/ESLint need it) with npm 11 (the
  bundled npm 10 crashed resolving some peer sets: `reading 'edgesOut'`); Playwright browsers and
  other tool caches (`XDG_CACHE_HOME`, `PLAYWRIGHT_BROWSERS_PATH`) are on the volume as well.
- `configs/models.yaml`: prices re-checked against the OpenAI and Anthropic price pages
  (2026-10-11); `gpt-5.4` input corrected to $2.50/M; `cached_input_per_1k` added where listed.
- **Git automation silently off when enabled in the project.** `clike.git.autoCommit` (like every
  machine-scoped setting: binaries, agent permissions, service URLs, push) is read by VS Code only
  from User settings, so a value in `.vscode/settings.json` was ignored without a word. CLike now
  warns at startup and on change, with **Apply in User settings**.
- `/init` wrote `.gitignore` with indented lines, so only `node_modules/` was ignored: chat
  sessions, telemetry, `.vscode/` and `.env` files could be committed. Lines are no longer
  indented, and `.clike/sessions/`, `.clike/telemetry/`, `.env.*` (except `.env.example`) and the
  eval scratch under `runs/` (`runs/eval/`, `node_modules/`, `.tmp/`, caches) are ignored;
  `runs/kit/<REQ>/` stays committable by the phase commits.
- **False `ACCEPTANCE_TAMPERED` ("removed: ci/LTC.json…") when a repair left scratch in `ci/`.**
  The acceptance manifest is capped at 2000 files and a repair agent's `ci/.tmp` (5,700 tool files)
  filled it, so the real files fell outside and were reported removed. Scratch and cache dirs
  (`.tmp`, `tmp`, `.cache`, `.npm-cache`, `.next`, `coverage`, `local-eval-workspaces`) are not
  acceptance, and a locked file is reported removed only if it is really gone.
- **A gate PASS with accepted warnings did not promote.** `GATE_PASS_WITH_WARNINGS` (gate `PASS`,
  warnings allowed by `clike.gate.strictWarnings` off) left the REQ `in_progress` without the
  promotion prompt; it is now promotable like a clean PASS.
- **A promoted REQ's check that reaches another REQ by a relative path failed as a regression**
  (`../../../../runs/kit/REQ-001/test` from its work copy: found in its own eval, not when re-run
  inside a later REQ's eval, so the later REQ could never pass). Next to every eval dir, nested
  regression and service runs included, `runs/kit/` now lists this REQ (work copy), its
  dependencies (composed copies) and every other REQ (project KIT, read-only); before only the
  current REQ was linked, and others resolved by chance.
- **Eval path rewriting corrupted paths containing `src`/`test`** (e.g. a project under
  `…/test-projects/` or a temp dir `pytest-of-…`): short keys were replaced as substrings, several
  times. The rewrite is now one pass over whole path segments.
- `ci/HOWTO.md` (and any Markdown under `test/` or `ci/`) is documentation, no longer part of the
  acceptance lock: editing it by hand no longer reports `ACCEPTANCE_TAMPERED`.
- `/init`: `README_1st.md` showed `${project.org}` and escaped backticks; the Git steps now create
  the GitHub repository first (`gh repo create … --source . --remote origin --push`), since pushing
  to a repository that does not exist fails with "Repository not found".

## [1.3.0] — 2026-10-11 — Project context sources

### Added

- **Project context sources** (`.clike/context.yaml`, created by `/init`; see
  [docs/context-sources.md](docs/context-sources.md)): the project files the Harper phases read as
  context, each with a path glob, a role (`requirements`, `ui_reference`, `ux_requirements`,
  `api_reference`, `data_sample`, `style_guide`, `domain_glossary`, `example_output`, `reference`)
  and the phases that read it. Resolved server-side, read-only, and delivered to both runners: the
  cloud phase message gets a `PROJECT CONTEXT SOURCES` block, the local agent the list of files to
  read (converted documents written to `runs/context/<phase>/`). docx, xlsx/xls/xlsb, pptx and pdf
  are converted to text; HTML, CSS, SVG and other text files are passed as they are; images are
  opened by the local agents and listed by name for cloud models. Without the file: `docs/inputs/**`
  → `requirements` (idea, spec, plan), `docs/harper/ux/**` → `ui_reference` (spec, plan, kit).
  Canonical Harper documents win; size caps per file and per phase; unsafe paths ignored.
- `/init` creates `docs/inputs/`, `docs/harper/ux/` and `docs/reference/`.

### Changed

- The office/PDF text extraction of RAG indexing moved to `services/document_text.py`, shared with
  the context sources.

## [1.2.4] — 2026-10-11 — Invalid agent model rejected up front, agent errors shown

### Added

- **Invalid agent model rejected before the agent starts**: `clike.localAgent.codex.model` is checked
  against the models of the Codex login (`~/.codex/models_cache.json`), `clike.claudeCode.model`
  against the Claude aliases (`opus`, `sonnet`, `haiku`) and `claude-*` ids. An invalid id blocks
  every Harper phase and agent chat turn with `LOCAL_AGENT_MODEL_INVALID` and the closest valid id
  (`gpt6-1-sol` → `gpt-6.1-sol`) until it is fixed; VS Code shows the error at start-up and when the
  setting changes (with "Use …" and "Open Settings"), and `/agent-model` refuses an invalid id.
  Without the Codex models cache the Codex id is not checked.

### Changed

- **Faster, always-current container rebuild**: `docker/rebuild.sh` builds with the layer cache,
  recreates the containers, waits for `(healthy)`, checks that each container runs the image just
  built and prunes dangling layers. The orchestrator and the eval sandbox share one image (built
  once instead of twice); the uv download cache is a build cache mount and no longer stored in the
  image layers.

### Fixed

- **A failed agent run showed no cause**: with machine-readable output the agent writes its error on
  stdout (Codex `turn.failed`, Claude `is_error`), not on stderr; `LOCAL_AGENT_EXITED_WITH_ERROR` now
  carries that message (for example the provider's 404 for an unknown model).

## [1.2.3] — 2026-10-10 — Codex Harper phases in a project without git

### Fixed

- **Codex Harper phases in a project that is not a git repository** (a new `harper-init` project):
  Codex exited 1 ("Not inside a trusted directory and --skip-git-repo-check was not specified").
  The local-agent Harper phases now pass `--skip-git-repo-check`, as the agent chat already did.
- **A failed local-agent run reported a misleading error**: when the agent wrote nothing, the
  extension sent the files already on disk (the empty template `IDEA.md`) and the orchestrator
  answered `document_phase_output_incomplete`. The document and EXTEND phases now send only the
  files written during the run, and an agent that exits with an error and writes nothing reports
  `LOCAL_AGENT_EXITED_WITH_ERROR` with its own stderr.

## [1.2.2] — 2026-10-10 — Local document phases with Codex and BMAD companions

### Fixed

- **Codex in the local IDEA / SPEC / PLAN / EXTEND phases**: with `clike.localAgent.codex.sandboxMode`
  = `auto` (the default) these phases started Codex `--sandbox read-only`, so the agent could not
  write `IDEA.md`, `SPEC.md`, `PLAN.md`/`plan.json` or the EXTEND report and the phase failed with
  missing outputs. Every Harper local-agent phase now runs `workspace-write`; an explicit
  `read-only` is rejected up front with `LOCAL_AGENT_WRITE_MODE_UNAVAILABLE`.
- **BMAD companions in the local document phases**: the companion documents of the BMAD agent
  (`docs/harper/bmad/idea|spec|plan|architecture/**`, `docs/harper/ux/**`) are now collected by the
  extension, accepted by the write policy and by the orchestrator (paths re-derived server-side from
  the bundled BMAD manifest, Markdown only, never outside the agent's roots), and listed in the
  package write roots. Missing companions are reported as a warning.
- **BMAD `spec --agent ux` is companion-only locally too**: it no longer requires `SPEC.md`, and
  writing `SPEC.md` is rejected.
- **BMAD artifact policy lost with the workspace vendor manifest**: when the workspace carried
  `.clike/skills/vendor/bmad/manifest.json` (every `harper-init` project), it replaced the bundled
  manifest entirely and dropped its `artifact_policy`, agent profiles, workflows and quality
  contracts. The vendor manifest now overrides only the keys it defines, so the active output
  contract declares the companions again — locally and in the cloud prompt, where they are
  required outputs as documented in `docs/integrations/bmad/COMMANDS.md` (BMAD cloud prompts grow
  by 3–10 KB).
- **BMAD `finalize` in the cloud always failed**: the gateway BMAD artifact filter dropped the native
  finalize documents (`HOWTO_RUN.md`, `RELEASE_NOTES.md`, `SANITY_CHECKS.md`, `TODO_NEXT.md`,
  `PR_BODY.md`) that the active output contract then required. The native required outputs of the
  phase now stay allowed (except for companion-only agents).
- **Local BMAD prompts name the outputs of the role**: canonical outputs, mandatory companions,
  allowed companion roots and forbidden outputs of the selected agent (the workflow list mixed
  `pm` and `ux` files).

## [1.2.1] — 2026-10-06 — Agent chat approvals, Harper chat can write, readable /help

### Added

- **Approvals in the agent chat** (Coding and Harper, `clike.agentChat.approvals`, default `ask`): every
  edit and command of the agent waits for Allow / Allow all this turn / Deny in VS Code; writes
  outside the Coding output root are denied without asking. Claude Code asks through
  `--permission-prompt-tool` (a one-turn local MCP server), Codex runs through `codex app-server`
  (the same sessions as `codex exec`). `auto` keeps the previous behaviour.

### Changed

- **Harper free text with an agent can create files**: a request like "create a script that
  computes N!" in Harper mode no longer gets a read-only refusal; the agent writes only under
  `generated/<id>/` (same sandbox and approvals as Coding) and the files appear in the Files tab.
  Free (Q&A) stays read-only.
- **`/help` is readable on every theme**: VS Code theme colours, commands grouped by topic, a
  filter box, Esc / click outside to close.

### Fixed

- MCP `eval_run` with `fix` returned the report of the first eval: it now returns the report of
  the last eval after the repairs, plus `auto_eval {outcome, cycles, reason}`.
- `gpt-6.1-sol` pricing ($2.00 / $10.00 per 1M input / output tokens), 1,050,000-token context
  window and 128,000 max output tokens (B16).
- MCP setup uses `localhost` URLs (managed Claude Code policies often allow only
  `http://localhost*`); Codex approval of the CLike MCP tools is documented
  (`default_tools_approval_mode = "approve"`).

## [1.2.0] — 2026-10-06 — Native agent chat, CLike from Claude Code / Codex, contract alignment

### Added

- **Native agent chat** (H1): with execution = agent, the CLike chat talks to Claude Code / Codex as
  one continuing session per mode (free, coding, harper) — the first message starts it, the next
  ones resume it (Claude `--session-id`/`--resume`, Codex `exec resume`) and only the new turn is
  sent; the agent's text and the tools it uses stream into a live bubble; Cancel stops the agent.
  `/agent-session [new|new all]` shows or restarts the sessions. Codex chat now runs with the
  mode's sandbox (read-only, workspace-write for coding).
- **CLike from Claude Code / Codex** (H2): the extension MCP server runs phases through the
  governed chat flow and returns their outcome (`harper_run_phase` waits up to `wait_seconds`,
  then `harper_run_status`), plus `eval_run` (optionally the auto-eval `fix`) and `gate_check`;
  no overrides, promotion or git from MCP. The orchestrator MCP Harper read tools accept a
  `project_root` (confined to the projects directory). Verified with Codex calling
  `harper_req_list` on a project.

### Changed

- One FILE_REQUIREMENTS for cloud and local agents (B15): the agent package uses the obligations
  the orchestrator builds for every KIT (the ones the cloud prompt, the output contract and the gate
  use) and keeps its extra guidance as policies; it also writes the copy the gate reads under the
  locked `ci/`. Agent KITs now get concrete file roles, the namespace, and the launcher/runtime
  manifest requirements of their family; the noisy `external_library_obligation` is gone.
- KIT autofix for every ecosystem: final newline in sources, gofmt for Go when installed.
- `/agent-model` shows execution, default agent and models; `/agent-model list` lists the models.

- KIT: `TARGET_CONTRACT.json` and `FILE_REQUIREMENTS.json` are written by CLike (in `ci/` and
  `docs/`, same content) instead of being re-emitted by the model — fewer output tokens and no
  divergent copies (B8). Follow-up KIT stages see their options in the prompt (B7). The agent
  KIT/finalize contracts ask for the same deliverables as the cloud.

- BMAD runs: SPEC, plan.json and lane guides are checked against the BMAD quality contracts
  (deterministic, no LLM) and the gaps are reported as advisory `bmad_quality:` warnings; the
  unused fixture-only IDEA scorecard module was removed (L1).
- Debt: one slash parser in the webview (L4), deterministic repository manifest (B13), lane guides
  Markdown-only in the extension (B12), single finalize auth check (B11), flat agent audit files
  (B9), valid sample documents checked in CI (B14).

### Fixed

- A follow-up KIT stage (`--hardener`, ...) after the first eval started a new KIT generation
  and could rewrite the locked tests: it now keeps the generation and its test/ci changes are
  governed like a repair (L3).
- An eval or gate whose caller disconnected kept running in the sandbox (e.g. after a stopped
  benchmark it delayed the next eval by more than 30 minutes): it is now cancelled, with its
  processes, and the orchestrator answers 499.

## [1.1.0] — 2026-10-06 — Governed auto-eval on both paths, acceptance-first KIT

### Added

- Auto-eval with local agents: the agent package carries the failed checks, the hint and the
  repair rules; the acceptance files the agent changed are governed through
  `POST /v1/acceptance/amend` and the extension restores what is rejected. Benchmark
  `--runner agent --auto-eval N`.
- **Acceptance-first KIT** (`clike.kit.acceptanceFirst`, opt-in): `/kit` first generates only the
  acceptance tests and eval profile from SPEC/PLAN and locks them (`POST /v1/acceptance/lock`),
  then the code KIT writes the implementation against the locked tests (cloud and local agents;
  benchmark `--acceptance-first`). Addresses the known limitation that criteria and code came
  from the same call.
- `/agent-model [claude|codex] [model]`: show or change the local agent model from the chat
  (any mode).
- Local-agent telemetry: usage, API-equivalent cost, model and duration of Claude Code / Codex
  runs, in `.clike/telemetry` and in the gateway portal (`POST /v1/harper/telemetry`).

### Changed

- KIT generation (cloud and local agents): an eval-readiness self-check closes the prompt, with
  one rule per failure class measured by the benchmark (checks the LTC runs, files asserted by
  tests, behaviour over internals, real library APIs, time-bounded tests, read-only project
  root). PLAN acceptance items are stated at their observable boundary.
- Generated KIT files get safe mechanical lint fixes before they are written and locked
  (per-ecosystem registry; Python: ruff import order, unused imports, whitespace).

- Local-agent KIT context: content also written as package files (selected-capability guide,
  FILE_REQUIREMENTS) is referenced by path instead of repeated (smaller context, re-read on
  every agent turn).

### Fixed

- The configured agent model (`clike.claudeCode.model`, `clike.localAgent.codex.model`) applied
  only to chat; Harper phases ran with the CLI default model.
- Local-agent runs (including the eval pre-pass) left no telemetry and were attributed to the
  cloud model selected in the UI.

## [1.0.0] — 2026-10-05 — Milestone M3: ready for evolution

### ⚠️ Breaking changes

- Gateway `POST /v1/harper/run` requires `composed_messages`: the phase messages (system prompt,
  context, output checklist) are composed by the orchestrator. The gateway adds RAG material and
  chat history and calls the provider. Orchestrator and gateway must be updated together.
- Phase prompts moved from `gateway/prompts/harper/` to `orchestrator/phases/<phase>/cloud_*.md`;
  the `PROMPT_*_SYSTEM_PATH` variables are no longer read.

### Added

- **Auto-eval** (`docs/auto-eval.md`): `/eval REQ --fix ["hint"]` runs eval → KIT repair from the
  real failures → eval, up to `clike.autoEval.maxCycles` (default 2); rerunnable with a developer
  hint; `clike.autoEval.afterKit` runs it after `/kit`. Tests stay locked; an LTC command that
  cannot run and `ci/` dependency upgrades are accepted as audited amendments of the acceptance
  lock. When the eval shows that a test itself is wrong (an error raised in the test file, not a
  failed assertion), the test is fixed instead of the code, with every assertion unchanged; the
  gate reports `review_required`. API: `kit.repair` object on `/v1/harper/run`; benchmark
  `--auto-eval N`.
- **Regression of promoted REQs**: `/v1/eval/run` and `/v1/gate/check` accept `regression: true`
  (extension: `clike.eval.regression`, default on) and re-run the acceptance checks of every promoted
  REQ (plan status `done`) against the new code; the gate reports
  `GATE_BLOCKED_REGRESSION`.
- Browser e2e checks in the eval sandbox: Chromium system libraries in the image
  (`ENABLE_BROWSER`), browser downloaded on demand in the project's Playwright version.
- Harper benchmark (`benchmark/`): documented sample projects, cloud and local-agent runners,
  promotability metrics.
- `PhaseContext` v1: the typed, versioned contract of a phase run
  (`docs/contracts/phase_context.v1.schema.json`); the wire `core_blobs` are produced from it.
- Phase definitions as data in `orchestrator/phases/`: per-phase `phase.yaml` (write roots, output
  contract, rules, accepted result paths) and `text.yaml` (local-agent prompt and policy text).
- GPT-6 family support (reasoning models recognized by generation number); `openai:gpt-6.1-sol`
  in the catalog.
- Tests: characterization snapshots for local-agent packages and result normalization, phase
  definition parity with the extension, cloud/local-agent equivalence per phase.

### Changed

- Gate: warnings (failed non-blocking checks) no longer block; the gate passes with
  `GATE_PASS_WITH_WARNINGS` unless strict (`strict: true`, `clike.gate.strictWarnings`,
  `CLIKE_GATE_STRICT_WARNINGS=1`). Eval `promotable` follows the same policy.
- `services/local_agent_package.py` (6,900 lines) split into `services/local_agent/` (one module
  per phase, shared helpers, normalization); the old module is a compatibility facade.
- Local Claude Code never receives `ANTHROPIC_AUTH_TOKEN` (it would override the subscription
  login), like `ANTHROPIC_API_KEY`.

### Fixed

- Cloud `/kit` produced unusable paths for many plans: free text and placeholders became file
  paths (B18), the ecosystem was guessed from scattered words (e.g. `.js` files in a Python
  project, B19), and `__init__.py`, `ci/requirements.txt` or extra tests rejected the whole KIT
  (B20). The cloud KIT contract now matches the local agent's.
- Lane guides and selected capabilities were dropped from the cloud KIT context; the SPEC
  validator and prompt disagreed on the required sections.
- Coding mode wrote generated files to `/generated/...` outside the workspace.
- `kit.repair` sent by the extension (`/kit --repair`) is accepted as a flag or as an auto-eval
  repair request (the gateway rejected the orchestrator's default `false`).
- Eval honors the LTC `run_from` field as the commands' working directory.
- Cloud `/plan` received IDEA.md and SPEC.md by name only and could return an empty plan; it now
  receives them in full. Cloud `/kit` received no project documents and could ignore the
  technology constraints (e.g. Flask for a FastAPI project); its prompt now includes the
  technology constraints, the target REQ with its dependencies, SPEC.md and IDEA.md.
- Chat webview: REQ ids were never recognized and message previews replaced the letter "s" with
  spaces (regexes inside the webview script lost their backslashes).

### Removed

- Dead code: unused KIT/EVAL prompt builders, a shadowed duplicate function, an unused copy of
  the cloud capability renderer, unused gateway helpers.
- WP9 cleanup (about 2,700 lines): modules unreachable from any service entry point
  (`harper_flow/`, `constraints/`, `embeddings.py`, `spec_plan_gates.py`, …), unused functions and
  imports, commented-out code, the extension's `rag.js` and `fix_ext_vs.sh`.
- The gateway's own Qdrant store and embedder (unused): RAG is owned by the orchestrator; the
  gateway is a client of `/v1/rag`. The gateway no longer reads `EMBEDDING_DIM`,
  `RAG_EMBED_FAMILY`, `RAG_SCORE_THRESHOLD`.

### Changed (code quality)

- Duplicated provider result builders and local-agent failure responses consolidated; extension
  lint at zero warnings; code comments in English.

## [0.9.5] — 2026-10 — Milestone M2: correct and governed

### ⚠️ Breaking changes

- `/v1/gate/check` no longer accepts manual verdicts (`mode=manual`): use the new
  `POST /v1/gate/override` (reason required, audited). The extension does this for
  `/gate <REQ> manual pass`.
- Eval/gate refuse to run when the REQ acceptance surface changed after it was locked; re-run
  `/kit` to re-baseline.
- Orchestrator `POST /git/branch`, `/git/commit`, `/git/pr` removed (unused; they ran `git add .`
  in the server directory). The extension remains the only Git actor.
- Error statuses: a provider without an API key on the gateway is `503`
  `{code: provider_not_configured}` (was `401`); an unknown/disabled model is `400`
  `{code: model_selection_error}` (was `500`); gateway failures during any Harper phase keep their
  status and cause (`429`/`503`/`4xx` pass through, others `502`) instead of a generic `500`.
- Gateway: unknown Harper phases are rejected (`400`) and a missing phase prompt is `503`;
  `eval`/`gate` use their own prompts instead of the SPEC prompt.
- Extension settings removed (never read): `verboseLogging`, `docRoot`, `chat.autoOpenOnStartup`,
  `execution.showInChat`, `mcp.clientEnabled`, `mcp.serverEnabled`,
  `localAgent.codex.approvalMode`, `localAgent.codex.printModeFlag`.
- DeepSeek provider and the dedicated vLLM/Ollama modules removed; Ollama is reached through its
  OpenAI-compatible API.

### Added

- Acceptance lock and tamper detection for `runs/kit/<REQ>/test/**` and `ci/**`, taken before any
  local-agent eval pre-pass; reports include an `integrity` section.
- Audited gate override endpoint; overrides are reported as `OVERRIDE` and promoted only with an
  audit id.
- `eval-sandbox` service: eval/gate commands run without credentials, isolated from the gateway
  and vector store, non-root on a read-only filesystem; optional offline mode
  (`compose.eval-offline.yml`). Reports include `executor`.
- Provider support for Claude Opus 5.5 / Sonnet 5.5 and newer OpenAI models, while older models
  receive exactly the requests they did before (provider contract suite with a model matrix).
- Provider retries with backoff on 429/5xx/529 and connection errors (never on read timeouts);
  orchestrator → gateway retries only when the connection could not be opened.
- Opt-in telemetry retention: `CLIKE_TELEMETRY_RETENTION_DAYS` (default: keep everything).

### Fixed

- Anthropic: `tool_choice` `required` was sent as a string; sampling parameters are omitted for
  models that reject them; long system prompts are cached.
- Gateway chat returned provider failures as HTTP 200 with empty text; `temperature: 0` became 0.4.
- The cloud eval phase spent an LLM call whose output was discarded.
- The staged KIT chain crashed at the hardener stage (`NameError`).
- Extension: several runtime `ReferenceError`s, broken/unregistered commands, local agents left
  child processes running after a timeout, chat image previews rendered as text.
- `runId` could travel as the string `"None"`; a request without `flags` was rejected by the gateway.
- Extension `eval`/`gate` requests used `fetch`, which aborts after 300 s without response
  headers; all service calls now share one client with the Harper time budget.
- A passing gate reported `reason_code` `GATE_BLOCKED_STATUS_PASS` (now `GATE_PASS`).
- A gate `mode` passed as a query parameter was ignored.
- KIT stage artifacts were written to a non-persistent path in containers (`RUNS_DIR` now
  `/app/runs`).

## [0.9.0] — 2026-10 — Milestone M1: safe to run

Consolidation release: no new end-user features; security, correctness of Git operations,
reproducibility and test coverage.

### ⚠️ Breaking changes

- **Service token required.** Orchestrator and gateway reject requests without
  `Authorization: Bearer <CLIKE_API_TOKEN>` (503 if the token is not configured). Set
  `CLIKE_API_TOKEN` in `.env` and run *CLike: Set Service Token* in VS Code. MCP clients must send
  the same header.
- **`POST /v1/apply` removed.** The extension applies generated files locally.
- **Eval/gate confinement.** The project root must be under `CLIKE_PROJECTS_DIR` (`DEV_FOLDER`) or
  `CLIKE_EVAL_ALLOWED_ROOTS`; the LTC profile is read from the workspace and an inline profile must
  be identical (`CLIKE_ALLOW_INLINE_LTC=1` re-enables inline-only profiles).
- **Git automation off by default.** `git.autoCommit`, `git.openPR`, `git.gitMergeOnGate` and
  `git.pushRebase` default to `false`; pushing requires the new `git.autoPush`.
- **Extension MCP server off by default**; when enabled it always requires a token.
- **No CORS** on orchestrator and gateway.

### Security

- Authenticated services on loopback, Host-header validation, fail-closed configuration.
- Service-to-service authentication; telemetry UI login with an `HttpOnly`, `SameSite=Strict` cookie.
- Path confinement for workspace writes, KIT stage artifacts, telemetry and MCP reads.
- Eval commands run without credentials; containers run as non-root with the repository read-only.
- Argv-only process execution in the extension; prompt via stdin on Windows.
- Webview: cryptographic nonce, `img-src data:` only, escaped server-provided content.
- 18 security-relevant settings are machine-scoped; untrusted workspaces are not supported.
- Telemetry, certificates and build artifacts removed from the repository and its history.

### Fixed

- Harper Git sync could drop commits from an existing REQ branch and move the default branch
  (`checkout -B`); it also staged unrelated changes (`git add -A`) and committed every file when
  initializing a repository. Sync is now non-destructive and commits only the phase files.
- PR creation through the GitHub CLI never ran (it was invoked as `git gh …`).
- Conventional commit messages and per-REQ draft PRs were disabled by setting-name mismatches.
- `/v1/apply` client path fell through to the local path after a server error.

### Build and quality

- Python 3.12 for both services; `pyproject.toml` + `uv.lock` per service; container images built
  from the lockfiles; healthchecks; optional Ollama profile; Podman supported.
- Golden snapshots of the phase boundary; contract fixtures decoupling gateway tests from the
  orchestrator; security regression suites; Git tests on real repositories.
- ESLint with a frozen baseline; npm scripts; reproducible `.vsix` packaging.
- Repository hygiene check (pre-commit and CI); GitHub Actions CI.

### Removed

- Unused modules that executed shell commands (`new_eval.py`, `services/evals.py`,
  `services/embedded_ops.py`) and dead Git helpers.

## Earlier

Development history before 0.9.0 (Harper lifecycle, local agents for all phases, BMAD
methodology profile, `/extend`, capabilities) is available in the Git log.
