@fitchmultz/pi-subagents 0.44.7 → 0.45.0

package/src/runs/foreground/wait-observation.ts

@@ -0,0 +1,160 @@
+import * as path from "node:path";
+import { ownedRunStatusResult, ownedRunView, resolveOwnedRun } from "../shared/run-records.ts";
+import {
+  getRunMetadataDir,
+  listOwnedRunQuestions,
+  questionProcessAlive,
+  readRunJson,
+} from "../shared/supervisor-questions.ts";
+import { getSingleResultOutput, readStatus } from "../../shared/utils.ts";
+import { isRecord } from "../../shared/unknown.ts";
+import type {
+  OwnedRun,
+  OwnedRunView,
+  ReadonlySubagentState,
+  SubagentExecutionResult,
+  SupervisorQuestionView,
+} from "../../shared/types.ts";
+import { resolveSubagentRunId } from "../background/run-id-resolver.ts";
+import { resolveNestedAsyncDir } from "../shared/nested-events.ts";
+import { nestedResolutionScopeForExecutor } from "./execution-routing.ts";
+import type { ExecutorReadDeps } from "./subagent-params.ts";
+
+/** Small projections deliberately consume unknown JSON, not asserted persisted contracts. */
+export function savedRunString(runId: string, file: string, field: string): string | undefined {
+  const saved = readRunJson(path.join(getRunMetadataDir(runId), file));
+  return isRecord(saved) && typeof saved[field] === "string" ? saved[field] : undefined;
+}
+
+export function resolveWaitTarget(
+  id: string,
+  deps: ExecutorReadDeps,
+): { readonly run?: OwnedRun; readonly nested: boolean } {
+  const run = resolveOwnedRun(deps.state, id);
+  return run ? { run, nested: false } : resolveNestedWaitTarget(id, deps);
+}
+
+function resolveNestedWaitTarget(
+  id: string,
+  deps: ExecutorReadDeps,
+): { readonly run?: OwnedRun; readonly nested: boolean } {
+  const resolved = resolveSubagentRunId(id, {
+    state: deps.state,
+    nested: nestedResolutionScopeForExecutor(deps),
+  });
+  if (resolved?.kind !== "nested") {
+    return { nested: false };
+  }
+  const asyncDir = resolveNestedAsyncDir(resolved.match.rootRunId, resolved.match.run);
+  const status = asyncDir === undefined ? null : readStatus(asyncDir);
+  if (status?.runId !== resolved.id) {
+    return { nested: false };
+  }
+  // Read only through the authorized route: never adopt or account a descendant here.
+  return {
+    nested: true,
+    run: {
+      runId: resolved.id,
+      rootRunId: resolved.match.rootRunId,
+      ownerSessionId:
+        savedRunString(resolved.id, "question-owner.json", "sessionId") ?? status.sessionId ?? "",
+      source: "async",
+      mode: status.mode,
+      cwd: status.cwd ?? "",
+      task: "Nested delegated run",
+      startedAt: status.startedAt,
+      asyncDir,
+      pid: status.pid,
+      children: (status.steps ?? []).map((step, childIndex) => ({
+        agent: step.agent,
+        index: childIndex,
+        sessionFile: step.sessionFile,
+      })),
+    },
+  };
+}
+
+type WaitChildren = OwnedRunView["children"];
+export interface WaitObservation {
+  readonly view: OwnedRunView;
+  readonly children: WaitChildren;
+  readonly questions: readonly SupervisorQuestionView[];
+}
+
+export function observeWait(
+  run: OwnedRun,
+  state: ReadonlySubagentState,
+  owner: string,
+  index?: number,
+): WaitObservation {
+  const runQuestions = listOwnedRunQuestions(run.ownerSessionId, run.runId);
+  // Exactly one fresh view per poll; transcripts and unrelated questions stay outside the hot path.
+  const view = ownedRunView(run, state, {
+    pendingInput: runQuestions.some(
+      (question) => question.state === "awaiting_input" || question.state === "answer_pending",
+    ),
+    readConfiguration: false,
+    includeContinuations: false,
+  });
+  return {
+    view,
+    children: view.children.filter((child) => index === undefined || child.index === index),
+    questions: runQuestions.filter(
+      (question) =>
+        question.ownerSessionId === owner &&
+        (index === undefined || question.index === index) &&
+        question.state === "awaiting_input",
+    ),
+  };
+}
+
+export function waitHasSavedResult(observation: WaitObservation, index?: number): boolean {
+  const { view, children } = observation;
+  return (
+    (index !== undefined || (view.resultPath !== undefined && view.resultPath.length > 0)) &&
+    children.every(
+      (child) => child.result !== undefined && child.state !== "live" && child.state !== "unknown",
+    ) &&
+    (index !== undefined || view.state !== "live")
+  );
+}
+
+export function waitProducerAlive(run: OwnedRun, children: WaitChildren): boolean {
+  const pid =
+    run.pid ??
+    (run.asyncDir !== undefined && run.asyncDir.length > 0
+      ? readStatus(run.asyncDir)?.pid
+      : undefined);
+  return pid !== undefined && pid !== 0
+    ? questionProcessAlive({ pid })
+    : children.some((child) => child.state === "live");
+}
+
+function childSavedOutput(child: WaitChildren[number]): string {
+  const output = child.result === undefined ? "" : getSingleResultOutput(child.result);
+  const text = output.length > 0 ? output : child.result?.error;
+  return `\n${child.agent}: ${child.state}\n${text !== undefined && text.length > 0 ? text : "(no output)"}`;
+}
+
+export function savedWaitResult(
+  run: OwnedRun,
+  state: ReadonlySubagentState,
+  observation: WaitObservation,
+  index?: number,
+): { readonly result: SubagentExecutionResult; readonly text: string } {
+  const { view, children } = observation;
+  const result = ownedRunStatusResult(run, state);
+  const isError =
+    children.some((child) => child.state === "failed") ||
+    (index === undefined && view.state === "failed") ||
+    undefined;
+  const selectedState = index === undefined ? view.state : children[0]?.state;
+  return {
+    result: { ...result, isError },
+    text: [
+      `Saved result for ${run.runId}${index !== undefined ? ` child ${index}` : ""}: ${selectedState}`,
+      ...children.map(childSavedOutput),
+      result.content.map((part) => (part.type === "text" ? part.text : "")).join("\n"),
+    ].join("\n"),
+  };
+}

