@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/dist/runs/foreground/execution-input.js

@@ -1,296 +0,0 @@
-import * as path from "node:path";
-import { errorMessage } from "../../shared/unknown.js";
-import { getStepAgents, isParallelStep, isDynamicParallelStep } from "../../shared/settings.js";
-import { findDuplicateOutputPath, resolveSingleOutputPath } from "../shared/single-output.js";
-import { resolveChildCwd } from "../../shared/utils.js";
-import { validateAcceptanceInput } from "../shared/acceptance.js";
-import { findWorktreeTaskCwdConflict, formatWorktreeTaskCwdConflict, } from "../shared/worktree.js";
-import { resolveForegroundTimeoutMs } from "./execution-timeout.js";
-export { resolveForegroundTimeoutMs, normalizeRoleForegroundTimeout } from "./execution-timeout.js";
-export { normalizeRepeatedParallelCounts } from "./invocation-expansion.js";
-function validationError(mode, text) {
-    return { content: [{ type: "text", text }], isError: true, details: { mode, results: [] } };
-}
-function acceptanceForStep(step, index) {
-    const prefix = `chain[${index}]`;
-    if (isParallelStep(step)) {
-        if (Object.hasOwn(step, "acceptance")) {
-            return `${prefix}.acceptance is not supported on static parallel groups; set acceptance on each parallel task.`;
-        }
-        for (const [taskIndex, task] of step.parallel.entries()) {
-            const errors = validateAcceptanceInput(task.acceptance, `${prefix}.parallel[${taskIndex}].acceptance`);
-            if (errors.length > 0) {
-                return errors.join(" ");
-            }
-        }
-        return;
-    }
-    if (isDynamicParallelStep(step)) {
-        if (Object.hasOwn(step, "acceptance")) {
-            return `${prefix}.acceptance is not supported on dynamic fanout groups; set acceptance on ${prefix}.parallel.acceptance for each materialized child.`;
-        }
-        const errors = validateAcceptanceInput(step.parallel.acceptance, `${prefix}.parallel.acceptance`);
-        return errors.length > 0 ? errors.join(" ") : undefined;
-    }
-    const errors = validateAcceptanceInput(step.acceptance, `${prefix}.acceptance`);
-    return errors.length > 0 ? errors.join(" ") : undefined;
-}
-function validateAcceptance(params) {
-    const errors = validateAcceptanceInput(params.acceptance);
-    if (errors.length > 0) {
-        return validationError("single", errors.join(" "));
-    }
-    for (const [index, task] of (params.tasks ?? []).entries()) {
-        const taskErrors = validateAcceptanceInput(task.acceptance, `tasks[${index}].acceptance`);
-        if (taskErrors.length > 0) {
-            return validationError("parallel", taskErrors.join(" "));
-        }
-    }
-    for (const [index, step] of (params.chain ?? []).entries()) {
-        const error = acceptanceForStep(step, index);
-        if (error !== undefined) {
-            return validationError("chain", error);
-        }
-    }
-    return;
-}
-function validateMode(params, agents, modes) {
-    if (params.tasks?.length === 0) {
-        return validationError("parallel", "tasks must contain at least one task.");
-    }
-    if (params.worktree !== undefined && !modes.hasTasks) {
-        return validationError(getRequestedModeLabel(params), "Top-level worktree is supported only with tasks parallel mode.");
-    }
-    if (modes.hasSingle && params.task !== undefined && invalidTask(params.task)) {
-        return validationError("single", "task must be a non-empty string when provided.");
-    }
-    if (Number(modes.hasChain) + Number(modes.hasTasks) + Number(modes.hasSingle) !== 1) {
-        const names = agents.map((agent) => agent.name).join(", ");
-        return validationError("single", `Provide exactly one mode. Agents: ${names.length > 0 ? names : "none"}`);
-    }
-    return;
-}
-export function validateExecutionInput(params, agents, modes) {
-    const error = validateAcceptance(params) ?? validateMode(params, agents, modes);
-    if (error) {
-        return error;
-    }
-    const timeout = resolveForegroundTimeoutMs(params);
-    if (timeout.error !== undefined) {
-        return validationError(getRequestedModeLabel(params), timeout.error);
-    }
-    const agentError = modes.hasSingle ? validateSingleAgent(params.agent, agents) : undefined;
-    if (agentError) {
-        return agentError;
-    }
-    if (modes.hasTasks && params.tasks) {
-        return validateTasks(params.tasks, agents);
-    }
-    if (modes.hasChain && params.chain) {
-        return validateChain(params, agents, modes.allowClarifyTaskPrompt);
-    }
-    return null;
-}
-function validateSingleAgent(name, agents) {
-    if (name !== undefined && name.length > 0 && !agents.some((agent) => agent.name === name)) {
-        return validationError("single", `Unknown agent: ${name}`);
-    }
-    return;
-}
-function invalidTask(task) {
-    return typeof task !== "string" || task.trim().length === 0;
-}
-function validateTasks(tasks, agents) {
-    for (const [index, task] of tasks.entries()) {
-        if (invalidTask(task.task)) {
-            return validationError("parallel", `tasks[${index}].task must be a non-empty string.`);
-        }
-        if (!agents.some((agent) => agent.name === task.agent)) {
-            return validationError("parallel", `Unknown agent: ${task.agent} (task ${index + 1})`);
-        }
-    }
-    return null;
-}
-function firstStepError(step, params, clarify) {
-    if (isParallelStep(step)) {
-        const missing = step.parallel.findIndex((task) => task.task === undefined || task.task.length === 0);
-        return missing < 0
-            ? undefined
-            : `First parallel step: task ${missing + 1} must have a task (no previous output to reference)`;
-    }
-    if (isDynamicParallelStep(step)) {
-        return "First step in chain cannot be dynamic fanout; expand.from requires a prior structured named output";
-    }
-    if ((step.task === undefined || step.task.length === 0) &&
-        (params.task === undefined || params.task.length === 0) &&
-        !clarify) {
-        return "First step in chain must have a task";
-    }
-    return;
-}
-const SEQUENTIAL_KEYS = new Set([
-    "agent",
-    "task",
-    "phase",
-    "label",
-    "as",
-    "outputSchema",
-    "cwd",
-    "output",
-    "outputMode",
-    "reads",
-    "progress",
-    "skill",
-    "model",
-    "acceptance",
-]);
-const PARALLEL_KEYS = new Set(["parallel", "concurrency", "failFast", "worktree", "cwd"]);
-const DYNAMIC_KEYS = new Set([
-    "expand",
-    "parallel",
-    "collect",
-    "concurrency",
-    "failFast",
-    "phase",
-    "label",
-]);
-function allowedStepKeys(step) {
-    if (isParallelStep(step)) {
-        return PARALLEL_KEYS;
-    }
-    return isDynamicParallelStep(step) ? DYNAMIC_KEYS : SEQUENTIAL_KEYS;
-}
-function stepTaskError(step, index) {
-    if ("task" in step && Object.hasOwn(step, "task") && invalidTask(step.task)) {
-        return `chain[${index}].task must be a non-empty string when provided.`;
-    }
-    if (isParallelStep(step)) {
-        const empty = step.parallel.findIndex((task) => Object.hasOwn(task, "task") && invalidTask(task.task));
-        if (empty >= 0) {
-            return `chain[${index}].parallel[${empty}].task must be a non-empty string when provided.`;
-        }
-    }
-    if (isDynamicParallelStep(step) &&
-        Object.hasOwn(step.parallel, "task") &&
-        invalidTask(step.parallel.task)) {
-        return `chain[${index}].parallel.task must be a non-empty string when provided.`;
-    }
-    return;
-}
-function validateChain(params, agents, clarify) {
-    const chain = params.chain ?? [];
-    const first = chain.at(0);
-    if (!first) {
-        return validationError("chain", "Chain must have at least one step");
-    }
-    const firstError = firstStepError(first, params, clarify);
-    if (firstError !== undefined) {
-        return validationError("chain", firstError);
-    }
-    for (const [index, step] of chain.entries()) {
-        const allowed = allowedStepKeys(step);
-        const unsupported = Object.keys(step).filter((key) => !allowed.has(key));
-        if (unsupported.length > 0) {
-            return validationError("chain", `chain[${index}] fields are not supported for this step mode: ${unsupported.join(", ")}.`);
-        }
-        const taskError = stepTaskError(step, index);
-        if (taskError !== undefined) {
-            return validationError("chain", taskError);
-        }
-        const missing = getStepAgents(step).find((name) => !agents.some((agent) => agent.name === name));
-        if (missing !== undefined) {
-            return validationError("chain", `Unknown agent: ${missing} (step ${index + 1})`);
-        }
-        if (isParallelStep(step) && step.parallel.length === 0) {
-            return validationError("chain", `Parallel step ${index + 1} must have at least one task`);
-        }
-    }
-    return null;
-}
-function getRequestedModeLabel(params) {
-    if ((params.chain?.length ?? 0) > 0) {
-        return "chain";
-    }
-    if ((params.tasks?.length ?? 0) > 0) {
-        return "parallel";
-    }
-    return "single";
-}
-export function buildRequestedModeError(params, message) {
-    return withForkContext(validationError(getRequestedModeLabel(params), message), params.context);
-}
-export function withForkContext(result, context) {
-    if (context !== "fork") {
-        return result;
-    }
-    return { ...result, details: { ...result.details, context: "fork" } };
-}
-export function toExecutionErrorResult(params, error, context = params.context) {
-    const message = errorMessage(error);
-    return withForkContext(validationError(getRequestedModeLabel(params), message), context);
-}
-function sessionAgents(step, maximum) {
-    if (isParallelStep(step)) {
-        return step.parallel.map((task) => task.agent);
-    }
-    if (isDynamicParallelStep(step)) {
-        return Array.from({ length: step.expand.maxItems ?? maximum }, () => step.parallel.agent);
-    }
-    return [getStepAgents(step)[0]];
-}
-export function collectChainSessionFiles(chain, sessionFileForIndex, sessionFileForAgentIndex, dynamicFanoutMaxItems = 0) {
-    return chain
-        .flatMap((step) => sessionAgents(step, dynamicFanoutMaxItems))
-        .map((agent, index) => sessionFileForAgentIndex(agent, index) ?? sessionFileForIndex(index));
-}
-export function buildParallelModeError(message) {
-    return validationError("parallel", message);
-}
-export function buildParallelWorktreeTaskCwdError(tasks, sharedCwd) {
-    const conflict = findWorktreeTaskCwdConflict(tasks, sharedCwd);
-    return conflict ? formatWorktreeTaskCwdConflict(conflict, sharedCwd) : undefined;
-}
-export function buildChainWorktreeTaskCwdError(chain, sharedCwd) {
-    for (const [index, step] of chain.entries()) {
-        if (!isParallelStep(step) || step.worktree !== true) {
-            continue;
-        }
-        const cwd = resolveChildCwd(sharedCwd, step.cwd);
-        const conflict = findWorktreeTaskCwdConflict(step.parallel, cwd);
-        if (conflict) {
-            return `parallel chain step ${index + 1}: ${formatWorktreeTaskCwdConflict(conflict, cwd)}`;
-        }
-    }
-    return;
-}
-export function resolveParallelTaskCwd(task, cwd, worktree, index) {
-    if (!worktree) {
-        return resolveChildCwd(cwd, task.cwd);
-    }
-    const assigned = worktree.worktrees.at(index);
-    if (!assigned) {
-        throw new Error(`Missing worktree assignment for child ${index}.`);
-    }
-    return assigned.agentCwd;
-}
-export function findDuplicateParallelOutputPath(input) {
-    return findDuplicateOutputPath(input.tasks.map((task, index) => {
-        const output = input.behaviors.at(index)?.output;
-        if (output === false || output === undefined || output.length === 0) {
-            return { agent: task.agent };
-        }
-        return {
-            agent: task.agent,
-            outputPath: resolveSingleOutputPath(output, input.ctxCwd, resolveParallelTaskCwd(task, input.paramsCwd, input.worktreeSetup, index)),
-        };
-    }));
-}
-export function findDuplicateAbsoluteParallelOutputPath(input) {
-    return findDuplicateOutputPath(input.tasks.map((task, index) => {
-        const output = input.behaviors.at(index)?.output;
-        if (typeof output !== "string" || !path.isAbsolute(output)) {
-            return { agent: task.agent };
-        }
-        return { agent: task.agent, outputPath: path.resolve(output) };
-    }));
-}

