@zachwill/pi-orchestrate 0.1.0 → 0.2.0

package/extension/runtime.ts

@@ -1,5 +1,6 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import { Effect, Option } from "effect";
 import {
   CANCELLATION_GRACE_MS,
   EMPTY_WORKER_USAGE,
@@ -72,6 +73,31 @@ export interface CompletedWave {
   readonly results: readonly CompletedResult[];
 }
 
+export type SettlementFailureStage = "startup" | "prompt" | "workflow" | "cancellation";
+
+export interface WorkerSettlement {
+  readonly eventId: string;
+  readonly sequence: number;
+  readonly ownerSessionId: string;
+  readonly waveId: WaveId;
+  readonly workerId: WorkerId;
+  readonly generation: number;
+  readonly mode: WaveMode;
+  readonly worker: string;
+  readonly title: string;
+  readonly lifecycle: WorkerRecord["lifecycle"];
+  readonly status: Exclude<WaveCompleteWorkerStatus, "closed">;
+  readonly outcome: WorkerOutcome;
+  readonly failureStage?: SettlementFailureStage;
+  readonly usage: WorkerUsage;
+  readonly startedAt: number;
+  readonly settledAt: number;
+  readonly remainingActive: number;
+  readonly waveSize: number;
+  readonly waveComplete: boolean;
+  readonly sessionFile: string | undefined;
+}
+
 export interface RuntimeSnapshot {
   readonly waves: readonly WaveRecord[];
   readonly workers: readonly WorkerRecord[];
@@ -79,6 +105,8 @@ export interface RuntimeSnapshot {
 
 export type CompletionListener = (wave: CompletedWave) => void;
 export type UnsubscribeCompletion = () => void;
+export type SettlementListener = (settlement: WorkerSettlement) => void;
+export type UnsubscribeSettlement = () => void;
 export type StateListener = (ownerSessionId: string) => void;
 
 export type AbortTarget =
@@ -118,18 +146,21 @@ export interface OrchestratorRuntime {
     tasks: readonly OrchestrateTaskInput[],
     mode: "async",
     signal?: AbortSignal,
+    onSettlement?: SettlementListener,
   ): Promise<AcceptedWave>;
   orchestrate(
     context: OrchestrationContext,
     tasks: readonly OrchestrateTaskInput[],
     mode: "inline",
     signal?: AbortSignal,
+    onSettlement?: SettlementListener,
   ): Promise<CompletedWave>;
   orchestrate(
     context: OrchestrationContext,
     tasks: readonly OrchestrateTaskInput[],
     mode: WaveMode,
     signal?: AbortSignal,
+    onSettlement?: SettlementListener,
   ): Promise<AcceptedWave | CompletedWave>;
   send(
     context: OrchestrationContext,
@@ -137,6 +168,7 @@ export interface OrchestratorRuntime {
     instructions: string,
     mode: "async",
     signal?: AbortSignal,
+    onSettlement?: SettlementListener,
   ): Promise<AcceptedWave>;
   send(
     context: OrchestrationContext,
@@ -144,6 +176,7 @@ export interface OrchestratorRuntime {
     instructions: string,
     mode: "inline",
     signal?: AbortSignal,
+    onSettlement?: SettlementListener,
   ): Promise<CompletedWave>;
   send(
     context: OrchestrationContext,
@@ -151,11 +184,13 @@ export interface OrchestratorRuntime {
     instructions: string,
     mode: WaveMode,
     signal?: AbortSignal,
+    onSettlement?: SettlementListener,
   ): Promise<AcceptedWave | CompletedWave>;
   abort(ownerSessionId: string, target: AbortTarget): Promise<void>;
   close(ownerSessionId: string, workerId: WorkerId): Promise<void>;
   snapshot(ownerSessionId: string): Promise<RuntimeSnapshot>;
   subscribeCompletion(listener: CompletionListener): UnsubscribeCompletion;
+  subscribeSettlement(listener: SettlementListener): UnsubscribeSettlement;
   subscribeState(listener: StateListener): () => void;
   shutdown(): Promise<void>;
 }
@@ -167,6 +202,7 @@ interface RuntimeEntry {
   session?: WorkerSessionHandle;
   unsubscribeUsage?: () => void;
   unsubscribeActivity?: () => void;
+  unsubscribeMessageDirection?: () => void;
 }
 
 interface WaveWaiter {
@@ -178,17 +214,16 @@ interface WaveWaiter {
 
 const defaultBestEffortDeadline: BestEffortDeadline = {
   wait(promise, timeoutMs) {
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    const settled = promise.then(
+    const settled = Effect.promise(() => promise.then(
       () => "settled" as const,
       () => "settled" as const,
+    ));
+    return Effect.runPromise(
+      settled.pipe(
+        Effect.timeoutOption(timeoutMs),
+        Effect.map((result) => Option.getOrElse(result, () => "timed-out" as const)),
+      ),
     );
-    const timedOut = new Promise<DeadlineResult>((resolve) => {
-      timer = setTimeout(() => resolve("timed-out"), timeoutMs);
-    });
-    return Promise.race([settled, timedOut]).finally(() => {
-      if (timer !== undefined) clearTimeout(timer);
-    });
   },
 };
 
@@ -208,7 +243,10 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
   private readonly terminalWorkerOrder: WorkerId[] = [];
   private readonly completedWaveOrder: WaveId[] = [];
   private readonly completionListeners = new Set<CompletionListener>();
+  private readonly settlementListeners = new Set<SettlementListener>();
+  private readonly waveSettlementListeners = new Map<WaveId, SettlementListener>();
   private readonly stateListeners = new Set<StateListener>();
+  private settlementSequence = 0;
   private readonly disposedSessions = new WeakSet<WorkerSessionHandle>();
   private shuttingDown = false;
   private shutdownPromise: Promise<void> | undefined;
@@ -226,24 +264,28 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     tasks: readonly OrchestrateTaskInput[],
     mode: "async",
     signal?: AbortSignal,
+    onSettlement?: SettlementListener,
   ): Promise<AcceptedWave>;
   orchestrate(
     context: OrchestrationContext,
     tasks: readonly OrchestrateTaskInput[],
     mode: "inline",
     signal?: AbortSignal,
+    onSettlement?: SettlementListener,
   ): Promise<CompletedWave>;
   orchestrate(
     context: OrchestrationContext,
     tasks: readonly OrchestrateTaskInput[],
     mode: WaveMode,
     signal?: AbortSignal,
+    onSettlement?: SettlementListener,
   ): Promise<AcceptedWave | CompletedWave>;
   async orchestrate(
     context: OrchestrationContext,
     tasks: readonly OrchestrateTaskInput[],
     mode: WaveMode,
     signal?: AbortSignal,
+    onSettlement?: SettlementListener,
   ): Promise<AcceptedWave | CompletedWave> {
     this.assertOpen();
     throwIfAborted(signal);
@@ -275,12 +317,15 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
         lifecycle: definition.lifecycle,
         status: "starting",
         usage: copyUsage(EMPTY_WORKER_USAGE),
+        messageDirection: "to-model",
+        startedAt: this.clock(),
       };
     });
 
     const waiter = makeWaveWaiter();
     this.waves.set(waveId, wave);
     this.waveWaiters.set(waveId, waiter);
+    if (onSettlement) this.waveSettlementListeners.set(waveId, onSettlement);
     for (let index = 0; index < records.length; index += 1) {
       const record = records[index];
       const definition = definitions[index];
@@ -304,6 +349,7 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     instructions: string,
     mode: "async",
     signal?: AbortSignal,
+    onSettlement?: SettlementListener,
   ): Promise<AcceptedWave>;
   send(
     context: OrchestrationContext,
@@ -311,6 +357,7 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     instructions: string,
     mode: "inline",
     signal?: AbortSignal,
+    onSettlement?: SettlementListener,
   ): Promise<CompletedWave>;
   send(
     context: OrchestrationContext,
@@ -318,6 +365,7 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     instructions: string,
     mode: WaveMode,
     signal?: AbortSignal,
+    onSettlement?: SettlementListener,
   ): Promise<AcceptedWave | CompletedWave>;
   async send(
     context: OrchestrationContext,
@@ -325,6 +373,7 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     instructions: string,
     mode: WaveMode,
     signal?: AbortSignal,
+    onSettlement?: SettlementListener,
   ): Promise<AcceptedWave | CompletedWave> {
     this.assertOpen();
     throwIfAborted(signal);
@@ -349,11 +398,14 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
       state: "running",
       createdAt: this.clock(),
     };
-    const running = {
+    const running: WorkerRecord = {
       ...transitionWorkerStatus(current, "running"),
       waveId,
       instructions,
       activity: undefined,
+      messageDirection: "to-model",
+      startedAt: this.clock(),
+      settledAt: undefined,
     };
     const waiter = makeWaveWaiter();
 
@@ -361,6 +413,7 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     const generation = entry.generation;
     this.waves.set(waveId, wave);
     this.waveWaiters.set(waveId, waiter);
+    if (onSettlement) this.waveSettlementListeners.set(waveId, onSettlement);
     this.workers.set(workerId, running);
     this.subscribeEntryObservability(workerId, entry, entry.session, generation);
     this.emitState(context.ownerSessionId);
@@ -414,6 +467,17 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     };
   }
 
+  subscribeSettlement(listener: SettlementListener): UnsubscribeSettlement {
+    if (typeof listener !== "function") throw new Error("Settlement listener must be a function");
+    this.settlementListeners.add(listener);
+    let subscribed = true;
+    return () => {
+      if (!subscribed) return;
+      subscribed = false;
+      this.settlementListeners.delete(listener);
+    };
+  }
+
   subscribeState(listener: StateListener): () => void {
     if (typeof listener !== "function") throw new Error("State listener must be a function");
     this.stateListeners.add(listener);
@@ -446,6 +510,10 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
         // Scheduler closure is best-effort during process shutdown.
       } finally {
         await this.awaitTrackedCleanupBestEffort();
+        this.waveSettlementListeners.clear();
+        this.completionListeners.clear();
+        this.settlementListeners.clear();
+        this.stateListeners.clear();
       }
     }
   }
@@ -490,11 +558,15 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
   }
 
   private launchBootstrap(workerId: WorkerId, generation: number): void {
-    this.scheduler.start(
-      workerId,
-      () => this.trackCleanup(this.bootstrapAndPrompt(workerId, generation)),
-      (error) => this.settleWorkflowDefect(workerId, generation, error),
-    );
+    try {
+      this.scheduler.start(
+        workerId,
+        this.bootstrapAndPrompt(workerId, generation),
+        (error) => this.settleWorkflowDefect(workerId, generation, error),
+      );
+    } catch (error) {
+      this.settleWorkflowDefect(workerId, generation, error);
+    }
   }
 
   private launchPrompt(
@@ -503,51 +575,101 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     session: WorkerSessionHandle,
     instructions: string,
   ): void {
-    this.scheduler.start(
-      workerId,
-      () => this.trackCleanup(this.executePrompt(workerId, generation, session, instructions)),
-      (error) => this.settleWorkflowDefect(workerId, generation, error),
-    );
+    try {
+      this.scheduler.start(
+        workerId,
+        this.executePrompt(workerId, generation, session, instructions),
+        (error) => this.settleWorkflowDefect(workerId, generation, error),
+      );
+    } catch (error) {
+      this.settleWorkflowDefect(workerId, generation, error);
+    }
   }
 
-  private async bootstrapAndPrompt(workerId: WorkerId, generation: number): Promise<void> {
-    const session = await this.bootstrap(workerId, generation);
-    if (!session) return;
-    const current = this.workers.get(workerId);
-    if (!current) return;
-    await this.executePrompt(workerId, generation, session, current.instructions);
+  private bootstrapAndPrompt(
+    workerId: WorkerId,
+    generation: number,
+  ): Effect.Effect<void, never> {
+    const runtime = this;
+    return Effect.gen(function* () {
+      const session = yield* runtime.bootstrap(workerId, generation);
+      if (!session) return;
+      const current = runtime.workers.get(workerId);
+      if (!current) return;
+      yield* runtime.executePrompt(workerId, generation, session, current.instructions);
+    });
   }
 
-  private async bootstrap(
+  private bootstrap(
     workerId: WorkerId,
     generation: number,
-  ): Promise<WorkerSessionHandle | undefined> {
-    const entry = this.entries.get(workerId);
-    if (!entry) return undefined;
+  ): Effect.Effect<WorkerSessionHandle | undefined, never> {
+    return Effect.suspend(() => {
+      const entry = this.entries.get(workerId);
+      if (!entry) return Effect.succeed(undefined);
 
-    let session: WorkerSessionHandle;
-    try {
-      session = await this.workerSessionFactory.create({
-        cwd: entry.context.cwd,
-        agentDir: entry.context.agentDir,
-        parentSessionFile: entry.context.parentSessionFile,
-        projectTrusted: entry.context.projectTrusted,
-        definition: entry.definition,
-        parentModel: entry.context.parentModel,
-        modelRegistry: entry.context.modelRegistry,
-      });
-    } catch (error) {
-      this.settleCreationFailure(workerId, generation, error);
-      return undefined;
-    }
+      let creation: Promise<WorkerSessionHandle>;
+      try {
+        creation = this.workerSessionFactory.create({
+          cwd: entry.context.cwd,
+          agentDir: entry.context.agentDir,
+          parentSessionFile: entry.context.parentSessionFile,
+          projectTrusted: entry.context.projectTrusted,
+          definition: entry.definition,
+          parentModel: entry.context.parentModel,
+          modelRegistry: entry.context.modelRegistry,
+        });
+      } catch (error) {
+        this.settleCreationFailure(workerId, generation, error);
+        return Effect.succeed(undefined);
+      }
 
+      this.trackCleanup(creation.then(() => undefined, () => undefined));
+      void creation.then((session) => {
+        if (!this.canAdoptCreatedSession(workerId, generation, entry)) {
+          this.disposeSession(session);
+        }
+      }, () => undefined);
+
+      return Effect.tryPromise({
+        try: () => creation,
+        catch: (error) => error,
+      }).pipe(
+        Effect.match({
+          onFailure: (error) => {
+            this.settleCreationFailure(workerId, generation, error);
+            return undefined;
+          },
+          onSuccess: (session) => this.adoptCreatedSession(
+            workerId,
+            generation,
+            entry,
+            session,
+          ),
+        }),
+      );
+    });
+  }
+
+  private canAdoptCreatedSession(
+    workerId: WorkerId,
+    generation: number,
+    entry: RuntimeEntry,
+  ): boolean {
     const current = this.workers.get(workerId);
-    if (
-      this.shuttingDown ||
-      !current ||
-      current.status !== "starting" ||
-      entry.generation !== generation
-    ) {
+    return !this.shuttingDown &&
+      current?.status === "starting" &&
+      entry.generation === generation;
+  }
+
+  private adoptCreatedSession(
+    workerId: WorkerId,
+    generation: number,
+    entry: RuntimeEntry,
+    session: WorkerSessionHandle,
+  ): WorkerSessionHandle | undefined {
+    const current = this.workers.get(workerId);
+    if (!this.canAdoptCreatedSession(workerId, generation, entry) || !current) {
       this.disposeSession(session);
       return undefined;
     }
@@ -568,31 +690,54 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     }
   }
 
-  private async executePrompt(
+  private executePrompt(
     workerId: WorkerId,
     generation: number,
     session: WorkerSessionHandle,
     instructions: string,
-  ): Promise<void> {
-    const before = this.workers.get(workerId);
-    const entry = this.entries.get(workerId);
-    if (
-      !before ||
-      before.status !== "running" ||
-      !entry ||
-      entry.generation !== generation ||
-      entry.session !== session
-    ) {
-      return;
-    }
+  ): Effect.Effect<void, never> {
+    return Effect.suspend(() => {
+      const before = this.workers.get(workerId);
+      const entry = this.entries.get(workerId);
+      if (
+        !before ||
+        before.status !== "running" ||
+        !entry ||
+        entry.generation !== generation ||
+        entry.session !== session
+      ) {
+        return Effect.void;
+      }
 
-    let outcome: WorkerOutcome;
-    try {
-      outcome = await session.prompt(instructions);
-    } catch (error) {
-      outcome = { status: "failed", message: describeError(error, "Worker prompt failed") };
-    }
-    this.settleOutcome(workerId, generation, session, outcome);
+      let prompt: Promise<WorkerOutcome>;
+      try {
+        prompt = session.prompt(instructions);
+      } catch (error) {
+        this.settleOutcome(workerId, generation, session, {
+          status: "failed",
+          message: describeError(error, "Worker prompt failed"),
+        });
+        return Effect.void;
+      }
+      this.trackCleanup(prompt.then(() => undefined, () => undefined));
+
+      return Effect.tryPromise({
+        try: () => prompt,
+        catch: (error) => error,
+      }).pipe(
+        Effect.match({
+          onFailure: (error): WorkerOutcome => ({
+            status: "failed",
+            message: describeError(error, "Worker prompt failed"),
+          }),
+          onSuccess: (outcome) => outcome,
+        }),
+        Effect.tap((outcome) => Effect.sync(() => {
+          this.settleOutcome(workerId, generation, session, outcome);
+        })),
+        Effect.asVoid,
+      );
+    });
   }
 
   private settleCreationFailure(
@@ -606,7 +751,7 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     this.settleTerminalWorker(current, "failed", {
       status: "failed",
       message: describeError(error, "Worker session creation failed"),
-    });
+    }, "startup");
   }
 
   private settleWorkflowDefect(
@@ -626,7 +771,7 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     this.settleTerminalWorker(current, "failed", {
       status: "failed",
       message: describeError(error, "Worker workflow failed"),
-    });
+    }, "workflow");
   }
 
   private settleOutcome(
@@ -663,17 +808,27 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
       };
     }
 
