Skip to content

fix(durable): don't journal a step whose context ended partway - #234

Merged
reka18 merged 38 commits into
mainfrom
fix/durable-canceled-service
Nov 16, 2026
Merged

reka18 merged 38 commits into
mainfrom
fix/durable-canceled-service

Conversation

@reka18

@reka18 reka18 commented Nov 5, 2026 •

Copy link
Copy Markdown
Contributor

What this change does

A step whose context ends partway no longer journals what the kernel may have refused, and recovery now replays actors, services and timers the way the live run ran them.

One rule for an ended context. Tick, RunService, DeliverToActor and Fire record nothing and fail the Handle with ErrHandleFailed once the step's context ended by the end of the step, or once a Fire the step drove was refused with a context's error. The second case catches a context middleware derived from the caller's. Fire, Start and Recover check only for the refusal, through refusedByContext, since a context that ends after their Fire applied cost them nothing. Tick, RunService and DeliverToActor check the context too, through stepCanceled; Tick only when it fired a timer.

  • Tick: records nothing once its context ended, even for timers that applied. Recover re-arms the timers, and they fire again.
  • RunService: records nothing once its context ended during the service or while the settle's effects were absorbed. After Recover the service is in flight again and runs a second time.
  • DeliverToActor: records nothing once its context ended by the end of the delivery, since the ending may have made the kernel refuse the actor's own Fire and lose the event. An InvokeActor actor restarts from its initial state after Recover.
  • Fire: records nothing when an actor its state spawned failed to start and a context's ending refused that spawn's onError. The event applied, so fire it again on the recovered Handle.
  • Start and Recover: fail when a context's ending refused a parent Fire one of their actors drove, such as a failed spawn's onError. A context that ends with no Fire refused doesn't fail Start, or Recover once it has spawned its actors, since their behaviors already ran. The baseline is recorded, so Recover the instance.
  • Deterministic refusals still journal. A Fire refused for another reason, such as a failing guard or middleware that denied it, is recorded as refused, and replay accepts the same refusal. Before, a refused parent Fire made every later Recover fail.

Actors replay as they ran.

  • A failed spawn is retried only when nothing caught it. Recover retries a spawn that failed to start when it declared no onError, or a context ending refused its onError. One whose declared onError applied, or was refused for any other reason, such as a guard returning false, is done: the journal holds the refusal, and a retry would run the behavior again. An invoked actor with no onError fires the zero event at the parent, as v1 does, so durable reads a "no transition" refusal as none declared. That's a stopgap with known gaps, tracked in state: an InvokeActor with no onError fires the zero event at the parent instead of escalating #250.
  • Ended actors aren't spawned again. Each step records the declared actors that ran and ended in Record.EndedActors, and those that never started in Record.UnstartedActors; checkpoints keep both. Recover spawns only the declared actors that aren't ended.
  • Every parent Fire an actor drove is journaled with its step: a spawn-time message, a failed spawn's onError, and a settle. For Start's and Recover's spawns, they're journaled with the step after. Replay re-fires each where it ran.
  • A running actor respawns quietly. Recover spawns the actors that were running with state's new ActorSystem.AbsorbRespawn, before the actors whose spawn it retries. Nothing their start drives reaches the parent again: not their messages, not a nested actor's onDone or onError, and not an escalation the live run already reported. A respawned actor that fails or settles now, which didn't happen live, still reaches the parent.
  • An actor's output replays with the Fire that carried it, not the last Fire of the delivery.

Services and timers follow actors.

  • A state an actor's Fire enters arms its timers and services, live, at Start and Recover, and on replay, as a host Fire does.
  • A checkpoint records the services that settled, and Recover doesn't start them again. Re-entering or leaving the state forgets the settle.
  • Tick drops each timer it fired, by id, live and on replay, so a fired timer can't stay in a checkpoint and fire again after Recover.
  • DeliverToActor and RunService journal their step's clock reads, so a checkpoint on that step can't leave a read for the next step to replay.
  • A chained timer's deadline is the scheduler's. Tick and its replay take it from state's new Scheduler.Due, so a later checkpoint persists the deadline the scheduler armed, whatever clock reads the tick's transitions took.

