@fitchmultz/pi-subagents 0.49.1 → 0.51.0

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

@@ -1,160 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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,366 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-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 {
-  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;
-  }
-
-  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] });
-  }
-}