+    const settledAt = this.clock();
     this.workers.set(workerId, {
       ...transitionWorkerStatus(current, status),
       activity: undefined,
       outcome: copyOutcome(settledOutcome),
+      settledAt,
     });
     if (status !== "ready") this.disposeEntrySession(entry);
     const affectedOwners = this.maybeCompleteWave(current.waveId);
+    affectedOwners.add(current.ownerSessionId);
+    this.emitSettlement(
+      workerId,
+      generation,
+      settledAt,
+      status === "failed" ? "prompt" : undefined,
+    );
     if (isTerminalWorkerStatus(status)) {
       addAll(affectedOwners, this.rememberTerminalWorker(workerId));
+    } else {
+      addAll(affectedOwners, this.pruneHistory());
     }
-    affectedOwners.add(current.ownerSessionId);
     this.emitStateForOwners(affectedOwners);
   }
 
@@ -681,18 +836,91 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     current: WorkerRecord,
     status: "failed" | "aborted",
     outcome: WorkerOutcome,
+    failureStage?: SettlementFailureStage,
   ): void {
+    const settledAt = this.clock();
     this.workers.set(current.id, {
       ...transitionWorkerStatus(current, status),
       activity: undefined,
       outcome: copyOutcome(outcome),
+      settledAt,
     });
     const affectedOwners = this.maybeCompleteWave(current.waveId);
-    addAll(affectedOwners, this.rememberTerminalWorker(current.id));
     affectedOwners.add(current.ownerSessionId);
+    const generation = this.entries.get(current.id)?.generation;
+    if (generation !== undefined) {
+      this.emitSettlement(current.id, generation, settledAt, failureStage);
+    }
+    addAll(affectedOwners, this.rememberTerminalWorker(current.id));
     this.emitStateForOwners(affectedOwners);
   }
 
