refactor(core): simplify session run coordination (#33388)

specs/v2/schema-changelog.md

@@ -1,5 +1,10 @@
 # V2 Schema Changelog
 
+## 2026-06-22: Make Session Interruption Process-Local
+
+- Remove the unprojected `session.next.interrupt.requested.1` event from the experimental durable Session event union and generated SDK.
+- No canonical V1 data requires migration; experimental V2 event history containing the retired event is disposable.
+
 ## 2026-06-05: Execute Automatic Session Compaction
 
 - Trigger automatic compaction before provider turns using the complete estimated request and absolute model-aware headroom.

specs/v2/session.md

@@ -20,10 +20,10 @@ sessions.prompt({ id?, sessionID, prompt, delivery?, resume? })
   -> resume false admits only
 
 sessions.interrupt(sessionID)
-  -> interrupts the active ownership chain on this process
-  -> waits for active drain cleanup and settlement
-  -> suppresses reruns already queued before interruption
-  -> preserves durable inbox rows for a later fresh wake or resume
+  -> interrupts active execution on this process
+  -> waits for runner cleanup and settlement
+  -> clears a coalesced follow-up wake already registered with this coordinator
+  -> preserves durable inbox rows for a later wake or resume
   -> idle or missing Session is a no-op
 ```
 
@@ -152,12 +152,12 @@ Inbox delivery is explicit:
 
 Execution has two entry points:
 
-- `run` is an explicit resume. It joins an active drain chain or starts one, and performs at least one provider attempt even when no input is eligible.
+- `run` is an explicit resume. It joins any active execution or starts a forced drain while idle. A forced drain bypasses the no-eligible-input guard, but preparation may still fail before a provider attempt.
 - `wake` reports newly recorded durable inbox work. Repeated wakes coalesce. A wake calls the provider only when it can promote eligible input.
 
 Post-crash activity recovery is intentionally deferred. A wake does not infer that ambiguous provider work is safe to retry after an input has already been promoted. Explicit `run` may deliberately continue from durable projected history. A future recovery slice should model durable activity identity, provider-dispatch ambiguity, required continuation, queue-opener reservation, retry policy, and visible recovery status together.
 
-A process-global `SessionRunCoordinator` serializes each local Session drain chain while allowing different Sessions to drain concurrently. It enters the Session's current Location only when a drain starts, so interruption targets process execution ownership rather than Location cache identity. Interruption establishes a local ownership-chain boundary by stopping the current chain while preserving pending/unpromoted durable inbox rows for a later fresh wake and projected history for explicit resume. A Location runner also fences every new provider turn against its captured Location so a moved Session cannot begin another turn through source-Location tools or context. An already-dispatched provider turn may still settle source-Location calls until a future move-control slice interrupts active ownership. Automatic startup discovery, durable multi-node ownership, stale-owner fencing, and retry policy remain future work.
+A process-global `SessionRunCoordinator` serializes execution for each local Session while allowing different Sessions to run concurrently. Resumes join active execution, overlapping wakes coalesce into one follow-up, and interruption stops current process-local execution without deleting durable inbox work. The runner enters the Session's current Location when execution starts and fences each new provider turn against that Location.
 
 Inbox promotion coalesces pending steers in durable admission order and opens one queued activity at a time in FIFO order. Add explicit inbox backlog and steering-batch limits before exposing broad multi-caller admission or untrusted queue growth.
 

specs/v2/todo.md

@@ -33,12 +33,7 @@ through legacy `SessionPrompt.loop(...)`:
 Prompt admission now uses a durable `session_input` inbox rather than immediate
 transcript projection. `steer` inputs coalesce into the active activity at the
 next safe provider-turn boundary. `queue` inputs form a FIFO of future activities
-that open one at a time. A process-global `SessionRunCoordinator` coalesces process-local wakeups
-around settlement races. Explicit `run` resumes perform at least one provider
-attempt; advisory `wake` notifications call the provider only for eligible inbox
-work. Steers coalesce into the active activity at
-safe provider boundaries; queued inputs open later activities one at a time in
-FIFO order.
+that open one at a time.
 
 Next reviewed slices: