FE-743: Petri parallel execution — concurrent firing, resource pools, worktree-per-slice

[kostandinang]

TL;DR. Phase 2 of the Petri orchestrator arc: parallel firing policy with greedy token claiming, shared resource-pool tokens that cap global concurrency, and per-slice worktrees. Decision gate passed — parallel measurably beats serial on multi-slice plans.

What changed

Interpreter (petri-net.ts)

• FiringPolicy = 'serial' | 'parallel'.
• runParallel() — greedy token claiming in registration order + Promise.allSettled concurrent fire.
• Extracted isEnabled() helper (was inlined 3×); removed unused hasTokens().

Compiler (net-compiler.ts)

• Shared pool:test-agent / pool:code-agent places replace per-slice agent places.
• agentPoolSize on RunPolicy caps global concurrency (default = slice count = unbounded).
• Per-slice sandbox dirs via join(sandboxDir, sliceId) for all action contexts.

CLI (cook-cli.ts)

• Retired dead --engine=proc|petri flag (proc engine deleted in FE-730).
• Added --policy=serial|parallel wired to createOrchestrator().

Naming

• Renamed worktreeDir → sandboxDir across orchestrator files — disambiguates from git worktrees.

Why now

Parallelism is the primary value claim for Petri over proc. Without it, both engines are serial and proc wins on simplicity. Decision gate: if parallel didn't beat proc on wall clock for a representative multi-slice fixture, the substrate commitment would have paused. It does.

Verification

• All 41 contract tests pass under both serial and parallel.
• Concurrency proof — maxConcurrent > 1 under parallel.
• Wall-clock benchmark — parallel < 85% of serial time.
• Pool-bound tests — agentPoolSize=1 → 1; =2 → 2; default → 3.
• Per-slice sandbox isolation adapter test.
• npm run verify clean.

Traceability

Requirements 46–50; spec §3 (token taxonomy — resource tokens), §4 (canonical slice-net terminal join). Frontier petri-parallel-execution in memory/PLAN.md. Under umbrella H-6476.

[cursor]

PR Summary

Medium Risk
Changes core orchestrator concurrency and token-pool semantics; risk is mitigated by broad dual-policy contract tests but parallel batch rollback and epic verify sandbox scope remain subtle execution edges.

Overview
Phase 2 (FE-743) delivers parallel Petri execution so independent plan slices can advance concurrently, with shared agent pools and per-slice sandboxes—the decision gate (parallel faster than serial on multi-slice plans) is recorded as passed in memory/PLAN.md.

The interpreter adds FiringPolicy parallel: each step greedily claims tokens for all enabled transitions, runs fires with Promise.allSettled, commits successes, and rolls back the whole batch on handler failure. Serial behavior is unchanged aside from shared claim/deposit helpers.

The compiler moves test-agent / code-agent capacity into global pool:* places (replacing per-slice agent places), with agentPoolSize on RunPolicy capping concurrent agent work (default = slice count). Handlers get sandboxDir per slice (<run>/<sliceId>) with path-escape checks; verify-epic still uses the parent run sandbox (noted TODO for epic-scoped merge).

CLI: brunch cook accepts --policy=serial|parallel (replacing the removed --engine flag); worktreeDir is renamed sandboxDir across the orchestrator. Contract tests now run under both policies, plus concurrency, pool-bound, wall-clock, and sandbox-isolation coverage.

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

[kostandinang]

Warning

This pull request is not mergeable via GitHub because a downstack PR is open. Once all requirements are satisfied, merge this PR as a stack on Graphite.
Learn more

• FE-755: Cook codebase-mode — brownfield resolver for brunch cook #155
• FE-747: Declarative output arcs — topology-level routing for branching transitions #154
• FE-745: Merge slice worktrees into epic-scoped dir for verify-epic #152
• FE-743: Petri parallel execution — concurrent firing, resource pools, worktree-per-slice #149 👈 (View in Graphite)
• FE-738: Petri semantic lanes — two-lane subnet, compiler split, engine factory #148
• FE-730: Orchestrator POC — Greenfield orchestrator 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.

[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 9e6a0e8. Configure here.}