package/src/runs/foreground/wait-registration.ts

@@ -0,0 +1,18 @@
+import type { SubagentState } from "../../shared/types.ts";
+
+/** Own the waiter count; release the captured map even if session state is replaced. */
+export function acquireRunWait(state: SubagentState, runId: string): () => void {
+  if (state.waitingRuns === undefined) {
+    state.waitingRuns = new Map<string, number>();
+  }
+  const waiting = state.waitingRuns;
+  waiting.set(runId, (waiting.get(runId) ?? 0) + 1);
+  return () => {
+    const remaining = (waiting.get(runId) ?? 1) - 1;
+    if (remaining !== 0) {
+      waiting.set(runId, remaining);
+    } else {
+      waiting.delete(runId);
+    }
+  };
+}

package/src/runs/foreground/wait-run.ts

@@ -1,124 +1,366 @@
-import * as path from "node:path";
-import { writeAsyncControlRequest } from "../background/async-control.ts";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { ownedRunExecutionResult, ownedRunProgressResult, ownedRunStatusResult, ownedRunView, resolveOwnedRun } from "../shared/run-records.ts";
-import { formatSupervisorQuestions, getRunMetadataDir, listOwnedRunQuestions, questionProcessAlive, readRunJson, supervisorQuestionPage } from "../shared/supervisor-questions.ts";
+import { watch, type FSWatcher } from "node:fs";
+import { writeAsyncControlRequest } from "../background/async-control.ts";
+import {
+  ownedRunExecutionResult,
+  ownedRunProgressResult,
+  ownedRunStatusResult,
+} from "../shared/run-records.ts";
+import {
+  INTERCOM_DETACH_REQUEST_EVENT,
+  INTERCOM_DETACH_RESPONSE_EVENT,
+  POLL_INTERVAL_MS,
+  type SubagentExecutionUpdateCallback,
+  type OwnedRun,
+  type SubagentExecutionResult,
+} from "../../shared/types.ts";
+import { errorMessage, isRecord } from "../../shared/unknown.ts";
 import { formatRunAction } from "../../shared/status-format.ts";