Also:

  • A panic during a step fails the Handle before it goes on to the caller, so the Handle can't run ahead of its journal.
  • One replay walk. Recover and StateAt share replayRecord. Both fail on a context that ends during the walk, checked before each replayed Record.
  • A step that touches no actor doesn't recompute the actor sets. They're reused while the configuration, the running actors and the step's spawns are unchanged.
  • CI runs nothing on a draft. Every job in ci.yml, the required gate included, skips on a draft. The cost is stated in ci.yml's header: a skipped required check counts as passing, so a PR merged in the seconds between marking it ready and its new run starting would merge without CI. That window is accepted to keep drafts free of runs.

state additions (additive, v1.1.0):

  • ActorSystem.WithParentFireObserver reports each parent Fire the system drives as a ParentFire: its result, the actor, whether it settled that actor with its output or error, and whether it routed a failed spawn's onError.
  • ActorSystem.AbsorbRespawn spawns actors that were running without letting their start reach the parent again. Its quiet rides the call chain that spawns each actor, so a delivery another goroutine makes meanwhile is heard.
  • Scheduler.Due reports a pending timer's deadline.

Journal compatibility. Each Record, the Start baseline and each checkpoint now carry Format, 1 from this version. Replay arms an actor-driven Fire's timers and services only for a Record of format 1 or later, and fails on a Record whose format is lower than its checkpoint's, which means the Store lost the field. A journal this version writes isn't for an older durable, so don't downgrade a Store it has written to.

A journal an older version wrote replays as it did for its actor-driven Fires, which arm nothing. A few replay changes apply to it with no version check, each closer to what the older live run did: a replayed settle arms its state's timers, a replayed Tick drops each timer it fired, and settles count toward the next checkpoint's settled services.

For Store authors: a Store must keep Record.Format, EndedActors and UnstartedActors, and keep an empty actor set distinct from nil. MemStore and FileStore do. A Store that drops Format now fails Recover instead of recovering wrong.

Why

The kernel refused a step live, but the result was journaled, so recovery committed something the live instance never applied. For an actor, it left a journal Recover couldn't replay. The seams guarded this inconsistently, and none saw a refusal from a derived context. Fixing that exposed how recovery treated actors: it spawned actors the live run had ended, lost or doubled the parent Fires their start drove, and gave outputs to the wrong transition. Journaling those Fires in turn exposed that a state an actor entered never armed its timers or services.

Relates to: #214, #243, #245

Left for a follow-up:

Evidence

On GOTOOLCHAIN=go1.27.4, at the PR head:

Check Result
go test -race -count=1 ./... in every workspace module Pass
go vet on durable and state Clean
Pinned golangci-lint on durable and state 0 issues

New tests cover:

  • each seam whose context ends, including through a derived middleware context, and Start with and without a refusal;
  • a deterministic actor refusal that recovers;
  • ended and unstarted actors across Recover and checkpoints;
  • a spawn-time message, a failed spawn's onError and a settle from Fire, RunService, Start and Recover, each applied once;
  • a running actor respawned before a retried one, and a nested start Fire or escalation that stays quiet;
  • an output carried by the settling Fire;
  • the timers and services an actor-driven Fire enters, live and after Recover;
  • settled services across checkpoints, and services a timer's state entered;
  • timers Tick fired between its clock reads, and a chained zero-delay timer;
  • an older journal's actor Fire, with no Format, replayed without arming, and a Store that drops Format failing Recover;
  • a failed spawn with no onError retried; one whose onError a guard refused left alone; and a re-entry retry that doesn't repeat the first start's message;
  • ResumeEffects after a Restore not restarting a compound state's settled service;
  • a delivery whose context ends before the actor handles it failing; Recover failing when its context ends during the last replayed Record, and returning its Handle when it ends once its actors are spawned;
  • a panic out of a delivery's host code leaving no step context behind;
  • AbsorbRespawn hearing another actor's delivery, and a lifted Fire that starts a re-entered actor once;
  • chained timer deadlines, one or two per Tick, and when a transition reads the clock, live and after Recover;
  • a step that touches no actor allocating about as much with actors as without;
  • a panic under the step lock.

