Skip to content

Route executable-operation Actions through scheduler-owned Ticks#688

Merged
flyingrobots merged 64 commits into
mainfrom
feat/executable-operation-scheduler-bridge
Jul 25, 2026
Merged

Route executable-operation Actions through scheduler-owned Ticks#688
flyingrobots merged 64 commits into
mainfrom
feat/executable-operation-scheduler-bridge

Conversation

@flyingrobots

@flyingrobots flyingrobots commented Jul 24, 2026

Copy link
Copy Markdown
Owner

Summary

  • accepts canonical executable-operation Actions through the ordinary WAL-backed submission lifecycle and restores accepted-but-undecided Actions after restart
  • routes admitted Actions through the normal head inbox so only the scheduler invokes bounded private evaluation while constructing a Tick
  • constructs one atomic composite Tick for independently admitted Actions at one exact parent basis, with typed per-Action committed, obstructed, and footprint-conflict outcomes
  • persists the decided Tick, state transition, receipts, correlations, and executable-operation outcomes in one scheduler WAL transaction before publishing frontier or Receipt state
  • validates and restores the Tick, state, per-Action outcomes, and Receipts during recovery, including strict homogeneous WAL framing and canonical Action ordering
  • keeps direct prepare/commit executable-operation entry points explicitly transitional and hidden from the permanent application surface

Acceptance evidence

  • cargo fmt --all -- --check
  • cargo clippy -p warp-core --lib -- -D warnings -D missing_docs
  • cargo clippy -p warp-core --lib --features native_rule_bootstrap,trusted_runtime,host_test -- -D warnings
  • cargo clippy -p warp-core --features native_rule_bootstrap,trusted_runtime,host_test --test executable_operation_pipeline_tests -- -D warnings -D missing_docs
  • cargo test -p warp-core --features native_rule_bootstrap,trusted_runtime,host_test
  • cargo test -p warp-core
  • cargo test -p warp-core --features native_rule_bootstrap,trusted_runtime,host_test --test executable_operation_pipeline_tests scheduler_commits_two_independent_executable_actions_in_one_durable_tick
  • cargo test -p warp-core scheduler::tests::partitioned_admission_never_mixes_native_and_executable_actions
  • cargo test -p warp-core causal_wal_tests::tick_batch_rejects_mixed_action_outcome_framing
  • bash -n scripts/verify-local.sh tests/hooks/test_verify_local.sh
  • bash tests/hooks/test_verify_local.sh (162 passed, 0 failed)
  • git diff --check

Documentation

ADR 0025 defines the scheduler-owned lifecycle and updates the canonical application-hosting, scheduler, WAL, and generated-rules documentation. The changelog records the new Action/Tick/WAL boundary.

Explicit non-goals

  • This PR does not claim real Edict compiler emission or a production Graft lawpack; its handcrafted package is an Echo-owned test fixture only.
  • This PR does not implement production Graft transport or git-warp migration behavior.
  • This PR does not claim cross-head atomicity for the filesystem WAL; the proven atomic unit is one scheduler-owned Tick on one head.

Closes #687

Summary by CodeRabbit

  • New Features
    • Added scheduler-owned executable-operation Actions with deterministic admission, bounded Tick construction, and typed per-Action outcomes.
    • Added WAL support for batched Tick receipts and recording Action outcomes.
    • Added receipt reporting for executable-operation obstructions.
  • Bug Fixes
    • Improved recovery when Tick construction or WAL persistence fails, including stricter validation for batched/correlated evidence and obstruction handling.
    • Prevented mixed execution categories and rejected invalid Action-outcome framing in batches.
  • Documentation
    • Updated README, architecture docs, specs, ADRs, and changelog to reflect the new scheduler-owned Action lifecycle and WAL behavior.

@coderabbitai

coderabbitai Bot commented Jul 24, 2026

Copy link
Copy Markdown
Contributor

Review Change Stack

Warning

Review limit reached

@flyingrobots, you've reached your PR review limit, so we couldn't start this review.

Next review available in: 45 minutes

Enable usage-based reviews in Billing to review now. Otherwise, wait until the next included review is available.
You're only billed for reviews past your plan's rate limits ($0.25/file).

How can I continue?

After more reviews become available, a review can be triggered using the @coderabbitai review command as a PR comment. Alternatively, push new commits to this PR.

To avoid repeated limits, reduce automatic review volume by pausing incremental auto-reviews earlier, using label-based review opt-in, excluding WIP or generated PR titles, or requesting reviews manually when the PR is ready. If your team needs uninterrupted high-volume reviews, an organization admin can enable usage-based reviews.

How do review limits work?

CodeRabbit enforces per-developer PR review limits for each organization. Most developers receive the normal plan review availability.

For paid Pro and Pro+ PR reviews, CodeRabbit uses adaptive limits for sustained high-volume activity. When a developer's recent PR review activity reaches the 95th percentile or higher among CodeRabbit users, additional reviews become available more gradually as earlier reviews age out of the rolling window.

Please refer docs for additional details.

Review details
⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro Plus

Run ID: 7119b136-445e-44ec-a07d-de45bf4aeec7

📥 Commits

Reviewing files that changed from the base of the PR and between bdd8632 and aed42bc.

📒 Files selected for processing (10)
  • CHANGELOG.md
  • crates/warp-core/src/coordinator.rs
  • crates/warp-core/src/echo_operation.rs
  • crates/warp-core/src/head_inbox.rs
  • crates/warp-core/src/lib.rs
  • crates/warp-core/src/trusted_runtime_host.rs
  • crates/warp-core/tests/executable_operation_pipeline_tests.rs
  • docs/adr/0025-scheduler-owned-executable-operation-actions.md
  • docs/spec/scheduler-warp-core.md
  • docs/topics/WAL.md
📝 Walkthrough

Walkthrough

This PR routes canonical executable-operation Actions through scheduler-owned atomic Ticks, adding typed outcomes, batch WAL persistence, recovery validation, obstruction handling, integration tests, CI coverage, and lifecycle documentation.

Changes

Executable-operation Action pipeline

Layer / File(s) Summary
Action, receipt, and WAL contracts
crates/warp-core/src/echo_operation.rs, crates/warp-core/src/receipt.rs, crates/warp-core/src/causal_wal.rs, crates/warp-core/src/provenance_codec.rs
Adds canonical Action envelopes, typed outcomes, obstruction receipt encoding, batch Tick WAL records, and strict batch/recovery validation.
Admission and scheduler Tick construction
crates/warp-core/src/coordinator.rs, crates/warp-core/src/head_inbox.rs
Partitions Action ingress, resolves evaluation bases, constructs bounded candidates, and commits multiple Actions into one composite Tick.
Host WAL persistence and recovery
crates/warp-core/src/trusted_runtime_host.rs
Tracks pending Actions, persists per-Action outcomes, validates Tick correspondence, restores outcomes and pending submissions, and updates recovery roots.
Integration tests and quality gates
crates/warp-core/tests/*, .github/workflows/*, scripts/verify-local.sh, tests/hooks/test_verify_local.sh
Covers multi-Action commits, obstructions, conflicts, recovery, rollback, failure injection, and feature-specific test/clippy execution.
Architecture and lifecycle documentation
docs/adr/*, docs/spec/*, docs/topics/*, README.md, CHANGELOG.md
Documents scheduler-owned Action execution, atomic Tick durability, obstruction semantics, recovery rules, and ADR 0025.

Estimated code review effort: 5 (Critical) | ~120 minutes

Possibly related issues

  • Issue 689 — Tracks removal of the transitional direct prepare/commit seams retained by this PR.

Possibly related PRs

  • flyingrobots/echo#683: Extends the executable-operation pipeline and trusted-runtime/WAL plumbing that this PR uses for scheduler-owned Actions and action outcomes.
  • flyingrobots/echo#379: Established related runtime-WAL tick, receipt, and recovery evidence used by the new Action outcome reconstruction.
  • flyingrobots/echo#360: Added related witnessed-submission and receipt-correlation tracking extended here for Action outcomes.
🚥 Pre-merge checks | ✅ 5
✅ Passed checks (5 passed)
Check name Status Explanation
Description Check ✅ Passed Check skipped - CodeRabbit’s high-level summary is enabled.
Title check ✅ Passed The title is concise and accurately summarizes the main change: routing executable-operation Actions through scheduler-owned Ticks.
Linked Issues check ✅ Passed The changes implement scheduler-owned Action intake, atomic Tick batching, WAL durability, recovery, and transitional direct APIs as required by #687.
Out of Scope Changes check ✅ Passed The diff stays within routing, recovery, docs, tests, scripts, and CI support for executable-operation Actions; no unrelated feature work is evident.
Docstring Coverage ✅ Passed Docstring coverage is 100.00% which is sufficient. The required threshold is 80.00%.
✨ Finishing Touches
🧪 Generate unit tests (beta)
  • Create PR with unit tests
  • Commit unit tests in branch feat/executable-operation-scheduler-bridge

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

Comment @coderabbitai help to get the list of available commands.

@chatgpt-codex-connector chatgpt-codex-connector Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

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

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 242392d76e

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

Comment thread crates/warp-core/src/trusted_runtime_host.rs Outdated
Comment thread crates/warp-core/src/trusted_runtime_host.rs
Comment thread crates/warp-core/src/echo_operation.rs
Comment thread crates/warp-core/src/echo_operation.rs

@coderabbitai coderabbitai Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Actionable comments posted: 5

🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@crates/warp-core/src/coordinator.rs`:
- Around line 1741-1765: Document and enforce the positional mapping in this
same-basis correlation branch: bind the ingress_id sorting and receipt.entries()
index lookup to the ordering established by
commit_scheduler_action_batch_to_state_v1, using a debug_assert! or equivalent
invariant check. Preserve no_match() for missing correlations or out-of-range
entries, and ensure any ordering change cannot silently attribute the wrong
disposition.

In `@crates/warp-core/src/trusted_runtime_host.rs`:
- Around line 1572-1614: The scheduler path must stop scanning the full
witnessed-submission history. Update admit_pending_echo_operation_actions_v1 to
consume a bounded pending-submission index, and update the tick_once per-outcome
lookup to use the existing receipt_correlation_by_submission mapping keyed by
submission identity instead of witnessed_submissions().find; preserve admission
and outcome behavior while avoiding repeated durable-history scans.

In `@docs/adr/0025-scheduler-owned-executable-operation-actions.md`:
- Around line 132-138: Update the documented canonical Action order so each Tick
WAL transaction contains exactly one TickReceiptRecorded, followed by one
ordered ReceiptCorrelationRecorded and ActionOutcomeRecorded pair per Action,
then exactly one RuntimeStateDeltaRecorded; remove the implication that
TickReceiptRecorded repeats per Action.

In `@docs/topics/GeneratedRules.md`:
- Around line 143-149: Update the stale corridor prose below the Action
submission bullets to describe composite Action Ticks rather than singleton
ticks: revise the “parent patch and singleton tick entry” statement to
acknowledge multiple Actions, and replace the claim that the current slice lacks
general scheduler batch integration with the shipped behavior where two
independent executable Actions are composed and committed in one durable Tick.

In `@README.md`:
- Around line 260-267: Update the earlier README statement that excludes
scheduler-batch composition so it reflects the implemented behavior described in
the later section: independent Actions can share one scheduler-owned Tick. Keep
any remaining scope limitations accurate and consistent with the
executable-operation discussion.
🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

  • Push a commit to this branch (recommended)
  • Create a new PR with the fixes

ℹ️ Review info
⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro Plus

Run ID: b2add678-a8a0-4fbb-aeb3-57269de878f7

📥 Commits

Reviewing files that changed from the base of the PR and between 6d81506 and 242392d.

📒 Files selected for processing (27)
  • .github/workflows/ci.yml
  • .github/workflows/macos-local.yml
  • CHANGELOG.md
  • README.md
  • crates/warp-core/Cargo.toml
  • crates/warp-core/src/causal_wal.rs
  • crates/warp-core/src/causal_wal_tests.rs
  • crates/warp-core/src/contract_obstruction.rs
  • crates/warp-core/src/coordinator.rs
  • crates/warp-core/src/echo_operation.rs
  • crates/warp-core/src/engine_impl.rs
  • crates/warp-core/src/head_inbox.rs
  • crates/warp-core/src/lib.rs
  • crates/warp-core/src/provenance_codec.rs
  • crates/warp-core/src/receipt.rs
  • crates/warp-core/src/trusted_runtime_host.rs
  • crates/warp-core/tests/executable_operation_pipeline_tests.rs
  • docs/README.md
  • docs/adr/0023-admitted-executable-operation-packages.md
  • docs/adr/0025-scheduler-owned-executable-operation-actions.md
  • docs/adr/README.md
  • docs/architecture/application-contract-hosting.md
  • docs/spec/scheduler-warp-core.md
  • docs/topics/GeneratedRules.md
  • docs/topics/WAL.md
  • scripts/verify-local.sh
  • tests/hooks/test_verify_local.sh

Comment thread crates/warp-core/src/coordinator.rs Outdated
Comment thread crates/warp-core/src/trusted_runtime_host.rs
Comment thread docs/adr/0025-scheduler-owned-executable-operation-actions.md
Comment thread docs/topics/GeneratedRules.md
Comment thread README.md

Copy link
Copy Markdown
Owner Author

Self-Code Review — merge gate locked

Reviewed fresh origin/main...ea978cd39920 after a clean-worktree lockdown and git fetch origin. Baseline evidence remains green (30/30 executable-operation pipeline tests, focused WAL test, formatting, Markdown lint, and GitHub CI), but the following paths are not covered by that evidence.

@codex please independently confirm or rebut each finding against the current head.

ID Severity Location Finding
SCR-01 P0 Critical crates/warp-core/src/trusted_runtime_host.rs:1575-1632 One durably accepted but unadmittable Action permanently poisons tick_once. admit_pending_echo_operation_actions_v1 returns on the first missing package, policy mismatch, authority mismatch, or malformed reserved-kind payload. The Action stays pending, the same error repeats forever, and all unrelated native or valid Action work is blocked before the scheduler runs. A syntactically canonical invocation may lawfully name a package that is not installed yet, so this is reachable through the ordinary WAL-acknowledged submission boundary.
SCR-02 P0 Critical crates/warp-core/src/trusted_runtime_host.rs:3880-3964, 4304-4440 Recovery decodes but never validates the per-Action ETICK003 decision. TickReceiptRecord.decision is indexed by WAL recovery, but recover_runtime_state_delta_material uses only its receipt reference; the Action validator never receives the batch records. A checksum-consistent rewritten WAL can therefore say Applied in the batched decision record while the provenance Tick entry and typed outcome say Obstructed, and activation accepts both contradictory authorities.
SCR-03 P1 High crates/warp-core/src/coordinator.rs:1720-1802; crates/warp-core/src/trusted_runtime_host.rs:1660-1664 Contractless Action outcomes can be attributed to the wrong Tick entry. intent_outcome_decision first applies the legacy entry.scope.local_id == ingress_id heuristic to every contractless correlation and only uses canonical positional attribution when that search returns nothing. Action scopes are application-controlled node IDs. Action A can therefore use Action B's known ingress hash as its node ID, causing B to inherit A's disposition. The host then uses that ambiguous observation to write the durable WAL decision.
SCR-04 P1 High crates/warp-core/src/trusted_runtime_host.rs:4050-4055, 4122-4137; crates/warp-core/src/echo_operation.rs:4320-4330 Recovery groups Action Ticks by bare commit hash. The commit hash excludes worldline/head/global-Tick identity. Two worldlines with identical parent state, operations, patch, and policy can legitimately produce the same hash. The provenance map overwrites one entry and outcomes_by_commit merges both batches, causing a valid multi-worldline WAL to fail recovery or bind outcomes to the wrong entry.
SCR-05 P1 High crates/warp-core/src/trusted_runtime_host.rs:4081-4095, 4159-4187 Recovered Action evaluation bases are only compared with the retained invocation, not the reconstructed parent state. Committed receipts self-consistently bind state_root_before to their own basis, but this validator never corroborates the basis state root, parent commit, parent global Tick, or application-basis proposition against replayed pre-Tick state. The direct-operation recovery path has explicit parent-state validation; the scheduler-Action path omits it.
SCR-06 P1 High crates/warp-core/src/trusted_runtime_host.rs:4107-4120, 4200-4210; crates/warp-core/src/echo_operation.rs:4242-4288 Footprint-conflict recovery is circular rather than evidentiary. Recovery ignores preparation_id, never reconstructs the rejected preparation or actual footprint, and merely checks that the outcome's blocked_by list equals the Tick receipt's list. A self-consistent rewrite can classify a non-conflicting Action as conflicted and still activate. There is also no scheduler integration/restart test for the conflict variant.
SCR-07 P1 High crates/warp-core/src/trusted_runtime_host.rs:4367-4440 Recovery accepts a second, noncanonical Action-WAL shape. In the legacy ETICK002 branch, an ExecutableOperationActionOutcomeRecorded frame may follow every singleton receipt/correlation pair; the final check only requires all-or-none outcomes. Since Action outcome records did not predate this PR, there is no compatibility reason to accept this alternate shape. It contradicts ADR 0025's one-ETICK003-record invariant.
SCR-08 P2 Medium crates/warp-core/src/head_inbox.rs:802-836; crates/warp-core/src/echo_operation.rs:4225-4292 Executable-Action Tick construction is not intrinsically bounded. AcceptAll and KindFilter select up to usize::MAX; composition compares every prepared footprint against all prior accepted footprints and can retain quadratic blocker evidence. Per-Action Edict budgets do not meter scheduler composition, so a valid inbox policy permits unbounded CPU/memory use in one Tick.
SCR-09 P2 Medium crates/warp-core/src/trusted_runtime_host.rs:1578-1613 Budgeted backlogs are re-decoded and cloned in quadratic total work. Every tick_once scans, clones, canonical-decodes, re-admits, and duplicate-stages every undecided Action, even those already ticketed and deferred by max_per_tick. Draining N Actions at budget 1 costs N + (N-1) + ... admissions and copies.
SCR-10 P2 Medium crates/warp-core/src/trusted_runtime_host.rs:6500-6536 The legacy recovery-certificate identity changed under the unchanged executable-operation-index:v1 domain. The function now hashes a zero Action-outcome count even for pre-PR WALs containing only installations/direct receipts. Thus identical legacy WAL evidence produces a different recovered-index root solely because the runtime revision changed.
SCR-11 P3 Low crates/warp-core/Cargo.toml:96-98; crates/warp-core/tests/executable_operation_pipeline_tests.rs:3121-3290 The whole executable-operation integration target now requires host_test. Two injection tests need that feature, but moving it into required-features removes the previously covered production feature combination native_rule_bootstrap,trusted_runtime. CI now proves only the test-instrumented build of this suite.
SCR-12 P3 Low crates/warp-core/src/trusted_runtime_host.rs:835-880; docs/adr/0025-scheduler-owned-executable-operation-actions.md:73-76,154 The ADR says application code “cannot” invoke direct evaluation/commit, but both methods remain public. #[doc(hidden)] removes documentation, not Rust access. This can be an explicitly transitional seam, as the ADR says earlier, but the absolute consequence is factually false and the bypass remains callable by downstream crates.
SCR-13 P3 Low PR description The focused two-Action acceptance command names a nonexistent test. The PR body uses scheduler_commits_two_executable_actions_in_one_durable_tick; the real test is scheduler_commits_two_independent_executable_actions_in_one_durable_tick. Cargo exits successfully with zero matching tests, so the listed focused witness is misleading even though the broader suite currently covers it.
SCR-14 P5 Nit CHANGELOG.md:20-23 The sentence is wrapped between “every” and “outcome.” Markdown renders correctly and lint passes, but the source is needlessly harder to scan. Keep the noun phrase together.

Agent-ready mitigation prompts

  1. SCR-01: “Add a RED test with one canonical Action naming an unavailable package plus unrelated valid work. Make admission failure terminal and typed for only that Action (or quarantine it under a typed pending posture) so it cannot abort every host Tick. Preserve WAL-first acknowledgement and prove restart recovery.”
  2. SCR-02: “Mutate one ETICK003 member decision while keeping the WAL structurally/checksum consistent. Require recovery to derive the expected WalTickDecision from the canonical Tick entry and typed Action outcome and reject any mismatch. Apply the same validation before append.”
  3. SCR-03: “Construct two Actions where A's scope.local_id equals B's ingress ID and their dispositions differ. Detect executable-Action correlations from the retained submission kind and use canonical same-Tick positional mapping directly; never run the legacy scope heuristic for Actions.”
  4. SCR-04: “Create two worldlines with identical initial state and identical first Action consequences, commit them in separate durable Ticks, restart, and prove both recover. Key provenance and outcome groups by the full causal Tick coordinate, not bare commit hash.”
  5. SCR-05: “Add adversarial recovery tests that alter the Action invocation/receipt parent state root, parent commit, parent global Tick, and application proposition while recomputing internal identities. Reconstruct the pre-Tick state and validate the exact basis just as the direct-operation recovery path does.”
  6. SCR-06: “Add a two-Action footprint-conflict WAL/restart witness plus a mutated false-conflict vector. Reconstruct or retain independently verifiable preparation/actual-footprint evidence, validate preparation_id, and prove every blocker is an earlier applied member whose footprint actually conflicts.”
  7. SCR-07: “Build a checksum-consistent scheduler transaction using repeated singleton ETICK002 receipt/correlation/outcome triples. Reject it. Require ETICK003 whenever any Action-outcome frame exists while preserving truly legacy non-Action singleton recovery.”
  8. SCR-08: “Introduce a finite scheduler-owned executable-Action batch/composition budget independent of InboxPolicy::AcceptAll; meter candidate count, footprint comparisons, blocker entries, and aggregate operations. Add exact-boundary and one-over-bound tests.”
  9. SCR-09: “Instrument Action admission counts under max_per_tick: 1. Cache/stage admitted evidence once or admit only the scheduler-selected bounded set so each pending Action is decoded/admitted O(1) times across backlog drain and restart.”
  10. SCR-10: “Add a golden legacy recovery-certificate vector from origin/main. Preserve the exact v1 hash layout when Action outcomes are absent, and introduce a separately versioned/domain-separated layout when they are present.”
  11. SCR-11: “Restore the integration target's production required features. Gate or split only the two fault-injection tests behind host_test, and run both production and instrumented feature combinations in CI.”
  12. SCR-12: “Choose one honest posture: make direct prepare/commit pub(crate) or host_test-only, or amend ADR 0025 to say the public seam is temporarily callable but architecturally forbidden and name its removal issue.”
  13. SCR-13: “Update the PR acceptance command to the exact current test symbol and run it with output proving one test executed.”
  14. SCR-14: “Reflow the changelog paragraph so fresh-host recovery validates every outcome remains together while respecting the repository line width.”

Judgment: MERGE GATE: LOCKED 🔒. Green CI does not exercise these adversarial/collision/boundary cases.

@chatgpt-codex-connector chatgpt-codex-connector Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

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

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: ea978cd399

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

Comment thread crates/warp-core/src/trusted_runtime_host.rs Outdated
Comment thread crates/warp-core/src/trusted_runtime_host.rs
Comment thread crates/warp-core/src/coordinator.rs Outdated
Comment thread crates/warp-core/src/trusted_runtime_host.rs
Comment thread crates/warp-core/src/trusted_runtime_host.rs
Comment thread docs/adr/0025-scheduler-owned-executable-operation-actions.md Outdated
Comment thread crates/warp-core/src/trusted_runtime_host.rs Outdated
Comment thread crates/warp-core/src/trusted_runtime_host.rs Outdated
Comment thread crates/warp-core/src/trusted_runtime_host.rs
Comment thread crates/warp-core/src/trusted_runtime_host.rs Outdated

Copy link
Copy Markdown
Owner Author

Code Lawyer Activity Summary

Lockdown began from a clean worktree and fresh origin. The combined CodeRabbit, Codex, and self-audit queue is closed on head 022ebf7d3e1a25f61c195ef069a554385ac88f68.

# Priority Source Surface Commit Outcome
1 P0 PR WAL Action submission acknowledgement 6f8944915 WAL-enabled plain submission now rejects executable Actions before mutation and directs callers to the durable-ack boundary.
2 P1 PR Scheduler category liveness cc42aeeba Competing execution categories alternate deterministically by durable parent-Tick parity, preventing starvation by caller-shaped ingress IDs.
3 P1 PR Receipt attribution 305600ddf Positional attribution is restricted to executable Actions; ordinary outcomes fail closed when semantic candidates are absent.
4 P2 PR Hot-path WAL acceptance/correlation lookup 9f5ce098b Durable acceptances are indexed and newly committed correlations are consumed directly without full-history rescans.
5 P2 PR Recovery installation snapshots f5c8cd355 Installation order uses monotonic ordinals and count boundaries instead of cloning the full package set per outcome.
6 P2 PR Recovery basis replay 7f208f35c Reconstructed worldline states are cached by exact coordinate and reused across Action outcomes and Tick groups.
7 P2 PR Recovery package lookup dd774096e Installed Action packages are indexed by package ID; recovery no longer performs a linear scan per outcome.
8 P3 PR Scheduler candidate-bound witness e4db43112 The exported candidate limit drives a fixture whose Actions use independent nodes and compose without accidental conflicts.
9 P3 PR Partition limit tests 18fdeb8c3 Both policy-vs-partition clamp directions and the untouched non-selected partition are pinned.
10 P3 PR Decoder allocation guard a12bd02d5 The hostile retained-outcome fixture now reaches the impossible blocker-count guard through a complete canonical prefix.
11 P4 PR Verification feature lanes c7c4d7569 Extra test-target features are centralized and shared by collection, execution, and Clippy paths.
12 P3 PR Legacy Tick framing test cf1a0b9db The legacy-path rejection witness uses opaque invalid payload bytes and proves rejection by frame kind without coupling to EOACT003.
13 P4 PR Homogeneous Action batch invariant 7be9f41fc Coordinator detection and commit sites now state the partition invariant and fail-closed rollback posture.
14 P4 PR WAL documentation witnesses 376a139ae The scheduler rule names concrete composite-Tick, rollback, recovery, obstruction, and isolation tests.
15 P1 Codex Admission candidate order caa83d9cf The bounded Action prefix is selected by durable ingress order, not content-derived submission ID order.
16 P1 Codex Noncommitted outcome identity bdd86324d Obstructions and footprint conflicts carry and recover the exact deciding Tick coordinate and member index; hostile index mutation is rejected.
17 P1 Codex Host decomposition state loss 022ebf7d3 TrustedRuntimeHostParts now owns and round-trips runtime, authority, WAL, pending/admitted state, and typed Action outcomes.

Verification

  • All 40 GitHub review threads are resolved.
  • VERIFY_FORCE=1 scripts/verify-local.sh full passed fresh: format, guards, and CI-owned test lanes.
  • Focused executable-operation pipeline, trusted-host, recovery, Clippy, Rustdoc, Markdown, and diff-integrity checks passed during the per-issue RED/GREEN loop.
  • Worktree is clean and the pushed PR head matches local HEAD.
  • GitHub CI is still running on the current head; completed jobs are green.
  • CodeRabbit follow-up review is currently processing the repair range.

@codex review please. Independently confirm the final head, especially ingress-order bounding, noncommitted decision coordinates, and TrustedRuntimeHostParts round-trip preservation.

@coderabbitai coderabbitai Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

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

Actionable comments posted: 4

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (2)
crates/warp-core/src/head_inbox.rs (1)

833-864: 🚀 Performance & Scalability | 🟠 Major | ⚡ Quick win

Ordinary bulk admission regresses from mem::take to per-key BTreeMap::remove.

The coordinator calls admit_partitioned for every head whenever Action support is active (operation_actions.is_some()), so the non-Action path no longer hits admit()'s O(1) std::mem::take. Instead each tick allocates a Vec<Hash> of up to pending.len() ids (32 B each) and then performs N × O(log N) removals. On a large inbox that is measurable per-SuperTick overhead for work that used to be a single move.

Add a drain fast path when the selected category is the entire pending set and the limit does not bind.

⚡ Fast path for the unbounded whole-inbox case
         if limit == 0 {
             return Vec::new();
         }
+        // Whole-inbox, unbounded case: keep the O(1) move instead of
+        // rebuilding the key set and removing entry by entry.
+        if !(has_partition && has_other) && limit >= self.pending.len() {
+            return std::mem::take(&mut self.pending).into_values().collect();
+        }
 
         let mut selected_ids = Vec::new();
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/warp-core/src/head_inbox.rs` around lines 833 - 864, Update the
admission logic around policy_limit, limit, and selected_ids to return the
entire pending map directly when the selected category covers all entries and
limit is unbounded. Use std::mem::take on self.pending for this fast path, while
preserving partition filtering and bounded-limit behavior.
crates/warp-core/src/trusted_runtime_host.rs (1)

1955-1970: 🚀 Performance & Scalability | 🔵 Trivial | 💤 Low value

Deep-clones every Action outcome per tick just to build a lookup map.

action_outcomes.iter().cloned() copies each EchoOperationActionOutcomeV1 (boxed receipts, footprints, conflict blocker vectors) solely so record_tick_receipt_batch can read them; the originals are then consumed again at Line 2026. A borrowed map avoids the copy — record_tick_receipt_batch only reads through .get().

♻️ Borrow instead of clone
-        let action_outcomes_by_submission =
-            action_outcomes.iter().cloned().collect::<BTreeMap<_, _>>();
+        let action_outcomes_by_submission = action_outcomes
+            .iter()
+            .map(|(submission_id, outcome)| (*submission_id, outcome))
+            .collect::<BTreeMap<_, &EchoOperationActionOutcomeV1>>();

Then change record_tick_receipt_batch's parameter to &BTreeMap<Hash, &EchoOperationActionOutcomeV1>.

As per path instructions: "Performance matters — flag unnecessary allocations in hot paths."

🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/warp-core/src/trusted_runtime_host.rs` around lines 1955 - 1970,
Update the action-outcome lookup construction to borrow outcomes instead of
cloning them: collect `action_outcomes.iter()` into a `BTreeMap<Hash,
&EchoOperationActionOutcomeV1>`. Change `record_tick_receipt_batch` to accept
that borrowed map and keep its lookup logic read-only, while preserving the
later consumption of the original `action_outcomes`.

Source: Path instructions

🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@crates/warp-core/src/echo_operation.rs`:
- Around line 4965-5012: Add a debug_assert_eq! immediately before the decisions
mapping to verify decisions.len() matches tick_receipt.entries().len(). Keep
enumerate() as the source of member_index so positional alignment remains
explicit for recovery validation.

In `@crates/warp-core/src/trusted_runtime_host.rs`:
- Around line 436-441: The recovery performance counters are currently
hard-wired or never updated, making their test assertions vacuous. In
crates/warp-core/src/trusted_runtime_host.rs:436-441, either implement
increments at the actual installed-package lookup and per-Action
installation-set materialization sites (including mutable metrics/counter
bindings) or remove the instrumentation; in
crates/warp-core/tests/executable_operation_pipeline_tests.rs:2932-2943, retain
the two counter assertions only if counters become real, otherwise remove them
while keeping the echo_operation_parent_state_replay_count_for_test == 1
assertion.

In `@crates/warp-core/tests/executable_operation_pipeline_tests.rs`:
- Around line 2932-2943: The kernel instrumentation behind the two
installation-related test counters is inert, so the assertions cannot detect
regressions. Update the relevant trusted-runtime counter definitions and the
validate_recovered_echo_operation_action_outcomes path to increment installation
snapshot and linear comparison counters when those operations occur, while
preserving the existing parent replay counter behavior.

In `@docs/adr/0025-scheduler-owned-executable-operation-actions.md`:
- Around line 131-138: Update the typed executable-Action outcome description to
make the committed member consequence conditional: only applied Actions bind a
committed patch member, while obstruction and footprint-conflict outcomes
explicitly carry no committed consequence. Preserve the existing evidence
requirements for rejected outcomes, including writer head, worldline, Tick
coordinates, commit and receipt identities, and canonical member index.

---

Outside diff comments:
In `@crates/warp-core/src/head_inbox.rs`:
- Around line 833-864: Update the admission logic around policy_limit, limit,
and selected_ids to return the entire pending map directly when the selected
category covers all entries and limit is unbounded. Use std::mem::take on
self.pending for this fast path, while preserving partition filtering and
bounded-limit behavior.

In `@crates/warp-core/src/trusted_runtime_host.rs`:
- Around line 1955-1970: Update the action-outcome lookup construction to borrow
outcomes instead of cloning them: collect `action_outcomes.iter()` into a
`BTreeMap<Hash, &EchoOperationActionOutcomeV1>`. Change
`record_tick_receipt_batch` to accept that borrowed map and keep its lookup
logic read-only, while preserving the later consumption of the original
`action_outcomes`.
🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

  • Push a commit to this branch (recommended)
  • Create a new PR with the fixes

ℹ️ Review info
⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro Plus

Run ID: 2dfbac7f-3d0f-4d8d-84c4-b7cd794710de

📥 Commits

Reviewing files that changed from the base of the PR and between 909dec8 and bdd8632.

📒 Files selected for processing (12)
  • CHANGELOG.md
  • crates/warp-core/src/contract_obstruction.rs
  • crates/warp-core/src/coordinator.rs
  • crates/warp-core/src/echo_operation.rs
  • crates/warp-core/src/head_inbox.rs
  • crates/warp-core/src/lib.rs
  • crates/warp-core/src/trusted_runtime_host.rs
  • crates/warp-core/tests/executable_operation_pipeline_tests.rs
  • docs/adr/0025-scheduler-owned-executable-operation-actions.md
  • docs/spec/scheduler-warp-core.md
  • docs/topics/WAL.md
  • scripts/verify-local.sh

Comment thread crates/warp-core/src/echo_operation.rs
Comment thread crates/warp-core/src/trusted_runtime_host.rs
Comment thread crates/warp-core/tests/executable_operation_pipeline_tests.rs
Comment thread docs/adr/0025-scheduler-owned-executable-operation-actions.md Outdated

@chatgpt-codex-connector chatgpt-codex-connector Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

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

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 022ebf7d3e

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

Comment thread crates/warp-core/src/trusted_runtime_host.rs Outdated
Comment thread crates/warp-core/src/trusted_runtime_host.rs Outdated
Comment thread crates/warp-core/src/head_inbox.rs
Comment thread crates/warp-core/src/trusted_runtime_host.rs Outdated

Copy link
Copy Markdown
Owner Author

Code Lawyer Final Activity Summary

Lockdown began from a clean worktree and fresh origin. The combined CodeRabbit, Codex, and self-audit queue is closed on head 0b76eaaa0cabbb7848558700a8290830a7717e9a.

# Priority Source Surface Commit Outcome
1 P0 PR WAL Action submission acknowledgement 6f8944915 WAL-enabled plain submission rejects executable Actions before mutation and directs callers to durable acknowledgement.
2 P1 PR Scheduler category liveness cc42aeeba Competing execution categories no longer select solely by caller-shaped ingress IDs.
3 P1 PR Receipt attribution 305600ddf Positional attribution is restricted to executable Actions; ordinary outcomes fail closed.
4 P2 PR Hot-path WAL acceptance/correlation lookup 9f5ce098b Durable acceptances are indexed and new correlations are consumed directly.
5 P2 PR Recovery installation snapshots f5c8cd355 Installation order uses monotonic ordinals and count boundaries, not package-set clones.
6 P2 PR Recovery basis replay 7f208f35c Reconstructed worldline states are cached by exact coordinate.
7 P2 PR Recovery package lookup dd774096e Installed packages are indexed by package ID.
8 P3 PR Scheduler candidate-bound witness e4db43112 The exported limit drives independent, nonconflicting fixture Actions.
9 P3 PR Partition limit tests 18fdeb8c3 Both clamp directions and the untouched nonselected partition are pinned.
10 P3 PR Decoder allocation guard a12bd02d5 Hostile retained bytes reach the intended blocker-count guard.
11 P4 PR Verification feature lanes c7c4d7569 Extra test-target features are centralized.
12 P3 PR Legacy Tick framing test cf1a0b9db The framing witness uses opaque invalid payload bytes.
13 P4 PR Homogeneous Action batch invariant 7be9f41fc Coordinator detection and commit sites document fail-closed homogeneous batching.
14 P4 PR WAL documentation witnesses 376a139ae The scheduler rule names concrete commit, rollback, recovery, obstruction, and isolation tests.
15 P1 Codex Admission candidate order caa83d9cf The bounded prefix is selected by durable ingress order.
16 P1 Codex Noncommitted outcome identity bdd86324d Rejected outcomes carry and recover exact Tick coordinates and member indexes.
17 P1 Codex Host decomposition state loss 022ebf7d3 TrustedRuntimeHostParts round-trips WAL, policy, pending state, and typed outcomes.
18 P4 CodeRabbit Action member position 3459337b7 Tick construction executes a decision-count versus receipt-entry-count alignment invariant.
19 P2 CodeRabbit Recovery performance evidence 4e4708378 Constant-zero proxy metrics were removed; tests count actual indexed package and installation-order lookups.
20 P3 CodeRabbit ADR rejected-consequence semantics 434a6d9d6 ADR 0025 now states that only applied Actions bind committed patch members.
21 P1 Codex Cross-head admission capacity ec83d1771 The 64-Action bound is applied per runnable head; dormant/faulted heads cannot starve siblings.
22 P1 Codex Cross-worldline recovery 49fc0fa3a Recovery validates submitted basis on its worldline and the deciding transition on the target head worldline.
23 P1 Codex Multi-head category alternation 4086a353b Parent global-Tick parity advances once per scheduler pass, so every head alternates categories even on a shared worldline.
24 P2 Codex Admission-only drain progress 0b76eaaa0 run_until_idle continues when a no-Step pass advances bounded Action admission.

Verification on the final local head

  • All 48 GitHub review threads are resolved; zero Changes Requested reviews are open.
  • VERIFY_FORCE=1 scripts/verify-local.sh full passed fresh: format, guards, and CI-owned local lanes.
  • 700 Warp Core library tests passed after the scheduler-round repair.
  • 41 executable-operation pipeline tests and 38 trusted-host loop tests passed after the final drain repair.
  • Relevant feature-lane Clippy, Rustdoc, Prettier, Markdownlint, and git diff --check gates passed.
  • Worktree is clean; local HEAD, pushed branch, and PR head all equal 0b76eaaa0cabbb7848558700a8290830a7717e9a.
  • The branch is mergeable and is 61 commits ahead / 0 behind fresh origin/main.
  • GitHub CI has restarted on the final head and must finish green before merge.
  • CodeRabbit is rate-limited, so repository policy requires a substantive Codex follow-up.

@codex review please. Review the exact final head, with particular attention to per-runnable-head admission capacity, cross-worldline obstruction recovery, global-Tick category alternation, and admission-only drain progress.

@chatgpt-codex-connector

Copy link
Copy Markdown

Codex Review: Didn't find any major issues. 🎉

Reviewed commit: 0b76eaaa0c

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

@flyingrobots

Copy link
Copy Markdown
Owner Author

Code Lawyer self-finding

@codex please confirm the current-head repair after it lands.

ID Severity File Finding Planned mitigation
CL-26 P5 Nit crates/warp-core/src/head_inbox.rs:684 The test-only filtered-removal counter compiles in featureless lib tests, but its regression test requires native_rule_bootstrap and trusted_runtime, producing a dead-code warning. Give the counter and its initialization/increment sites the same feature predicate as the test, then rerun both featureless and feature-enabled lanes.

@chatgpt-codex-connector

Copy link
Copy Markdown

Summary

  • Confirmed CL-26 against the current head: featureless library tests previously failed under -D warnings because the filtered-removal counter was compiled but unread.
  • Applied the regression test’s native_rule_bootstrap and trusted_runtime feature predicate to the counter field and both initialization sites. crates/warp-core/src/head_inbox.rsL679-L711
  • Applied the identical predicate to the counter increment, while retaining the feature-enabled whole-inbox fast-path regression test. crates/warp-core/src/head_inbox.rsL870-L878 crates/warp-core/src/head_inbox.rsL1050-L1073
  • Committed the repair as 76836cd (Fix: gate partition removal test counter) and created the requested follow-up PR metadata.
  • No documentation update was necessary because this only changes test-instrumentation compilation and does not affect runtime behavior or public contracts.

Testing

  • RUSTFLAGS='-D warnings' cargo test -p warp-core --lib --no-run
  • RUSTFLAGS='-D warnings' cargo test -p warp-core --lib --features native_rule_bootstrap,trusted_runtime homogeneous_unbounded_partitioned_admission_moves_the_whole_inbox — 1 passed
  • cargo fmt --all -- --check
  • git diff --check
  • git status --short --branch — clean worktree on work after commit

View task →

@flyingrobots

Copy link
Copy Markdown
Owner Author

Code Lawyer Final Activity Summary — 27-item closure

Lockdown began from a clean worktree and fresh origin. The combined inline-thread, global-review, and self-audit queue is closed on exact head aed42bc274398e1772f340ffb3043bda265dbab2.

# Priority Source Surface Commit Outcome
1 P0 PR Durable Action acknowledgement 6f8944915 WAL-enabled plain submission rejects executable Actions before mutation and directs callers to durable acknowledgement.
2 P1 PR Scheduler category liveness cc42aeeba Executable and ordinary categories cannot starve one another by ingress order.
3 P1 PR Action receipt attribution 305600ddf Positional attribution is restricted to exact executable-Action scope.
4 P2 PR Action persistence lookup 9f5ce098b Accepted Actions use an indexed persistence path instead of retained-history scans.
5 P2 PR Installation ordering f5c8cd355 Recovery records monotonic installation order without package-set snapshots.
6 P2 PR Recovered basis replay 7f208f35c Reconstructed Action basis states are cached by exact coordinate.
7 P2 PR Recovered installation lookup dd774096e Package resolution uses a package-ID index instead of linear scans.
8 P3 Self Candidate ceiling witness e4db43112 The exported 64-Action ceiling is proven with independent targets.
9 P4 PR Partition limit tests 18fdeb8c3 Both policy and partition clamps have deterministic coverage.
10 P4 PR Blocker allocation metering a12bd02d5 The Action blocker allocation guard is reached by executable evidence.
11 P4 PR Verification feature lanes c7c4d7569 Extra feature selection is centralized for tests and Clippy.
12 P4 PR Legacy Tick framing test cf1a0b9db Legacy rejection uses opaque payload bytes and depends only on frame kind.
13 P5 PR Homogeneous batch invariant 7be9f41fc Coordinator documentation states the homogeneous category guarantee and rollback posture.
14 P4 PR WAL evidence documentation 376a139ae Action and Tick durability witnesses are named explicitly.
15 P2 Self Pending Action order caa83d9cf Admission is bounded by canonical ingress identity rather than submission identity.
16 P1 Self Rejected Action decision binding bdd86324d Every noncommitted Action outcome binds its deciding Tick coordinates and member index.
17 P2 Self Host decomposition 022ebf7d3 Opaque host parts preserve WAL, policy, authority, pending admission, and outcomes.
18 P4 PR Decision and receipt alignment 3459337b7 A debug invariant pins Action decisions to Tick receipt entries.
19 P2 PR Recovery performance counters 4e4708378 Tests measure real package-index and installation-order lookups.
20 P3 PR ADR rejected-outcome semantics 434a6d9d6 Only applied Actions claim committed consequences.
21 P1 PR Runnable-head admission scope ec83d1771 Dormant and faulted heads cannot consume a runnable sibling capacity.
22 P1 PR Cross-worldline recovery 49fc0fa3a Recovery uses the submitted worldline for basis state and deciding worldline for transition evidence.
23 P1 PR Per-round category alternation 4086a353b Category selection uses durable global-Tick parity across shared worldlines.
24 P2 PR Admission-only progress 0b76eaaa0 run_until_idle drains after bounded admission progress even when no Step commits.
25 P3 PR global Homogeneous inbox performance 77c7dc882 Unbounded one-category admission restores the whole-map move instead of N removals.
26 P5 Self Test instrumentation cfg 606b5e0d3 Performance instrumentation is compiled only with the feature-gated regression.
27 P4 PR global WAL outcome staging aed42bc27 The read-only outcome index borrows Action outcomes instead of deep-cloning them.

Current-head evidence

  • Worktree clean; local and remote branch both aed42bc274398e1772f340ffb3043bda265dbab2.
  • VERIFY_FORCE=1 scripts/verify-local.sh full: all three fresh lanes passed.
  • 41 executable-operation pipeline tests passed.
  • 20 trusted-runtime WAL unit tests passed.
  • 16 focused head-inbox tests passed.
  • Featureless and feature-enabled Clippy lanes passed with warnings denied.
  • Formatting, git diff --check, Prettier, and Markdown lint passed.
  • GraphQL thread scan: zero unresolved review threads.

@codex review please — independently review this exact head. CodeRabbit is currently rate-limited; its review will be re-requested when the stated cooldown expires.

@chatgpt-codex-connector

Copy link
Copy Markdown

Codex Review: Didn't find any major issues. Already looking forward to the next diff.

Reviewed commit: aed42bc274

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

  • Open a pull request for review
  • Mark a draft as ready
  • Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

@flyingrobots

Copy link
Copy Markdown
Owner Author

@coderabbitai review please

@coderabbitai

coderabbitai Bot commented Jul 25, 2026

Copy link
Copy Markdown
Contributor

@flyingrobots: Reviewing the current PR head, with focus on Action-batch reconstruction, fresh-host recovery, causal-coordinate binding, WAL framing, and bounded scheduler behavior.

✅ Action performed

Review finished.

Note: CodeRabbit is an incremental review system and does not re-review already reviewed commits. This command is applicable only when automatic reviews are paused.

@flyingrobots
flyingrobots merged commit 4295d71 into main Jul 25, 2026
41 checks passed
@flyingrobots
flyingrobots deleted the feat/executable-operation-scheduler-bridge branch July 25, 2026 17:38
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Route executable-operation Actions through scheduler-owned Ticks

1 participant