package/dist/runs/foreground/execution-routing.js

@@ -1,33 +0,0 @@
-import * as path from "node:path";
-import { resolveInheritedNestedRouteFromEnv, resolveNestedParentAddressFromEnv, } from "../shared/nested-events.js";
-export const MUTATING_MANAGEMENT_ACTIONS = new Set([
-    "create",
-    "update",
-    "delete",
-]);
-export function resolveRequestedCwd(runtimeCwd, requestedCwd) {
-    return requestedCwd !== undefined && requestedCwd.length > 0
-        ? path.resolve(runtimeCwd, requestedCwd)
-        : runtimeCwd;
-}
-/** Child-safe callers may resolve only their inherited descendant route. */
-export function nestedResolutionScopeForExecutor(deps) {
-    if (deps.allowMutatingManagementActions !== false) {
-        return;
-    }
-    const route = resolveInheritedNestedRouteFromEnv();
-    const address = route ? resolveNestedParentAddressFromEnv() : undefined;
-    return {
-        routes: route ? [route] : [],
-        ...(address
-            ? {
-                descendantOf: {
-                    parentRunId: address.parentRunId,
-                    ...(address.parentStepIndex !== undefined
-                        ? { parentStepIndex: address.parentStepIndex }
-                        : {}),
-                },
-            }
-            : {}),
-    };
-}