Each fix fails its test with the fix removed.

Checklist

  • Commits are signed off (git commit -s) per the DCO
  • Conventional commit messages (type: subject)
  • mage check passes locally (lint + race tests + govulncheck): not run as a whole; the parts above were run individually
  • Tests added/updated for the change
  • Public API changes documented (godoc) and noted for the changelog

@reka18 reka18 added not-ready On every new PR until all review dimensions are confirmed wait:correctness ACR pending: correctness wait:regression-safety ACR pending: regression-safety wait:concurrency-discipline ACR pending: concurrency-discipline wait:replay-determinism ACR pending: replay-determinism wait:api-compatibility ACR pending: api-compatibility wait:missed-context ACR pending: missed-context wait:human-readability ACR pending: human-readability labels Nov 5, 2026
@reka18
reka18 force-pushed the fix/durable-canceled-service branch from 15ab425 to 41bfbb4 Compare November 5, 2026 16:38
@reka18
reka18 force-pushed the fix/durable-canceled-service branch from 41bfbb4 to f87bc98 Compare November 5, 2026 16:40
@reka18
reka18 force-pushed the fix/durable-canceled-service branch from f87bc98 to 8c4ce15 Compare November 5, 2026 16:53
@reka18
reka18 force-pushed the fix/durable-canceled-service branch from 8c4ce15 to 83c5655 Compare November 5, 2026 17:09
@reka18
reka18 force-pushed the fix/durable-canceled-service branch from 83c5655 to 1023215 Compare November 5, 2026 17:14
@reka18
reka18 force-pushed the fix/durable-canceled-service branch from 1023215 to 1890a2c Compare November 5, 2026 17:22
@reka18
reka18 force-pushed the fix/durable-canceled-service branch from 1890a2c to 2e345fa Compare November 5, 2026 17:33
@reka18
reka18 added this pull request to stack #238 November 5, 2026 17:34
@reka18
reka18 force-pushed the fix/durable-canceled-service branch from 2e345fa to 96cceff Compare November 5, 2026 17:42
@reka18
reka18 force-pushed the fix/durable-canceled-service branch from 96cceff to 0d6f9ce Compare November 5, 2026 18:04
@reka18
reka18 force-pushed the fix/durable-canceled-service branch from 0d6f9ce to f6c246d Compare November 5, 2026 18:20
…s only on a refusal

A respawned actor's start stays quiet, but the parent Fires its failure or
settle drives (onError, onDone) and the effects they absorb now run as under
Absorb. Before, an actor such a Fire spawned couldn't reach the parent, and
its messages were dropped without being journaled.

Start fails only when a context's ending refused a held actor Fire. A context
that ends with no Fire refused no longer fails a consistent Start, which a
retry couldn't recover from (ErrInstanceExists).

Also: Recover absorbs the running and retried spawns in one call each, the
service and actor start filters share one helper, and heldFires is inlined.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
…the system

AbsorbRespawn kept a respawned actor's messages from the parent, but let
through the onDone or onError of a nested actor its start spawned. The
journal holds that Fire too, so Recover applied it twice. Now only the
actors AbsorbRespawn names can drive a new parent Fire: a spawn that fails
now, or one that settles while the others start. While such a Fire and its
effects run, the parent hears them.

The quiet mark is a field on the ActorSystem, not a context value, so a
dispatch to the parent no longer walks the context chain, and the mark
can't leak into a context a behavior captures.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
A parent Fire an actor drove (its onDone, onError or a message) reached only
the actor system, so the state it entered had no service in flight and no
timer armed, live or after Recover; a checkpoint then recorded the service
as settled. Such a Fire now arms them, live, at Start and Recover, and on
replay, as a host Fire does.