+  private emitSettlement(
+    workerId: WorkerId,
+    generation: number,
+    settledAt: number,
+    failureStage?: SettlementFailureStage,
+  ): void {
+    const worker = this.workers.get(workerId);
+    const wave = worker ? this.waves.get(worker.waveId) : undefined;
+    if (!worker || !wave || !worker.outcome || !isWorkerCompleteForWave(worker.status)) return;
+    if (worker.status === "closed") return;
+
+    let remainingActive = 0;
+    let waveComplete = true;
+    for (const waveWorkerId of wave.workerIds) {
+      const waveWorker = this.workers.get(waveWorkerId);
+      if (!waveWorker || waveWorker.waveId !== wave.id || !isWorkerCompleteForWave(waveWorker.status)) {
+        waveComplete = false;
+        if (waveWorker && isActiveWorkerStatus(waveWorker.status)) remainingActive += 1;
+      }
+    }
+
+    const sequence = ++this.settlementSequence;
+    const settlement: WorkerSettlement = Object.freeze({
+      eventId: `${sequence}:${wave.id}:${workerId}:${generation}`,
+      sequence,
+      ownerSessionId: worker.ownerSessionId,
+      waveId: wave.id,
+      workerId,
+      generation,
+      mode: wave.mode,
+      worker: worker.worker,
+      title: worker.title,
+      lifecycle: worker.lifecycle,
+      status: worker.status,
+      outcome: Object.freeze(copyOutcome(worker.outcome)),
+      ...(failureStage ? { failureStage } : {}),
+      usage: Object.freeze(copyUsage(worker.usage)),
+      startedAt: worker.startedAt,
+      settledAt,
+      remainingActive,
+      waveSize: wave.workerIds.length,
+      waveComplete,
+      sessionFile: worker.sessionFile,
+    });
+
+    const localListener = this.waveSettlementListeners.get(wave.id);
+    if (waveComplete) this.waveSettlementListeners.delete(wave.id);
+    notifySettlementListener(localListener, settlement);
+    for (const listener of [...this.settlementListeners]) {
+      notifySettlementListener(listener, settlement);
+    }
+    if (waveComplete) this.emitCompletedWave(wave.id);
+  }
+
+  private emitCompletedWave(waveId: WaveId): void {
+    const completed = this.completedWaves.get(waveId);
+    if (!completed || completed.mode !== "async") return;
+    for (const listener of [...this.completionListeners]) {
+      try {
+        listener(completed);
+      } catch {
+        // One subscriber cannot prevent other subscribers from receiving completion.
+      }
+    }
+  }
+
   private maybeCompleteWave(waveId: WaveId): Set<string> {
     const affectedOwners = new Set<string>();
     if (this.completedWaves.has(waveId)) return affectedOwners;
@@ -719,17 +947,6 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     this.waveWaiters.get(waveId)?.resolve(completed);
     this.waveWaiters.delete(waveId);
 
-    if (wave.mode === "async") {
-      for (const listener of [...this.completionListeners]) {
-        try {
-          listener(completed);
-        } catch {
-          // One subscriber cannot prevent other subscribers from receiving completion.
-        }
-      }
-    }
-
-    addAll(affectedOwners, this.pruneHistory());
     return affectedOwners;
   }
 
