@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/runs/foreground/wait-observation.js

@@ -1,104 +0,0 @@
-import * as path from "node:path";
-import { ownedRunStatusResult, ownedRunView, resolveOwnedRun } from "../shared/run-records.js";
-import { getRunMetadataDir, listOwnedRunQuestions, questionProcessAlive, readRunJson, } from "../shared/supervisor-questions.js";
-import { getSingleResultOutput, readStatus } from "../../shared/utils.js";
-import { isRecord } from "../../shared/unknown.js";
-import { resolveSubagentRunId } from "../background/run-id-resolver.js";
-import { resolveNestedAsyncDir } from "../shared/nested-events.js";
-import { nestedResolutionScopeForExecutor } from "./execution-routing.js";
-/** Small projections deliberately consume unknown JSON, not asserted persisted contracts. */
-export function savedRunString(runId, file, field) {
-    const saved = readRunJson(path.join(getRunMetadataDir(runId), file));
-    return isRecord(saved) && typeof saved[field] === "string" ? saved[field] : undefined;
-}
-export function resolveWaitTarget(id, deps) {
-    const run = resolveOwnedRun(deps.state, id);
-    return run ? { run, nested: false } : resolveNestedWaitTarget(id, deps);
-}
-function resolveNestedWaitTarget(id, deps) {
-    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,
-            })),
-        },
-    };
-}
-export function observeWait(run, state, owner, index) {
-    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, index) {
-    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, children) {
-    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) {
-    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, state, observation, index) {
-    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/dist/runs/foreground/wait-registration.js

@@ -1,17 +0,0 @@
-/** Own the waiter count; release the captured map even if session state is replaced. */
-export function acquireRunWait(state, runId) {
-    if (state.waitingRuns === undefined) {
-        state.waitingRuns = new Map();
-    }
-    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/dist/runs/foreground/wait-run.js

@@ -1,301 +0,0 @@
-import { watch } from "node:fs";
-import { writeAsyncControlRequest } from "../background/async-control.js";
-import { ownedRunExecutionResult, ownedRunProgressResult, ownedRunStatusResult, } from "../shared/run-records.js";
-import { INTERCOM_DETACH_REQUEST_EVENT, INTERCOM_DETACH_RESPONSE_EVENT, POLL_INTERVAL_MS, } from "../../shared/types.js";
-import { errorMessage, isRecord } from "../../shared/unknown.js";
-import { formatRunAction } from "../../shared/status-format.js";
-import { formatSupervisorQuestions, supervisorQuestionPage, } from "../shared/supervisor-questions.js";
-import { nestedResolutionScopeForExecutor } from "./execution-routing.js";
-import { acquireRunWait } from "./wait-registration.js";
-import { observeWait, resolveWaitTarget, savedRunString, savedWaitResult, waitHasSavedResult, waitProducerAlive, } from "./wait-observation.js";
-function unavailableWait(text) {
-    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) {
-    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 {
-    finished = false;
-    timer;
-    watcher;
-    unsubscribe;
-    pending = Promise.withResolvers();
-    previous = "";
-    release;
-    session;
-    input;
-    target;
-    owner;
-    constructor(input, target, owner, session) {
-        this.input = input;
-        this.target = target;
-        this.owner = owner;
-        this.session = session;
-        this.release = acquireRunWait(input.deps.state, target.runId);
-    }
-    start() {
-        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;
-    }
-    watchPublications() {
-        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();
-        }
-    }
-    closeWatch() {
-        const watcher = this.watcher;
-        this.watcher = undefined;
-        watcher?.close();
-    }
-    watchFailed = () => {
-        try {
-            this.closeWatch();
-        }
-        catch {
-            // This optional wakeup failed; the original live polling owner remains.
-        }
-    };
-    finish(outcome) {
-        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" },
-                },
-            });
-        }
-    }
-    cleanup() {
-        let failure;
-        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;
-    }
-    result(outcome) {
-        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 },
-            },
-        };
-    }
-    abort = () => {
-        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.`,
-        });
-    };
-    detach = (payload) => {
-        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.`,
-        });
-    };
-    check = () => {
-        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)}`,
-            });
-        }
-    };
-    observeOutcome(observation) {
-        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;
-    }
-    update(observation) {
-        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] });
-    }
-}