Fixing it exposed clock-read gaps, now closed: DeliverToActor and RunService
journal their step's clock reads; a replayed service settle re-arms its
timers; Recover keeps its spawns' reads and re-arms a checkpoint's timers
before it spawns; Tick drops the timers it fired at its own read.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
During AbsorbRespawn, a nested actor whose spawn failed, or that crashed,
with no onError escalated again on every Recover, though the live run had
already reported it. Escalation now follows the quiet rule: a failure the
journal's run already saw stays quiet, and a respawned actor's own new
failure still escalates.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
… old journals as before

- A checkpoint records the services that settled, not every declared
  service that isn't pending. A service a timer's state invoked never
  started, and Recover used to skip it for good. Re-entering or leaving a
  state forgets its settle.
- Tick drops each timer the scheduler fired, by id, live and on replay. A
  timer that came due between a tick's clock reads, or a chained zero-delay
  timer, no longer stays in the table to fire again after Recover.
- A journal written before actor-driven Fires armed timers and services
  replays without arming them, so its clock reads line up as they did.
- An actor-driven Fire's arming gets the step's context; actor sets are
  computed each step; Recover builds one replay mirror.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
…urnal format

Recover re-armed a timer the checkpoint recorded even when a later step had
canceled it, since the cancel replays before the re-arm. The replay mirror now
notes the timers the tail cancels, and the re-arm skips them.

Each Record now carries Format, and replay arms an actor-driven Fire's timers and
services from it, instead of inferring the format from whether UnstartedActors is
nil. The CHANGELOG tells Store authors which fields to keep.

Also narrow the CHANGELOG's context-error sentence to Fire callbacks, correct the
DeliverToActor godoc for a delivery that drove no parent Fire, and drop dead code:
replayed.tick, the unused receivers on stepCanceled and consumedCanceled, and
actorEntry's parameters that repeat the ParentFire.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
…y a refused onError

Recover restored a checkpoint's pending timers only after the tail walk, so a
tail Tick that fired one live fired nothing on replay, and the timer was re-armed
and fired again. Recover now arms them into the replay scheduler at their
persisted deadlines before the walk, through state's new Scheduler.ArmAt, which
takes no clock reading. Tail cancels and Ticks then act on them as they did live,
which replaces the canceled-timer filter.

A spawn whose onError a guard or middleware refused counted as unstarted, so
every Recover ran its behavior again. It now counts as handled. A spawn with no
onError to route to, or whose onError a context's ending refused, is still
retried.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
… checkpoint timers to #236

An invoked actor with no onError fires the zero event at the parent when it can't
start, so durable could tell "none declared" from "a declared onError was refused"
only by matching the refusal's text. That retried a declared onError the parent had
no transition for, and a denial worded the same way. state now reports it:
SpawnActor.NoOnError and ParentFire.NoOnError, additive. The builder records the
declaration, so an onError that is the zero event, such as an iota enum's first
constant, still counts as declared. The zero event still fires, as v1 documents.
Recover retries a failed spawn only when it declared no onError or a context ending
refused its onError.

Restoring a checkpoint's timers before the replay walk is #236's, so this takes
that change and its tests back out, along with state's Scheduler.ArmAt, and
Recover re-arms them after the walk as before.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
…in review questions with tests

A spawn that failed with no onError declared counted as uncaught even when the parent
handled the zero event it routes, so Recover retried it, running the behavior again.
An onError Fire that applied now always counts as caught; NoOnError only decides what
a refused zero event means.

Tests that settle questions from the review:
- a re-entry spawn retried at Recover doesn't repeat the first start's message;
- a lifted Fire that re-enters a state during AbsorbRespawn starts its actor once;
- a timer leaving a service state, and a timer entering an actor state, leave the
  drivers as live does. Skipped: Tick hands a timer transition's effects only to the
  scheduler, which #236 fixes.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
…eduler armed it at

Tick recorded a chained timer's deadline from the tick's last clock read, later than
the absorb read the scheduler armed it at, so a checkpoint persisted a later deadline
and the timer fired late after Recover. Scheduler.Tick reads the clock once to find
each due timer and once to absorb its effects; Tick and its replay now take the i-th
fire's absorb read. A state test pins that order of reads, so a change to it fails
there rather than drifting deadlines silently.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
…nError