package/dist/runs/foreground/execution-timeout.js

@@ -1,81 +0,0 @@
-import { loadRunsForAgent } from "../shared/run-history.js";
-import { getStepAgents } from "../../shared/settings.js";
-function timeoutRole(name) {
-    if (name === undefined) {
-        return;
-    }
-    if (/(^|[._-])reviewer($|[._-])/i.test(name)) {
-        return "reviewer";
-    }
-    if (/(^|[._-])planner($|[._-])/i.test(name)) {
-        return "planner";
-    }
-    if (/(^|[._-])researcher($|[._-])/i.test(name)) {
-        return "researcher";
-    }
-    return;
-}
-function historyFloor(name) {
-    const durations = loadRunsForAgent(name)
-        .filter((entry) => entry.status === "ok" && Number.isFinite(entry.duration) && entry.duration > 0)
-        .slice(0, 20)
-        .map((entry) => entry.duration)
-        .sort((left, right) => left - right);
-    if (durations.length < 3) {
-        return;
-    }
-    const percentile = durations.at(Math.ceil(durations.length * 0.75) - 1);
-    return percentile === undefined ? undefined : Math.min(1_800_000, Math.ceil(percentile * 1.25));
-}
-function roleFloor(name) {
-    const role = timeoutRole(name);
-    if (role === undefined) {
-        return;
-    }
-    const historical = historyFloor(name);
-    return role === "reviewer" ? Math.max(900_000, historical ?? 0) : historical;
-}
-/** Validate both aliases before choosing a value; invalid runtime inputs are not trusted. */
-export function resolveForegroundTimeoutMs(params) {
-    const timeout = params.timeoutMs;
-    const maximum = params.maxRuntimeMs;
-    const invalid = invalidTimeout("timeoutMs", timeout) ?? invalidTimeout("maxRuntimeMs", maximum);
-    if (invalid !== undefined) {
-        return { error: invalid };
-    }
-    if (timeout !== undefined && maximum !== undefined && timeout !== maximum) {
-        return {
-            error: "timeoutMs and maxRuntimeMs are aliases; provide only one or use identical values.",
-        };
-    }
-    const value = timeout ?? maximum;
-    return typeof value === "number" ? { timeoutMs: value } : {};
-}
-function invalidTimeout(name, value) {
-    if (value !== undefined && (typeof value !== "number" || !Number.isInteger(value) || value < 1)) {
-        return `${name} must be a positive integer.`;
-    }
-    return;
-}
-function requestAgents(params) {
-    if ((params.chain?.length ?? 0) > 0) {
-        return (params.chain ?? []).flatMap(getStepAgents);
-    }
-    if ((params.tasks?.length ?? 0) > 0) {
-        return (params.tasks ?? []).map((task) => task.agent);
-    }
-    return params.agent === undefined ? [] : [params.agent];
-}
-export function normalizeRoleForegroundTimeout(params, timeoutMs) {
-    if (timeoutMs === undefined) {
-        return;
-    }
-    let normalized = timeoutMs;
-    for (const name of new Set(requestAgents(params))) {
-        const floor = roleFloor(name);
-        if (floor !== undefined && normalized < floor) {
-            normalized = floor;
-        }
-    }
-    return normalized;
-}

