fix(runtime): apply graph stops while child work is running

packages/runtime-host/src/server/execution-composition.ts

@@ -1240,8 +1240,8 @@ export async function createExecutionRuntimeHostComposition(
       bindRun: (identity) => messages.bindRun(identity),
       executeRoot: (input) =>
         executeHostedExecutionToSettlement(requireRootCoordinator(rootCoordinator), input),
-      stopRoot: (identity, input) =>
-        requireRootCoordinator(rootCoordinator).stopRoot(identity, input),
+      stopRoot: (identity, input, options) =>
+        requireRootCoordinator(rootCoordinator).stopRoot(identity, input, options),
       stopSession: (sessionId, input) =>
         requireRootCoordinator(rootCoordinator).stopSession(sessionId, input),
     };

packages/runtime-host/src/server/root-turn-coordinator.ts

@@ -56,6 +56,7 @@ import {
   RuntimeHostedRootConflictError,
   RuntimeHostedRootUnavailableError,
   RuntimeMessageAuthorityInvariantError,
+  type RuntimeHostedRootStopOptions,
   type RuntimeMessageRunIdentity,
 } from '@maka/runtime/message-authority';
 import {
@@ -1240,15 +1241,24 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
     );
   }
 
-  stopRoot(identity: RuntimeMessageRunIdentity, input: StopSessionInput = {}): Promise<void> {
+  stopRoot(
+    identity: RuntimeMessageRunIdentity,
+    input: StopSessionInput = {},
+    options: RuntimeHostedRootStopOptions = {},
+  ): Promise<void> {
     normalizeStopSessionSource(input.source, input.workHubActionId);
+    // Only an activation-scoped graph stop targets one Run. Public turn.stop,
+    // shutdown and supervisor stops keep the Session-level Runtime stop, which
+    // also reaches a claim whose Run has not attached yet.
+    const scoped = options.scope === 'run';
     return this.runCommand(async () => {
       const declared = await this.sessionAdmission.run(identity.sessionId, (lease) =>
         this.declareStopFence(
           identity,
           () => this.messages.commitStopFence(identity),
           lease,
           input,
+          scoped,
         ),
       );
       await declared?.deliverStop();
@@ -1258,10 +1268,28 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
       );
       if (disposition.kind === 'complete') {
         if (!disposition.outcome.ok) throwHostedStopError(identity.sessionId, disposition.outcome);
+        if (!scoped) return;
+        const logical = await readLogicalRuntimeExecutionForRun(
+          this.stores.runtimeEventStore,
+          identity,
+        );
+        await this.deliverRuntimeStopIntent(identity.sessionId, input, {
+          ...identity,
+          runId: logical?.tip.runId ?? identity.runId,
+        });
         return;
       }
       if (disposition.kind === 'request_stop') {
-        await this.deliverRuntimeStopIntent(identity.sessionId, input);
+        await this.deliverRuntimeStopIntent(
+          identity.sessionId,
+          input,
+          scoped
+            ? {
+                ...identity,
+                runId: disposition.active.continuation?.runId ?? identity.runId,
+              }
+            : undefined,
+        );
       }
       await disposition.active.done;
     });
@@ -2700,6 +2728,7 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
     commitQueueFence: () => QueueFenceResult,
     admission: SessionAdmissionLease,
     stopInput: StopSessionInput = {},
+    scoped = false,
   ): Promise<DeclaredStopFence | undefined> {
     const active = this.#executions.get(input.sessionId);
     if (!active || active.turnId !== input.turnId || active.runId !== input.runId) {
@@ -2718,13 +2747,22 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
       'turn_stopped',
       admission,
     );
-    const shouldDeliverStop = !active.stopRequested;
+    const shouldDeliverStop = scoped || !active.stopRequested;
     active.stopRequested = stopInput;
     return {
       active,
       deliverStop: () =>
         shouldDeliverStop
-          ? this.deliverRuntimeStopIntent(input.sessionId, stopInput)
+          ? this.deliverRuntimeStopIntent(
+              input.sessionId,
+              stopInput,
+              scoped
+                ? {
+                    ...input,
+                    runId: active.continuation?.runId ?? active.runId,
+                  }
+                : undefined,
+            )
           : Promise.resolve(),
     };
   }
@@ -3376,8 +3414,9 @@ export class RootTurnCoordinator implements HostedExecutionAuthority {
   private async deliverRuntimeStopIntent(
     sessionId: string,
     input: StopSessionInput = { source: 'stop_button' },
+    identity?: RuntimeMessageRunIdentity,
   ): Promise<void> {
-    await this.manager.deliverHostedRootStop(sessionId, input);
+    await this.manager.deliverHostedRootStop(sessionId, input, identity);
   }
 
   private async stopActiveTurn(sessionId: string, active: ActiveRootTurn): Promise<void> {