An InvokeActor actor with no WithInvokeOnError fired the zero event at the parent when
it couldn't start or failed after running, and a wildcard, a forbid or a transition on
that event could take it as a declared onError. Durable then counted the spawn as
caught and never retried it. The actor system now reads SpawnActor.NoOnError and
escalates, as it does for a Spawn with no onError, firing nothing; durable retries
such a spawn at Recover. ParentFire.NoOnError, which no Fire could set any more, is
removed.

Tick and its replay now fail when a fired timer's arming read is missing, instead of
falling back to another read, so a change to the scheduler's order of reads surfaces.
Two comments describing the old deadline rule are corrected.

A parent Fire an actor drove doesn't have its domain effects dispatched; its test is
skipped for #235.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
Working the deadline out from the order of the Tick's clock reads breaks when a fired
transition reads the instance's clock itself: the extra read moves the index, and the
recorded deadline silently differs from the scheduler's. state's Scheduler now reports
a pending timer's deadline (Scheduler.Due, additive), and Tick and its replay take
each chained timer's deadline from it. The read-order helpers go.

Tests: Scheduler.Due; a chained deadline when the fired transition reads the clock;
an uncomparable event in a JSON-loaded onError doesn't panic declaresOnError.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
…fail on a lost Format

- state: AbsorbRespawn's quiet rides the call chain that spawns each actor, rather
  than one flag for the whole system, so a delivery another goroutine makes while it
  runs is heard. It ends when AbsorbRespawn returns.
- state: an Invocation writes the onError key only when one was declared and reads a
  present key as declared, so a zero-valued onError survives the JSON IR. IR written
  before this always has the key and keeps routing as it did.
- durable: the Start baseline and checkpoints record the journal format, and replay
  fails on a Record whose format is lower, instead of silently replaying a Store that
  lost Record.Format as an older journal.
- durable: the actor sets are reused while the configuration, the running actors and
  the step's spawns are unchanged.
- durable: actor entries are decoded once on replay; actorBuf, the dropFiredTimers
  wrapper, the replayed struct and a redundant nil check are gone.

Tests confirm each: a delivery during AbsorbRespawn is heard; a zero-valued onError
survives JSON; Recover fails on a Store that drops Format; a step that touches no
actor allocates about as much with actors as without. A host read of the instance
clock mid-step is journaled but can't be replayed; its test is skipped pending an
issue, as it isn't this PR's.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
…over from an older checkpoint

An older version started only the active leaves' services and actors at Start and
Recover, so its checkpoints record no compound state's as settled or ended. Now that
StartEffects includes a compound state's, Recover from such a checkpoint put a service
that had settled into a child back in flight, and spawned an actor that had finished.
For a checkpoint without a journal format, Recover counts a compound state's services
as settled and its actors as ended, as that version left them, including on a later
Recover after this version has recorded steps on top.

The skipped host-clock test now points at #247.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
…e its spawns ran

- durable: DeliverToActor records nothing and fails the Handle once its context ended
  by the end of the delivery, even when it drove no parent Fire. The ending may have
  made the kernel refuse the actor's own Fire, losing the event, while the call
  reported success.
- durable: Recover no longer fails on a context that ends once it has spawned its
  actors with no Fire refused, as Start doesn't; their behaviors already ran, and a
  retry would run them again.
- state: ResumeEffects covers the active leaves alone again, services and actors as
  well as timers. After a Restore, a compound state's service or actor may already have
  settled into a child, and starting it again ran it twice.
- state: an Invocation's JSON is parsed once on load; AbsorbRespawn's doc no longer
  warns against concurrent deliveries, which the scoped quiet hears.

Tests: a delivery refused inside the actor; Recover's context ending during a respawn;
ResumeEffects after a compound service settled; every Invocation field kept when it
declares no onError (by reflection, so a later field is covered).

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
…n undeclared invoke

- durable: Recover checks its context once more after the replay walk, before any
  actor spawns. b97e07d dropped the only check after the last Record, so a context that
  ended while the last Tick or settle replayed could return a Handle short of the
  journal.
