FE-743: Petri parallel execution with resource pools and per-slice sandboxes

[kostandinang]

Summary

• Adds FiringPolicy (serial | parallel) to the Petri interpreter: parallel mode claims all ready transitions and fires them concurrently with Promise.allSettled, subject to pool limits.
• Introduces shared agent resource places so test-writer and code-writer transitions contend under a configurable global concurrency cap.
• Isolates each slice in its own sandbox directory under the run tree, which parallel execution and later epic merge depend on.

Context

• FE-738 separated mechanical and semantic completion lanes; this PR delivers the main structural advantage of Petri over proc: independent slices can advance concurrently when policy and pools allow.
• Planning decision gate: parallel policy must demonstrate measurable benefit on a multi-slice fixture relative to serial before the frontier is considered complete.
• Renaming worktreeDir to sandboxDir clarifies that the path is a per-run filesystem root, not necessarily a git worktree (brownfield worktrees land in FE-755).

What changed

• FiringPolicy: serial preserves prior single-fire behavior; parallel batches independent ready transitions.
• RunPolicy.agentPoolSize: caps simultaneous agent-backed transitions via pool:test-agent and pool:code-agent places.
• Per-slice sandboxes: artifacts live under join(sandboxDir, sliceId) so concurrent slices do not stomp the same tree.
• CLI: removes dead --engine flag; adds --policy=serial|parallel for explicit policy selection at cook time.

Verification

• Engine contract scenarios exercised under both policies (41 contract tests in this area).
• Dedicated tests for pool bounds, concurrent firing behavior, and sandbox isolation between slices.
• npm run verify green.

Out of scope

• Merging slice sandboxes for epic-level verify-epic (FE-745).
• Codebase/brownfield cook on real repos (FE-755).

Traceability

• Requirements 46–50; SPEC §3, §4; frontier petri-parallel-execution in memory/PLAN.md; umbrella H-6476.

[cursor]

PR Summary

Medium Risk
Changes core orchestrator concurrency, token pooling, and filesystem isolation; parallel batch rollback can abort a whole step if one transition fails, and epic verification still uses the parent sandbox until merge work lands.

Overview
FE-743 delivers parallel Petri execution so independent slices can advance concurrently, with shared agent pools and per-slice sandboxes, and marks the frontier done in memory/PLAN.md.

The interpreter gains a parallel firing policy: it greedily claims tokens for all enabled transitions, runs them with Promise.allSettled, commits successes, and rolls back the whole batch on any handler rejection (including falsy rejections). serial behavior is unchanged. RunPolicy.agentPoolSize seeds capped tokens on pool:test-agent / pool:code-agent instead of per-slice agent places, bounding concurrent agent-backed work.

The net compiler and wiring pass route slice actions and tests through sandboxDir/<sliceId> (with path validation), create those dirs at wire time, and keep verify-epic on the parent sandbox (epic merge called out as follow-up). The run root is renamed sandboxDir / createSandbox across cook, types, and Pi actions.

brunch cook accepts --policy=serial|parallel; help drops the unused --engine flag. Contract and adapter tests now cover both policies, plus concurrency, pool limits, wall-clock vs serial, and sandbox isolation.

^{Reviewed by Cursor Bugbot for commit c4ab8b1. Bugbot is set up for automated code reviews on this repo. Configure here.}

[kostandinang]

• FE-800: Spec to orchestrator plan emitter — generate plan.yaml from a completed specification #167 : 2 dependent PRs (#168 , #170 )
• FE-764: Brunch<> Petrinaut stream — ephemeral orchestrator hosted SSE server #165
• FE-784: Petrinaut export: colour-fold per-slice subnet #160
• FE-763: Petrinaut event stream — initial markings + transition firings #158
• FE-762: Petrinaut-format JSON export of the compiled net #157
• FE-761: Petri-net semantic alignment for Petrinaut visualization #156
• FE-755: Cook codebase mode for brownfield brunch #155
• FE-747: Declarative output routing for branching transitions #154
• FE-745: Epic-scoped sandbox merge for verify-epic #152
• FE-743: Petri parallel execution with resource pools and per-slice sandboxes #149 👈 (View in Graphite)
• FE-738: Petri semantic lanes with two-lane subnet and engine factory #148
• FE-730: Greenfield orchestrator POC with pi-agent dispatch #143
• main

This stack of pull requests is managed by Graphite. Learn more about stacking.

[augmentcode]

🤖 Augment PR Summary

Summary: This PR completes FE-743 by adding true parallel Petri-net execution, shared agent resource pools, and per-slice worktree isolation to reduce wall-clock time on multi-slice plans.

Changes:

• Extend FiringPolicy to serial | parallel and implement runParallel() using greedy token claiming + Promise.allSettled.
• Add shared pool:test-agent/pool:code-agent places and RunPolicy.agentPoolSize to cap global agent concurrency.
• Route action contexts and test runs through join(worktreeDir, sliceId) to isolate slice execution directories.
• Update brunch cook CLI: retire --engine, add --policy=serial|parallel, default to serial.
• Expand contract tests to cover both policies and add explicit concurrency/pool/worktree isolation checks.
• Update memory/PLAN.md to mark petri-parallel-execution done and adjust sequencing.

Technical Notes: Parallel execution aims for serial parity while allowing bounded concurrency via shared pool tokens.

_{🤖 Was this summary useful? React with 👍 or 👎}

[augmentcode]

Review completed. 2 suggestions posted.

Comment augment review to trigger a new review at any time.

[lunelson]

Parallel firing + shared pools land cleanly, and the decision gate (parallel beats serial on wall clock) is the right thing to clear before adding this much machinery. The runSerial/runParallel split with shared restoreClaim/depositClaim helpers is nice.

Three architectural reflections, all comment-only — none block:

1. Parallel failure semantics is all-or-nothing batch. runParallel uses Promise.allSettled, but on any rejection it restores claims for every transition in the batch and rethrows. That means one slice's transient agent failure aborts every other concurrent slice's in-flight work, not just halts the failing one. The tests don't exercise mixed success/failure batches, so this is currently invisible. Likely too coarse once real agent flakiness shows up — worth naming as an explicit design choice (or queuing per-claim rollback as follow-up).

2. wireHandlers now has a filesystem side effect. FE-738 was careful to keep compileTopology pure and put runtime concerns in wireHandlers. This PR adds mkdirSync(sliceSandboxDir(...)) inside wireHandlers — the wiring pass now also provisions directories on disk. Small but real layering creep. Could factor out a prepareRunFilesystem(blueprint, input) step that engine.ts invokes before wireHandlers.

3. Naming drift between abstraction and artifact. worktreeDir → sandboxDir is done thoroughly across types, CLI flags, and handlers (createWorktree → createSandbox). But the file worktree.ts still has that name, and the returned sandboxDir is still literally .cook/runs/<id>/worktree on disk. The abstraction says "sandbox," the artifact still says "worktree." OK to defer if FE-755 will revisit the on-disk convention; worth a one-line decision either way.

Pool-token contention and per-slice sandbox isolation look solid. 👍

[lunelson]

Approving — architectural reflections above are non-blocking. 👍

The base branch was changed.

[cursor]

Cursor Bugbot has reviewed your changes and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit a865631. Configure here.}