-import { getSingleResultOutput, readStatus } from "../../shared/utils.ts";
-import { INTERCOM_DETACH_REQUEST_EVENT, INTERCOM_DETACH_RESPONSE_EVENT, POLL_INTERVAL_MS, type OwnedRun, type SubagentExecutionResult } from "../../shared/types.ts";
-import { resolveSubagentRunId } from "../background/run-id-resolver.ts";
-import { resolveNestedAsyncDir } from "../shared/nested-events.ts";
-import { nestedResolutionScopeForExecutor } from "./foreground-control.ts";
+import {
+  formatSupervisorQuestions,
+  supervisorQuestionPage,
+} from "../shared/supervisor-questions.ts";
+import { nestedResolutionScopeForExecutor } from "./execution-routing.ts";
 import type { ExecutorDeps } from "./subagent-params.ts";
+import { acquireRunWait } from "./wait-registration.ts";
+import {
+  observeWait,
+  resolveWaitTarget,
+  savedRunString,
+  savedWaitResult,
+  waitHasSavedResult,
+  waitProducerAlive,
+  type WaitObservation,
+} from "./wait-observation.ts";
+
+interface WaitInput {
+  readonly id: string;
+  readonly index?: number;
+  readonly deps: Readonly<ExecutorDeps>;
+  readonly ctx: ExtensionContext;
+  readonly signal?: AbortSignal;
+  readonly onUpdate?: SubagentExecutionUpdateCallback;
+  readonly cancelNewRun?: boolean;
+  readonly executionResult?: boolean;
+  readonly includeProgress?: boolean;
+}
+type WaitStatus = "completed" | "cancelled" | "yielded" | "awaiting_input" | "unavailable";
+interface WaitOutcome {
+  readonly status: WaitStatus;
+  readonly text: string;
+  readonly result?: SubagentExecutionResult;
+}
+
+function unavailableWait(text: string): SubagentExecutionResult {
+  return {
+    content: [{ type: "text", text }],
+    isError: true,
+    details: { mode: "management", results: [] },
+  };
+}
+
+/** Wait on the saved outcome, not the notification file or an early terminal status. */
+export async function waitForOwnedRun(input: WaitInput): Promise<SubagentExecutionResult> {
+  try {
+    const owner = input.ctx.sessionManager.getSessionId();
+    const session = input.deps.state.currentSessionId;
+    const { run, nested } = resolveWaitTarget(input.id, input.deps);
+    if (!run || (!nested && run.ownerSessionId !== owner)) {
+      return unavailableWait(
+        "Run is not available to wait on in this session. This wait did not start or stop work.",
+      );
+    }
+    return await new RunWait(input, run, owner, session).start();
+  } catch (error) {
+    return unavailableWait(errorMessage(error));
+  }
+}
+
+/** Own one foreground wait, its live timer, listener, cancellation and exactly-once release. */
+class RunWait {
+  private finished = false;
+  private timer: ReturnType<typeof setInterval> | undefined;
+  private watcher: FSWatcher | undefined;
+  private unsubscribe: (() => void) | undefined;
+  private readonly pending = Promise.withResolvers<SubagentExecutionResult>();
+  private previous = "";
+  private readonly release: () => void;
+  private readonly session: string | null;
+
+  private readonly input: WaitInput;
+  private readonly target: OwnedRun;
+  private readonly owner: string;
+
+  constructor(input: WaitInput, target: OwnedRun, owner: string, session: string | null) {
+    this.input = input;
+    this.target = target;
+    this.owner = owner;
+    this.session = session;
+    this.release = acquireRunWait(input.deps.state, target.runId);
+  }
+
+  start(): Promise<SubagentExecutionResult> {
+    try {
+      this.unsubscribe = this.input.deps.pi.events.on(INTERCOM_DETACH_REQUEST_EVENT, this.detach);
+      this.input.signal?.addEventListener("abort", this.abort, { once: true });
+      if (this.input.signal?.aborted === true) {
+        this.abort();
+      } else {
+        this.watchPublications();
+        this.check();
+      }
+      // Unlike passive background tracking, this call owes a result. Keep the
+      // process alive until finish() releases its timer; detached children cannot.
+      if (!this.finished) {
+        this.timer = setInterval(this.check, POLL_INTERVAL_MS);
+      }
+    } catch (error) {
+      this.finish({ status: "unavailable", text: errorMessage(error) });
+    }
+    return this.pending.promise;
+  }
+
+  private watchPublications(): void {
+    const { asyncDir } = this.target;
+    if (asyncDir === undefined || asyncDir.length === 0) {
+      return;
+    }
+    try {
+      this.watcher = watch(asyncDir, (_event, filename) => {
+        // Publication only wakes the authoritative observation; temporary
+        // files and event streams are not status or saved-result authority.
+        if (filename === null || filename === "status.json" || filename === "result.json") {
+          this.check();
+        }
+      });
+      this.watcher.on("error", this.watchFailed);
+    } catch {
+      this.watchFailed();
+    }
+  }
+
+  private closeWatch(): void {
+    const watcher = this.watcher;
+    this.watcher = undefined;
+    watcher?.close();
+  }
+
+  private readonly watchFailed = (): void => {
+    try {
+      this.closeWatch();
+    } catch {
+      // This optional wakeup failed; the original live polling owner remains.
+    }
+  };
+
+  private finish(outcome: WaitOutcome): void {
+    if (this.finished) {
+      return;
+    }
+    this.finished = true;
+    const cleanupError = this.cleanup();
+    try {
+      this.pending.resolve(
+        this.result(
+          cleanupError === undefined
+            ? outcome
+            : {
+                status: "unavailable",
+                text: `${outcome.text}\nWait cleanup failed: ${cleanupError}`,
+              },
+        ),
+      );
+    } catch (error) {
+      const result = unavailableWait(
+        `Wait could not read ${this.target.runId}: ${errorMessage(error)}`,
+      );
+      this.pending.resolve({
+        ...result,
+        details: {
+          ...result.details,
+          wait: { runId: this.target.runId, index: this.input.index, status: "unavailable" },
+        },
+      });
+    }
+  }
+
+  private cleanup(): string | undefined {
+    let failure: string | undefined;
+    for (const release of [
+      this.release,
+      () => {
+        if (this.timer !== undefined) {
+          clearInterval(this.timer);
+          this.timer = undefined;
+        }
+      },
+      () => {
+        this.unsubscribe?.();
+      },
+      () => {
+        this.input.signal?.removeEventListener("abort", this.abort);
+      },
+      () => {
+        this.closeWatch();
+      },
+    ]) {
+      try {
+        release();
+      } catch (error) {
+        failure ??= errorMessage(error);
+      }
+    }
+    return failure;
+  }
+
+  private result(outcome: WaitOutcome): SubagentExecutionResult {
+    const { status, text, result } = outcome;
+    const { index, deps, includeProgress } = this.input;
+    const completed = status === "completed";
+    const execution =
+      this.input.executionResult === true && completed
+        ? ownedRunExecutionResult(this.target, deps.state, index, includeProgress)
+        : undefined;
+    const completionId = completed
+      ? savedRunString(this.target.runId, "result.json", "completionId")
+      : undefined;
+    return {
+      ...result,
+      ...execution,
+      content: completed && execution ? execution.content : [{ type: "text", text }],
+      ...(status === "unavailable" || status === "cancelled" ? { isError: true } : {}),
+      details: {
+        mode: "management",
+        results: [],
+        ...result?.details,
+        ...execution?.details,
+        wait: { runId: this.target.runId, completionId, index, status },
+      },
+    };
+  }
+
+  private readonly abort = (): void => {
+    if (this.finished) {
+      return;
+    }
+    try {
+      if (
+        this.input.cancelNewRun === true &&
+        this.target.asyncDir !== undefined &&
+        this.target.asyncDir.length > 0
+      ) {
+        writeAsyncControlRequest(this.target.asyncDir, this.target.runId, "cancel");
+      }
+    } catch (error) {
+      this.finish({
+        status: "cancelled",
+        text: `Wait cancelled; cancellation request for newly launched run ${this.target.runId} could not be saved: ${errorMessage(error)}. Process exit is unconfirmed.`,
+      });
+      return;
+    }
+    this.finish({
+      status: "cancelled",
+      text:
+        this.input.cancelNewRun === true
+          ? `Wait cancelled; cancellation requested for newly launched run ${this.target.runId}. Process exit is not yet confirmed.`
+          : `Stopped waiting for ${this.target.runId}. The child was not stopped; completion will arrive automatically.`,
+    });
+  };
+
+  private readonly detach = (payload: unknown): void => {
+    if (this.finished || !isRecord(payload) || typeof payload.requestId !== "string") {
+      return;
+    }
+    this.input.deps.pi.events.emit(INTERCOM_DETACH_RESPONSE_EVENT, {
+      requestId: payload.requestId,
+      accepted: true,
+    });
+    this.finish({
+      status: "yielded",
+      text: `Released the wait for an incoming Intercom message. Run ${this.target.runId} is unchanged. Continue useful work or end the turn; completion will arrive automatically.`,
+    });
+  };
+
+  private readonly check = (): void => {
+    if (this.finished) {
+      return;
+    }
+    const { deps, ctx, index } = this.input;
+    try {
+      if (
+        deps.state.currentSessionId !== this.session ||
+        ctx.sessionManager.getSessionId() !== this.owner
+      ) {
+        this.finish({
+          status: "unavailable",
+          text: "The owning session changed. This wait ended without stopping the child.",
+        });
+        return;
+      }
+      const observation = observeWait(this.target, deps.state, this.owner, index);
+      const outcome = this.observeOutcome(observation);
+      if (outcome) {
+        this.finish(outcome);
+      } else {
+        this.update(observation);
+      }
+    } catch (error) {
+      this.finish({
+        status: "unavailable",
+        text: `Wait could not read ${this.target.runId}: ${errorMessage(error)}`,
+      });
+    }
+  };
+
+  private observeOutcome(observation: WaitObservation): WaitOutcome | undefined {
+    const { deps, index } = this.input;
+    const { children, questions } = observation;
+    if (index !== undefined && children.length === 0) {
+      return {
+        status: "unavailable",
+        text: `Run ${this.target.runId} has no child at index ${index}.`,
+      };
+    }
+    if (questions.length > 0) {
+      const result = ownedRunStatusResult(this.target, deps.state);
+      const page = supervisorQuestionPage(questions);
+      const childSafe = nestedResolutionScopeForExecutor(deps) !== undefined;
+      return {
+        status: "awaiting_input",
+        text: `Run ${this.target.runId} needs input; waiting ended without stopping it.\n\n${formatSupervisorQuestions(page.questions, childSafe)}\n\nAll questions: ${formatRunAction("questions", this.target.runId, index === undefined ? {} : { index }, childSafe)}`,
+        result: { ...result, details: { ...result.details, ...page } },
+      };
+    }
+    if (waitHasSavedResult(observation, index)) {
+      return {
+        status: "completed",
+        ...savedWaitResult(this.target, deps.state, observation, index),
+      };
+    }
+    if (!waitProducerAlive(this.target, children)) {
+      return {
+        status: "unavailable",
+        text: `No saved final result is available for ${this.target.runId}; completion is unconfirmed. Inspect the saved session. No work was started.`,
+        result: ownedRunStatusResult(this.target, deps.state),
+      };
+    }
+    return undefined;
+  }
 
-/** Wait on the saved outcome, not the transient notification file or an early terminal status. */
-export async function waitForOwnedRun(input: {
-	id: string;
-	index?: number;
-	deps: ExecutorDeps;
-	ctx: ExtensionContext;
-	signal?: AbortSignal;
-	onUpdate?: (result: SubagentExecutionResult) => void;
-	cancelNewRun?: boolean;
-	executionResult?: boolean;
-	includeProgress?: boolean;
-}): Promise<SubagentExecutionResult> {
-	const { deps, id, index, ctx } = input;
-	const owner = ctx.sessionManager.getSessionId(), session = deps.state.currentSessionId;
-	let run: OwnedRun | undefined, nested = false;
-	try {
-		run = resolveOwnedRun(deps.state, id);
-		if (!run) {
-			const resolved = resolveSubagentRunId(id, { state: deps.state, nested: nestedResolutionScopeForExecutor(deps) });
-			if (resolved?.kind === "nested") {
-				const asyncDir = resolveNestedAsyncDir(resolved.match.rootRunId, resolved.match.run);
-				const status = asyncDir ? readStatus(asyncDir) : null;
-				if (status?.runId === resolved.id) {
-					const savedOwner = readRunJson<{ sessionId: string }>(path.join(getRunMetadataDir(resolved.id), "question-owner.json"));
-					// Read through the authorized route without adopting the descendant or attributing its usage to this caller.
-					run = { runId: resolved.id, rootRunId: resolved.match.rootRunId, ownerSessionId: savedOwner?.sessionId ?? status.sessionId ?? "",
-						source: "async", mode: status.mode, cwd: status.cwd ?? "", task: "Nested delegated run", startedAt: status.startedAt, asyncDir, pid: status.pid,
-						children: (status.steps ?? []).map((step, index) => ({ agent: step.agent, index, sessionFile: step.sessionFile })) };
-					nested = true;
-				}
-			}
-		}
-	} catch (error) {
-		return { content: [{ type: "text", text: String(error) }], isError: true, details: { mode: "management", results: [] } };
-	}
-	if (!run || (!nested && run.ownerSessionId !== owner)) return { content: [{ type: "text", text: "Run is not available to wait on in this session. This wait did not start or stop work." }], isError: true, details: { mode: "management", results: [] } };
-	const target = run;
-	const waiting = deps.state.waitingRuns ??= new Map();
-	waiting.set(target.runId, (waiting.get(target.runId) ?? 0) + 1);
-	return new Promise((resolve) => {
-		let finished = false, timer: ReturnType<typeof setInterval> | undefined, unsubscribe: (() => void) | undefined;
-		let previous = "";
-		const finish = (status: "completed" | "cancelled" | "yielded" | "awaiting_input" | "unavailable", text: string, result?: SubagentExecutionResult) => {
-			if (finished) return;
-			finished = true;
-			const remaining = (waiting.get(target.runId) ?? 1) - 1;
-			if (remaining) waiting.set(target.runId, remaining); else waiting.delete(target.runId);
-			if (timer) clearInterval(timer);
-			unsubscribe?.(); input.signal?.removeEventListener("abort", abort);
-			const execution = input.executionResult && status === "completed" ? ownedRunExecutionResult(target, deps.state, index, input.includeProgress) : undefined;
-			const saved = status === "completed" ? readRunJson<{ completionId?: string }>(path.join(getRunMetadataDir(target.runId), "result.json")) : undefined;
-			resolve({ ...result, ...execution, content: status === "completed" && execution ? execution.content : [{ type: "text", text }],
-				...(status === "unavailable" || status === "cancelled" ? { isError: true } : {}),
-				details: { mode: "management", results: [], ...result?.details, ...execution?.details, wait: { runId: target.runId, completionId: saved?.completionId, index, status } } });
-		};
-		const abort = () => {
-			if (input.cancelNewRun && target.asyncDir) {
-				writeAsyncControlRequest(target.asyncDir, target.runId, "cancel");
-			}
-			finish("cancelled", input.cancelNewRun ? `Wait cancelled; cancellation requested for newly launched run ${target.runId}. Process exit is not yet confirmed.` : `Stopped waiting for ${target.runId}. The child was not stopped; completion will arrive automatically.`);
-		};
-		const check = () => {
-			if (deps.state.currentSessionId !== session || ctx.sessionManager.getSessionId() !== owner) { finish("unavailable", "The owning session changed. This wait ended without stopping the child."); return; }
-			try {
-				const runQuestions = listOwnedRunQuestions(target.ownerSessionId, target.runId);
-				// Poll execution facts once. Native conversation configuration is only
-				// needed when returning an inspection, never for live progress.
-				const view = ownedRunView(target, deps.state, {
-					pendingInput: runQuestions.some((question) => question.state === "awaiting_input" || question.state === "answer_pending"),
-					readConfiguration: false, includeContinuations: false,
-				});
-				const children = view.children.filter((child) => index === undefined || child.index === index);
-				if (index !== undefined && !children.length) { finish("unavailable", `Run ${target.runId} has no child at index ${index}.`); return; }
-				const questions = runQuestions.filter((question) => question.ownerSessionId === owner && (index === undefined || question.index === index) && question.state === "awaiting_input");
-				if (questions.length) {
-					const result = ownedRunStatusResult(target, deps.state);
-					const page = supervisorQuestionPage(questions), childSafe = Boolean(nestedResolutionScopeForExecutor(deps));
-					Object.assign(result.details, page);
-					finish("awaiting_input", `Run ${target.runId} needs input; waiting ended without stopping it.\n\n${formatSupervisorQuestions(page.questions, childSafe)}\n\nAll questions: ${formatRunAction("questions", target.runId, index === undefined ? {} : { index }, childSafe)}`, result); return;
-				}
-				if ((index !== undefined || view.resultPath) && children.every((child) => child.result && child.state !== "live" && child.state !== "unknown") && (index !== undefined || view.state !== "live")) {
-					const result = ownedRunStatusResult(target, deps.state);
-					result.isError = children.some((child) => child.state === "failed") || (index === undefined && view.state === "failed") || undefined;
-					finish("completed", [`Saved result for ${target.runId}${index !== undefined ? ` child ${index}` : ""}: ${index !== undefined ? children[0]!.state : view.state}`, ...children.map((child) => `\n${child.agent}: ${child.state}\n${getSingleResultOutput(child.result!) || child.result?.error || "(no output)"}`), result.content.map((part) => part.type === "text" ? part.text : "").join("\n")].join("\n"), result);
-					return;
-				}
-				const pid = target.pid ?? (target.asyncDir ? readStatus(target.asyncDir)?.pid : undefined);
-				const producerAlive = pid ? questionProcessAlive({ pid }) : children.some((child) => child.state === "live");
-				if (!producerAlive) { finish("unavailable", `No saved final result is available for ${target.runId}; completion is unconfirmed. Inspect the saved session. No work was started.`, ownedRunStatusResult(target, deps.state)); return; }
-				const update = `Waiting for ${target.runId}${index !== undefined ? ` child ${index}` : ""}: ${children.map((child) => child.state).join(", ")}. ${input.cancelNewRun ? "Cancelling requests cancellation of this newly launched run; process exit still needs confirmation." : "Cancelling this wait leaves existing work alive."}`;
-				if (input.onUpdate) {
-					const progress = ownedRunProgressResult(target, deps.state, index, view);
-					const signature = JSON.stringify(progress.details.progress?.map(({ durationMs: _duration, ...activity }) => activity));
-					if (signature !== previous) { previous = signature; input.onUpdate({ ...progress, content: [{ type: "text", text: update }, ...progress.content] }); }
-				}
-			} catch (error) { finish("unavailable", `Wait could not read ${target.runId}: ${error instanceof Error ? error.message : String(error)}`); }
-		};
-		unsubscribe = deps.pi.events.on(INTERCOM_DETACH_REQUEST_EVENT, (payload) => {
-			if (finished || !payload || typeof payload !== "object") return;
-			const requestId = (payload as { requestId?: unknown }).requestId;
-			if (typeof requestId !== "string") return;
-			deps.pi.events.emit(INTERCOM_DETACH_RESPONSE_EVENT, { requestId, accepted: true });
-			finish("yielded", `Released the wait for an incoming Intercom message. Run ${target.runId} is unchanged. Continue useful work or end the turn; completion will arrive automatically.`);
-		});
-		input.signal?.addEventListener("abort", abort, { once: true });
-		if (input.signal?.aborted) abort(); else check();
-		// Unlike passive background tracking, this foreground call owes a result.
-		// The detached runner cannot keep this process alive; finish() releases the timer.
-		if (!finished) timer = setInterval(check, POLL_INTERVAL_MS);
-	});
+  private update(observation: WaitObservation): void {
+    const { deps, index, onUpdate } = this.input;
+    if (!onUpdate) {
+      return;
+    }
+    const progress = ownedRunProgressResult(this.target, deps.state, index, observation.view);
+    const signature = JSON.stringify(
+      progress.details.progress?.map(({ durationMs: _duration, ...activity }) => activity),
+    );
+    if (signature === this.previous) {
+      return;
+    }
+    this.previous = signature;
+    const text = `Waiting for ${this.target.runId}${index !== undefined ? ` child ${index}` : ""}: ${observation.children.map((child) => child.state).join(", ")}. ${this.input.cancelNewRun === true ? "Cancelling requests cancellation of this newly launched run; process exit still needs confirmation." : "Cancelling this wait leaves existing work alive."}`;
+    onUpdate({ ...progress, content: [{ type: "text", text }, ...progress.content] });
+  }
 }