Repository navigation
Releases
v5.23.3
Fixed
A session that waits for a cplat command no longer loops on model calls (#750). The Stop hook blocked the stop of a session while its wait ran, and every block made the session answer with another model call; a 60 s wait could cost dozens of calls. Now the session may stop and the hook counts nothing. Under cplat headless the wait runs detached, no next session starts until it ends (polling local files, no model call), and the next session is told the result at its start. A loop guard stops a session that makes calls model calls without progress in minutes minutes and escalates with looping: ...: --loop-guard <calls>/<minutes> (default 10/5), guard.loop_calls (3 to 100) and guard.loop_minutes (1 to 60) in .platform/dispatch.yml. cplat dispatch pause now reaches running units at their next stop, status shows paused_at and the units escalated today, and cplat needs names the cause of an escalation (ADR-115). Update the plugins (/plugin marketplace update).
cplat next reads all its sources within its 20 s limit again (#782). In journey 20 its run records and GitHub sources timed out on every call, so the hand-over guide never showed the next step. The run store now asks its days in parallel, and one next, status or needs call reads each day once for all its readers. Only the system's own runs get rows and PR lookups, and the GitHub sources are asked at once: on the journey's system next takes about 10 s with every source read, where before it hit 20 s with two sources missing. Releases show again (gh release list has no url field). Update the plugins (/plugin marketplace update).
cplat pr wait --merge no longer merges before a pull request's CI run exists (#787). GitHub creates the pull_request workflow runs a few seconds after a push, while CodeQL's checks may already have passed. A wait that polled in that gap saw only green CodeQL checks and merged; two platform PRs reached main with their CI red. Now, in a repo whose workflows run on pull requests, a head is green only once such a run exists on it, and if none appears within 5 minutes the wait ends with an error instead of a merge.
v5.23.2
Fixed
The ship hand-off passes the kube context, so the dev smoke runs (J19-1, spec 203). cplat component ship start <spec> --detach started the headless run without a kube context when the interactive session had none in CPLAT_KUBE_CONTEXT, so its ship deploy recorded the dev smoke as "not run". The hand-off now resolves one context (--context C, the run's recorded one, CPLAT_KUBE_CONTEXT, KUBE_CONTEXT, kube_context: in the settings, the local k3d-<system>-local cluster), refuses a --context the kubeconfig does not have, records it in the ship state, gives it to the process and prints context: <name> (<where it came from>) after the headless: line; a restart keeps it. Without any context it prints context: none (dev is not checked; pass --context <kube-context>). Update the plugins (/plugin marketplace update).
A changed committed plan reschedules the units before the next unit (J19-2, spec 203). A plan committed after the units were scheduled left the run building the old units. The ship run now reschedules the units from the changed plan before it starts the next unit.
cplat next stops waiting on a slow source (J19-3, spec 203). One slow or hanging source held cplat next indefinitely. Each source now gets 20 seconds and the whole command 60 seconds, and no source can read input.
A resumed dispatcher unit is finished only when its own pull request merged (#767). Since #755 a paused ship unit was marked done on resume when any pull request of its branch had merged, so a spec whose approval PR used the same branch was ended mid-build and its worktree removed; a merged pull request now counts only when it holds the unit's current commit.
v5.23.1
Fixed
A detached component ship's own unit sessions do their unit again instead of waiting on the run (#757). Since 5.23.0 an interactive /component:ship hands its run to cplat headless; the run's status block then showed headless: pid …, and a unit session that printed it (through a plain cplat component ship start) followed the hand-off procedure and waited on its own run forever. The status block now names the process run process: pid …, and a session running under cplat headless never shows it, so only the interactive session that handed the run off waits. Update the plugins (/plugin marketplace update).
A detached component ship's unit sessions can finish while the shipping session waits (#765). Since 5.23.0 the interactive /component:ship waits on its detached run with cplat component ship wait in the same checkout, and a unit session's Stop hook counted every running cplat wait of the checkout as its own, so the plan unit was held as "not finished" and escalated although it was done. A wait now records the session that runs it, and a unit session's Stop hook is held only by its own waits (a mark without a session, from an older version, still counts for every session).
v5.23.0
Added
/platform:next shows where you are in the delivery process and what waits for you, as choices (spec 192). cplat next prints one screen: the process bar from triage to release, what is happening now, and your part, with the questions as options you pick instead of commands you type; your answers are recorded as follow-ups and appear as person time in cplat platform runs report. Triage, spec approval, build, ship and release now end by handing over to it (ADR-112). Update the plugins (/plugin marketplace update).
Changed
An interactive /component:ship hands its run to its own headless session and only waits, relays questions and reports (#200). "Ship the spec" ran plan, build, PR, land and deploy in the session you typed it in, which took 5.7 to 8.6 M tokens of that main session, and in journey 16 (J16-1) a CI fix that only touched a test helper stopped the run with a question nobody could answer. Now /component:ship starts cplat component ship start <spec> --detach, which runs one cplat headless process for the run; your session runs cplat component ship wait, asks you each question the shipping session escalates (or resumes with suggested answers you said to take) and prints the final report from cplat component ship status. Every fix round runs cplat spec test-diff after the fix and settles a test-helper or type-only change without a stop. Pass --here to keep the run in your session as before. See ADR-113. Update the plugins (/plugin marketplace update).
Fixed
A resumed dispatcher unit whose pull request merged while it was paused is finished, not started again (#755). cplat dispatch resume used to start a paused unit's session again even when its pull request had merged meanwhile, so the unit kept its slot and held every other ship as ship-busy; it is now marked done and frees its slot.
v5.22.1
Changed
/issue:triage proposes in one table and hands fixes to the dispatcher (spec 176). Triage used to ask issue by issue and start each /component:fix in your session. Now cplat issue triage batch reads the whole queue once, you see one overview (needs your decision, clear, already handled), answer the open questions as choices, confirm once (OK, do it / Change one / Cancel), and act labels the issues and posts a Triage: comment. New specs of a run share one docs/triage-<date> branch and one draft PR. No fix starts in the session: the dispatcher reads the newest Triage: comment of a user with write access as the fix run's task, with the reporter's text fenced (ADR-111). Update the plugins (/plugin marketplace update).
Fixed
Smoke, promotion evidence and Grafana links follow the port the local cluster's Gateway got (#199). When 8088 was taken, cluster-up mapped the Gateway to another port, but smoke, the promotion evidence and the Grafana URL still used LOCAL_HTTP_PORT or 8088 and reached nothing or another cluster. For *.localhost hosts cplat now uses LOCAL_HTTP_PORT when it is a number, else the port the k3d cluster's Gateway listens on, else 8088 (see Smoke in dev).
v5.22.0
Fixed
Five seams found in journey 13 are closed (spec 197). cplat component build reviewed finds the tester's acceptance-test commit by the AC id in its subject; cplat platform runs agent findings --deviation <id> of a merged-away task is recorded on its final task with a note; cplat system set --observability lgtm and cplat system status name where Grafana answers; the web release agent's next-dev-version step uses --no-git-checks, so it works with the uncommitted changelog; and generated Python, Java and Go repos fail a hung test after 120 s (Go: stop a package after 5 min) through scripts/gate.sh, so /platform:update carries the limits and a repo's own limit wins (ADR-110). Update the plugins (/plugin marketplace update).
The web-nextjs image runs on a distroless Node runtime and the platform scans its template images (#682). The web image shipped a Node base with a shell and npm, which carried CVE-2023-45853 (zlib in the base image). The runtime stage is now distroless: no shell, no npm, and the CVE is gone. A new template image scan (.github/workflows/template-image-scan.yml, spec 189) checks every template's base images for critical CVEs; accepted findings sit in a list whose entries expire. Action: existing repos pick up the new image with /platform:update.
The inbox no longer lists escalations of work that is already finished (#730). cplat needs, cplat dispatch inbox and the console Inbox kept the escalation of a spec that was finished by hand (merged and set to done) for the whole 30-day run window, which buried the real items. An escalation is now hidden when its spec is done, its feature/<spec> pull request or the run's own pull request is merged, or, for a run for an issue, the issue is closed. When GitHub cannot answer, the escalation stays listed.
The build benchmark runs on a refreshed sample again (#736). Its pinned sample ika100/todo-api predated the template's docs/ ruff exclude and recipe arguments, so with ruff 0.17 (which formats Markdown code blocks) lint-fix touched the architect's design.md and a new OpenTelemetry advisory sent verification to a cplat deps patch the old recipe could not run; both stopped the benchmark, not the prompts under test. The sample now excludes docs/, passes recipe arguments and pins OpenTelemetry 1.45.2, and benchmark/tasks.json pins that revision.
A new Python service passes its own type check again (#740). The per-test limit plugin that 5.22.0 adds to the service-python and library-python templates had no type annotations, so a fresh repo's strict mypy . failed and its first image was never published. The plugin is annotated now, and the platform's template check runs the same mypy . as the generated repo instead of only mypy src. Run /platform:update in a repo created from 5.22.0.
v5.21.0
Added
A hung test now fails fast and names itself (spec 185). Spec 184's verification hung for 2.5 hours because older tests slept through the usage-limit pause. Now a cplat test stops after 120 s with its id, the limit and the stack; a test whose real sleeps pass 1 s fails at the crossing sleep, which does not sleep; and cplat quiet test-fast gives up after 9 minutes, stops every process it started, lists the tests still running and exits 124 without a flaky rerun (ADR-108). A decision taken on an escalation that needs code, test or document work becomes a task in the spec's plan before the ship goes on (component and system ship prompts), and the suite time is measured in CI and in the weekly retro. Update the plugins (/plugin marketplace update).
/resource:query reads a database, so a restore drill needs no kubectl (spec 195). /resource:query <db> --env <env> [--copy g<N>] "<sql>" [--json] runs a read-only statement on the active instance or a restored copy and prints a plain table (at most 1000 rows) or JSON; cplat resource restore --to and the backup guide point to it. Update the plugins (/plugin marketplace update).
cplat platform runs benchmark explore-stop: a real /component:explore session is asked to write and commit a decisions file, then to stop; it passes only when the working tree, HEAD and the sample repo's PRs are as they were (spec 188, AC-188.1).
Changed
cplat system ship next --wait now ends within its timeout plus one poll interval (#194). Progress of a running repo used to restart the timeout, so one call could run up to about 54 minutes, past the 10-minute Bash limit, and Claude Code moved it to the background. The deadline is now fixed: when it runs out with the action still wait and a repo made progress, the call prints the wait action and WAIT: repos still running, progress in the last <T>s; run the same wait again and exits 0 (with --json, stdout holds only the action and the WAIT: line goes to stderr); when no repo made progress it still prints TIMEOUT: and exits 2.
v5.20.0
Added
Backups and the observability UI are set by command, not by editing system.yaml (#187). /resource:backup <db> --env <env> --to <bucket> [--schedule <cron>] [--retention <n>d|<n>w] [--off] sets a database's scheduled backup in one PR (without an option it still takes one backup now), and /system:set --env <env> --observability lgtm|none|off sets the environment's observability block; /resource:add points to both. Update the plugins (/plugin marketplace update).
/component:explore and /system:explore let you decide a feature in conversation before its spec is written (#662). Both commands are read-only: they read the code, specs and issues, ask about behaviour and constraints one point at a time and end in a DECIDED block that /component:spec or /system:spec takes as its starting point. /issue:triage has a new route, "needs exploring", for issues too open to spec. The weekly /platform:retro shows explored specs next to the others since this release. Update the plugins (/plugin marketplace update).
Changed
A journey waits less: a system ship answers escalations while other repos run, a task pair that needs each other is merged instead of escalated, and the release reuses the CI run (#186). cplat system ship next returns the new action answer for an escalated repo even while others run; the system ship resumes a decision escalation that has a suggested answer with cplat system ship repo resume <repo> --answer '<text>' and holds every other one with cplat system ship repo hold <repo>, so running repos finish, nothing that depends on the held repo starts, and the run ends escalated with the repo table once nothing can go on. When a build task's checks fail only because a later task that depends on it has not landed, the session runs cplat plan merge <task> <later task> --reason '<why>' and goes on, and the architect plans such a pair as one task. /component:release runs cplat component release gates --commit <sha> and prints gates: reused CI run <url> on <short sha> when main's ci run on that commit passed within 7 days, else gates: run locally (<reason>); for this, component CI in the service-python, service-java, service-go and web-nextjs templates builds the image alongside the gates and tags it only after every gate passed. The local Argo CD scripts of the gitops-app and cluster-gitops templates poll git every 30 s, and restore and discard ask Argo CD for one refresh. Update the plugins (/plugin marketplace update) and run /platform:update in your repos to get the template changes.
Fixed
A land session no longer calls a running check stuck by misreading time zones (#673). When cplat pr wait and cplat component ship land ended with checks still pending, the session was left to judge from raw timestamps, and spec 179's land session mixed local time with UTC and escalated an e2e job that had run for 17 minutes. The message now names each pending check with how long it has run (from the API's startedAt, in UTC), and its hint says a running check is not stuck, because cplat itself reruns runs whose jobs only queue.
A killed run's idle time no longer counts against the minutes budget on resume (#676). When a ship run ended without writing a stop (its process was ended on purpose), the resume carried its minutes up to the resume, so an idle night used the whole budget and cplat headless stopped at once with budget exhausted: minutes. The ledger now records each root's last sign of life, and the resume carries the minutes only up to it.
v5.19.0
Changed
Prompt tests check structure, not sentences, and the prompt size cap has a sanctioned way up (spec 180). About 67 test files pinned exact sentences of the plugin prompts, so every prompt change broke unrelated tests, and the byte baseline of the rule register could not be raised without a hand edit. cplat platform rules check now resolves every link, heading anchor, plugin-root path, cplat <noun> <verb> name and slash command a prompt names, and fails a test literal of 4 or more words that occurs in a prompt unless it is marked # interface: <reason>; its report counts the targets and the interface pins. The tests assert what a prompt points to (tests/cplat/structure.py) and leave behaviour to the eval gate. cplat platform rules rebaseline --reason "<why>" raises baseline.prompt_bytes only when the eval gate passes for a clean tree and records the raise in baseline.history; cplat platform pr-check shows it and refuses a raise without its history entry. See ADR-103 and the register guide.
Fixed
Turning on observability no longer fails the gitops repo's secrets scan on the log tailer's checksum (#678). Since 5.18.0 the generated collector carries a checksum/tailer annotation for the log tailer, and the secrets scan flagged its 16 hex digits as a secret, because the baseline skipped only checksum/config. The baseline's generated-lines pattern now covers both checksums, and /platform:update widens exactly that pattern in an existing repo's .secrets.baseline.json (the file stays repo-owned; nothing else in it changes). Action: run /platform:update in each gitops repo that has observability on.
v5.18.0
Added
Container logs now reach the log backend (#182). Until now logs arrived only if a service's SDK pushed them. With observability on, the environment's collector pod runs a log-tailer container that follows every pod's stdout through the Kubernetes API (a namespaced Role for pods and pod logs; no ClusterRole, DaemonSet or host path, so the Kyverno guard rails still admit every workload) and sends it to the collector with service_name, k8s_namespace_name, k8s_pod_name and deployment_environment. The component templates log trace_id and span_id so a log line links to its trace. See ADR-098. Run /platform:update to pick it up in existing environments.
Shared numbers and indexes now come from cplat (#659, #660, #477, #577). cplat spec new takes one more than the highest spec number on main, every pushed branch and every open PR, and cplat spec check reports a spec or ADR number that this branch and another branch or PR both add. cplat adr add <slug> --decision "<one line>" writes the next ADR from the platform's template and appends exactly one row to the ADR index, so the architect no longer numbers ADRs or edits the index by hand. A criterion that changes another spec's active criterion ends with (replaces AC-<NNN>.<n>); the old one is struck through as superseded by, counts as withdrawn in trace, verify and the done count, and cplat spec check refuses an unstruck target (cplat spec new --from-plan strikes it for a system plan's slice). A cplat command whose output pipe is closed (cplat … | head -1) exits 141 without a traceback and no longer files a crash issue. See ADR-099 and spec 183. Update the plugins (/plugin marketplace update).
Parallel ships no longer stop each other, and the usage limit pauses a run instead of failing it (#184). Runs in several worktrees used to collide on one ship slot, a usage limit ended a run as a failure, and a land stopped when another PR took the same ADR number or rule number. Now cplat headless takes a slot from a per-repo pool (slots in .platform/dispatch.yml, shared with the dispatcher and every worktree), prints waiting for a slot: held by … or, with --no-wait, exits 1 with slot busy: held by …, and frees a stale slot with freed a stale slot of …. A session that hits the usage limit pauses the run (paused: usage limit, next try at <time>, 5 to 60 minutes between tries) and after 360 minutes in total exits 1 with environment pause: usage limit resets at <time or "unknown">, recorded as escalated with cause environment; running the same command again continues. The land renumbers a clashing ADR and rule register entry (renumbered ADR-<old> to ADR-<n> …) and reads CI logs on its allowlist. devbox run ci lints changed templates and reports file, line and rule, and env-prefixed devbox commands in a plan are allowed verbatim. See the guide. Update the plugins (/plugin marketplace update).
A guide to reviewing a spec before you approve it (#661). Approval is the one decision the platform cannot take for you, but nothing said what to check in it. The new guide Reviewing a spec gives a reading order that lets you stop at the first wrong part, one question per part, and red flags for acceptance criteria, including a criterion that changes what an earlier spec promised (#477). The quickstart links to it at the approval step.
Changed
Unattended runs ask less: instance settings, git rm, type-only test changes, one test review and smoke findings no longer stop for you, and platform-repo escalations go to the desktop (spec 179). Instance settings from the system plan become before-merge gitops entry operations (#653), git rm of tracked files is allowed (never forced, #654), type-only test changes are recorded with --tighten (#655), the acceptance tests are reviewed once before they freeze (ADR-101), the tester fixes smoke-test findings in the build (#616), and escalations of runs in the platform repo go to the desktop, never to GitHub, unless events.escalation.github is set (#642, #643). Action: update the plugins (/plugin marketplace update); gitops-app repos get the new plan check with /platform:update.
The journey measurement counts the system ship's repo sessions as agent time and attributes waiting only from evidence (spec 181). The old scripts/journey/measure.py counted a minute as waiting whenever the coordinator waited, even while a headless repo session worked, and named the kind of wait from the command text alone. The measurement is now cplat platform runs journey measure (scripts/journey/measure.py forwards to it): each minute counts once, a person first, then agents when any thread works (the coordinator, its subagents, and the repo sessions found through the run records), then waiting. Waiting is attributed to CI, deploy, promotion, restore, cluster or smoke only from evidence (Actions runs, run-store phases, wait records), otherwise it is unattributed. --steps prints a per-step table, --json the exact split, and --journey <run_id> writes it to the journey record as a journey_split follow-up that cplat platform runs report --benchmarks shows as medians per stage, part and journey. See ADR-096 and spec 181.
Fixed
Every merge into main takes one land path with a stated mode (#648). A release whose branch fell behind main used to catch up silently; it now pushes and merges nothing and stops with main moved: start the release again and a fix: line (close the release PR, delete the release branch, run cplat platform release). The other land commands update the branch and wait for the new head's checks before merging, and a refused merge goes back to waiting, at most 3 times, then stops with merge refused 3 times: <reason>. Tests in tests/cplat wait for events through tests/cplat/waiting.py instead of fixed sleeps, and scripts/check-test-sleeps.py checks it (ADR-100, ADR-097).