@zachwill/pi-orchestrate 0.1.1 → 0.2.0

package/extension/presentation.ts

@@ -14,6 +14,7 @@ import {
   visibleWidth,
   type Component,
 } from "@earendil-works/pi-tui";
+import { Result, Schema } from "effect";
 import type { WorkerDeliveryDetails } from "./delivery.js";
 import type { WorkerOutcome, WorkerRecord, WorkerStatus, WorkerUsage } from "./domain.js";
 import type { OrchestratorRuntime, RuntimeSnapshot } from "./runtime.js";
@@ -22,33 +23,97 @@ export const ORCHESTRATION_PRESENTATION_KEY = "pi-orchestrate";
 export const MAX_RESULT_PREVIEW_LINES = 6;
 export const MAX_WIDGET_WORKERS = 8;
 
-const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
+const WORKER_ANIMATIONS = {
+  starting: {
+    frames: ["⠂", "⠌", "⡑", "⢕", "⣫", "⣿", "⣫", "⢕"],
+    color: "muted",
+  },
+  running: {
+    frames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+    color: "accent",
+  },
+  stopping: {
+    frames: ["⣿", "⣶", "⣤", "⣀", "⠠", "⠐", "⠈", "⠁"],
+    color: "dim",
+  },
+} as const;
+const ANIMATION_CYCLE_TICKS = 40;
 const SPINNER_INTERVAL_MS = 140;
 const ACTIVE_STATUSES: ReadonlySet<WorkerStatus> = new Set(["starting", "running", "stopping"]);
 
 export type PresentationRuntime = Pick<OrchestratorRuntime, "snapshot" | "subscribeState">;
 