@@ -884,7 +1101,12 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
       if (entry) this.disposeEntrySession(entry);
       const current = this.workers.get(workerId);
       if (current?.status === "stopping") {
-        this.settleTerminalWorker(current, "aborted", { status: "aborted" });
+        this.settleTerminalWorker(
+          current,
+          "aborted",
+          { status: "aborted" },
+          "cancellation",
+        );
       }
     }
   }
@@ -897,7 +1119,7 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     this.settleTerminalWorker(current, "failed", {
       status: "failed",
       message: describeError(error, "Worker cancellation failed"),
-    });
+    }, "cancellation");
   }
 
   private async cancelExactWave(wave: WaveRecord): Promise<void> {
@@ -952,6 +1174,7 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
       ...transitionWorkerStatus(current, "closed"),
       activity: undefined,
       outcome: { status: "closed" },
+      settledAt: this.clock(),
     });
     const affectedOwners = this.maybeCompleteWave(current.waveId);
     addAll(affectedOwners, this.rememberTerminalWorker(current.id));
@@ -986,6 +1209,14 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
       this.workers.set(workerId, { ...latest, activity });
       this.emitState(latest.ownerSessionId);
     });
+    entry.unsubscribeMessageDirection = session.subscribeMessageDirection((messageDirection) => {
+      const latest = this.workers.get(workerId);
+      if (!latest || entry.session !== session || entry.generation !== generation) return;
+      if (latest.status !== "starting" && latest.status !== "running") return;
+      if (latest.messageDirection === messageDirection) return;
+      this.workers.set(workerId, { ...latest, messageDirection });
+      this.emitState(latest.ownerSessionId);
+    });
   }
 
   private emitState(ownerSessionId: string): void {
@@ -1015,6 +1246,8 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     entry.unsubscribeUsage = undefined;
     safelyCall(entry.unsubscribeActivity);
     entry.unsubscribeActivity = undefined;
+    safelyCall(entry.unsubscribeMessageDirection);
+    entry.unsubscribeMessageDirection = undefined;
   }
 
   private disposeEntrySession(entry: RuntimeEntry): void {
@@ -1026,7 +1259,12 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
   private disposeSession(session: WorkerSessionHandle): void {
     if (this.disposedSessions.has(session)) return;
     this.disposedSessions.add(session);
-    safelyCall(() => session.dispose());
+
+    try {
+      this.trackCleanup(session.dispose());
+    } catch {
+      // Cleanup is best-effort and cannot leave lifecycle state unsettled.
+    }
   }
 
   private trackCleanup(operation: Promise<void>): Promise<void> {
@@ -1114,6 +1352,18 @@ function addAll(target: Set<string>, source: ReadonlySet<string>): void {
   for (const value of source) target.add(value);
 }
 
+function notifySettlementListener(
+  listener: SettlementListener | undefined,
+  settlement: WorkerSettlement,
+): void {
+  if (!listener) return;
+  try {
+    listener(settlement);
+  } catch {
+    // One observer cannot prevent settlement or other observers from being notified.
+  }
+}
+
 function makeWaveWaiter(): WaveWaiter {
   let complete!: (wave: CompletedWave) => void;
   const waiter: WaveWaiter = {