Conversation
|
All source checks have passed for The connected cooperative worker/client path is still the next implementation step. Existing integration success verifies the preserved supported protocol 1.19 surface. It does not qualify the new delivery intent, heartbeat observation, acknowledgment recovery or active local activity fencing against Server PR291. This PR remains a draft and advertises no cooperative cancellation capability. The completed local test worktree and tool images are removed, with the active branch preserved. |
Request and delivery client source
Delivery requires explicit compatible protocol 1.20, worker credentials, the recorded lease owner/attempt and a canonical call/range. Success must acknowledge the exact task/request/boundary. Transport retry preserves that body. Lease and attempt refusals retain Server's machine reason and do not retry as another claim. Local source check on Python 3.12.14: pytest tests/test_cooperative_cancellation_client.py tests/test_client.py tests/test_cooperative_cancellation.py tests/test_replay_regression_corpus.py -q
ruff check src/ tests/
mypy src/durable_workflow/
python scripts/ci/validate-regression-corpus.py --base-ref f542486e125fdb2738d0d6185ff8fe748e89ddcdAll 323 tests pass, including 52 new carrier cases. Lint, strict typing and corpus policy pass. CI36793706333 is qualifying this head. The next Worker change must consume claim and heartbeat observations, persist the replay delivery intent before throwing, then reload Server-issued canonical history with the same owner/attempt. Active local activity results must be fenced across delivery, death and reclaim. Default protocol/capability advertisement remains unchanged until that path, all three SDK implementations and the exact published tuple qualify. |
Client source qualification completeAt The new client carrier requires explicit compatible capability discovery for cooperative requests. A run-bound handle preserves its run fence. Worker delivery requires protocol 1.20, worker credentials, claim owner/attempt and the authored call range. Duplicate requests preserve Server's original identity and deadline. Lost acknowledgments retry the identical delivery, and malformed or mismatched acknowledgments are rejected. Earlier immediate cancellation and termination remain covered. The completed source worktree, dependencies, caches, tool images and build context have been removed. The active draft branch remains. Next is Worker integration for claim/heartbeat observations, canonical history refresh, delivery persistence and active local-result fencing, then the accepted connected failure cases and equivalent PHP/Rust behavior. Default protocol and published capability claims remain unchanged. |
Worker source gates completedExact head The local suite passed 1,607 tests with two existing skips and 31 integration cases deselected. Thirty Worker cases exercise claim/heartbeat observation, canonical paging and delivery, earlier commands, acknowledgment loss, local work and lease fencing, shielded cleanup, cold replay and incapable registrations. The draft remains protocol 1.19 by default. Connected candidate Server qualification, actual process death/reclaim, shutdown during shielded cleanup, synchronous and remote in-flight work, deadlines and termination remain required, along with PHP/Rust equivalents and coordinated publication. Existing Server integration covers the preserved current protocol surface. Cleanup is complete: the clean source worktree, virtual environment, test logs, build context and both disposable tool images are removed. The remote branch and this evidence retain the implementation and reproducible commands. |
Negotiated local cleanup shutdown and synchronous executionExact head Synchronous local handlers execute off the event loop in a lazy pool bounded by Local evidence: 1,611 tests passed, two existing skips, 31 integration cases deselected, 26.77seconds. All 34 focused Worker cases pass. Ruff, strict mypy for all 26 source modules and the revision-aware corpus guard pass. The synchronous observation case deliberately limits replay to one thread to expose a shared-pool deadlock. Replacement source cases preserve canonical request/history and use a different lease owner and attempt5 without redelivery. Execution uses Python3.12.14, UID/GID1000:1000, two CPUs, 1GiB memory with no additional swap allowance and pids256. Python base index is ruff check src/ tests/
mypy src/durable_workflow/
pytest tests/ -m "not integration" -q
python scripts/ci/validate-regression-corpus.py --base-ref f542486e125fdb2738d0d6185ff8fe748e89ddcdNormal CI for the exact head completed successfully at 01:25:59 UTC on October 1. All jobs pass, including Python 3.10/3.11/3.12, existing Server integration, lint, corpus, package and target-branch qualification. Docs and public boundary checks also pass at the same head. The draft remains pending connected candidate Server qualification, actual native process replacement, native shutdown/in-flight work, deadline/termination and acknowledgment-loss cases, PHP/Rust equivalents and coordinated publication. Default protocol1.19 and current registration advertisement remain intact. Completed local worktree, dependencies, build context, diagnostics and task images have been removed. No published support claim is added by these source checks. |
Connected Python/Server source qualificationAt October 1, 2026, 02:25 UTC, Python
The host used isolated containers at UID/GID 1000, 2 CPU and 1 GiB memory with no additional swap per tool/service. Runtime base is published Server 2.4.34 index Local checks:
Normal Python CI and the explicit Python/MySQL candidate run pass every job at the exact head. The candidate integration completed at 02:29:45 UTC, with 33 passed and one existing CLI skip in 80.19 seconds. All eleven cooperative cases are present and passed in the downloaded JUnit artifact, which expires October 8. The log verifies the exact Server SHA above, and stack teardown passed. Supported Python 3.10/3.11/3.12, lint, corpus, package, docs and public boundaries pass. Server source/corpus CI passes 2,279 tests and 47,800 assertions. MySQL replay/query topology passes. Polling bounded-growth smoke and its performance qualification also pass at this exact head. All normal Server gates are complete. PHP/Rust equivalents, coordinated specification/capability activation and exact published tuple conformance remain required. Both PRs remain drafts. Local stack and disposable source/dependency/proof/tool resources are removed. Downloaded CI diagnostics and transport files are removed after updating this record. |
|
Next source phase: supervise actual cooperative remote activity callbacks through the qualified Server readonly observation route (Server073a516bbd4063f57d4ad65ad732ec423131c8ff). Keep worker registration and only authored activity progress, observe canonical cancellation/attempt/session/deadline fences, abandon on failed observation or shutdown expiry, and reject late heartbeat/result/failure publication. Qualify blocked async callbacks and synchronous handlers while preserving event-loop responsiveness and the existing bounded thread-pool model. Python threads cannot be forcibly stopped, so prove their late publication is fenced and document the remaining external-effect/process-supervisor responsibility. Extend the connected actual-worker cases and retain exact gates before claiming parity. Ordinary protocol1.19 registration and published capabilities stay unchanged. |
|
Remote worker qualification is running at Python The exact-head ordinary CI and connected integration pass. The opt-in candidate run 36825588696 passes 39 connected cases, fails the new killed-remote-owner recovery case, and retains the existing CLI skip. All six new async/sync blocked-callback and shutdown cases pass. The replacement process in the kill case times out before receiving its workflow claim. Its result is not a qualified recovery claim. Next action: reproduce that case in an isolated local stack using the same Server commit and inspect task leases, registration state and durable history. Determine whether the failure is a fixture bound or a recovery defect before changing it, then rerun the exact-head candidate gate. The failed runner completed teardown successfully and retained JUnit in artifact |
|
The isolated reproduction identifies the failure as Workflow #599. A still-issued workflow poll claims the new task for the killed process. Native repair then hides that expired workflow lease behind the older activity lease and repeatedly returns A native regression using the actual workflow and activity bridges fails on the published baseline, while its fresh-lease case passes. Prioritizing expired leases in the native run summary makes both cases pass, with 33 assertions checking that only the workflow claim changes and the activity task, execution, attempt and history stay unchanged. The unchanged Python SIGKILL case passes in 18.28 seconds when the isolated Server loads that corrected source. Its 30-second claim bound is unchanged. The replacement workflow task has attempt 2 and repair count 1, commits canonical delivery/cleanup, and the dead activity owner's late completion and failure are rejected. This local source result is the counterfactual for the defect. The full cooperative source suite, Workflow quality cycle, patch publication and exact dependent candidate gate are still running or pending. Protocol 1.20 remains opt-in. Next action: qualify and publish the Workflow repair patch, update the Server candidate to that exact package, then rerun Python's entire connected candidate suite and retire the local qualification resources. |
|
The cooperative Server candidate now consumes published Workflow 2.3.1 at Workflow's complete source matrix and all 16 published Laravel/PHP upgrade combinations pass. Server #292 is separately qualifying stable image 2.4.35. A focused ordinary-protocol signal drill reproduces the expired-workflow/older-active-activity defect on published Server 2.4.34 and PHP SDK 2.1.6, so this repair also affects existing service callers. The entire Python candidate CI is dispatched at unchanged Python |
Exact native correction requalification completePython head Server's current exact head passes feature/corpus with 2,300 tests and 47,995 assertions, MySQL HTTP topology, MySQL/Postgres rolling, bounded polling, chart validation/install and public boundaries. The correction is also published independently in stable Server 2.4.35 with its default protocol 1.19. Its focused published recovery test and all 12 published portable lifecycle cells pass. These candidate source results do not activate cooperative protocol 1.20. Next action is finish Rust's equivalent actual remote-worker path and active activity-attempt reclaim qualification, then coordinate publication and exact published tuple gates. PHP/Python/Server PRs remain drafts through that work. |
Requalified against the current Server and published Native packagePython The connected suite reports 40 passed, 1 skipped in 128.61 seconds, including all 18 cooperative cases. These include actual async/synchronous remote callbacks with and without authored heartbeats, accepted owner registration heartbeats, shutdown fencing, canonical waiting/delivery, lost replies, local callback result suppression, shielded cleanup replacement, real remote-owner SIGKILL, cleanup reclamation in a new process, and cleanup deadline/termination fencing. Ordinary smoke, payload, session and memo integration cases also pass. The supported Python matrix, package, corpus and Avro checks pass in the same run. Raw connected JUnit is retained for seven days. CI removed its isolated stack, network, payload volume and task images. The Server prefix successor fix is included in this candidate. Next: complete active remote-attempt replacement qualification and the remaining shared per-language scenarios, then qualify the exact published tuple. This is source qualification, and this PR remains a draft. Published protocol/capability defaults are unchanged. |
Child waits release the Python claimSource The worker returns to polling without publishing completion or failure and Focused local source checks passed: 151 tests, Ruff, and mypy over all 26 Connected child-policy qualification remains required. This is a source draft, |
Prepared sequential local consumer qualified against the exact Source tuple
Source CI 37001051027 passed every job. Connected integration passed 43 cases with one existing CLI-binary skip, zero failures or errors, in 480.41 seconds. Both new prepared-local cases passed with no skip. Durable sequential executionThe 2.775-second case checkpoints memo metadata before admission, executes two distinct backend attempts in supervised processes, records exactly two real application heartbeats, completes both activities and the workflow, then cold-replays the results without callbacks. Canonical history contains one memo event, two Scheduled/Started/Completed activity sequences and one workflow completion. Original 30-second cancellation and cleanup recoveryThe case stops the original local callback without application heartbeats and verifies physical exit before cancellation acknowledgment. It delivers cancellation once, starts shielded cleanup, SIGKILLs the workflow owner, verifies the surviving supervisor stopped the cleanup callback, and runs a replacement owner. Native records unknown stop for the old cleanup attempt, releases the claim for a durable retry, and admits one new cleanup attempt. Both admissions retain the original root/local request IDs, delivery history ID and deadline. Duplicate cancellation preserves request identity, request time and deadline.
Completion was 26.031501 seconds after the request, leaving 3.968499 seconds. The whole test took 28.242 seconds including setup. The qualification stack uses a 10-second workflow-task timeout and a 10-second repair cadence. Independent callback control polls at most once per second and bounds transport by five seconds and original authority. This is one measured Source scenario, with no claim about arbitrary workloads or a published capacity/SLA change. The original and replacement cleanup admissions share delivery ID Retained evidence and additional checks
Reproduce with The image retains published Composer Native authority PR stays draft. Python atomic local group consumption, operation policies, scopes, the exact published PHP parent → Python child → Rust remote activity / PHP local activity cascade, one inspection view and fair competitive proof remain outstanding. Shared issue 136 stays open. Published artifacts, default protocol 1.19 and Cloud adoption are unchanged. |
Atomic prepared local group consumer implemented, connected qualification runningCandidate Group interruption joins all callbacks before workflow replay proceeds. Unknown stop retains capacity and worker registration. The tests exposed cancellation interrupting a supervisor join. Confirmed joins and prepared-finalization now finish before cancellation propagates, with a dedicated process regression test. Result receipts remain required, and Native owns retries and deadlines. Selection and turn-closing waits remain explicitly refused by this admission path. Local Python 3.12.15 verification passed:
Exact Source qualification 37005040454 is running against Server PR stays draft and shared issue 136 stays open. The earlier sequential report qualifies its own earlier head. This candidate is not published. Operation policies, scopes, the exact published PHP → Python → Rust cascade, one inspection view and fair competitive proof remain required. |
Source group qualification failed, nested admission diagnosis in progressRun 37005040454 completed with 44 passing cases, one failure and one existing CLI-binary skip. Exact tuple:
The nested mixed local/timer case failed after a refused prepared operation and a local heartbeat deadline. The original warning did not retain the refusal reason. This run does not qualify atomic groups. The next candidate retains the exact refusal and final canonical history rather than weakening or skipping the scenario. The two-member cancellation case passed on this tuple. Two active callback processes stopped without application heartbeats. Two cleanup processes exited with their SIGKILLed owner. Two replacement cleanup processes exited after completion. All six physical exit assertions passed. Both unknown-stop recoveries preserved the original root request, local request, delivery event and cleanup deadline. Duplicate requests returned the original identity and deadline. Canonical terminal time was Raw connected artifact, retained until December 31, 2026. Artifact SHA256 Diagnostic head |
Diagnostic result narrows the group failure to application heartbeatDiagnostic Source run 37007105955 at Python Raw canonical histories, receipts and source provenance, retained until December 31, 2026. Artifact SHA256 Inspection also found a separate concrete progress-loss defect. Python sent authored heartbeat data under Local Python 3.12.15 checks pass 104 affected cases, zero skips, 20.64 seconds, plus Ruff and mypy. JUnit SHA256 Exact Source run 37008870970 is running with this head, Server |
Repairing prepared group heartbeat persistence and SDK progressTwo concrete defects are corrected in the Source candidates:
Intermediate Python run reported 43 passed, two failed, one existing CLI-binary skip, zero errors, 494.250 seconds. Raw results and provenance, retained until December 31, 2026. Artifact SHA256 Corrected Python passes 104 affected tests, zero skips, 20.64 seconds, Ruff and mypy locally. JUnit SHA256 Native full Source qualification and Python connected Source qualification are running. Python binds SDK |
Prepared groups and heartbeat persistence pass connected Source qualificationRun 37010610371 passes all jobs at Python Both sequential and nested mixed local/timer cases persist the authored Cancellation cases independently verify physical process exit without application heartbeats, owner SIGKILL during shielded cleanup, replacement-worker recovery, one canonical delivery, immutable duplicate identity/time/deadline and timely Cancelled closure.
The group has one request, one delivery, two activity cancellations, two stop acknowledgments, two unknown-stop recoveries, two cleanup completions and one WorkflowCancelled event. Four cleanup admissions use distinct attempts but one unchanged request/root/delivery/deadline tuple. Unknown stop state remains explicit after owner loss. No application heartbeat or renewed cancellation budget appears in either cancellation history. Raw histories, receipts, results, source provenance and image digests are retained until December 31, 2026. Artifact SHA256 Current Native Next action is portable activity cancellation policies and deterministic scopes, followed by the exact published PHP parent → Python child → Rust remote activity plus PHP local activity cascade and one coherent API/CLI/UI inspection view. This PR remains draft and shared issue 136 remains open. Published protocol 1.19 and packages are unchanged. Protocol 1.20 remains an explicit, unfrozen Source opt-in. |
Pending Activity cancellation response qualifiedExact Python SDK source The client validates pending Activity cancellation replies for Activity, LocalActivity, Parallel and SelectionHandle boundaries. It retains child pending validation and requires explicit claim release, matching task identity and null delivery fields. Malformed fields, unknown or non-string reasons, timers and unrelated child/activity kinds are refused before the worker defers delivery. Exact Source CI passes every job, including Python 3.10–3.12, lint/type checks, package, Avro, corpus and target-branch qualification. The unit matrix covers seven valid reason/kind pairs, malformed fields for both reasons and unrelated-kind refusal. Ordinary exact-head CI also passes. The preceding runtime commit's Source run stopped at two Ruff line-length findings in tests, which this final head corrects. Its skipped integration job is not used as qualification evidence. Connected qualification uses Raw histories, process observations, JUnit, image identities and source provenance are retained until 2026-12-31. Artifact SHA256 This qualifies the reply validator and rebinds existing connected component cases. Explicit portable Activity policy authoring and the required published mixed-language cascade remain separate gates. Protocol 1.20 remains an unfrozen Source opt-in, the published package is unchanged, this PR remains draft and shared issue 136 stays open. Next: author and admit explicit Activity policies before running their actual worker scenarios. |
Remote Activity policies qualified in Python SourceExact Python
The replayer previously accepted a change from recorded Wait to authored Try. A focused reproduction fails before repair and passes afterward. Replay now keeps the original canonical Activity policy through later events that omit it, checks ordinary/group/selection matching and cancellation delivery, and rejects malformed or conflicting history. The minimal Complete exact Source CI passes every required job, including Python 3.10–3.12, full lint/type analysis, package and corpus. Connected qualification passes 50 cases, zero errors or failures, one existing unavailable-CLI skip, 562.214 seconds. JUnit contains 51 cases including that skip. Hosted stack teardown passes. All five new connected policy cases pass without skips. Explicit Try and Wait physically stop both async and sync callbacks without application heartbeats, preserve original stop receipts and refuse stale completion/failure. Wait checks that the receipt precedes canonical workflow delivery. Bounded Abandon proves the callback process remains live after parent Cancelled closure, then commits independent completion under the original total deadline, retains parent cancellation and refuses a second outcome from the completed attempt. The four Try/Wait times are 11.225, 11.180, 11.656 and 11.652 seconds. Abandon takes 27.052 seconds. These are Source policy cases with distinct cleanup and total Activity budgets. Local Python 3.12 focused replay, child-policy, cancellation and corpus qualification passes 181 cases, zero errors, failures or skips. Full Ruff and mypy pass. Commands: Raw scenarios, JUnit, source provenance and image authority are retained until 2026-12-31. Artifact SHA256 PHP's matching Source policy cases are qualified. Rust is qualifying its matching consumer. Explicit local policies, independent local Abandon lifetime, scopes, coherent inspection and the published mixed-language cascade remain required. This PR remains draft, shared issue 136 stays open, protocol 1.20 remains explicit/unfrozen and published artifacts are unchanged. |
Python deterministic remaining-time Source candidateHead The helper initializes at committed delivery, advances through consumed blocking cleanup outcomes, and preserves synchronous side-effect and inline-local decisions between first execution and cold replay. Selection follows its committed winner, awaited handles use their own durable result or first cancellation receipt, and failed groups exclude later sibling outcomes. Recorded clock skew cannot increase the budget. Fractional seconds are retained and expiry clamps to zero. A detached snapshot, ended replay, or missing/invalid boundary timestamp fails without using host time. Local affected checks passed 206 cases, including 12 helper cases and the two Git-backed public-boundary scanner cases, zero errors, failures or skips. Full Ruff and mypy across 29 source files passed. Affected JUnit SHA-256: The actual Python SIGKILL scenario now records the delivery budget in the original worker, requires an identical value and metadata in the replacement, and checks the post-cleanup value against committed delivery/completion timestamps and the original deadline. Source run 37065839981 is pending against Server The qualified PHP helper and mixed cascade remains bound to its exact tuple, including preceding Python |
Python remaining-time qualification now covers both cleanup pathsCurrent head Preceding Source run 37065839981 passed all ordinary jobs, including Python 3.10–3.12, lint/types, package and regression corpus. Connected qualification had 49 passes / 1 failure / 1 existing unavailable-CLI skip. The failing assertion expected legacy inline cleanup to consume its later persistence timestamp. Its delivery and post-inline values were correctly equal at 119.462336 seconds, matching the documented first-execution/cold-replay contract. That assertion now requires equality and verifies the original delivery timestamp. The existing sequential and atomic prepared-cleanup tests now capture the actual original and replacement worker's delivery values and metadata, require equality after SIGKILL, and verify the final value against committed cleanup completion and original deadline. Both already require stopped callbacks without application heartbeats, unknown-stop recovery, duplicate original identity/deadline, and Cancelled convergence before the original 30-second deadline. The new observations add no workflow commands. Current local Ruff, mypy across 29 source files, all 12 helper cases, collection of the 28 affected connected cases and whitespace checks passed. Helper JUnit SHA-256: Current Source run 37067939883 is pending against Server Local venv, generated caches and the temporary Python image are removed after hosted handoff. Next: inspect actual current prepared/inline observations and Native qualification, then port Rust and finish explicit local policies/scopes/competitive and final published closure proof. All candidates remain drafts, shared #136 stays open, protocol 1.20 remains unfrozen and published/default 1.19 is unchanged. |
Python consumed cleanup budget qualifiedExact Python Connected JUnit records 50 passes, zero errors/failures, one existing unavailable-CLI skip, 561.247 seconds. Both prepared-cleanup SIGKILL cases pass without skips. The actual original and replacement worker observations are byte-equivalent metadata and equal remaining time:
Each uses the original 30-second deadline, physically stopped callbacks without application heartbeats, one canonical delivery, actual owner-process SIGKILL during cleanup, fresh replacement recovery, unknown stop state preserved, and duplicate requests retaining original identity/deadline. The final helper value matches original deadline minus the latest consumed committed cleanup completion within one microsecond. Sequential/group histories contain zero application heartbeat records and respectively one/two callback stop acknowledgments. Both contain one Cancelled terminal before the original deadline. The legacy inline recovery case correctly retains 119.502138 seconds at original delivery, replacement delivery and post-inline callback. Inline persistence is synchronous, so it does not change first-execution/cold-replay cleanup decisions. The earlier incorrectly written assertion remains recorded in its preceding failed run. The current core helper is unchanged by the qualification correction. Raw artifact 11253209659 retains JUnit, actual observations, histories, callback process IDs, recovery receipts, exact source provenance, images and package provenance until December 31. SHA-256: Native's exact-head full qualification is retained separately. Rust's consumed-budget helper is now under local qualification. Explicit local policies, nested scopes, fair competitive qualification and the complete exact published mixed-language cascade remain required. All cancellation candidates remain drafts, shared #136 remains open, protocol 1.20 is unfrozen and published/default 1.19 is unchanged. |
Next: explicit prepared local Activity cancellation policies in PythonPHP's current source qualification now exercises the Native and Server prepared Add optional TryCancel and WaitCancellationCompleted policies to local Activity Test fresh admission, completed and unresolved cold replay, capability refusal, This remains part of draft #90 and unfrozen protocol 1.20. Published/default |
Python prepared local policies implemented, qualification runningCandidate Local Python 3.12.15, Git 2.47.3, Ruff and mypy pass. The full non-integration Full JUnit SHA-256 Exact source qualification Protocol 1.20 remains opt-in and unfrozen, published/default 1.19 unchanged. |
Historical-omission assertion corrected, full Source retry runningSource run 37084482121 Both historical-omission cleanup/recovery variants reach an assertion that Current head Full exact-head Source retry 37085616916 Failed-run artifact 11259778858 |
Current Python Source tuple qualifiedSource run 37085616916 Connected integration finishes with 54 passed, zero errors/failures and one All six prepared-local cancellation cases pass: historical omission, explicit
These values are the workflow's deterministic remaining-time observations. Raw artifact 11260048832
The preceding failed Source run remains classified as two historical-omission Current PHP mixed Source run 37086658222 Shared #136 stays open, the PR stays draft and protocol 1.20 stays unfrozen. |
This branch has not been deployed
2 participants
Cooperative cancellation source candidate
Implements shared cancellation issue 136
in the Python SDK. Default and published worker protocol remains 1.19.
Cooperation requires explicit source protocol 1.20, installed Server/Native
discovery and matching worker capabilities. This PR remains draft.
The candidate includes immutable cancellation context and lineage, deterministic
remaining-time helpers, operation policies for children and remote activities,
physical supervised callback stop, prepared sequential and atomic local
admission, stale-attempt fences and durable cleanup recovery after owner loss.
Current change
Current head
d41e76deb76d3a04c25c5879984b85bb9c23cda3retains the runtimeimplementation from
afa7cfaabd0d7fad8049f7b6e3b4c19ce15d0aa2and correctsonly the connected assertion for valid historical policy omission. It adds explicit prepared local
Activity TryCancel and WaitCancellationCompleted. It preserves historical
omission, refuses local Abandon and unsupported/legacy policies before callbacks
or checkpoint submission, registers only discovered policy support, and checks
original canonical policy on cold replay. Queries, updates and validators use
the same negotiated replay consumer.
Local implementation qualification passes 2,040 non-integration cases, two existing skips,
zero failures/errors, plus Ruff and mypy. Dedicated policy coverage passes
38 cases with zero skips. Actual supervised callback tests cover omission
and both explicit policies with no application heartbeats.
Exact source qualification
passes all required jobs against Server
dd8996fdd6d488b48d575b1b934821bd8bedc8edand Nativeba1aa4770c4b94533548bd45bd3ba028229c54e8. Connected scenarios now coversequential and atomic cleanup SIGKILL recovery for omission, Try and Wait,
preserving the original request, delivery and 30-second budget. All six cases
pass. Connected integration finishes with 54 passed, one existing unavailable-CLI
skip and zero failures/errors. Ordinary exact-head CI also passes. Current
results and raw artifact 11260048832 are retained in the PR comments and Actions.
The preceding Source attempt finished with 52 passed, one existing unavailable
CLI skip and two historical-omission assertion failures. Both explicit policies
passed sequential and atomic SIGKILL recovery. The assertion mistakenly required
an explicit canonical field where omission means historical Try. The full suite
passes after this runner correction. Raw failed-run evidence
is retained through January 1, 2027. This is not claimed as a completed Source pass.
The preceding exact implementation head
0e1c427eae2f6120155a5cf3c9c1ae79ba7a5756passed its source qualification.
Its evidence remains attached to its tested tuple and does not qualify new code.
Remaining gates
Complete the remaining model decisions and current mixed source qualification,
then qualify exact published Server/PHP/Python/Rust artifacts in the required
mixed-language cascade with one API/CLI/UI view and fair competitive evidence.
Shared #136 stays open. This candidate is not published or adopted by Cloud.