Update README

Author: ericallam

internal-packages/run-engine/README.md

@@ -201,8 +201,6 @@ The Run Engine emits events using its `eventBus`. This is used for runs completi
 
 # RunEngine System Architecture
 
-The RunEngine is composed of several specialized systems that handle different aspects of task execution and management. Below is a diagram showing the relationships between these systems.
-
 ```mermaid
 graph TD
     RE[RunEngine]
@@ -216,6 +214,7 @@ graph TD
     DRS[DelayedRunSystem]
     TS[TtlSystem]
     WFS[WaitingForWorkerSystem]
+    RCS[ReleaseConcurrencySystem]
 
     %% Core Dependencies
     RE --> DS
@@ -228,6 +227,7 @@ graph TD
     RE --> DRS
     RE --> TS
     RE --> WFS
+    RE --> RCS
 
     %% System Dependencies
     DS --> ESS
@@ -239,11 +239,13 @@ graph TD
 
     WS --> ESS
     WS --> ES
+    WS --> RCS
 
     ES --> ESS
 
     CS --> ESS
     CS --> ES
+    CS --> RCS
 
     DRS --> ES
 
@@ -260,54 +262,34 @@ graph TD
         RL[RunLocker]
         EB[EventBus]
         WRK[Worker]
-        RCQ[ReleaseConcurrencyQueue]
     end
 
     %% Resource Dependencies
     RE -.-> Resources
-    DS & RAS & ESS & WS & BS & ES & CS & DRS & TS & WFS -.-> Resources
+    DS & RAS & ESS & WS & BS & ES & CS & DRS & TS & WFS & RCS -.-> Resources
 ```
 
 ## System Responsibilities
 
-### DequeueSystem
-
-- Handles dequeuing of tasks from master queues
-- Manages resource allocation and constraints
-- Handles task deployment verification
-
-### RunAttemptSystem
-
-- Manages run attempt lifecycle
-- Handles success/failure scenarios
-- Manages retries and cancellations
-- Coordinates with other systems for run completion
-
-### ExecutionSnapshotSystem
-
-- Creates and manages execution snapshots
-- Tracks run state and progress
-- Manages heartbeats for active runs
-- Maintains execution history
-
-### WaitpointSystem
+### Core Systems
 
-- Manages waitpoints for task synchronization
-- Handles waitpoint completion
-- Coordinates blocked runs
-- Manages concurrency release
+- **ExecutionSnapshotSystem (ESS)**: Manages execution state tracking and history
+- **EnqueueSystem (ES)**: Handles run scheduling and queueing
+- **RunAttemptSystem (RAS)**: Controls run lifecycle and execution attempts
+- **ReleaseConcurrencySystem (RCS)**: Manages concurrency control and token management
 
-### BatchSystem
+### Queue Management
 
-- Manages batch operations
-- Handles batch completion
-- Coordinates batch-related task runs
+- **DequeueSystem (DS)**: Handles task dequeuing and resource allocation
+- **DelayedRunSystem (DRS)**: Manages delayed run scheduling
+- **WaitingForWorkerSystem (WFS)**: Coordinates runs waiting for worker availability
 
-### EnqueueSystem
+### State Management
 
-- Handles enqueueing of runs
-- Manages run scheduling
-- Coordinates with execution snapshots
+- **CheckpointSystem (CS)**: Manages execution checkpoints and resumption
+- **WaitpointSystem (WS)**: Coordinates task synchronization points
+- **BatchSystem (BS)**: Handles batch operations and coordination
+- **TtlSystem (TS)**: Manages run time-to-live and expiration
 
 ## Shared Resources
 
@@ -318,13 +300,27 @@ graph TD
 - **RunLocker**: Run locking mechanism
 - **EventBus**: Event communication
 - **Worker**: Background task execution
-- **ReleaseConcurrencyQueue**: Manages concurrency token release
 
 ## Key Interactions
 
-1. **RunEngine** orchestrates all systems and manages shared resources
-2. **DequeueSystem** works with **RunAttemptSystem** for task execution
-3. **RunAttemptSystem** coordinates with **WaitpointSystem** and **BatchSystem**
-4. **WaitpointSystem** uses **EnqueueSystem** for run scheduling
-5. **ExecutionSnapshotSystem** is used by all other systems to track state
-6. All systems share common resources through the `SystemResources` interface
+1. **Core Execution Flow**
+
+   - ExecutionSnapshotSystem provides state tracking for all systems
+   - EnqueueSystem coordinates with multiple systems for scheduling
+   - RunAttemptSystem manages execution lifecycle
+   - ReleaseConcurrencySystem controls concurrent execution limits
+
+2. **Queue Management**
+
+   - DequeueSystem coordinates with RunAttemptSystem for execution
+   - DelayedRunSystem and WaitingForWorkerSystem handle specialized queuing
+
+3. **State Coordination**
+
+   - CheckpointSystem works with ReleaseConcurrencySystem and EnqueueSystem
+   - WaitpointSystem coordinates with ReleaseConcurrencySystem for execution control
+   - TtlSystem manages expiration through WaitpointSystem
+
+4. **Resource Management**
+   - All systems share common resources through SystemResources
+   - ReleaseConcurrencySystem provides centralized concurrency control