package/dist/runs/foreground/foreground-control.js

@@ -1,276 +0,0 @@
-import * as path from "node:path";
-import { errorMessage } from "../../shared/unknown.js";
-import { listSupervisorQuestions, readQuestionContract } from "../shared/supervisor-questions.js";
-import { deliverSubagentIntercomMessageEvent } from "../../intercom/result-intercom.js";
-import { resolveSubagentRunId } from "../background/run-id-resolver.js";
-import { buildManagementControl, formatRunAction } from "../../shared/status-format.js";
-import { ownedRunView, resolveOwnedRun } from "../shared/run-records.js";
-import { nestedResolutionScopeForExecutor } from "./execution-routing.js";
-import { resolveResumeTarget, resolveNestedResumeTarget, } from "./resume-target.js";
-import { LIVE_ACCEPTANCE_OVERRIDE_NOTICE, resumeLiveNestedRun } from "./nested-control.js";
-import { nudgeSubagentRun } from "./run-nudge.js";
-import { reviveSavedSubagent } from "./saved-revival.js";
-import { continueQuestionSession } from "./question-continuation.js";
-export { writeAsyncInterruptRequest } from "../background/async-control.js";
-export { MUTATING_MANAGEMENT_ACTIONS, resolveRequestedCwd, nestedResolutionScopeForExecutor, } from "./execution-routing.js";
-export { rememberedForegroundStatusResult, resolveRememberedForegroundRun, } from "./foreground-memory.js";
-export { extendAsyncTimeoutResult, interruptAsyncRun } from "./run-interrupt.js";
-export { interruptNestedRun } from "./nested-control.js";
-export { nudgeSubagentRun } from "./run-nudge.js";
-export { reviveSavedSubagent } from "./saved-revival.js";
-function failure(text) {
-    return {
-        content: [{ type: "text", text }],
-        isError: true,
-        details: { mode: "management", results: [] },
-    };
-}
-function requestedOwnedId(params) {
-    const id = params.id ?? params.runId;
-    return id !== undefined && id.length > 0 && (params.dir === undefined || params.dir.length === 0)
-        ? id
-        : undefined;
-}
-export function liveLaunchOverrideNotice(params) {
-    if (params.acceptance !== undefined) {
-        return LIVE_ACCEPTANCE_OVERRIDE_NOTICE;
-    }
-    return [
-        params.agent,
-        params.model,
-        params.cwd,
-        params.output,
-        params.outputMode,
-        params.outputSchema,
-        params.skill,
-        params.maxOutput,
-        params.control,
-        params.artifacts,
-        params.share,
-    ].some((value) => value !== undefined)
-        ? "Launch overrides change a newly started continuation, not this live child. No launch settings were changed."
-        : undefined;
-}
-function withLiveNotice(result, params) {
-    const notice = liveLaunchOverrideNotice(params);
-    if (notice !== undefined) {
-        result.content.push({ type: "text", text: notice });
-    }
-    return result;
-}
-function normalizedFollowUp(params) {
-    return (params.message ?? params.task ?? "").trim();
-}
-function usesSession(candidate, deps, sessionFile) {
-    return (candidate.children.some((child) => child.sessionFile === sessionFile) ||
-        deps.state.asyncJobs.get(candidate.runId)?.sessionFile === sessionFile);
-}
-function nudgeContinuation(input, runId, sessionFile) {
-    if (sessionFile === undefined || sessionFile.length === 0) {
-        return;
-    }
-    for (const candidate of input.deps.state.ownedRuns?.values() ?? []) {
-        if (candidate.runId === runId) {
-            continue;
-        }
-        if (!usesSession(candidate, input.deps, sessionFile)) {
-            continue;
-        }
-        const active = ownedRunView(candidate, input.deps.state, {
-            readConfiguration: false,
-        }).children.find((child) => child.sessionFile === sessionFile && child.state === "live");
-        if (!active) {
-            continue;
-        }
-        return nudgeSubagentRun({
-            params: {
-                ...input.params,
-                dir: undefined,
-                id: candidate.runId,
-                index: active.index,
-                message: normalizedFollowUp(input.params),
-            },
-            deps: input.deps,
-            ctx: input.ctx,
-        }).then((result) => withLiveNotice(result, input.params));
-    }
-    return;
-}
-async function resumeOwned(
-// Owned continuation may persist a new run; deps retains the actual session mutation owner.
-input, owned) {
-    const view = ownedRunView(owned, input.deps.state);
-    if (view.children.length > 1 && input.params.index === undefined) {
-        throw new Error(`Run '${owned.runId}' has ${view.children.length} children. Provide index to choose one.`);
-    }
-    const child = view.children.find((entry) => entry.index === (input.params.index ?? 0));
-    if (!child) {
-        throw new Error(`Run '${owned.runId}' has no child at index ${input.params.index ?? 0}.`);
-    }
-    if (child.state === "live") {
-        return withLiveNotice(await nudgeSubagentRun({
-            params: {
-                ...input.params,
-                id: owned.runId,
-                message: normalizedFollowUp(input.params),
-            },
-            deps: input.deps,
-            ctx: input.ctx,
-        }), input.params);
-    }
-    const liveContinuation = nudgeContinuation(input, owned.runId, child.sessionFile);
-    if (liveContinuation) {
-        return await liveContinuation;
-    }
-    return reviveSavedSubagent(input, ownedRevivalTarget(owned, child));
-}
-function ownedRevivalTarget(owned, child) {
-    const contract = readQuestionContract(owned.runId, child.index);
-    return {
-        ...contract,
-        runId: owned.runId,
-        agent: child.agent,
-        index: child.index,
-        source: owned.source,
-        cwd: child.launch?.cwd ?? owned.cwd,
-        sessionFile: child.sessionFile,
-        effectiveAcceptance: contract?.effectiveAcceptance ?? child.result?.acceptance?.effectiveAcceptance,
-        model: child.result?.model,
-    };
-}
-function trustedSessionRoots(input, parentSessionFile) {
-    const roots = [];
-    const configured = input.deps.config.defaultSessionDir;
-    if (configured !== undefined && configured.length > 0) {
-        roots.push(path.resolve(input.deps.expandTilde(configured)));
-    }
-    if (parentSessionFile !== null && parentSessionFile.length > 0) {
-        roots.push(input.deps.getSubagentSessionRoot(parentSessionFile));
-    }
-    return roots;
-}
-function resolveRequestedRun(params, deps) {
-    const id = params.id ?? params.runId;
-    if (id === undefined || id.length === 0) {
-        return;
-    }
-    return resolveSubagentRunId(id, {
-        state: deps.state,
-        nested: nestedResolutionScopeForExecutor(deps),
-    });
-}
-async function resolveContinuation(
-// Resolution includes question/owned revival, whose durable updates belong to this session owner.
-input, parentSessionFile) {
-    const requested = requestedOwnedId(input.params);
-    const questions = requested !== undefined
-        ? listSupervisorQuestions(input.ctx.sessionManager.getSessionId(), requested).filter((question) => question.state === "awaiting_input" || question.state === "answer_pending")
-        : [];
-    if (questions.length > 0) {
-        return { kind: "result", result: continueQuestionSession(input, questions) };
-    }
-    const owned = requested !== undefined ? resolveOwnedRun(input.deps.state, requested) : undefined;
-    if (owned) {
-        return { kind: "result", result: await resumeOwned(input, owned) };
-    }
-    const resolved = resolveRequestedRun(input.params, input.deps);
-    if (resolved?.kind !== "nested") {
-        return { kind: "target", target: resolveResumeTarget(input.params, input.deps.state) };
-    }
-    if (resolved.match.run.state === "running" || resolved.match.run.state === "queued") {
-        return {
-            kind: "result",
-            result: await resumeLiveNestedRun({
-                target: resolved,
-                message: normalizedFollowUp(input.params),
-                index: input.params.index,
-                acceptanceOverrideSupplied: input.params.acceptance !== undefined,
-                pi: input.deps.pi,
-                childSafe: nestedResolutionScopeForExecutor(input.deps) !== undefined,
-            }),
-        };
-    }
-    return {
-        kind: "target",
-        target: resolveNestedResumeTarget(resolved, trustedSessionRoots(input, parentSessionFile)),
-    };
-}
-function lookupFailure(
-// Recovery may revive a saved question; the real dependency state remains owned, not frozen.
-input, error) {
-    const message = errorMessage(error), requested = requestedOwnedId(input.params);
-    const recoverable = (error instanceof Error && error.message.startsWith("Async run not found.")) ||
-        message.includes("is detached for intercom coordination");
-    if (requested !== undefined && recoverable) {
-        try {
-            const questions = listSupervisorQuestions(input.ctx.sessionManager.getSessionId(), requested);
-            if (questions.length > 0) {
-                return continueQuestionSession(input, questions);
-            }
-        }
-        catch (questionError) {
-            return failure(errorMessage(questionError));
-        }
-    }
-    return failure(message);
-}
-async function deliverLiveContinuation(input, target) {
-    const followUp = normalizedFollowUp(input.params);
-    const delivered = await deliverSubagentIntercomMessageEvent(input.deps.pi.events, target.intercomTarget, `Follow-up for async run ${target.runId} (${target.agent}):\n\n${followUp}`, 500, { source: "async-resume", runId: target.runId, agent: target.agent, index: target.index });
-    if (!delivered) {
-        return failure([
-            "Async child appears live but its intercom target is not registered.",
-            `Run: ${target.runId}`,
-            `Intercom target: ${target.intercomTarget}`,
-            `Wait for completion, then retry ${formatRunAction("resume", target.runId, { message: "..." }, nestedResolutionScopeForExecutor(input.deps) !== undefined)}.`,
-        ].join("\n"));
-    }
-    const lines = [
-        "Delivered follow-up to live async child.",
-        `Run: ${target.runId}`,
-        `Intercom target: ${target.intercomTarget}`,
-    ];
-    if (input.params.acceptance !== undefined) {
-        lines.push(LIVE_ACCEPTANCE_OVERRIDE_NOTICE);
-    }
-    return {
-        content: [{ type: "text", text: lines.join("\n") }],
-        details: {
-            mode: "management",
-            results: [],
-            managementControl: buildManagementControl({
-                state: "live",
-                runId: target.runId,
-                index: target.index,
-                intercomTarget: target.intercomTarget,
-                canNudge: true,
-                canResume: true,
-                canInterrupt: true,
-            }),
-        },
-    };
-}
-/** Pending question, owned/live continuation, then saved session revival—in that order. */
-export async function resumeAsyncRun(
-// Resume owns durable question delivery and newly launched continuation state through its helpers.
-input) {
-    if (normalizedFollowUp(input.params).length === 0) {
-        return failure("action='resume' requires message.");
-    }
-    const parentSessionFile = input.ctx.sessionManager.getSessionFile() ?? null;
-    let resolution;
-    try {
-        resolution = await resolveContinuation(input, parentSessionFile);
-    }
-    catch (error) {
-        return lookupFailure(input, error);
-    }
-    if (resolution.kind === "result") {
-        return resolution.result;
-    }
-    const { target } = resolution;
-    if (target.kind === "live") {
-        return deliverLiveContinuation(input, target);
-    }
-    return (nudgeContinuation(input, target.runId, target.sessionFile) ?? reviveSavedSubagent(input, target));
-}