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 failedand 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
donein 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 onfeature/req-026, a new KIT of REQ-026 started onmain). 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.examplewith 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_envdeclaration (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. Likesupersedes, 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<=,toEqualtotoContain) 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 turnedset(env) == set(names)intoset(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 withsupersedes(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_envin 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 underclassic./idea --extendwrites 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 warnsenv::disk-spacewith 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.jsonbuilt 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.tsfor the declaredtest/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 --extendno 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 --extendholds the UI references indocs/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)./planand/idea --extendget 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./idearecords the design system the sources name, else shadcn/ui as an assumption; the/initplaceholder 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. Seedocs/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 --verifythat 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
(
REJECTEDorFAILEDand 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
/finalizeis no longer rejected for a cloud apply guard it has: theCLIKE_ALLOW_CLOUD_MUTATIONcheck 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 runsolution_local.py, which importssolution_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 --extendreads 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 --extendkeeps the project inputs current: it writes the release’s deltadocs/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,/planand the next release read it first as the current truth./idea --extendkeeps 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
/ideawhole. Arequirementssource 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>resolvesuv.lockorpackage-lock.jsonin 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.shwarns 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.capacityProfiledefaults toC2(REQs sized as vertical slices for a coding agent), whatever executor runs/plan:autofollowed the/planexecutor, so a plan made in the cloud sized REQs for one cloud call although the KITs ran on an agent. ChooseC1when the KITs run in the cloud.
Fixed
/ideaalways writes the Technology Constraints rooted attech_constraints:(validated on every executor) and treats a stack the sources decide as a decision; theTECH_CONSTRAINTS.yamlthat/initwrites is a plain placeholder;/specstops with a clear message when no technology decision exists. Before, the agent took the/initstub as an approved “no stack”,/specwrote nothing and/planproduced REQs with no lane and no lane guides.
[1.8.0] — 2026-11-14 — Verified before the eval
Changed
/ideawrites 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,/planand/extendread them before the raw documents, and a new/ideakeeps their IDs./ideaalso runs on the documents indocs/inputs/without an attachment. The cloud output budget of/ideais 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.agentEvalChecksruns (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/telemetryand 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--fixloop 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_WORKERSdefaults toauto, 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 nevernpm cithemselves. - 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
/autopilotor--fixloop: 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--fixloop 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_modulesor venvs); cloud/ideaaccepts further files indocs/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/ideareads 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/ideaor a KIT may run;DECISIONS.mdwith no open decision is valid;/eval --acceptreleases a REQ also from a running/autopilot; an out-of-rangeclike.kit.agentEvalChecksno 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 --acceptreleases the REQ from the autopilot’s parked REQs: its files do not change, so the next/autopilotkept 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 readsPLAN.mdandplan.jsonand writes stories, story map and implementation readiness. Before, both roles regenerated the plan and the second run discarded the first./plan --agent pmstops before any run when the plan is missing or older than the SPEC. Native/planis 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 andeval-contract-writernow show the id as the plan numbers it.eval-contract-writersays what the eval reads:cases[], or a project’scommands[]/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::coverageblocks the REQ otherwise. After/planthe 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.jsonandPROGRESS.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/skillsinstalled 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>withVENDORED.json(pinned commit, license, review date, digests) andtools/skills_vendor.py(verify,check-updates,update --applywith 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-writeris now the proof contract (the exactci/LTC.jsonfields 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: 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_WARNINGSpromotes (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; writesdocs/harper/ADOPT_<date>.md.--area <name>adopts one area first,--dry-runwrites only the report. It writes the code mapdocs/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/initon 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 onlydocs/and the main READMEs. A file the model returns outsidedocs/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 --extendin a project of areas: the model gets the areas of.clike/project.json; every new REQ names itsarea(orareasfor a journey across modules), a new module is declared once withnew_area(folder, source, tests, commands) and registered in.clike/project.jsonwith 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,nodejs24in the tools catalog) without a question and for its own checks only — the venv anduvon 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 throughruns/kit/<REQ>/root/<repository path>; a check withcwdan area runs in its composed copy in the eval workspace (never in the project’s own folder) with the area’s ownsrc//tests/paths; the area tests are locked liketest/; 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/xis 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.jsonare 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/anddocs/reference/, a.gitignorechange that is not CLike’s, and any file naming a folder of this machine. - Next step: the cockpit and the outcome no longer propose
/finalizein a project only adopted. They propose the next area, the analysis to run again, or the next release.
- Write filter: a returned path is checked as it is written, so
-
/adoptchecks: 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_DIRgets its tests run: when eval, gate or the/adoptbaseline start on such a project, CLike asks to mount it. On confirmation,docker/mount-project.shmounts that folder only, read-only (a CLike project, never a parent), and recreates the containers.GET /v1/eval/rootslists the folders eval reads, and the new settingclike.stackDirgives the stack folder. /adoptwith a local agent finishes: the run guide (docs/harper/HOWTO_RUN.md) is accepted (only in the adoption:/idea --extendnever 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 --areaof 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). /adoptruns its analysis: it was sent to the/evaland/gatehandler and stopped after the survey, leaving the/inittemplates. 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. uvprojects run in the sandbox: every REQ gets a writableuvproject environment of its own. Before, the image’sUV_PROJECT_ENVIRONMENTpointed at CLike’s own read-only environment, so a project’suv sync/uv runfailed.-
The cloud KIT has the same root rules as the local agents: env examples,
.gitignore, the solution profile and runbooks underroot/, 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-node7.1.2 (an override under the packaging tool, GHSA-xcx6-jx8p-x3h5) andqs6.17.0 (GHSA-6pq8-jhm2-2vcw); both were build-time dependencies of.vsixpackaging, 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
/initwith 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./initkeeps 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), linked from the
README: what does not change for the team, every step from
/initin place to/adoptand/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
/finalizeor/finalize --verifywhile the solution verification runs is refused with a message, and the eval sandbox runs one request at a time per eval workspace. Before, a--verifysent 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 --extendwrites every journey the release adds or changes as a SPEC use case, as/specdoes (UC-nnwith 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 casestable 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.jsonand project docs (docs/<runbook>.md, neverdocs/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/finalizereceives 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 underci/shared/, the gate promotedsrc/andtest/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 criteriondonewith the blocking checks that verify it,partial,missing, ordeveloper_evidence), and the eval’s blocking checkacceptance::coveragesends 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_jsonare installed whatever the LTC’s main runtime: a Python LTC with a web frontend that namessrc/web/package.json(or requires a Node version) getsnpm installbefore its frontend checks. Before, they ran withoutnode_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 inruns/extend/declared-supersedes.jsonland runs the eval. A failing delivered test of a REQ the candidate amends gets a note with that exact command, and a stopped--fixloop repeats it: a repair may not change the plan. Before, the only way was to editplan.jsonby 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 onlychecks), 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,/evaland/gatekeeps what changed in the plan meanwhile: the status is written onplan.jsonas it is on disk, not on the copy read when the run started. Before, asupersedesentry added during a 25-minute repair was erased when the repair ended. /idea --extendnames 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 addand no question; a check that runspwsh -NoProfile …is found before the eval. Before,pwsh: not foundwas outside the catalog and--fixsent it to the repair agent twice. --fixdoes 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>(orcustom:in.clike/eval-tools.yaml) for a program outside the catalog./autopilotretries 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/autopilotended at once with “no REQ can go on”.
[1.6.3] — 2026-10-26 — An extend that keeps its work
Fixed
/idea --extendno longer discards a cascade for a reference it can complete: every check section of a delivered REQ’s eval profile counts (commandsandexternal_checkstoo: a validREQ-032#keycloakwas 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 underruns/extend/rejected/<time>/instead of losing them.- A rejected
/idea --extendleaves 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 underruns/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 --extendholds 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
/finalizedelivers the release: the finalize commit names the release and its REQs, the annotated tagvNmarks 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/finalizelater./idea --extendtakesvNas the baseline. -
/finalizechecks the local start on your machine: after the verification passes in the sandbox (which runs the solution natively), CLike runsscripts/check_solution_localon 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
/finalizeagain: 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 --extendand the cockpit target v4 instead of the v3 with its inputs. -
/finalizeno longer rejects a correct cloud deploy: a script named after the secret references it creates (04_secrets.sh) is code, not a secret store; theCLIKE_ALLOW_CLOUD_MUTATIONguard 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 missingand exited (instead of the shell’scommand 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
FAILfor failures the eval marks non-blocking (already failing without the candidate, unstable, warnings); they are shown asWARN … 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 asregression::<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
--acceptfinds 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. NewPOST /v1/rag/sources;POST /v1/rag/purgeaccepts exactpaths. - A successful
/finalizeopens 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.
/finalizeaccepts 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
/finalizeis no longer shown as done: the cockpit keeps it as the next action with its reason, and the project stays below 100% until a/finalizepasses. - The eval advice of an edited locked test points to
--acceptwith 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/.tmpcopies (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 --fixstop: 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 toexample.testfailed 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 --fixcycles: 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_reqson/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/…-regressionof a promoted REQ re-runs tests of earlier REQs, which CLike’s regression already runs on their promoted tests (regression-checks::not-runlists 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,1restores 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 ofplan.jsonhaskit_readyandblockers(owner questions only); the KIT never stops on an open detail. After/planCLike lists the REQs that wait (⚠KIT READINESS),/autopilotparks them before/kitwith their questions, a manual/kitwarns. 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--fixloop, 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 onGET /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;/autopilotstops 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 --extendwhen every REQ is done and the next release has its inputs (adocs/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 (
/kitthe ready ones,/evalthose with a KIT,/gatethose 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 addfrom the catalog,/agent-modelmodels), 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 --fixstops 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
### Acceptanceheading, 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 letterZ(\Zis not an end-of-text anchor in JavaScript). -
/agent-model listshows 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//gateshows the command as typed also when it contains ansin a flag (--ask): the webview split the text on the lettersinstead 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 Casessection — 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/planand/idea --extendCLike 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,/gateeach, 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|claudeand--methodology bmadchoose 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 inruns/autopilot/report.md. It stops before/finalize.harper_autopilotMCP tool andscripts/clike-autopilot.sh/.ps1:/autopilotfrom a local agent or a terminal —startreturns at once,status/stopsteer it; the scripts start it directly or through a local agent and wait by polling the server (no tokens).harper_initMCP tool:/initof the folder open in VS Code, in place (existing files kept), so an agent can run a project from/initto/finalizethrough 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
LICENSEis 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 toNOTICE; bothpyproject.tomldeclarelicense = "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
/evaland/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/finalizeverification 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
ENOMEMin 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 nowEVAL_SANDBOX_EXHAUSTED:--fixstops 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.mdas run on the developer’s machine. -
A local agent can verify a regression repair before it finishes:
eval-checkaccepted 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-014now re-runs that REQ’s checks with the candidate overlaid (/v1/eval/runacceptscheckswithregression_reqs). -
A reformatted shared file is no longer named as the cause of a regression: on B2B REQ-026 the only difference in
worker.pywas a wrapped line, yetShared files changednamed 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_*.jsonkept 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. Theexcerptandfingerprintare 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
regressioncheck no longer fails for tests it does not have: on B2B REQ-025 and REQ-026 the KIT’sregressioncheck 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./autopilotwaits and retries on a model at capacity. A KIT withoutci/LTC.jsonis 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__.pyfiles undertest/; 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 --fixno 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__.pyfiles 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 whenxis 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 undernode_modules/ a venv) stays environment-blocked. -
/eval REQ --fix --methodology bmadkeeps 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/â–¶ EVALlines showmethodology=bmad/<role>, and the chat echoes/evaland/gateas typed instead of dropping--methodology/--agent. - Promotion resolves a spot the REQ only rewrote, and
conflicts.mdreads line by line: when the gate ran the candidate with the regression of the promoted REQs, a spot where it rewrotesrc/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.mdnow 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 rootconftest.pykeeps 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 })andtoMatch('Senza limite.*scelta esplicita')). - A REQ phase run from another branch is committed on the REQ branch:
/kit REQ-021run onmain(after the gate of REQ-020 merged and left you there) wroteruns/kit/REQ-021/files thatfeature/req-021tracks, 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/finalizeand/specrun from a REQ branch, carried ontomain. 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 --fixnow names the REQ whose surface changed — often a promoted REQ run by the regression, not the candidate — and its files, instead of always suggesting/kitof 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 olderports.py). - Cancel did not stop an eval: the chat’s Cancel aborted only chat requests, so
/eval,/gateand their--fixloops went on (also with VS Code closed, the eval kept running in the sandbox). Cancel (and MCPcancel_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.pystays the REQ’s own. - A candidate carrying a promoted file replaced every REQ’s copy: B2B REQ-020 shipped the
canonical
test/conftest.pyunchanged and the regression put it in place of the rootconftest.pyof 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.pyreplaced 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.timeoutMinutesalways 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 withModuleNotFoundErrorin 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 orconftestbeside it; aconftestelsewhere 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 asunlocked), for cloud repairs as for local agents. clike.localAgent.allowEval: falsewas ignored:/evalran 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.mdupdated 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.jsonwith${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_phasetakesattachments(workspace-relative files, as Attach → Workspace files):/ideaand/idea --extendcan 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_summaryandgate_read_decisionaccepted anyrun_id(..left the runs directory). A run id is now a run directory name only, CLike’sstate/is never a run, and withproject_root+req_idthe eval/gate tools read that project’s latest report. - Claude Code reported “Dynamic Client Registration rejected (HTTP 401)” when the
Authorizationheader was missing: OAuth discovery and/registeranswered 401, so the client attempted OAuth. They answer 404 now (orchestrator and extension), and the docs show the.mcp.jsonwith${CLIKE_API_TOKEN}andlocalhost. - 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 arun_id(alsoharper_kit_next,harper_continue_loop,await: false), the registry is bounded,cancel_runstops a run; a run that stops early says why, and confirmations are answered withconfirm: trueinstead of a modal nobody sees;harper_run_phasetakestext,methodology,agentandextend/release/dry_run(/idea --extend);harper_next_actionfollowsdependsOnand finishes an in-progress REQ first. - CLike’s own Claude Harper runs load no MCP server (
--strict-mcp-config). The orchestrator MCP states that itsrag_reindex_*tools write the RAG index.
Fixed
/eval --fixcould not remove a root conftest it was asked to remove. The repair moved the REQ’s fixtures into its package and deleted the KIT roottest/conftest.pythatstructure::shared-conftestflagged, 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) anddocs/reference/vN/(background), plus any attached file (an attachment is required only whendocs/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 typedADDED,MODIFIED(amends,supersedesthe checks it replaces,unchanged) orREMOVED(retires), withreleaseandorigin, while delivered REQs stay read-only. CLike checks the baseline is delivered, tags itharper/v<N-1>, validates the delta and appends its own verification to the EXTEND report;--dry-runwrites only the report. Then/kit,/eval --fix,/gateand/finalizeas usual. BMAD works on it:--methodology bmad --agent analyst|pm|architect|ux(defaultpm), also on/extend.- The regression follows declared changes. Checks a
MODIFIEDREQ supersedes are not run for the REQ it amends (reported assuperseded, with the reason); a REQ retired by aREMOVEDREQ 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 --extendsees 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 --repaircarries the latest failures and files; the local KIT and FINALIZE packages receive the attachments; cloud/ideaaccepts 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
/extendand/idea --extend, and the KITroot/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
/evalrecords 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);/gateon 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_modulesare 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, plusroot_folders/root_filesin.clike/project.json; never.git,.clike,runs,docs,src,test,cior private files.
Fixed
- A KIT that rewrote the shared root
conftest.pypassed the gate and then stopped the promotion on a conflict (B2B REQ-015 replacedtest/conftest.pyand 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 --fixrepairs 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, soroot/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 uxoverwrote 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;/specno 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 vNsection: 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 (roleprevious_release);docs/reference/**is part of the default convention./extendnever 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
/finalizesays it is a CLike project: CLike, Harper and Finalize badges linked to the CLike repository, its Harper lifecycle andFINALIZE_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. /finalizebrings 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./finalizewritesdocs/harper/FINALIZE_REPORT.mdfor 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 — andscripts/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.mdalso lists the verification cycles and the last gate of every REQ.
Fixed
- The solution started by
/finalizecould 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
/finalizeuntil the developer answered the offer to configure and start the solution locally; the offer no longer holds the chat. /finalizecommitted only part of the solution it verified. Files in a new directory were missed (git statuslisted only the directory), and the work of an earlier/finalizerun 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
/finalizewas rejected for writing the solution. The extension checked its files with the KIT rule (nosrc/, nodocs/harper/):/finalizewrites exactly there. It is now checked against the write roots and forbidden paths of its own package (nevertest/,runs/,.git,.envor caches). The finalize run scripts detectdocker compose,podman composeorpodman-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
setupstep that runs before the variables and the services; the/finalizeprofile 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./finalizewarns 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. /finalizeleft 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./finalizelists 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 thansrc/): composition files such asapp.py,conftest.py, CSS tokens and.env.examplegrew 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 keepssrc/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 updateand./rebuild.sh --update-toolsrebuild every installed tool at its latest version (the image’s PostgreSQL client too) and showold → 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./toolsand 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@17andmaven), and two new kinds of catalog entry:pipfor CLIs published on PyPI (azure-cli, whose conda-forge package does not resolve) anddownloadfor 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.yamlapproves tools for a project and adds its own conda-forge packages./toolslists, 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:--fixstops instead of “repairing” it. KIT and repair rules ask agents to keep their caches outsideruns/kit/<REQ>/. /eval --fixrepeated 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:
HEADheld 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 --fixrepaired 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 filledpids_limitwithin a day of evals, and every check then failed withspawn 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_EXHAUSTEDand--fix(eval, gate, finalize verification) stops with how to recover; a local agent’seval-checkanswersBLOCKED; - 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
/healthshows processes in use, zombies and PID 1.
- the sandbox runs with an init (
[1.4.2] — 2026-10-15 — Conflicts you can read, plans that stay intact
Added
conflicts.mdin the promotion report: every spot still in conflict, readable without conflict markers: whatsrc/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.
/extendcould 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 --forceoverwrote an existing project (README, docs, every template file) and replaced.gitignore.--forcenow only allows a non-empty folder: missing template files are added, existing ones kept,.gitignoregets the CLike rules it lacks.- Context sources skipped source code (
.py,.java,.go, … were “unsupported format”). They are read now, with the new roleexisting_code. - A
.conflict-…file left insrc/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--fixa 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 --fixrepairs 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/ortest/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,fingerprintin 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 cloud repair prompt filled its 160k-character file budget alphabetically with CLike’s own
context files, so no
-
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/runchecks) is never a verdict. /finalizeverifies that the integrated solution runs end to end, and repairs it (no flag;clike.finalize.verify,clike.finalize.verifyMaxCycles)./finalizewritesci/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 (withoutruns/,.git,.clike/) and, while it fails, runs/finalizeagain 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 indocs/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
--allowedToolsfor it.
Fixed
- Extension dev dependencies: 0 known vulnerabilities.
@vscode/vsce3.9.2 → 4.0.0 (packaging tool only, not in the VSIX): itssecretlint → globby → fast-glob → micromatch → braceschain had a high-severity DoS (braces, no patched version). Requires Node ≥ 22 to build the VSIX. -
Merge-on-gate left
mainunpushed when the remotemainhad 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 andmaindid not. CLike now fetches and mergesorigin/mainbefore 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 --fixrepair (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 makesgit addfail, and the phase commit was skipped. Ignored paths are now left out (logged) and the rest of the phase is committed. /gateauto-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 commitgit show rev:pathexits 0 with no output, so the base looked like an empty file. The base is read withgit 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_MISSINGalthough it wrotesrc/andtest/. The artifacts sent to the orchestrator are capped (500 files, 8 MB) and were kept in discovery order: an agent’s scratch inci/.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 budgetsrc/andtest/come first, then the CI profile and the docs; dropped files are logged. -
/kitfailed withCLIKE_SELECTED_CAPABILITIES_MISSINGon 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 rootrequirements.txtand ran a CLike-internal module). It now runs repository checks that fit any Harper project:plan.jsonvalid, no.env/local state committed, no promotion leftovers or conflict markers insrc//test/. The generated.gitignorealso 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_ROOTis 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,integrationof 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 insidenode_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.jsonandci/REQ_PROMOTION_MANIFEST.mdare written by CLike from the plan at every package: they are not part of the acceptance lock (a rewrite reportedACCEPTANCE_TAMPERED).
[1.4.0] — 2026-10-11 — Autonomous eval and gate
Added
- Test infrastructure for the eval sandbox (
docker/eval.env, git-ignored, templatedocker/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 inci/LTC.jsoninstead of asking the developer:environment.required_variableswithprovisiontoken/uuid/timestamp/template(generated per run),postgres_database(a disposable database per REQ, recreated every run, on the server ofCLIKE_EVAL_POSTGRES_URLindocker/eval.env),serviceorexternal; andservices: [{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 indocker/eval.envwin. KIT prompts (cloud and local agent) andci/HOWTO.mdfollow the contract. /eval --fixrepairs a missing environment when a repair can declare it (BLOCKEDwithenvironment_repairable): the repair completes the LTCenvironment/services(an audited, non-weakening amendment). Only values markedexternalor 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_requiredat the gate. Until now only Python tests had this, so a correct repair of a TS fixture was reverted and--fixkept failing on it. The eval pre-pass now receives the previous failures as evidence too. /gatepromotes by auto-merge, without prompts (clike.gate.autoPromote, defaultmerge): a 3-way merge per file ofruns/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 inruns/kit/<REQ>/promotion/<ts>/(report.md,report.json,promotion.diff), opened at the end and summarized in the chat./gate --ask/--no-promoteoverride it for one run.- Auto-merge base = what the KIT started from: per file, the last direct dependency KIT
(
plan.jsondependsOn, 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.exampleentries) 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 frommain; 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 --fixkeeps going while it improves: afterclike.autoEval.maxCycles, up toclike.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
--fixcycle); it now sends batches (RAG_EMBED_BATCH_SIZE, default 64,RAG_EMBED_CONCURRENCY4) and skips files whose content is already indexed (point ids derive from path + content). The gateway/v1/embeddingsaccepts a list input and returns one vector per item in one provider call (it joined the items before). /evalchecks the required variables first. The KIT declares them inci/LTC.json(environment.required_variables: [{name, purpose, example}]; the free-formenvironment: {NAME: "Required ..."}of earlier KITs is understood too). When one is missing from the sandbox, the eval reportsBLOCKED(reason_code: EVAL_ENVIRONMENT_MISSING) with the variable names and thedocker/eval.envline to add, runs no check, and/eval --fixstops without a repair (no tokens spent on code that is not at fault).- KIT (cloud and local agent):
ci/HOWTO.mdgets a mandatory## Run with CLike /evalsection (required variables,docker/eval.envlines, one-time setup, rebuild,/evaland--fix).
Fixed
/evalfailed withACCEPTANCE_TAMPEREDfrom 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./evalwith a local agent failed withACCEPTANCE_TAMPEREDafter its own pre-pass. The eval pre-pass agent repairs the candidate and could edit locked files undertest/andci/(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--fixrepair: accepted ones are recorded, the others are restored. The eval agent is told thattest/andci/are locked and that evidence goes underreports/.- 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 Anthropiccache_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 fromconfigs/models.yaml(new optionalcached_input_per_1k; set forgpt-6.1-sol), also for the rows already recorded, markedpricing.estimated. - Eval sandbox OOM-killed on large JavaScript installs (
503 eval sandbox unavailable, thennpm installexit 137 and every checkENOENT). Its work dirs (venvs,node_modules, npm cache) lived on the tmpfs/tmp, which counts against the container memory limit. They now live on theeval_workdisk volume (CLIKE_EVAL_BASE_DIR=/var/clike-eval);/tmpis 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.4input corrected to $2.50/M;cached_input_per_1kadded 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.jsonwas ignored without a word. CLike now warns at startup and on change, with Apply in User settings. /initwrote.gitignorewith indented lines, so onlynode_modules/was ignored: chat sessions, telemetry,.vscode/and.envfiles could be committed. Lines are no longer indented, and.clike/sessions/,.clike/telemetry/,.env.*(except.env.example) and the eval scratch underruns/(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 inci/. The acceptance manifest is capped at 2000 files and a repair agent’sci/.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(gatePASS, warnings allowed byclike.gate.strictWarningsoff) left the REQin_progresswithout 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/testfrom 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 dirpytest-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 undertest/orci/) is documentation, no longer part of the acceptance lock: editing it by hand no longer reportsACCEPTANCE_TAMPERED./init:README_1st.mdshowed${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): 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 aPROJECT CONTEXT SOURCESblock, the local agent the list of files to read (converted documents written toruns/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. /initcreatesdocs/inputs/,docs/harper/ux/anddocs/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.modelis checked against the models of the Codex login (~/.codex/models_cache.json),clike.claudeCode.modelagainst the Claude aliases (opus,sonnet,haiku) andclaude-*ids. An invalid id blocks every Harper phase and agent chat turn withLOCAL_AGENT_MODEL_INVALIDand 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-modelrefuses an invalid id. Without the Codex models cache the Codex id is not checked.
Changed
- Faster, always-current container rebuild:
docker/rebuild.shbuilds 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, Claudeis_error), not on stderr;LOCAL_AGENT_EXITED_WITH_ERRORnow 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-initproject): 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 answereddocument_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 reportsLOCAL_AGENT_EXITED_WITH_ERRORwith 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 writeIDEA.md,SPEC.md,PLAN.md/plan.jsonor the EXTEND report and the phase failed with missing outputs. Every Harper local-agent phase now runsworkspace-write; an explicitread-onlyis rejected up front withLOCAL_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 uxis companion-only locally too: it no longer requiresSPEC.md, and writingSPEC.mdis rejected. - BMAD artifact policy lost with the workspace vendor manifest: when the workspace carried
.clike/skills/vendor/bmad/manifest.json(everyharper-initproject), it replaced the bundled manifest entirely and dropped itsartifact_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 indocs/integrations/bmad/COMMANDS.md(BMAD cloud prompts grow by 3–10 KB). - BMAD
finalizein 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
pmanduxfiles).
[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, defaultask): 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 throughcodex app-server(the same sessions ascodex exec).autokeeps 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. /helpis readable on every theme: VS Code theme colours, commands grouped by topic, a filter box, Esc / click outside to close.
Fixed
- MCP
eval_runwithfixreturned the report of the first eval: it now returns the report of the last eval after the repairs, plusauto_eval {outcome, cycles, reason}. gpt-6.1-solpricing ($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
localhostURLs (managed Claude Code policies often allow onlyhttp://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, Codexexec 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_phasewaits up towait_seconds, thenharper_run_status), pluseval_run(optionally the auto-evalfix) andgate_check; no overrides, promotion or git from MCP. The orchestrator MCP Harper read tools accept aproject_root(confined to the projects directory). Verified with Codex callingharper_req_liston 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 noisyexternal_library_obligationis gone. - KIT autofix for every ecosystem: final newline in sources, gofmt for Go when installed.
-
/agent-modelshows execution, default agent and models;/agent-model listlists the models. -
KIT:
TARGET_CONTRACT.jsonandFILE_REQUIREMENTS.jsonare written by CLike (inci/anddocs/, 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/amendand the extension restores what is rejected. Benchmark--runner agent --auto-eval N. - Acceptance-first KIT (
clike.kit.acceptanceFirst, opt-in):/kitfirst 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/telemetryand 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/runrequirescomposed_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/toorchestrator/phases/<phase>/cloud_*.md; thePROMPT_*_SYSTEM_PATHvariables 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 toclike.autoEval.maxCycles(default 2); rerunnable with a developer hint;clike.autoEval.afterKitruns it after/kit. Tests stay locked; an LTC command that cannot run andci/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 reportsreview_required. API:kit.repairobject on/v1/harper/run; benchmark--auto-eval N. - Regression of promoted REQs:
/v1/eval/runand/v1/gate/checkacceptregression: true(extension:clike.eval.regression, default on) and re-run the acceptance checks of every promoted REQ (plan statusdone) against the new code; the gate reportsGATE_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. PhaseContextv1: the typed, versioned contract of a phase run (docs/contracts/phase_context.v1.schema.json); the wirecore_blobsare produced from it.- Phase definitions as data in
orchestrator/phases/: per-phasephase.yaml(write roots, output contract, rules, accepted result paths) andtext.yaml(local-agent prompt and policy text). - GPT-6 family support (reasoning models recognized by generation number);
openai:gpt-6.1-solin 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_WARNINGSunless strict (strict: true,clike.gate.strictWarnings,CLIKE_GATE_STRICT_WARNINGS=1). Evalpromotablefollows the same policy. services/local_agent_package.py(6,900 lines) split intoservices/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), likeANTHROPIC_API_KEY.
Fixed
- Cloud
/kitproduced unusable paths for many plans: free text and placeholders became file paths (B18), the ecosystem was guessed from scattered words (e.g..jsfiles in a Python project, B19), and__init__.py,ci/requirements.txtor 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.repairsent by the extension (/kit --repair) is accepted as a flag or as an auto-eval repair request (the gateway rejected the orchestrator’s defaultfalse).- Eval honors the LTC
run_fromfield as the commands’ working directory. - Cloud
/planreceived IDEA.md and SPEC.md by name only and could return an empty plan; it now receives them in full. Cloud/kitreceived 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’srag.jsandfix_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 readsEMBEDDING_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/checkno longer accepts manual verdicts (mode=manual): use the newPOST /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
/kitto re-baseline. - Orchestrator
POST /git/branch,/git/commit,/git/prremoved (unused; they rangit 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}(was401); an unknown/disabled model is400{code: model_selection_error}(was500); gateway failures during any Harper phase keep their status and cause (429/503/4xxpass through, others502) instead of a generic500. - Gateway: unknown Harper phases are rejected (
400) and a missing phase prompt is503;eval/gateuse 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/**andci/**, taken before any local-agent eval pre-pass; reports include anintegritysection. - Audited gate override endpoint; overrides are reported as
OVERRIDEand promoted only with an audit id. eval-sandboxservice: 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 includeexecutor.- 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_choicerequiredwas 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: 0became 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
ReferenceErrors, broken/unregistered commands, local agents left child processes running after a timeout, chat image previews rendered as text. runIdcould travel as the string"None"; a request withoutflagswas rejected by the gateway.- Extension
eval/gaterequests usedfetch, 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_codeGATE_BLOCKED_STATUS_PASS(nowGATE_PASS). - A gate
modepassed as a query parameter was ignored. - KIT stage artifacts were written to a non-persistent path in containers (
RUNS_DIRnow/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). SetCLIKE_API_TOKENin.envand run CLike: Set Service Token in VS Code. MCP clients must send the same header. POST /v1/applyremoved. The extension applies generated files locally.- Eval/gate confinement. The project root must be under
CLIKE_PROJECTS_DIR(DEV_FOLDER) orCLIKE_EVAL_ALLOWED_ROOTS; the LTC profile is read from the workspace and an inline profile must be identical (CLIKE_ALLOW_INLINE_LTC=1re-enables inline-only profiles). - Git automation off by default.
git.autoCommit,git.openPR,git.gitMergeOnGateandgit.pushRebasedefault tofalse; pushing requires the newgit.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=Strictcookie. - 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/applyclient path fell through to the local path after a server error.
Build and quality
- Python 3.12 for both services;
pyproject.toml+uv.lockper 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
.vsixpackaging. - 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.