-interface SafeSettlement {
-  eventId?: string;
-  sequence?: number;
-  ownerSessionId: string;
-  waveId: string;
-  workerId: string;
-  generation: number;
-  mode: "async" | "inline";
-  worker: string;
-  title: string;
-  lifecycle: "one-shot" | "reusable";
-  status: "completed" | "ready" | "failed" | "aborted";
-  outcome: Exclude<WorkerOutcome, { status: "closed" }>;
-  usage: Partial<WorkerUsage>;
-  startedAt?: number;
-  settledAt?: number;
-  remainingActive?: number;
-  waveComplete?: boolean;
-  sessionFile?: string;
-  failureStage?: "startup" | "prompt" | "workflow" | "cancellation";
-}
+const NonnegativeFinite = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0));
+const NonnegativeInteger = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+const legacyOptionalKey = <S extends Schema.Constraint>(schema: S) =>
+  Schema.optionalKey(Schema.UndefinedOr(schema));
+
+const WorkerUsageSchema = Schema.Struct({
+  input: NonnegativeFinite,
+  output: NonnegativeFinite,
+  cacheRead: NonnegativeFinite,
+  cacheWrite: NonnegativeFinite,
+  cost: NonnegativeFinite,
+  contextTokens: NonnegativeFinite,
+  turns: NonnegativeInteger,
+});
+
+const WorkerCompletedOutcomeSchema = Schema.Struct({
+  status: Schema.Literal("completed"),
+  assistantText: Schema.String,
+});
+const WorkerReadyOutcomeSchema = Schema.Struct({
+  status: Schema.Literal("ready"),
+  assistantText: Schema.String,
+});
+const WorkerFailedOutcomeSchema = Schema.Struct({
+  status: Schema.Literal("failed"),
+  message: Schema.String,
+  assistantText: legacyOptionalKey(Schema.String),
+});
+const WorkerAbortedOutcomeSchema = Schema.Struct({
+  status: Schema.Literal("aborted"),
+  message: legacyOptionalKey(Schema.String),
+  assistantText: legacyOptionalKey(Schema.String),
+});
+const WorkerOutcomeSchema = Schema.Union([
+  WorkerCompletedOutcomeSchema,
+  WorkerReadyOutcomeSchema,
+  WorkerFailedOutcomeSchema,
+  WorkerAbortedOutcomeSchema,
+]);
+
+const SettlementPayloadSchema = Schema.Struct({
+  eventId: legacyOptionalKey(Schema.String),
+  sequence: legacyOptionalKey(NonnegativeInteger),
+  ownerSessionId: Schema.String,
+  waveId: Schema.String,
+  workerId: Schema.String,
+  generation: NonnegativeInteger,
+  mode: Schema.Literals(["async", "inline"]),
+  worker: Schema.String,
+  title: Schema.String,
+  lifecycle: Schema.Literals(["one-shot", "reusable"]),
+  status: Schema.Literals(["completed", "ready", "failed", "aborted"]),
+  outcome: WorkerOutcomeSchema,
+  usage: WorkerUsageSchema,
+  startedAt: NonnegativeInteger,
+  settledAt: NonnegativeInteger,
+  remainingActive: legacyOptionalKey(NonnegativeInteger),
+  waveComplete: legacyOptionalKey(Schema.Boolean),
+  sessionFile: legacyOptionalKey(Schema.String),
+  failureStage: legacyOptionalKey(Schema.Literals(["startup", "prompt", "workflow", "cancellation"])),
+}).check(Schema.makeFilter((settlement) => {
+  if (settlement.outcome.status !== settlement.status) return "outcome status must match settlement status";
+  if (settlement.settledAt < settlement.startedAt) return "settlement timestamp must not precede start timestamp";
+  if (settlement.failureStage !== undefined && settlement.status !== "failed" && settlement.status !== "aborted") {
+    return "failure stage requires a failed or aborted settlement";
+  }
+}));
+
+const SettlementEnvelopeSchema = Schema.Struct({ settlement: SettlementPayloadSchema });
+const decodeSettlementEnvelope = Schema.decodeUnknownResult(SettlementEnvelopeSchema);
+type SafeSettlement = Schema.Schema.Type<typeof SettlementPayloadSchema>;
 
 interface StatusBinding {
   readonly ownerSessionId: string;
@@ -96,7 +161,7 @@ export function formatWorkerUsage(usage: Partial<WorkerUsage> | undefined): stri
 }
 
 export function formatWorkerStatusLine(worker: WorkerRecord): string {
-  return `${worker.worker} → ${worker.title} · ${workerStateLabel(worker)} · ${compactLiveUsage(worker.usage)}`;
+  return `${worker.worker} → ${worker.title} · ${workerStateLabel(worker)} · ${formatTurnMarker(worker)} · ${formatCompactNumber(numberOrZero(worker.usage?.contextTokens))} ctx`;
 }
 
 export function formatFooterStatus(snapshot: RuntimeSnapshot): string | undefined {
@@ -229,7 +294,7 @@ export class WorkerStatusComponent implements Component {
   private startTimer(): void {
     if (this.timer || activeWorkers(this.snapshot).length === 0) return;
     this.timer = setInterval(() => {
-      this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
+      this.frameIndex = (this.frameIndex + 1) % ANIMATION_CYCLE_TICKS;
       this.tui?.requestRender();
     }, SPINNER_INTERVAL_MS);
     const timer = this.timer;
@@ -243,13 +308,19 @@ export class WorkerStatusComponent implements Component {
   }
 
   private workerLine(worker: WorkerRecord, width: number): string {
-    const glyph = this.theme.fg("warning", SPINNER_FRAMES[this.frameIndex] ?? SPINNER_FRAMES[0]);
-    const turns = `${numberOrZero(worker.usage?.turns)}t`;
-    const context = `${formatCompactNumber(numberOrZero(worker.usage?.contextTokens))} ctx`;
+    const animation = worker.status === "starting"
+      ? WORKER_ANIMATIONS.starting
+      : worker.status === "stopping"
+        ? WORKER_ANIMATIONS.stopping
+        : WORKER_ANIMATIONS.running;
+    const glyph = this.theme.fg(
+      animation.color,
+      animation.frames[this.frameIndex % animation.frames.length] ?? animation.frames[0],
+    );
+    const turns = formatTurnMarker(worker);
+    const context = `${formatContextTokens(numberOrZero(worker.usage?.contextTokens))} ctx`;
     const suffixFields = width >= 28 ? [turns, context] : width >= 12 ? [turns] : [];
-    const activity = workerStateLabel(worker);
     const requiredWidth = (fields: readonly string[]) => visibleWidth(`⠋  · ${fields.join(" · ")}`) + 10;
-    if (width >= 42 && requiredWidth([activity, ...suffixFields]) <= width) suffixFields.unshift(activity);
     const showWorker = width >= 72 && requiredWidth([worker.worker, ...suffixFields]) <= width;
     const prefix = showWorker ? `${glyph} ${this.theme.fg("muted", worker.worker)} → ` : `${glyph} `;
     const suffix = suffixFields.length ? ` · ${suffixFields.join(" · ")}` : "";
@@ -308,9 +379,19 @@ export class WorkerResultComponent implements Component {
         ? " · could not start"
         : "";
     const header = `${statusIcon(details)} ${details.worker} · ${details.title}${status}${elapsed ? ` · ${elapsed}` : ""}`;
+    const outcome = presentedOutcome(details);
     box.addChild(new Text(this.theme.fg(color, this.theme.bold(header)), 0, 0));
     box.addChild(new Spacer(1));
-    box.addChild(new WidthBoundComponent(new Markdown(outcomeText(details.outcome), 0, 0, getMarkdownTheme()), this.expanded ? undefined : MAX_RESULT_PREVIEW_LINES));
+    if (outcome.heading) {
+      box.addChild(new Text(this.theme.fg("success", this.theme.bold(outcome.heading)), 0, 0));
+      if (outcome.body) box.addChild(new Spacer(1));
+    }
+    if (outcome.body) {
+      box.addChild(new WidthBoundComponent(
+        new Markdown(outcome.body, 0, 0, getMarkdownTheme()),
+        this.expanded ? undefined : MAX_RESULT_PREVIEW_LINES,
+      ));
+    }
     if (!this.expanded) {
       box.addChild(new Spacer(1));
       box.addChild(new Text(this.theme.fg("dim", keyHint("app.tools.expand", "to expand")), 0, 0));
@@ -324,80 +405,11 @@ export class WorkerResultComponent implements Component {
 }
 
 function readSettlement(value: unknown): SafeSettlement | undefined {
-  const candidate = isRecord(value) && isRecord(value.settlement) ? value.settlement : value;
-  if (!isRecord(candidate)) return undefined;
-  const mode = enumField(candidate.mode, ["async", "inline"]);
-  const lifecycle = enumField(candidate.lifecycle, ["one-shot", "reusable"]);
-  const status = enumField(candidate.status, ["completed", "ready", "failed", "aborted"]);
-  const outcome = readOutcome(candidate.outcome);
-  const usage = readUsage(candidate.usage);
-  const generation = nonnegativeInteger(candidate.generation);
-  if (!mode || !lifecycle || !status || !outcome || outcome.status !== status || !usage || generation === undefined) return undefined;
-  const ownerSessionId = requiredString(candidate.ownerSessionId);
-  const waveId = requiredString(candidate.waveId);
-  const workerId = requiredString(candidate.workerId);
-  const worker = requiredString(candidate.worker);
-  const title = requiredString(candidate.title);
-  if (ownerSessionId === undefined || waveId === undefined || workerId === undefined || worker === undefined || title === undefined) return undefined;
-  const eventId = optionalString(candidate.eventId);
-  const sessionFile = optionalString(candidate.sessionFile);
-  const sequence = optionalInteger(candidate.sequence);
-  const startedAt = optionalInteger(candidate.startedAt);
-  const settledAt = optionalInteger(candidate.settledAt);
-  const remainingActive = optionalInteger(candidate.remainingActive);
-  const waveComplete = optionalBoolean(candidate.waveComplete);
-  const failureStage = optionalEnum(candidate.failureStage, ["startup", "prompt", "workflow", "cancellation"]);
-  if (eventId === INVALID || sessionFile === INVALID || sequence === INVALID || startedAt === INVALID || settledAt === INVALID ||
-      remainingActive === INVALID || waveComplete === INVALID || failureStage === INVALID) return undefined;
-  if (startedAt === undefined || settledAt === undefined || settledAt < startedAt) return undefined;
-  if (failureStage !== undefined && status !== "failed" && status !== "aborted") return undefined;
-  return {
-    ownerSessionId, waveId, workerId, generation, mode, worker, title, lifecycle, status, outcome, usage,
-    ...(eventId === undefined ? {} : { eventId }),
-    ...(sequence === undefined ? {} : { sequence }),
-    ...(startedAt === undefined ? {} : { startedAt }),
-    ...(settledAt === undefined ? {} : { settledAt }),
-    ...(remainingActive === undefined ? {} : { remainingActive }),
-    ...(waveComplete === undefined ? {} : { waveComplete }),
-    ...(sessionFile === undefined ? {} : { sessionFile }),
-    ...(failureStage === undefined ? {} : { failureStage }),
-  };
+  const envelope = isRecord(value) && isRecord(value.settlement) ? value : { settlement: value };
+  const decoded = decodeSettlementEnvelope(envelope);
+  return Result.isSuccess(decoded) ? decoded.success.settlement : undefined;
 }
 
-function readOutcome(value: unknown): WorkerOutcome | undefined {
-  if (!isRecord(value) || typeof value.status !== "string") return undefined;
-  if ((value.status === "completed" || value.status === "ready") && typeof value.assistantText === "string") return { status: value.status, assistantText: value.assistantText };
-  const message = optionalString(value.message);
-  const assistantText = optionalString(value.assistantText);
-  if (message === INVALID || assistantText === INVALID) return undefined;
-  if (value.status === "failed" && message !== undefined) return { status: "failed", message, ...(assistantText === undefined ? {} : { assistantText }) };
-  if (value.status === "aborted") return { status: "aborted", ...(message === undefined ? {} : { message }), ...(assistantText === undefined ? {} : { assistantText }) };
-  return undefined;
-}
-
-const INVALID = Symbol("invalid");
-type Invalid = typeof INVALID;
-function requiredString(value: unknown): string | undefined { return typeof value === "string" ? value : undefined; }
-function optionalString(value: unknown): string | undefined | Invalid { return value === undefined ? undefined : typeof value === "string" ? value : INVALID; }
-function nonnegativeInteger(value: unknown): number | undefined { return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0 ? value : undefined; }
-function optionalInteger(value: unknown): number | undefined | Invalid { return value === undefined ? undefined : nonnegativeInteger(value) ?? INVALID; }
-function optionalBoolean(value: unknown): boolean | undefined | Invalid { return value === undefined ? undefined : typeof value === "boolean" ? value : INVALID; }
-function enumField<const T extends string>(value: unknown, values: readonly T[]): T | undefined { return typeof value === "string" && values.includes(value as T) ? value as T : undefined; }
-function optionalEnum<const T extends string>(value: unknown, values: readonly T[]): T | undefined | Invalid { return value === undefined ? undefined : enumField(value, values) ?? INVALID; }
-function readUsage(value: unknown): WorkerUsage | undefined {
-  if (!isRecord(value)) return undefined;
-  const input = nonnegativeNumber(value.input);
-  const output = nonnegativeNumber(value.output);
-  const cacheRead = nonnegativeNumber(value.cacheRead);
-  const cacheWrite = nonnegativeNumber(value.cacheWrite);
-  const cost = nonnegativeNumber(value.cost);
-  const contextTokens = nonnegativeNumber(value.contextTokens);
-  const turns = nonnegativeInteger(value.turns);
-  if (input === undefined || output === undefined || cacheRead === undefined || cacheWrite === undefined || cost === undefined || contextTokens === undefined || turns === undefined) return undefined;
-  return { input, output, cacheRead, cacheWrite, cost, contextTokens, turns };
-}
-function nonnegativeNumber(value: unknown): number | undefined { return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined; }
-
 function statusHeading(result: SafeSettlement): string {
   if (result.status === "failed") return result.failureStage === "startup" ? "could not start" : "failed";
   if (result.status === "aborted") return "aborted";
@@ -418,6 +430,24 @@ function outcomeText(outcome: WorkerOutcome): string {
   return "Worker session closed.";
 }
 
+function presentedOutcome(result: SafeSettlement): { heading?: string; body: string } {
+  const body = outcomeText(result.outcome);
+  if (result.status !== "completed" && result.status !== "ready") return { body };
+
+  const lines = body.split("\n");
+  const headingIndex = lines.findIndex((line) => line.trim() !== "");
+  if (headingIndex < 0 || !/^#{1,6}\s+(?:completed|complete|done)\s*#*\s*$/i.test(lines[headingIndex]!)) {
+    return { body };
+  }
+
+  lines.splice(headingIndex, 1);
+  while (lines[headingIndex]?.trim() === "") lines.splice(headingIndex, 1);
+  return {
+    heading: result.status === "ready" ? "✓ Response complete" : "✓ Completed",
+    body: lines.join("\n").trimEnd(),
+  };
+}
+
 function settlementMetadata(result: SafeSettlement): string[] {
   return [
     `worker ID ${result.workerId} · wave ID ${result.waveId}`,
@@ -446,8 +476,9 @@ function workerStateLabel(worker: Pick<WorkerRecord, "status" | "activity">): st
   return TOOL_ACTIVITY[worker.activity] ?? worker.activity;
 }
 
-function compactLiveUsage(usage: Partial<WorkerUsage> | undefined): string {
-  return `${numberOrZero(usage?.turns)}t · ${formatCompactNumber(numberOrZero(usage?.contextTokens))} ctx`;
+function formatTurnMarker(worker: Pick<WorkerRecord, "messageDirection" | "usage">): string {
+  const direction = worker.messageDirection === "from-model" ? "↓" : "↑";
+  return `${numberOrZero(worker.usage?.turns)}${direction}`;
 }
 function elapsedBetween(start?: number, end?: number): string | undefined {
   return start !== undefined && end !== undefined && end >= start ? formatElapsed(end - start) : undefined;
@@ -462,6 +493,10 @@ function firstNonEmptyLines(text: string, limit: number): string[] {
   return text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(0, limit);
 }
 function numberOrZero(value: unknown): number { return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0; }
+function formatContextTokens(value: number): string {
+  if (value < 1_000) return String(Math.round(value));
+  return `${Math.round(value / 1_000)}k`;
+}
 function formatCompactNumber(value: number): string {
   if (value >= 1_000_000) return `${trimDecimal(value / 1_000_000)}m`;
   if (value >= 1_000) return `${trimDecimal(value / 1_000)}k`;

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,
@@ -201,6 +202,7 @@ interface RuntimeEntry {
   session?: WorkerSessionHandle;
   unsubscribeUsage?: () => void;
   unsubscribeActivity?: () => void;
+  unsubscribeMessageDirection?: () => void;
 }
 
 interface WaveWaiter {
@@ -212,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);
-    });
   },
 };
 
@@ -316,6 +317,7 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
         lifecycle: definition.lifecycle,
         status: "starting",
         usage: copyUsage(EMPTY_WORKER_USAGE),
+        messageDirection: "to-model",
         startedAt: this.clock(),
       };
     });
@@ -396,11 +398,12 @@ 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,
     };
@@ -558,7 +561,7 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     try {
       this.scheduler.start(
         workerId,
-        () => this.trackCleanup(this.bootstrapAndPrompt(workerId, generation)),
+        this.bootstrapAndPrompt(workerId, generation),
         (error) => this.settleWorkflowDefect(workerId, generation, error),
       );
     } catch (error) {
@@ -575,7 +578,7 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     try {
       this.scheduler.start(
         workerId,
-        () => this.trackCleanup(this.executePrompt(workerId, generation, session, instructions)),
+        this.executePrompt(workerId, generation, session, instructions),
         (error) => this.settleWorkflowDefect(workerId, generation, error),
       );
     } catch (error) {
@@ -583,44 +586,90 @@ class DefaultOrchestratorRuntime implements OrchestratorRuntime {
     }
   }
 
-  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;
     }
@@ -641,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(
@@ -1137,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 {
@@ -1166,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 {
@@ -1177,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> {