- state: an invoked actor with no onError emits its SpawnActor with a nil OnError, as a
  Spawn with none does, so a host that reads the effect sees none declared; the actor
  system already escalates on a nil OnError. SpawnActor.NoOnError, which only stood in
  for that, is removed.
- durable: DeliverToActor, Start and Recover restore the actor collector's step context
  in a defer, so a panic out of host code, such as a parent middleware's, doesn't leave
  it driving under the dead step's context. Start and Recover build StartEffects once.
- state: the ResumeEffects and StartEffects docs say which to call after a Restore.

Tests: the context ending during the last replayed Record; an undeclared invoke's nil
OnError; a middleware panic during a delivery.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
…tled

Pins that an actor restored from a snapshot resumes without spawning again a nested
actor its earlier start spawned, once that nested actor settled and moved it on, for a
nested actor declared on the actor's leaf state and on a compound state.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>
…d onErrors as issues

Reverts three changes to state's v1 behavior, so this PR adds to state without
changing what it does:
- StartEffects covers the active leaves again, as v1 does. A compound state's services
  and actors don't start at Start or Recover; tracked in #249. Recover's handling of an
  older checkpoint's compound invokes, which only that widening needed, goes too.
- An InvokeActor with no onError fires the zero event again, as v1 documents, rather
  than escalating. durable tells "none declared" from "refused" by the kernel's
  refusal reason, a stopgap with known gaps; tracked in #250.
- An Invocation's JSON writes onError as before; a declared zero-valued onError is
  lost through the IR, tracked in #251.

The tests for what those changes fixed stay in the PR, skipped with a pointer to the
issue.

Signed-off-by: Ray Karnes <ray.karnes@stablekernel.com>

@reka18 reka18 left a comment

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Pointers to the issues this PR leaves open, at the code they touch.

Comment thread durable/runner.go Resolved
Comment thread durable/runner.go Resolved
Comment thread durable/runner.go Resolved
- InvalidTransitionError.Is matches ErrNoTransition only for the kernel's own refusal
- durable drops its copy of the reason-string check
- a host refusal worded like the kernel's now counts as handled; unskip its test
- compare []S with slices.Equal instead of fmt.Sprint per step
- idle step with three actors: 35 to 32 allocs, 4088 to 4032 B/op
- add BenchmarkHandle_Fire_ActorIdleStep
…tarted set

- Mark Recover's quiet respawns so a failed one stays in neither actor set
- Next Recover respawns it quietly, so its start message applies once
- Cover zero-event, no-onError and context-ended respawn failures
@joshua-temple

Copy link
Copy Markdown
Collaborator

Thanks for this one, it's a careful piece of work. I ran a few review passes and pushed three small commits on top. Happy to revert any of them if they don't fit your plan.

Pushed

  • c9d083f adds state.ErrNoTransition, so durable stops matching the kernel's reason text. Before this, a host error worded the same made a behavior run twice (TestSpawnRule_DenialWordedLikeNoTransitionIsDone).
  • 00c9058 keys the actor-set cache on the configuration slice: 35 → 32 allocs per idle step (BenchmarkHandle_Fire_ActorIdleStep).
  • 7297597 keeps a running actor whose respawn fails at Recover out of UnstartedActors. Before this, the next Recover replayed its start message a second time (TestRecover_ARunningActorWhoseRespawn*).

Looked at, no change

  • Actors spawned before Start/Recover returns an error: they're in-process with no stop hook, and the rerun is documented.
  • checkFormat after a downgrade: the CHANGELOG forbids a downgrade, so failing loudly seems right.
  • Parent-fire observer race: the step lock covers it, and a -race stress run was clean.
  • Tick not absorbing actor effects: left for fix(durable): keep timers across recovery and skip idle ticks #236.

Checks

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

confirmed:api-compatibility ACR clean: api-compatibility confirmed:concurrency-discipline ACR clean: concurrency-discipline confirmed:correctness ACR clean: correctness confirmed:human-readability ACR clean: human-readability confirmed:missed-context ACR clean: missed-context confirmed:regression-safety ACR clean: regression-safety confirmed:replay-determinism ACR clean: replay-determinism ready All ACR dimensions confirmed - clear to merge

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants