* fix(update): publish plugin records without an empty config write
When plugin convergence after a core update changes no config path, publish the install records without writing openclaw.json. A config file the update cannot replace, such as a link to a provisioned read-only file, no longer fails an update whose plugin work converged, and the file keeps its bytes. A real config change against such a file is still refused.
The update report for a healthy Gateway with unfinished maintenance now names `openclaw gateway stop --force`, the command that works in a non-interactive shell and the one repair names.
Adds the published-driver-plugin-publication Docker lane: a published 2026.11.5 updater's first update with two official npm plugins and a symlinked read-only config.
* test(e2e): record the published-driver plugin cell before asserting
* test(update): keep the post-Doctor publication check on a real config change
* fix(update): bind records-only plugin publication to the planned config path
Check the config path proof captured for the update before and after the records-only publication, so a re-pointed config link cannot receive records planned for another config. The published-driver cell now pins its baseline plugin versions through a fixture registry and requires readable update history that names the update's own run.
* test(e2e): isolate and bound the published-driver plugin publication cell
Give the lane its own artifact directory, read readiness only from a successful probe in this run, bound fixture fetches by the cell deadline, and add a refused-channel-change mode: a real config write against the read-only config still fails the update, and the report names a Gateway stop that works unattended.
* test(e2e): pin the refused channel write and the cell's own artifact default
The negative control now requires the symlink refusal in post-update verification, the wrapper selects the plugin publication cell's artifact directory with its entry point, and the plugin observation is named after the local inventory it reads.
* test(e2e): default the plugin publication cell to a release and pin the refused control's plugins
* test(e2e): stamp lane plugin fixtures with the core target and check the config link itself
* fix(update): let automatic updates retry owed plugin convergence once
* test(update): prove the installed Gateway retries owed plugin convergence once
* test(update): serve the fixture release to the Gateway's own discovery
* test(update): keep fixture runs in production order and bound registry cleanup
* test: prove a killed update that stopped a real Gateway is finished by the next update
Add the package-installed-recovery-live-gateway Docker lane. It reuses the
installed-recovery cell's fixture-managed systemd service and real Gateway,
kills an update in its post-activation Doctor after it stopped the Gateway,
and checks that a plain next update finishes it and restarts the Gateway on
the installed version, and that --no-restart refuses until update repair.
* test: publish live-gateway command output in failure diagnostics
* test(ci): schedule isolated installed recovery cells
Run each installed recovery cut as a finite scheduler cell and publish package-bound receipts after its host process group joins. Preserve the landed timeout, deferred-schema witness, and installed-inventory owners.
* fix(ci): settle recovery producers before publication
* fix(ci): retain scheduler ownership through package entry
* fix(ci): bind recovery publication to scheduler custody
* fix(ci): retain published recovery failure annotations
* test(config): seed existing config before warning dedupe rewrites
The first write of a missing config seeds native session catalog opt-outs, so rewriting the same literal config was rejected as a size drop before the warning assertions ran.
(cherry picked from commit 2f8b92b458)
* fix(ci): size update-restart-auth budget from measured hosted runs
Hosted release checks passed this lane in 1678-2290s and were killed at the 2280s inner cap during recovery-update-restart. Derive a 3420s inner cap and 3720s lane budget from the slowest measured pass, and raise the targeted job timeout to 75 minutes so the job cap stays above the lane.
(cherry picked from commit cf7321814f)
* ci: run release Docker seed lanes on Blacksmith with the smoke package
Release validation children ran docker-seed-e2e on a hosted 4-vCPU runner with a full build-all and serial lanes (~91m, FRV 37607411898). Use the hourly-main Blacksmith 16-vCPU row, the existing smoke package step, and three parallel lanes for those children only; manual dispatches keep the hosted path.
* fix(ci): give long unfitted release rows a 90-minute hosted job cap
core-runtime-config was cancelled at the 60-minute hosted cap with 5544 of ~5554 tests passed (FRV 37623751955); cli-process and agent-chat ran 41-52 minutes. Splitting them exceeds the full manual manifest output budget, so extend their job timeout instead.
* docs(ci): record release validation runner and measured budgets
* fix(ci): preserve release runner recovery and weighted admission
* feat(release): qualify frozen candidates with their own harness
Keep candidate qualification code, required coverage, and baselines frozen while independently trusted tooling authenticates admission and publication. Preserve historical recovery and verify exact qualified npm and Docker artifacts without candidate-to-publisher ancestry.
Co-authored-by: RomneyDa <6581799+RomneyDa@users.noreply.github.com>
* fix(release): restore authenticated harnesses before execution
Bootstrap only from the immutable caller commit, then restore and verify the authenticated callee revision before any repository code runs. Preserve canonical origin and path guards, with real Git regression coverage. Remove duplicate coercion declarations without importing executable normalization code before bootstrap admission.
Co-authored-by: RomneyDa <6581799+RomneyDa@users.noreply.github.com>
* test(release): align qualification fixtures with frozen harnesses
Provide explicit ordinary-lane workflow inputs and the complete committed bootstrap closure. Assert immutable caller seeds rather than a moving main checkout, preserving authenticated harness restoration. Keep the internal evidence script constant private.
Co-authored-by: RomneyDa <6581799+RomneyDa@users.noreply.github.com>
* fix(ci): register frozen qualification dynamic entrypoints
Model the verified Node child runner and generated admission-transport fixture as exact Knip entrypoints. Keep the fixture out of production roots and preserve the hard-zero unused-file and export checks without ignores or fake imports.
Co-authored-by: RomneyDa <6581799+RomneyDa@users.noreply.github.com>
* test(release): include captured baselines in plugin fixtures
Model the independent phase qualification-baseline step with empty outputs and assert both trusted baseline output bindings. Preserve the substituted candidate SHA and the scanner checks against the separately admitted source identity.
Co-authored-by: RomneyDa <6581799+RomneyDa@users.noreply.github.com>
* fix(release): remove circular manifest policy dependency
Remove the retired empty-advisory helper and emit the unchanged empty wire fields at their producers. Keep strict advisory rejection and the single manifest builder.
Co-authored-by: RomneyDa <6581799+RomneyDa@users.noreply.github.com>
* test(release): cover frozen catalog checkout closure
Preserve exact sparse-path, byte-integrity, and candidate-isolation assertions for both catalog dependencies. Keep them excluded from preflight materialization.
Co-authored-by: RomneyDa <6581799+RomneyDa@users.noreply.github.com>
* refactor(release): remove unused evidence facade export
Keep manifest child evidence owned by the extracted manifest module; policy and state consumers use that owner directly.
Co-authored-by: RomneyDa <6581799+RomneyDa@users.noreply.github.com>
* fix(release): revalidate admission before publication effects
Carry authenticated admission authority through Docker and npm publication, rechecking it after preparation and immediately before each external registry mutation. Preserve original evidence and publisher guards; deny revoked authority in recovered and multi-package publication.
Co-authored-by: RomneyDa <6581799+RomneyDa@users.noreply.github.com>
* test: align release qualification coverage with main
* test: format release checklist coverage
* test: restore release fixture closure
* test: run compact admission from frozen tooling
* test: cover oldest supported upgrade baseline
* test: reconcile package acceptance coverage
* test(release): align candidate-owned dispatch docs
---------
Co-authored-by: roboclaw-bot <309084314+roboclaw-bot@users.noreply.github.com>
Co-authored-by: RomneyDa <6581799+RomneyDa@users.noreply.github.com>
Co-authored-by: Dallin Romney <dallinromney@gmail.com>
Runtime preserves authored cron definitions and consumes canonical ownership, delivery, and schedules. Doctor performs supported repairs with verified backups, while update rehearsals retain live legacy sources for the live import. Preserve durable receipts, explicit scope boundaries, and deletion fences.
Published 2026.9.7 updater acceptance passed on Testbox. The separately matched native published-driver CI timeout also fails on clean main; the PR records that inherited failure and its limits.
Raise first-hop lane weight to two under the existing npm limit of five, admitting at most two concurrent lanes while permitting one to overlap the weight-three survivor. Budget three 3500-second waves plus 20 minutes for the survivor and 10 minutes for setup/artifacts: 205 minutes, rounded to a 210-minute job timeout.
With the six-way contention bounded, return package-update-self-upgrade to the stable profile it was dropped from for 2026.9.7 (#161291, #161257).
CI Docker seed runs published-upgrade-survivor with
OPENCLAW_UPGRADE_SURVIVOR_UPDATE_RESTART_MODE=auto-auth, so the lane includes
the running-Gateway recovery update, but it kept the 1500s manual-mode
budget. Hosted 4-vCPU seed runs measured 846s and 1054s passes and then
1515s/1516s timeouts in upgrade-survivor:recovery-update-restart (CI
36496123315, 36519374717; FRV 36518668565).
Testbox 8-vCPU at the 2026.9.7 candidate: 627s lane, 325s recovery update.
x ~2.4 hosted ratio ~= 1505s, x ~1.5 => 2280s container budget, + 300s
host margin => 2580s lane, matching update-restart-auth. The recovery
update projects to ~780s (hosted 856s in 36506210440) against the 900s
command default, so the lane uses restart-auth's 1500s command timeout.
The release seed job runs six lanes serially: setup ~2m, package <=1032s,
other lanes <=1668s. (120 + 1032 + 1668) x 1.5 + 2580 = 6810s => 115m job
budget; the 60m budget already cancelled 36486786689 before fleet-cache.
Harness-only; no product code or scheduler concurrency changes.
Hosted run 36506342273 exhausted the first-hop container's 1800s budget.
Project 1558s + 560s final candidate hop + ~5s assertions ~= 2125s;
x ~1.5 gives 3200s inner, plus 300s host margin gives 3500s per lane.
Six sources still need two waves at npm weight limit 5; 2 x 3500s
plus 10m setup ~= 127m, rounded to a 130m self-upgrade chunk.
Restart-auth exceeded 1515s in run 36506342273: x ~1.5 gives 2280s
inner plus 300s host margin, or 2580s per lane. Run 36506210440
measured an 856s restart update; 4-CPU Crabbox measured 993s, so
set a lane-only 1500s command timeout and retain the global 900s default.
The OpenAI/recovery row's five weight-3 npm lanes serialize at limit 5:
30 + 30 + 20 + 25 + 43 = 148m, plus 10m setup => 160m rounded.
The chat lane overlaps. CI Docker seed excludes restart-auth and keeps
its 60m job budget. No product code or scheduler concurrency changes.
Validation: all 185 tests in the three focused files passed (71.13s wall,
one worker). Bash syntax, oxfmt, oxlint, and git diff --check passed.
Independent Codex autoreview found no actionable P0/P1 findings.
Legacy published baselines (2026.7.35, 2026.6.34) author plugins.allow from
their bundled provider inventory. The candidate's doctor restores those
now-external providers at the exact candidate version, which does not exist
on npm or ClawHub before publication, so the prepublish registry must carry
them. Stage every official provider from the selected candidate's external
provider catalog for legacy-operator-state lanes, loaded once per plan.
Allow 1800s per first-hop container and 2100s per lane using measured
published/candidate hop durations with a slow-host margin. Give the
six-source release self-upgrade job 80 minutes for two resource-limited
waves and setup. Preserve phase timing and concise update-step evidence.
Keep updater behavior, live authority checks, source coverage, and runner
concurrency unchanged. OverlayFS runtime-copy and journal-read overhead
remain a separate product performance follow-up.
Validation: 211 focused tests passed locally with one worker (55.36s wall);
inner/outer budget assertions failed against the prior harness. Bash syntax,
formatting, lint, timing formatter smoke, and diff checks passed. Independent
Codex review found no actionable P0-P2 findings.
Remove Tasks and TaskFlow runtime, APIs, CLI, SDK surfaces and panels after the Cron, session, native execution and media completion ownership cutovers. Preserve stored rows and import provable legacy native assignments through Doctor; ambiguous ownership stays untouched with a warning.
Follows #158221, #158217, #158225, #158222, #158702 and #158776. Related: #156532. Task-specific public APIs retire immediately; retained responsibilities use their existing owners.
Maintainer-authorized administrative landing after full CI run 36312986498 attempt 2 passed on 274595e2, with subsequent actual conflicts reviewed and focused checks passing. Current PR CI preflight hits the 64 KiB changed-path metadata limit before tests (run 36335042695); its duplicate security-review status mirrors that planning failure. Review and scoped proof are recorded in the PR. Published 9.4 native import is proven; remaining native completion and 9.4 rollback witnesses are explicitly unproven.
* fix(startup): keep legacy state repair in doctor
Separate current-state startup readiness from explicit Doctor migrations.
Preserve current config recovery, quarantine, device identity checks,
lease fencing and updater completion ownership.
Remove automatic startup migration/checkpoint and node-host import paths.
Keep shipped read-only context and roster projections unchanged.
* test(doctor): align proof callers with repair ownership
Keep survivor fixture setup in caller order and select the shared Doctor
flow separately from the channel-specific proof. Include the complete
isolated diagnostics dependency closure.
Prove ordinary startup preserves legacy directories before explicit
Doctor repair, and await SQLite worker closure before test cleanup.
* test(startup): verify index repair through gateway maintenance
* test(doctor): align cutover fixtures with state owners
Reacquire the database after Doctor retires its generation, retain real session history for startup refusal, and keep pending reads at their actual owners. Distinguish the reused readonly reader from independent snapshot-token children and verify every child settles.
* fix(doctor): preserve image activation and published migration receipts
Run the shared noninteractive Doctor owner before default and Compose Gateway
activation so retained Docker volumes keep their published upgrade path while
ordinary Gateway startup stays readiness-only. Preserve root selectors and
settle interrupted repair before executing the original command.
Retain the path-wide tombstones emitted by the published restart-sentinel
importer, including consumed notices, and validate completed source decisions
before retiring recreated inputs. Add the root-image activation lane and causal
receipt coverage without introducing a schema, option, or second importer.
* test(docker): preserve release state pairs in upgrade proof
Use the existing synthetic v2026.9.2 corpus instead of combining a July shared database with a later agent schema. Preserve its deletion journal, registry, both transcript payloads, paired backups, and unsafe-state controls. Register the two shell-launched helpers with Knip.
* test(docker): normalize persisted schema snapshot rows
Compare node:sqlite schema rows using the same plain-object representation as the saved JSON preimage. Keep strict schema, row, and value-type assertions intact.
* fix(models): retain discovered models after refresh failures
Record successful legacy catalog results at the producer boundary so unavailable refreshes retain the accepted inventory. Preserve explicit outcomes, advisory SDK fallback behavior, and first-discovery starter policy.
* fix(models): preserve skipped catalog outcome semantics
Mark bundled static, configured, and advisory catalog projections with
explicit empty outcomes so legacy success inference cannot promote them
to observed account inventory. Preserve live outcomes and helper types.
Keep exact auth provenance histories and move existing fixture/policy
code into focused owners where required by the line-cap ratchet.
Validation: 447 producer and sibling cases, 56 shared self-hosted cases,
95 auth/policy cases, causal missing-outcome failures, maintained checks,
and independent review.
* test(plugin-sdk): keep discovery loader types acyclic
Move the shared loader type into a leaf consumed by both discovery
contract helpers. Preserve its public provider-test-contracts export
without a child-to-parent type import cycle.
Validation: maintained Madge check reports zero cycles; core, all core
test graphs, extension test types, lint, formatting and independent
review pass. Runtime behavior and previous catalog proof are unchanged.
* fix(plugin-sdk): mark generated static catalogs explicitly
Keep the generated non-live, non-strict catalog adapter from claiming
successful acquisition for manifest or configured rows. Preserve null,
errors, strict and custom callbacks, static catalogs, and public types.
Validation: three existing controls fail before the correction; all49
owner and sibling cases pass afterward, with types, lint, line caps and
fresh independent review clean.
* test(gateway): cover restart import during state retirement
Exercise canonical database close while a legacy notice read is paused. Verify admission rejection, retained canonical and source bytes, no migration receipt, and joined maintenance custody without changing the accepted sidecar-stop drain contract.
* fix(test): drain sharing fixtures before removing state
* test: bind retirement regression to its own worker
* docs(docker): clarify automatic Doctor activation
* test(doctor): keep readiness fixture runtime private
* test: stabilize shared skill watcher fixture roots
(cherry picked from commit 15606be10ed61be99931fcf3bb300ebdb475ad89)
* perf(tooling): share indexed scope parsing for artifact scans
(cherry picked from commit 6e6eef9f5b556e0005b16363169e6a85cd310ad0)
* fix(team-reports): use source owners in scheduler tests
The source barrel retired in #157819, but the scheduler tests still imported
it, breaking the extension test typecheck on main. Import the Discord and
GitHub owners directly, matching the production caller.
Validated the original TS2307/TS7006 failure, the corrected extension type
graph, all 36 scheduler tests, changed checks, and independent P2 review.
(cherry picked from commit 7c4866c73b)
* test(install): isolate global npm configuration in version fixtures
Use a controlled absent global config inside the fixture home so the
release helper does not query the deliberately narrow npm stub. Keep
predecessor selection, fresh-install behavior, and expected exits intact.
(cherry picked from commit 0a9eefc76c82d81bd134add3ac3d269ae1b607bd)
* test(docker): verify the complete image activation entrypoint
* fix(memory): keep legacy dreaming cron repair in Doctor
Runtime reconciliation preserves historical and ambiguous dreaming rows and
manages only canonical declarations. The memory plugin classifies historical
jobs, while the cron store owns non-creating inventory, verified backup,
current-authority checks and atomic partition-local repair.
Preserve survivor IDs, ordering and runtime state; retain custom prompts and
foreign declarations. Remove the old core payload migration and runtime
adoption path. Published 2026.9.6 updater-child repair, exact backup retention
and repeated Doctor idempotence passed, with the landed plugin-inventory
handoff repair included in the proof candidate.
* docs(plugins): clarify trusted Doctor cron repair authority
* test: validate dreaming cron through public plugin boundaries
* fix(memory): keep authored tags from blocking dreaming
Warn about authored cron jobs that retain historical dreaming tags without
blocking creation or updates of the canonical dreaming declaration. Keep
Doctor responsible for recognized legacy and phase rows.
Extend the registered SQLite regression and published-updater scenario to
retain an independent authored tagged job through Doctor and real Gateway
convergence, then verify a settled plugin reload and preserved history.
* fix: keep failed update report uploads in the CLI
OpenClaw-Publication: fa59f7dd-6cf2-4ca9-937e-04f34e1604d4
Co-authored-by: eleqtrizit <31522568+eleqtrizit@users.noreply.github.com>
* fix: preserve browser reporting and safe report status checks
Keep failed update reports in the existing action menu with an explicit browser
handoff after known unsent failures. Preserve publication uncertainty after a
lost transport response, and keep status reconciliation from starting a new
submission when the receipt is unavailable.
Co-authored-by: eleqtrizit <31522568+eleqtrizit@users.noreply.github.com>
* test: finish pending report reconnect menu flow
Choose report once and explicitly exit the retained pending menu before checking
Gateway reconnect and durable receipt behavior. Assert the status action so the
fixture follows the supported flow instead of looping until the worker OOMs.
* fix(update): align report receipt handling with main
Adopt the prepared-receipt projection and terminal-receipt cleanup from
canonical refactor efa6369 while preserving explicit browser publication,
status-only reconciliation, and post-admission transport uncertainty.
Keep that logic in the existing report owner and remove the unnecessary
unshipped result module.
Replace two expiry fixtures' one-second polling waits with the existing
validation-start signal. Retain the ownership and artifact assertions,
and join each paused submission before restoring its clock in finally.
The original polling failures remain recorded separately from later proof.
Co-authored-by: eleqtrizit <31522568+eleqtrizit@users.noreply.github.com>
* test(agents): await maintenance lifecycle events
Carry canonical fixture fixes from 0589c8360b, 3b1f037214 and
ba068dc06c after CI 36034827210 reached their old startup polls and
wall-clock disposal assertion.
The local follow-through exposed the compaction fixture's remaining
five-second startup wait. Race actual entry against owner settlement under
the existing test abort signal, preserving disposal order, resource
retention, write-authority and physical cleanup assertions.
All 28 affected cases pass across the final compact file and unchanged
ownership/harness files. Selected checks and independent P2 review pass.
Update-report production behavior and dependency inputs are unchanged.
Co-authored-by: IWhatsskill <284122573+IWhatsskill@users.noreply.github.com>
Co-authored-by: Ayaan Zaidi <hi@obviy.us>
* test(update): exercise report recovery after published replacement
Run the published 9.6 updater first, then exercise the candidate CLI report
retry and uncertain-status paths through the maintained survivor PTY owner.
Preserve the real npm failure, receipts, installed package and operator state.
* test(update): size the report recovery PTY before interaction
Configure and verify the actual terminal dimensions instead of relying on
COLUMNS and LINES, which do not size util-linux script with piped input.
Keep the real CLI, report assertions and maintained timeout unchanged.
* test(update): register the report recovery harness entry
Model the existing shell-invoked CLI alongside the other survivor commands
so the hard-zero unused-file scan follows its real executable entry point.
* test(update): preserve concurrent survivor entry registration
Move the unchanged report recovery entry beside worker-cell-package so the
three-way merge preserves main’s independent admission-probe registration.
The executable entry set and scan policy remain unchanged.
* test(agents): retain main’s ownership startup settlement race
Carry the exact canonical fixture postimage from67fd7e910b89 so startup
settlement remains joined and the current-main content conflict is resolved.
Preserve every ownership assertion and cleanup operation.
Co-authored-by: stevenlee-oai <stevenlee@openai.com>
* test(update): assert released update ledger step keys
Match the persisted update status contract rather than executor stage IDs.
Keep both ENOENT checks, report counts, retention assertions and deadlines.
* test(agents): retain abortable foreign maintenance wait
Carry the canonical main fixture refinement from 0bbad56fa8. Keep the startup-versus-settlement race and all lifecycle assertions while allowing Vitest cancellation to reach owned cleanup.
Co-authored-by: galiniliev <5711535+galiniliev@users.noreply.github.com>
---------
Co-authored-by: eleqtrizit <31522568+eleqtrizit@users.noreply.github.com>
Co-authored-by: Peter Steinberger <steipete@gmail.com>
Co-authored-by: IWhatsskill <284122573+IWhatsskill@users.noreply.github.com>
Co-authored-by: Ayaan Zaidi <hi@obviy.us>
Co-authored-by: stevenlee-oai <stevenlee@openai.com>
Co-authored-by: galiniliev <5711535+galiniliev@users.noreply.github.com>
* refactor: retire pre-June config and upgrade test support
Retire obsolete Doctor keys and their runtime fallbacks. Older configurations use the documented 2026.9.5 Doctor bridge; current upgrade verification starts at June 2026 while historical receipts remain readable.
* fix: preserve retired config when the upgrade bridge is skipped
* test: align upgrade fixtures with retained migration contracts
Live, Docker, channel and release wrappers could repeat failed validation
or downgrade failed jobs automatically. Run each test invocation once,
remove known-flake redispatch, and require an explicit recorded waiver
when the release policy permits one.
Wait for the original plugin publisher to settle before reporting failure.
Keep bounded artifact-download recovery before tests. Read published
v2026.9.6 empty retry metadata without restoring executable allowances or
automatic waivers, preserving the sealed plan digest. Use the existing
fresh-read owner for release-priority cleanup.
Testbox owner/sibling proof and three CI-config replays passed. The two
freshness regressions passed 20 repetitions. Published evidence retained
its original digest; nonempty retry metadata remained rejected. The stale
Testbox assertion now matches its already-landed four-hour lease; this
change raises no runtime, test, hook or watchdog budget.
The update-first-hop-compat selection now expands at plan time into one
Docker lane per release recorded in scripts/lib/update-compat-inventory.json
(update-first-hop-compat-<version>), for both the Docker E2E pool and the
targeted GitHub matrix. Each lane runs the existing script with
OPENCLAW_UPDATE_FIRST_HOP_SOURCE_VERSIONS=<version>, writes its own
artifact directory, and carries a 25-minute budget at weight 1, so the
hops run concurrently instead of ~55 minutes serially.
* refactor: retire pre-June import and verification compatibility
Remove pre-June task, flow, and plugin-state sidecar imports, obsolete
runtime chunks, package/installer validation exceptions, the old MCP
attachment fallback, and the April self-upgrade lane with its orphan helpers.
Leave retired data files untouched and document migration through 2026.6.1.
Preserve June-and-later contracts and September delivery recovery receipts.
Refs #156190
* docs: route legacy upgrades through 2026.9.5
* test: await Telegram fixture lifecycle events
Replace the setup stopwatch with the actual stop event or terminal run outcome. Keep cancellation assertions and outer execution bounds, and prove early terminal outcomes fail promptly.
* fix(release): give the first-hop compat lane a four-hop budget
The packaged-updater first-hop lane now proves four serial hops
(2026.9.1 through 2026.9.4). On hosted runners each hop takes about six
minutes, so the 25-minute lane budget killed the fourth hop with SIGTERM
after the first three passed (release 2026.9.5 validation run
35287969616). Size the budget like the other multi-hop update lanes.
* test(release): align first-hop lane budget expectation
Complete update repair recovery after successful acknowledgement or failed finalization. Keep Gateway maintenance custody in the update parent, fence expired mutation work, and restore and verify the owned service before preserving the original failure exit. Doctor children do not activate their parent's Gateway. Clear acknowledged recovery warnings and actions in CLI and Control UI reports while retaining historical failure records.
Reuse the existing Doctor maintenance, activation deadline, and update ledger owners. Preserve recovery guidance for ordinary maintenance refusals and legacy failed-history handling without adding configuration, CLI options, database schema changes, or dependencies.
Related: #150950#151132. Also related: #150942. Reported by @shadesurgeon.
Validation: exact-head CI run 35284407181 passed with zero pending checks; committed-branch review is scoped-clean. Existing proof includes 430 selected tests, 177 survivor tooling tests, changed-file and import-cycle checks, and the published 2026.9.4-driver Linux qualification. The injected 15000 ms plugin deadline refused a late config write, restored the Gateway, released custody, and retained exit code 1. That qualification uses a systemd fixture with real Gateway processes. Synthetic before/after screenshots show cleared recovery prompts with historical failures preserved.
* test: add worker state upgrade survivor cells
Add opt-in Projects Doctor and terminal task/flow restoration cells using the unchanged published updater, verified package bytes, and the canonical survivor lifecycle. Preserve failed synthetic state until the outer Docker owner has joined.
Validation: 161 focused tests, selected changed checks, and P2 review. Actual package upgrade cells remain separately qualified against frozen candidate artifacts.
* test: activate taskflow survivor fixture on Gateway startup
* test: clean worker runtime with container ownership
* fix(test): preserve Docker status through exit traps
* perf(state): preserve prepared queries during healthy reads
Inspect the legacy Workshop index without toggling SQLite catalog flags on healthy handles. Retain the existing bounded repair admission when malformed schema blocks ordinary reads. A native-authorizer regression covers prepared-query reuse.
* fix(state): keep legacy catalog repair in Doctor
* refactor(state): use native repair connection options
* test(doctor): verify maintenance-only catalog admission
* fix(doctor): admit update ledger reads before service stop
Use Doctor's bounded read admission for pre-stop ledger inspection and
its live rechecks on fresh private snapshots. Reset SQLite's schema cache
when ending admission so unknown malformed indexes remain refused.
Keep legacy catalog repair in Doctor and preserve updater ownership,
future-version refusal, and the existing continuation writer fence.
* fix(e2e): register Workshop recovery assertions
Allow the existing Workshop Doctor recovery scenario through shared successful-update validation so it can reach the fresh candidate repair stage. Extend the real assertion CLI regression while preserving failed-step checks.
* fix(e2e): recognize the Workshop frozen catalog
* fix(doctor): repair legacy catalogs before migration reads
Keep the prepared Doctor repair inside the migration transaction, ahead of publication-ledger reads. This lets standalone Doctor repair handle the v16 Workshop catalog while regular Gateway reads continue to refuse it.
* fix(ci): run frozen bundle clients from their shipped layout
Resolve only the selected bundle contract with local committed-object reads and trusted syntax parsing. Preserve each legacy client's manifest, helper, import depth and bytes before Docker staging, and reject unknown or unreadable contracts.
* fix(ci): preserve frozen source read failures
Distinguish committed absence from missing, corrupt, or wrong-kind Git objects before selecting frozen compatibility. Share bounded local-only source reads across the shell and bundle resolver, and preserve errors through conditional callers before gateway Docker work. This is the source-read stage only; aggregate frozen admission remains separate.
* fix(ci): isolate frozen consumer contracts
* fix(ci): add inert frozen target admission
* fix(ci): validate Docker lane alias contracts
Anthropic tool loops could repeatedly write growing conversation history to the
prompt cache because a moving runtime-context carrier owned the checkpoint.
Use the existing replay lifecycle contract to exclude transient carriers from
both request builders while preserving retained anchors. Also omit empty beta
headers that caused direct API requests with thinking disabled to fail.
Add deterministic regression coverage and a packaged Docker test that verifies
real cache reads and incremental writes across two tool continuations and a new
user turn in both builders. Require that lane in stable/full release validation,
with explicit API-key preflight, no request retries, and a declared runtime entry
for dependency analysis.
Validation includes focused package/model/session and workflow tests, build and
package integrity checks, static checks, independent review, mock Docker, and
eight successful live Anthropic Docker requests. Hosted CI run 34379052492 passed
on the final PR head at attempt 2, after one unchanged browser-animation rerun.
Closes#140607
Thanks to @LightningWareLLC for reporting the regression and contributing the
lifecycle-aware cache repair.
Co-authored-by: LightningWareLLC <271410939+LightningWareLLC@users.noreply.github.com>
Co-authored-by: Peter Steinberger <steipete@gmail.com>
* fix(release): bind smoke and ancestry checks to selected sources
* fix(release): use the trusted owner for selected source checkout
* fix(ci): recognize frozen first-hop output declarations
Recognize reviewed literal and mapped postbuild output contracts without executing target code. Preserve required first-hop coverage for the frozen release while keeping unsupported-target and zero-run execution failures intact.
* fix(update): recover stale runs without stopping healthy gateways
Reconcile dead recorded drivers conservatively and make legacy recovery explicit through repair or new update admission. Retain driver, heartbeat, and post-core evidence across bounded ledger writes.
Related: #141273, #139284.
* fix(update): preserve preflight admission and fixture boundaries
Keep history diagnostics behind ownership admission and out of proven-pristine startup. Register the survivor catalog and tool entrypoint, and isolate repair option fixtures from retained update runs.
* fix(update): keep driver diagnostics best effort and inspect newer repairs
Continue adoption without an inspectable identity and keep heartbeat failures from aborting commands. Preserve unknown-adopter evidence and inspect newer abandoned post-core history before ledger-only repair.
* fix(update): restore untracked official plugins from the core release cohort
Keep update admission and Doctor repair on the selected stable core version when formerly bundled official plugins have no install record. Preserve existing selectors and capability policy. Add DuckDuckGo published-upgrade and standalone Doctor coverage for bundled and already-missing states.
Related: #135002, #116740
* test(update): recognize missing optional plugin warnings
* test(update): isolate plugin repair proof and satisfy helper lint
* test(update): preserve beta tag selection in doctor fixture
* chore(ci): register plugin doctor survivor entrypoint
* ci: gate published upgrades with legacy operator state
Add a latest-release PR/main tripwire and runtime-resolved weekly and release baselines. Exercise baseline-authored agents, approvals, cron owners, a plugin, and mock agent turns; preserve the narrow unfenced-updater refusal contract.
Related: #140778, #140784, #140886, #140825.
* test: verify native published upgrade lifecycle
Persist JSON-era CLI approval IDs, retain a moving plugin selector, and exercise the baseline updater-owned restart. Query cron owners before repair, reject malformed canonical approvals, and require clean Doctor evidence.
* test: keep survivor installs in disposable runtime state
Retain verification logs and hashes while letting the container own the legacy scenario npm prefix. Other survivor scenarios keep their existing artifact layout.
* test: preserve immutable sorting in CI docs guard
* fix: preserve historical release upgrade qualification
* test: handle absent release scenario output in assertions
* ci: preserve survivor coverage within existing limits
Keep all native operator and schema cases in their existing owner suites. Register the shell observer entry and current inert scenario catalog, and update fixture, request, and routing contracts without changing runner caps or assertions.
* ci: pair expanded upgrade baselines with native operator state
* test: classify upgrade baseline provenance as internal
* ci: preserve docs-only main push exclusions
* test: require successful upgrades from every supported baseline
Remove the temporary 2026.9.2 schema-refusal pass after #141109. Observe applied shared-state content while publication is deferred, retaining candidate, state-preservation, restart, and validated plugin-consent recovery checks.
* test: require legacy agent migration before upgrade probes
Snapshot the seeded roster and legacy session specimens independently of existing SQLite files. Require migrated agent stores, imported history, and preserved recovery artifacts before candidate probes can initialize state.
* test: scope upgrade specimens to session migration storage
Ignore native model catalogs and unrelated per-agent artifacts while preserving strict classification inside the legacy sessions directory and the existing SQLite runtime inventory.
Route Fleet-generated caches to writable tenant state and preserve explicit environment provenance through create, upgrade and restore. Retain normal container isolation and validate the packaged CLI through rootful Docker and rootless Podman lifecycle flows.
Co-authored-by: Ayaan Zaidi <hi@obviy.us>