@fitchmultz/pi-subagents 0.0.0-stage → 0.44.4

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

@@ -0,0 +1,817 @@
+import { randomUUID } from "node:crypto";
+import { formatRunIdAmbiguity } from "../shared/run-id-ambiguity.js";
+import { resolveRootSessionId } from "../../shared/session-identity.js";
+import { writeAsyncControlRequest, writeAsyncInterruptRequest } from "../background/async-control.js";
+import { getRunMetadataDir, listSupervisorQuestions, questionProcessAlive, readQuestionContract, readRunJson, recordQuestionDelivery, saveQuestionOwner } from "../shared/supervisor-questions.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {} from "../../agents/agents.js";
+import { providerQualifiedModelId, toModelInfo } from "../../shared/model-info.js";
+import { normalizeSkillInput } from "../../agents/skills.js";
+import { resolveExecutionAgentScope } from "../../agents/agent-scope.js";
+import { executeAsyncSingle, formatAsyncStartedMessage } from "../background/async-execution.js";
+import { resolveConfiguredChildProjectTrustPolicy } from "../shared/pi-args.js";
+import { requestChildExecutionCwd } from "../shared/child-execution-cwd.js";
+import { resolveCurrentSessionId } from "../../shared/session-identity.js";
+import { resolveIntercomBridge, resolveIntercomSessionTarget, resolveOrchestratorIntercomTarget, resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
+import { resolveControlConfig } from "../shared/subagent-control.js";
+import { readStatus } from "../../shared/utils.js";
+import { deliverSubagentIntercomMessageEvent } from "../../intercom/result-intercom.js";
+import { sendLiveSubagentMessage } from "../../intercom/live-intercom.js";
+import { buildRevivedAsyncTask, resolveAsyncResumeTarget } from "../background/async-resume.js";
+import { readNestedControlResults, resolveInheritedNestedRouteFromEnv, resolveNestedAsyncDir, resolveNestedParentAddressFromEnv, writeNestedControlRequest } from "../shared/nested-events.js";
+import { inspectSubagentStatus } from "../background/run-status.js";
+import { resolveSubagentRunId } from "../background/run-id-resolver.js";
+import { buildManagementControl, formatRunAction } from "../../shared/status-format.js";
+import { acceptanceInputFromResolved } from "../shared/acceptance.js";
+import { ownedRunStatusResult, ownedRunView, rememberOwnedRun, resolveOwnedRun } from "../shared/run-records.js";
+import { ASYNC_DIR, getAsyncConfigPath, RUNNER_ERROR_LOG_FILE, checkSubagentDepth, resolveCurrentMaxSubagentDepth, } from "../../shared/types.js";
+import {} from "./subagent-params.js";
+export { writeAsyncInterruptRequest } from "../background/async-control.js";
+export const MUTATING_MANAGEMENT_ACTIONS = new Set(["create", "update", "delete"]);
+export function resolveRequestedCwd(runtimeCwd, requestedCwd) {
+    return requestedCwd ? path.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
+}
+export function nestedResolutionScopeForExecutor(deps) {
+    if (deps.allowMutatingManagementActions !== false)
+        return undefined;
+    const route = resolveInheritedNestedRouteFromEnv();
+    const address = route ? resolveNestedParentAddressFromEnv() : undefined;
+    return {
+        routes: route ? [route] : [],
+        ...(address ? { descendantOf: { parentRunId: address.parentRunId, ...(address.parentStepIndex !== undefined ? { parentStepIndex: address.parentStepIndex } : {}) } } : {}),
+    };
+}
+const LATEST_FOREGROUND_ALIASES = new Set(["last", "latest"]);
+export function resolveRememberedForegroundRun(requested, state) {
+    if (!requested || !state.foregroundRuns?.size)
+        return undefined;
+    const normalized = requested.trim();
+    if (!normalized)
+        return undefined;
+    if (LATEST_FOREGROUND_ALIASES.has(normalized)) {
+        return [...state.foregroundRuns.values()].sort((left, right) => right.updatedAt - left.updatedAt)[0];
+    }
+    const direct = state.foregroundRuns.get(normalized);
+    const matches = direct ? [direct] : [...state.foregroundRuns.values()].filter((run) => run.runId.startsWith(normalized));
+    if (matches.length === 0)
+        return undefined;
+    if (matches.length > 1)
+        throw new Error(formatRunIdAmbiguity("foreground", normalized, matches.map((run) => run.runId)));
+    return matches[0];
+}
+function foregroundResumeGuidance(run, childSafe) {
+    const childWithSession = run.children.find((child) => child.sessionFile && child.status !== "detached");
+    if (!childWithSession && run.children.some((child) => child.status === "detached"))
+        return `Completion unconfirmed. Check ${formatRunAction("questions", run.runId, {}, childSafe)} before continuing.`;
+    if (run.children.length === 1 && childWithSession)
+        return `Continue: ${formatRunAction("resume", run.runId, { message: "..." }, childSafe)}`;
+    if (!childWithSession)
+        return "Revive: unavailable; no child session file was persisted.";
+    return `Continue child: ${formatRunAction("resume", run.runId, { index: childWithSession.index, message: "..." }, childSafe)}`;
+}
+function compactStatusText(value, maxLength = 240) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    return normalized.length > maxLength ? `${normalized.slice(0, maxLength - 1)}…` : normalized;
+}
+function foregroundResultChildren(run) {
+    return run.children.map((child) => ({ child, finalOutput: child.summary }));
+}
+function rememberedForegroundState(children) {
+    if (children.some(({ child }) => child.status === "failed" || child.status === "timed-out"))
+        return "failed";
+    if (children.some(({ child }) => child.status === "blocked"))
+        return "blocked";
+    if (children.some(({ child }) => child.status === "paused"))
+        return "paused";
+    return children.some(({ child }) => child.status === "detached") ? "unknown" : "completed";
+}
+export function rememberedForegroundStatusResult(run, childSafe = false) {
+    const children = foregroundResultChildren(run);
+    const childState = rememberedForegroundState(children);
+    const state = run.error ? "failed" : childState === "completed" && run.pausedReason ? "paused" : childState;
+    const resumable = children.find(({ child }) => child.sessionFile && child.status !== "detached")?.child;
+    const lines = [
+        `Run: ${run.runId}`,
+        "State: remembered foreground",
+        `Outcome: ${state}`,
+        ...(run.error ? [`Error: ${run.error}`] : state === "paused" && run.pausedReason ? [run.pausedReason] : []),
+        `Mode: ${run.mode}`,
+        `Updated: ${new Date(run.updatedAt).toISOString()}`,
+        `Launch cwd: ${run.cwd}`,
+        "Children:",
+        ...children.map(({ child, finalOutput }) => `  ${child.index + 1}. ${child.agent} ${child.status}${child.sessionFile ? `, session: ${child.sessionFile}` : ""}${child.artifactPath ? `, artifact: ${child.artifactPath}` : ""}${finalOutput ? `, final: ${compactStatusText(finalOutput)}` : ""}`),
+        foregroundResumeGuidance(run, childSafe),
+        `Status: ${formatRunAction("status", run.runId, {}, childSafe)}`,
+    ];
+    return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        details: {
+            mode: "management", results: [],
+            managementControl: buildManagementControl({ state, runId: run.runId, index: resumable?.index, canResume: Boolean(resumable) }),
+        },
+    };
+}
+function resolveForegroundResumeTarget(params, state) {
+    const requested = (params.id ?? params.runId)?.trim();
+    const run = resolveRememberedForegroundRun(requested, state);
+    if (!run)
+        return undefined;
+    if (run.children.length > 1 && params.index === undefined)
+        throw new Error(`Foreground run '${run.runId}' has ${run.children.length} children. Provide index to choose one.`);
+    const index = params.index ?? 0;
+    if (!Number.isInteger(index))
+        throw new Error(`Foreground run '${run.runId}' index must be an integer.`);
+    if (index < 0 || index >= run.children.length)
+        throw new Error(`Foreground run '${run.runId}' has ${run.children.length} children. Index ${index} is out of range.`);
+    const child = run.children[index];
+    if (child.status === "detached")
+        throw new Error(`Foreground run '${run.runId}' child ${index} is detached for intercom coordination and cannot be revived safely from the remembered foreground state. Reply to the supervisor request first; after the child exits, start a fresh follow-up if needed.`);
+    if (!child.sessionFile)
+        throw new Error(`Foreground run '${run.runId}' child ${index} does not have a persisted session file to resume from.`);
+    if (path.extname(child.sessionFile) !== ".jsonl")
+        throw new Error(`Foreground run '${run.runId}' child ${index} session file must be a .jsonl file: ${child.sessionFile}`);
+    const sessionFile = path.resolve(child.sessionFile);
+    if (!fs.existsSync(sessionFile))
+        throw new Error(`Foreground run '${run.runId}' child ${index} session file does not exist: ${child.sessionFile}`);
+    return { runId: run.runId, mode: run.mode, state: "complete", agent: child.agent, index, intercomTarget: resolveSubagentIntercomTarget(run.runId, child.agent, index), cwd: run.cwd, sessionFile, effectiveAcceptance: child.effectiveAcceptance };
+}
+function isAsyncRunNotFound(error) {
+    return error instanceof Error && error.message.startsWith("Async run not found.");
+}
+function isResumeAmbiguity(error) {
+    return error instanceof Error && /Ambiguous .*run id prefix/.test(error.message);
+}
+function resumeTargetExact(target, requested) {
+    return target?.runId === requested;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isExactResumeError(error, source, requested) {
+    if (!(error instanceof Error) || !requested)
+        return false;
+    return new RegExp(`\\b${source} run '${escapeRegExp(requested)}'`, "i").test(error.message);
+}
+function resolveResumeTarget(params, state) {
+    const requested = (params.id ?? params.runId)?.trim() ?? "";
+    let foregroundTarget;
+    let foregroundError;
+    let asyncTarget;
+    let asyncError;
+    try {
+        const target = resolveForegroundResumeTarget(params, state);
+        if (target)
+            foregroundTarget = { kind: "revive", source: "foreground", ...target };
+    }
+    catch (error) {
+        foregroundError = error;
+    }
+    try {
+        asyncTarget = { source: "async", ...resolveAsyncResumeTarget(params) };
+    }
+    catch (error) {
+        asyncError = error;
+    }
+    if (foregroundTarget && asyncTarget) {
+        const foregroundExact = resumeTargetExact(foregroundTarget, requested);
+        const asyncExact = resumeTargetExact(asyncTarget, requested);
+        if (foregroundExact && !asyncExact)
+            return foregroundTarget;
+        if (asyncExact && !foregroundExact)
+            return asyncTarget;
+        throw new Error(`Resume id '${requested}' is ambiguous between foreground run '${foregroundTarget.runId}' and async run '${asyncTarget.runId}'. Provide a full run id.`);
+    }
+    if (foregroundTarget) {
+        if (isExactResumeError(asyncError, "async", requested))
+            throw asyncError;
+        if (isResumeAmbiguity(asyncError) && !resumeTargetExact(foregroundTarget, requested))
+            throw asyncError;
+        return foregroundTarget;
+    }
+    if (asyncTarget) {
+        if (isExactResumeError(foregroundError, "foreground", requested))
+            throw foregroundError;
+        if (isResumeAmbiguity(foregroundError) && !resumeTargetExact(asyncTarget, requested))
+            throw foregroundError;
+        return asyncTarget;
+    }
+    if (foregroundError && !isAsyncRunNotFound(asyncError))
+        throw foregroundError;
+    if (foregroundError)
+        throw foregroundError;
+    if (asyncError)
+        throw asyncError;
+    throw new Error("Run not found. Provide id or runId.");
+}
+function getAsyncInterruptTarget(state, runId) {
+    if (runId) {
+        const direct = state.asyncJobs.get(runId);
+        if (direct)
+            return { asyncId: direct.asyncId, asyncDir: direct.asyncDir };
+        const owned = resolveOwnedRun(state, runId);
+        return owned?.asyncDir ? { asyncId: owned.runId, asyncDir: owned.asyncDir } : undefined;
+    }
+    let newest;
+    for (const job of state.asyncJobs.values()) {
+        if (job.status !== "running")
+            continue;
+        if (!newest || (job.updatedAt ?? 0) > newest.updatedAt) {
+            newest = { asyncId: job.asyncId, asyncDir: job.asyncDir, updatedAt: job.updatedAt ?? 0 };
+        }
+    }
+    for (const run of state.ownedRuns?.values() ?? []) {
+        if (!run.asyncDir || (newest && run.startedAt <= newest.updatedAt))
+            continue;
+        const status = readStatus(run.asyncDir);
+        if (status ? status.state !== "running" && status.state !== "queued" : !run.pid || !questionProcessAlive({ pid: run.pid }))
+            continue;
+        newest = { asyncId: run.runId, asyncDir: run.asyncDir, updatedAt: run.startedAt };
+    }
+    return newest ? { asyncId: newest.asyncId, asyncDir: newest.asyncDir } : undefined;
+}
+export function extendAsyncTimeoutResult(state, runId, extendMs) {
+    const target = getAsyncInterruptTarget(state, runId);
+    const status = target && readStatus(target.asyncDir);
+    const launch = target && readRunJson(path.join(target.asyncDir, "launch.json"));
+    const extendable = status ? status.runtimeVersion === 2 && status.state === "running" && !status.timedOut && status.timeoutAt
+        : launch?.runtimeVersion === 2 && launch.timeoutMs;
+    if (!target || !extendable)
+        return {
+            content: [{ type: "text", text: "No live run with an extendable timeout was found. No extension was requested." }], isError: true, details: { mode: "management", results: [] },
+        };
+    try {
+        writeAsyncControlRequest(target.asyncDir, target.asyncId, "extend", undefined, extendMs);
+        return { content: [{ type: "text", text: `Requested ${extendMs}ms more for run ${target.asyncId}. Inspect status for the owner's updated deadline.` }],
+            details: { mode: "management", results: [], managementControl: buildManagementControl({ state: "live", runId: target.asyncId, canInterrupt: true, canExtend: true }) } };
+    }
+    catch (error) {
+        return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true, details: { mode: "management", results: [] } };
+    }
+}
+export function interruptAsyncRun(state, runId, index) {
+    const target = getAsyncInterruptTarget(state, runId);
+    if (!target)
+        return null;
+    const status = readStatus(target.asyncDir);
+    if (!status || status.runId !== target.asyncId || status.state !== "running") {
+        return {
+            content: [{ type: "text", text: `No running async run with a matching control channel was found for '${runId ?? "current"}'.` }],
+            isError: true,
+            details: { mode: "management", results: [] },
+        };
+    }
+    if (index !== undefined && !status.indexedControl && (status.steps?.length ?? 0) > 1)
+        return {
+            content: [{ type: "text", text: "This older runner does not support selected-child stop. No stop was sent; whole-run stop remains an explicit separate action." }], isError: true, details: { mode: "management", results: [] },
+        };
+    if (index !== undefined && (!Number.isSafeInteger(index) || index < 0 || status.steps?.[index]?.status !== "running")) {
+        return { content: [{ type: "text", text: `Async run ${target.asyncId} has no running child at index ${index}. No siblings were stopped.` }], isError: true, details: { mode: "management", results: [] } };
+    }
+    try {
+        writeAsyncInterruptRequest(target.asyncDir, target.asyncId, index);
+        const tracked = state.asyncJobs.get(target.asyncId);
+        if (tracked) {
+            tracked.activityState = undefined;
+            tracked.updatedAt = Date.now();
+        }
+        return {
+            content: [{ type: "text", text: `Interrupt requested for async run ${target.asyncId}${index !== undefined ? ` child ${index} only` : ""}. Agent and command exit are not yet confirmed.` }],
+            details: { mode: "management", results: [], managementControl: buildManagementControl({ state: "live", runId: target.asyncId }) },
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Failed to interrupt async run ${target.asyncId}: ${message}` }],
+            isError: true,
+            details: { mode: "management", results: [] },
+        };
+    }
+}
+function nestedRunSessionFile(run) {
+    return run.sessionFile ?? (run.steps?.length === 1 ? run.steps[0]?.sessionFile : undefined);
+}
+function nestedRunAgent(run) {
+    return run.agent ?? run.agents?.[0] ?? (run.steps?.length === 1 ? run.steps[0]?.agent : undefined);
+}
+function pathWithin(base, candidate) {
+    const resolvedBase = path.resolve(base);
+    const resolvedCandidate = path.resolve(candidate);
+    return resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path.sep}`);
+}
+function validateNestedSessionFile(run, trustedSessionRoots) {
+    const sessionFile = nestedRunSessionFile(run);
+    if (!sessionFile)
+        throw new Error(`Nested run '${run.id}' does not have a persisted session file to resume from.`);
+    if (path.extname(sessionFile) !== ".jsonl")
+        throw new Error(`Nested run '${run.id}' session file must be a .jsonl file: ${sessionFile}`);
+    const resolved = path.resolve(sessionFile);
+    if (!path.isAbsolute(sessionFile))
+        throw new Error(`Nested run '${run.id}' session file must be absolute: ${sessionFile}`);
+    if (!fs.existsSync(resolved))
+        throw new Error(`Nested run '${run.id}' session file does not exist: ${sessionFile}`);
+    const stat = fs.lstatSync(resolved);
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new Error(`Nested run '${run.id}' session file is not a regular file: ${sessionFile}`);
+    const realSessionFile = fs.realpathSync(resolved);
+    const trustedRoots = trustedSessionRoots
+        .filter((root) => fs.existsSync(root))
+        .map((root) => fs.realpathSync(root));
+    if (!trustedRoots.some((root) => pathWithin(root, realSessionFile))) {
+        throw new Error(`Nested run '${run.id}' session file is outside trusted nested session roots: ${sessionFile}`);
+    }
+    if (!realSessionFile.split(path.sep).includes(run.id)) {
+        throw new Error(`Nested run '${run.id}' session file is not under that nested run's session directory: ${sessionFile}`);
+    }
+    return realSessionFile;
+}
+function resolveNestedResumeTarget(match, trustedSessionRoots) {
+    const run = match.match.run;
+    if (run.state === "running" || run.state === "queued")
+        throw new Error(`Nested run '${run.id}' is live; route the follow-up to the owner process instead.`);
+    const agent = nestedRunAgent(run);
+    if (!agent)
+        throw new Error(`Could not determine child agent for nested run '${run.id}'.`);
+    const state = run.state === "complete" || run.state === "failed" || run.state === "blocked" || run.state === "paused" ? run.state : "failed";
+    const asyncDir = resolveNestedAsyncDir(match.match.rootRunId, run);
+    const effectiveAcceptance = asyncDir ? readStatus(asyncDir)?.steps?.[0]?.acceptance?.effectiveAcceptance : undefined;
+    return {
+        kind: "revive",
+        source: "nested",
+        runId: run.id,
+        state,
+        agent,
+        index: 0,
+        intercomTarget: resolveSubagentIntercomTarget(run.id, agent, 0),
+        cwd: asyncDir ? path.dirname(asyncDir) : undefined,
+        sessionFile: validateNestedSessionFile(run, trustedSessionRoots),
+        effectiveAcceptance,
+    };
+}
+async function waitForNestedControlResult(target, requestId, timeoutMs = 1_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const result = readNestedControlResults(target.match.route).find((candidate) => candidate.requestId === requestId && candidate.targetRunId === target.match.run.id);
+        if (result)
+            return result;
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    return undefined;
+}
+async function sendNestedControlRequest(target, action, message, index) {
+    const requestId = randomUUID();
+    const targetChildIndex = target.match.run.path?.[0]?.stepIndex ?? target.match.run.parentStepIndex;
+    writeNestedControlRequest(target.match.route, {
+        ts: Date.now(),
+        requestId,
+        targetRunId: target.match.run.id,
+        ...(targetChildIndex !== undefined ? { targetChildIndex } : {}),
+        action,
+        ...(index !== undefined ? { index } : {}),
+        ...(message ? { message } : {}),
+    });
+    return waitForNestedControlResult(target, requestId);
+}
+function directNestedAsyncInterrupt(target, index) {
+    const run = target.match.run;
+    const asyncDir = resolveNestedAsyncDir(target.match.rootRunId, run);
+    if (!asyncDir)
+        return undefined;
+    const status = readStatus(asyncDir);
+    if (!status || status.runId !== run.id || status.state !== "running")
+        return undefined;
+    if (index !== undefined && !status.indexedControl && (status.steps?.length ?? 0) > 1)
+        return undefined;
+    if (index !== undefined && status.steps?.[index]?.status !== "running")
+        return { content: [{ type: "text", text: `No running nested child at index ${index}. No siblings were stopped.` }], isError: true, details: { mode: "management", results: [] } };
+    try {
+        writeAsyncInterruptRequest(asyncDir, run.id, index);
+        return { content: [{ type: "text", text: `Interrupt requested for nested async run ${run.id}.` }], details: { mode: "management", results: [], managementControl: buildManagementControl({ state: "live", runId: run.id, intercomTarget: run.intercomTarget ?? run.leafIntercomTarget, canInterrupt: true }) } };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `Failed to interrupt nested async run ${run.id}: ${message}` }], isError: true, details: { mode: "management", results: [] } };
+    }
+}
+export async function interruptNestedRun(target, index) {
+    const run = target.match.run;
+    if (run.state === "complete")
+        return { content: [{ type: "text", text: `Nested run ${run.id} is already complete and cannot be interrupted.` }], isError: true, details: { mode: "management", results: [] } };
+    if (run.state === "failed")
+        return { content: [{ type: "text", text: `Nested run ${run.id} has failed and cannot be interrupted.` }], isError: true, details: { mode: "management", results: [] } };
+    if (run.state === "paused")
+        return { content: [{ type: "text", text: `Nested run ${run.id} is already paused.` }], isError: true, details: { mode: "management", results: [] } };
+    if (index !== undefined && run.indexedControl !== true)
+        return directNestedAsyncInterrupt(target, index) ?? {
+            content: [{ type: "text", text: "This nested owner does not advertise selected-child stop. No stop was sent; inspect the child or explicitly stop the whole run." }], isError: true, details: { mode: "management", results: [] },
+        };
+    const result = await sendNestedControlRequest(target, "interrupt", undefined, index);
+    if (result?.ok)
+        return {
+            content: [{ type: "text", text: result.message }],
+            details: {
+                mode: "management", results: [],
+                managementControl: buildManagementControl({ state: "live", runId: run.id, intercomTarget: run.intercomTarget ?? run.leafIntercomTarget, canResume: true, canInterrupt: true }),
+            },
+        };
+    const direct = directNestedAsyncInterrupt(target, index);
+    if (direct)
+        return direct;
+    if (result)
+        return { content: [{ type: "text", text: result.message }], isError: true, details: { mode: "management", results: [] } };
+    return { content: [{ type: "text", text: `Nested run ${run.id} owner is not reachable and no safe direct async interrupt fallback is available.` }], isError: true, details: { mode: "management", results: [] } };
+}
+const LIVE_ACCEPTANCE_OVERRIDE_NOTICE = "Acceptance override applies only to revive and was not applied to this live delivery.";
+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;
+}
+async function resumeLiveNestedRun(input) {
+    const run = input.target.match.run;
+    const result = await sendNestedControlRequest(input.target, "resume", input.message, input.index);
+    if (result?.ok) {
+        return { content: [{ type: "text", text: [result.message, input.acceptanceOverrideSupplied ? LIVE_ACCEPTANCE_OVERRIDE_NOTICE : undefined].filter(Boolean).join("\n") }], details: { mode: "management", results: [] } };
+    }
+    const asyncDir = input.index !== undefined ? resolveNestedAsyncDir(input.target.match.rootRunId, run) : undefined;
+    const selected = asyncDir ? readStatus(asyncDir)?.steps?.[input.index] : undefined;
+    const directTarget = input.index === undefined ? run.leafIntercomTarget ?? run.intercomTarget
+        : selected?.status === "running" ? resolveSubagentIntercomTarget(run.id, selected.agent, input.index) : undefined;
+    if (directTarget) {
+        const delivered = await deliverSubagentIntercomMessageEvent(input.pi.events, directTarget, `Follow-up for nested run ${run.id}:\n\n${input.message}`, 500, { source: "nested-resume-fallback", runId: run.id, agent: run.agent, index: input.index ?? run.currentStep });
+        if (delivered) {
+            return { content: [{ type: "text", text: [`Delivered follow-up directly to live nested run ${run.id}.`, input.acceptanceOverrideSupplied ? LIVE_ACCEPTANCE_OVERRIDE_NOTICE : undefined].filter(Boolean).join("\n") }], details: { mode: "management", results: [] } };
+        }
+    }
+    if (result)
+        return { content: [{ type: "text", text: result.message }], isError: true, details: { mode: "management", results: [] } };
+    return { content: [{ type: "text", text: `Nested run ${run.id} appears live but its owner route is not reachable. Wait for completion, then retry ${formatRunAction("resume", run.id, { message: "..." }, input.childSafe)}.` }], isError: true, details: { mode: "management", results: [] } };
+}
+function terminalNudgeResult(runId, deps) {
+    const owned = resolveOwnedRun(deps.state, runId);
+    if (owned) {
+        const result = ownedRunStatusResult(owned, deps.state, undefined, { childSafe: Boolean(nestedResolutionScopeForExecutor(deps)) });
+        const state = result.details.run.state;
+        if (state === "live")
+            return undefined;
+        return { ...result, content: [{ type: "text", text: `Nudge not sent: ${state === "unknown" ? "completion is unconfirmed" : `run is already ${state}`}. No child was restarted.\n\n${result.content.map((part) => part.type === "text" ? part.text : "").join("\n")}` }] };
+    }
+    const remembered = deps.state.foregroundRuns?.get(runId);
+    const status = remembered
+        ? rememberedForegroundStatusResult(remembered, Boolean(nestedResolutionScopeForExecutor(deps)))
+        : inspectSubagentStatus({ id: runId }, { state: deps.state, nested: nestedResolutionScopeForExecutor(deps) });
+    const state = status.details.managementControl?.state;
+    if (status.isError || !state || state === "live" || state === "unknown")
+        return undefined;
+    return {
+        ...status,
+        content: [{ type: "text", text: `Nudge not sent: run is already ${state}. No child was restarted.\n\n${status.content.filter((part) => part.type === "text").map((part) => part.text).join("\n")}` }],
+    };
+}
+export async function nudgeSubagentRun(input) {
+    const message = input.params.message?.trim() || "What are you blocked on? Reply with the smallest next step, or state the exact decision you need.";
+    const requestedId = input.params.id ?? input.params.runId;
+    let runId;
+    let agent;
+    let index;
+    let target;
+    let resolvedRunId;
+    try {
+        const owned = input.params.dir ? undefined : resolveOwnedRun(input.deps.state, requestedId ?? getAsyncInterruptTarget(input.deps.state, undefined)?.asyncId ?? "latest");
+        if (owned) {
+            resolvedRunId = owned.runId;
+            const terminal = terminalNudgeResult(owned.runId, input.deps);
+            if (terminal)
+                return terminal;
+            const view = ownedRunView(owned, input.deps.state);
+            const children = view.children.filter((child) => child.state === "live" && (input.params.index === undefined || input.params.index === child.index));
+            if (children.length !== 1)
+                throw new Error(`Run '${owned.runId}' has ${children.length} matching live children. Provide index to choose one.`);
+            const child = children[0];
+            if (child.activity?.status === "pending")
+                throw new Error(`Child ${child.index} is waiting to start in run ${owned.runId}. No message was sent and no continuation was started.`);
+            runId = owned.runId;
+            agent = child.agent;
+            index = child.index;
+            target = resolveSubagentIntercomTarget(runId, agent, index);
+        }
+        else {
+            const resolved = requestedId ? resolveSubagentRunId(requestedId, { state: input.deps.state, nested: nestedResolutionScopeForExecutor(input.deps) }) : undefined;
+            const remembered = !resolved && requestedId ? resolveRememberedForegroundRun(requestedId, input.deps.state) : undefined;
+            resolvedRunId = resolved?.id ?? remembered?.runId;
+            const terminal = resolvedRunId ? terminalNudgeResult(resolvedRunId, input.deps) : undefined;
+            if (terminal)
+                return terminal;
+            if (resolved?.kind === "nested") {
+                const run = resolved.match.run;
+                const state = run.state === "running" || run.state === "queued" ? "live" : run.state === "complete" ? "completed" : run.state === "paused" || run.state === "blocked" || run.state === "failed" ? run.state : "unknown";
+                const intercomTarget = run.intercomTarget ?? run.leafIntercomTarget;
+                const childSafe = Boolean(nestedResolutionScopeForExecutor(input.deps));
+                const valid = [formatRunAction("status", run.id, {}, childSafe)];
+                if (state === "live" || run.sessionFile)
+                    valid.push(formatRunAction("resume", run.id, { message: "..." }, childSafe));
+                if (state === "live")
+                    valid.push(formatRunAction("interrupt", run.id, {}, childSafe));
+                return {
+                    content: [{ type: "text", text: `Nested run ${run.id} cannot be nudged. Valid actions: ${valid.join(" or ")}${intercomTarget ? `. Intercom target: ${intercomTarget}` : "."}` }],
+                    isError: true,
+                    details: { mode: "management", results: [], managementControl: buildManagementControl({ state, runId: run.id, intercomTarget, canNudge: false, canResume: state === "live" || Boolean(run.sessionFile), canInterrupt: state === "live", unavailableActions: { nudge: "Nested runs do not support nudge; use an advertised exact action or intercom target." } }) },
+                };
+            }
+            if (remembered)
+                return rememberedForegroundStatusResult(remembered, Boolean(nestedResolutionScopeForExecutor(input.deps)));
+            const asyncTarget = resolveAsyncResumeTarget({ id: input.params.id ?? (!requestedId ? getAsyncInterruptTarget(input.deps.state, undefined)?.asyncId : undefined), runId: input.params.runId, dir: input.params.dir, index: input.params.index });
+            if (asyncTarget.kind !== "live") {
+                return terminalNudgeResult(asyncTarget.runId, input.deps)
+                    ?? inspectSubagentStatus({ id: asyncTarget.runId }, { state: input.deps.state, nested: nestedResolutionScopeForExecutor(input.deps) });
+            }
+            runId = asyncTarget.runId;
+            agent = asyncTarget.agent;
+            index = asyncTarget.index;
+            target = asyncTarget.intercomTarget;
+        }
+    }
+    catch (error) {
+        const terminal = resolvedRunId ? terminalNudgeResult(resolvedRunId, input.deps) : undefined;
+        if (terminal)
+            return terminal;
+        const text = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text }], isError: true, details: { mode: "management", results: [] } };
+    }
+    const result = await sendLiveSubagentMessage(input.deps.pi.events, {
+        to: target,
+        message: `Nudge for subagent run ${runId} (${agent}${index !== undefined ? ` step ${index + 1}` : ""}):\n\n${message}`,
+        delivery: "steer",
+        extra: { source: "subagent-nudge", runId, agent, index },
+    });
+    if (!result.delivered) {
+        const terminal = terminalNudgeResult(runId, input.deps);
+        if (terminal)
+            return terminal;
+        return { content: [{ type: "text", text: [`Nudge was not delivered.`, `Run: ${runId}`, `Intercom target: ${target}`, result.reason ? `Reason: ${result.reason}` : undefined].filter((line) => Boolean(line)).join("\n") }], isError: true, details: { mode: "management", results: [] } };
+    }
+    return {
+        content: [{ type: "text", text: [`Nudge delivered to live subagent.`, `Run: ${runId}`, `Agent: ${agent}`, `Intercom target: ${target}`].join("\n") }],
+        details: { mode: "management", results: [], managementControl: buildManagementControl({ state: "live", runId, index, intercomTarget: target, canNudge: true, canResume: true, canInterrupt: true }) },
+    };
+}
+export async function resumeAsyncRun(input) {
+    const followUp = (input.params.message ?? input.params.task ?? "").trim();
+    if (!followUp) {
+        return {
+            content: [{ type: "text", text: "action='resume' requires message." }],
+            isError: true,
+            details: { mode: "management", results: [] },
+        };
+    }
+    let target;
+    const parentSessionFile = input.ctx.sessionManager.getSessionFile() ?? null;
+    const nudgeContinuation = (runId, sessionFile) => {
+        if (!sessionFile)
+            return;
+        for (const candidate of input.deps.state.ownedRuns?.values() ?? []) {
+            if (candidate.runId === runId)
+                continue;
+            if (!candidate.children.some((child) => child.sessionFile === sessionFile)
+                && input.deps.state.asyncJobs.get(candidate.runId)?.sessionFile !== sessionFile)
+                continue;
+            const active = ownedRunView(candidate, input.deps.state, { readConfiguration: false }).children.find((entry) => entry.sessionFile === sessionFile && entry.state === "live");
+            if (!active)
+                continue;
+            return nudgeSubagentRun({ params: { ...input.params, dir: undefined, id: candidate.runId, index: active.index, message: followUp }, deps: input.deps, ctx: input.ctx }).then((result) => {
+                const notice = liveLaunchOverrideNotice(input.params);
+                if (notice)
+                    result.content.push({ type: "text", text: notice });
+                return result;
+            });
+        }
+    };
+    try {
+        const requestedId = input.params.id ?? input.params.runId;
+        const pendingQuestions = requestedId && !input.params.dir
+            ? listSupervisorQuestions(input.ctx.sessionManager.getSessionId(), requestedId).filter((question) => question.state === "awaiting_input" || question.state === "answer_pending")
+            : [];
+        if (pendingQuestions.length)
+            return continueQuestionSession(input, pendingQuestions);
+        const owned = requestedId && !input.params.dir ? resolveOwnedRun(input.deps.state, requestedId) : undefined;
+        if (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") {
+                const result = await nudgeSubagentRun({ params: { ...input.params, id: owned.runId, message: followUp }, deps: input.deps, ctx: input.ctx });
+                const notice = liveLaunchOverrideNotice(input.params);
+                if (notice)
+                    result.content.push({ type: "text", text: notice });
+                return result;
+            }
+            const continuation = nudgeContinuation(owned.runId, child.sessionFile);
+            if (continuation)
+                return await continuation;
+            const contract = readQuestionContract(owned.runId, child.index);
+            return reviveSavedSubagent(input, {
+                ...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,
+            });
+        }
+        const resolved = requestedId ? resolveSubagentRunId(requestedId, { state: input.deps.state, nested: nestedResolutionScopeForExecutor(input.deps) }) : undefined;
+        if (resolved?.kind === "nested") {
+            if (resolved.match.run.state === "running" || resolved.match.run.state === "queued") {
+                return resumeLiveNestedRun({ target: resolved, message: followUp, index: input.params.index, acceptanceOverrideSupplied: input.params.acceptance !== undefined, pi: input.deps.pi, childSafe: Boolean(nestedResolutionScopeForExecutor(input.deps)) });
+            }
+            const trustedSessionRoots = [
+                ...(input.deps.config.defaultSessionDir ? [path.resolve(input.deps.expandTilde(input.deps.config.defaultSessionDir))] : []),
+                ...(parentSessionFile ? [input.deps.getSubagentSessionRoot(parentSessionFile)] : []),
+            ];
+            target = resolveNestedResumeTarget(resolved, trustedSessionRoots);
+        }
+        else {
+            target = resolveResumeTarget(input.params, input.deps.state);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const requestedId = input.params.id ?? input.params.runId;
+        if (requestedId && !input.params.dir && (isAsyncRunNotFound(error) || message.includes("is detached for intercom coordination"))) {
+            try {
+                const questions = listSupervisorQuestions(input.ctx.sessionManager.getSessionId(), requestedId);
+                if (questions.length)
+                    return continueQuestionSession(input, questions);
+            }
+            catch (questionError) {
+                return { content: [{ type: "text", text: questionError instanceof Error ? questionError.message : String(questionError) }], isError: true, details: { mode: "management", results: [] } };
+            }
+        }
+        return { content: [{ type: "text", text: message }], isError: true, details: { mode: "management", results: [] } };
+    }
+    if (target.kind === "live") {
+        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 {
+                content: [{ type: "text", text: [`Delivered follow-up to live async child.`, `Run: ${target.runId}`, `Intercom target: ${target.intercomTarget}`, input.params.acceptance !== undefined ? LIVE_ACCEPTANCE_OVERRIDE_NOTICE : undefined].filter(Boolean).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 }) },
+            };
+        }
+        return {
+            content: [{ type: "text", text: [`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: "..." }, Boolean(nestedResolutionScopeForExecutor(input.deps)))}.`].join("\n") }],
+            isError: true,
+            details: { mode: "management", results: [] },
+        };
+    }
+    return nudgeContinuation(target.runId, target.sessionFile) ?? reviveSavedSubagent(input, target);
+}
+function continueQuestionSession(input, questions) {
+    if (input.params.index === undefined && new Set(questions.map((question) => question.index)).size > 1)
+        throw new Error("Provide index to choose which child question to continue.");
+    const question = questions.findLast((entry) => input.params.index === undefined || entry.index === input.params.index);
+    if (!question)
+        throw new Error("No saved question for that child index.");
+    if (questionProcessAlive(question))
+        throw new Error("The question's child is still alive. Answer the question or stop it before continuing.");
+    if (question.delivery?.kind === "revive")
+        throw new Error(`Use continue with the answer's continuation run ${question.delivery.runId}.`);
+    const revival = question.revival;
+    const prior = revival ? resolveSubagentRunId(revival.runId, { state: input.deps.state, nested: nestedResolutionScopeForExecutor(input.deps) }) : undefined;
+    const priorExists = prior?.kind === "async"
+        ? prior.location.resultPath || (prior.location.asyncDir && fs.existsSync(path.join(prior.location.asyncDir, "status.json")))
+        : Boolean(prior);
+    if (revival && (questionProcessAlive(revival) || priorExists || fs.existsSync(getAsyncConfigPath(revival.runId)) || fs.existsSync(path.join(getRunMetadataDir(revival.runId), "launch.json")) || fs.existsSync(path.join(ASYNC_DIR, revival.runId, RUNNER_ERROR_LOG_FILE)))) {
+        throw new Error(`Continuation ${revival.runId} may already have launched. Inspect or continue that run; the original question was not restarted.`);
+    }
+    const message = [input.params.message ?? input.params.task, question.answer ? `Saved supervisor answer:\n${question.answer.message}\n\nOriginal question:\n${question.message}` : undefined].filter(Boolean).join("\n\n");
+    const result = reviveSavedSubagent({ ...input, params: { ...input.params, message } }, { ...question, source: "question" });
+    if (!result.isError && question.answer && !question.delivery)
+        recordQuestionDelivery(question, { kind: "revive", runId: result.details.asyncId, deliveredAt: Date.now() });
+    return result;
+}
+export function reviveSavedSubagent(input, target, runId = randomUUID()) {
+    const followUp = (input.params.message ?? input.params.task ?? "").trim();
+    const parentSessionFile = input.ctx.sessionManager.getSessionFile() ?? null;
+    if (!target.sessionFile || path.extname(target.sessionFile) !== ".jsonl" || !fs.existsSync(target.sessionFile)) {
+        return { content: [{ type: "text", text: `Saved child session file is unavailable: ${target.sessionFile ?? "none"}. No child was started; any saved answer remains pending.` }], isError: true, details: { mode: "management", results: [] } };
+    }
+    const { blocked, depth, maxDepth } = checkSubagentDepth(input.deps.config.maxSubagentDepth);
+    if (blocked) {
+        return {
+            content: [{ type: "text", text: `Nested subagent resume blocked (depth=${depth}, max=${maxDepth}). Complete the follow-up directly instead.` }],
+            isError: true,
+            details: { mode: "management", results: [] },
+        };
+    }
+    input.deps.state.currentSessionId = resolveCurrentSessionId(input.ctx.sessionManager);
+    const contract = readQuestionContract(target.runId, target.index) ?? target;
+    const savedLaunch = input.params.agent === undefined && contract.launch ? { ...contract.launch, ...contract.effectiveConfiguration } : undefined;
+    const generatedOutputFilename = input.params.output === undefined ? contract.launch?.generatedOutputFilename : undefined;
+    const effectiveCwd = input.params.cwd ?? savedLaunch?.cwd ?? target.cwd ?? input.requestCwd;
+    const scope = resolveExecutionAgentScope(input.params.agentScope);
+    if (!savedLaunch && !input.params.agent) {
+        return { content: [{ type: "text", text: `Run '${target.runId}' predates saved launch configuration. Its session and known result remain available, but the original profile cannot be reconstructed safely. Continue with agent: '${target.agent}' to explicitly use that profile's current configuration, including model and thinking; known output and acceptance are retained unless overridden.` }], isError: true, details: { mode: "management", results: [] } };
+    }
+    const discoveredAgents = savedLaunch ? [savedLaunch.agent] : input.deps.discoverAgents(effectiveCwd, scope, { projectTrusted: input.ctx.isProjectTrusted() }).agents;
+    const fallbackTarget = resolveIntercomSessionTarget(input.deps.pi.getSessionName(), input.ctx.sessionManager.getSessionId());
+    const orchestratorTarget = resolveOrchestratorIntercomTarget(input.deps.pi.events, fallbackTarget);
+    const intercomBridge = resolveIntercomBridge(orchestratorTarget);
+    const inheritedModel = providerQualifiedModelId(input.ctx.model?.provider, input.ctx.model?.id);
+    const agents = savedLaunch ? discoveredAgents : discoveredAgents.map((agent) => agent.model || !inheritedModel ? agent : { ...agent, model: inheritedModel });
+    const selectedAgent = input.params.agent ?? target.agent;
+    const profile = agents.find((agent) => agent.name === selectedAgent);
+    const agentConfig = profile && savedLaunch ? { ...profile, thinking: savedLaunch.thinking ?? profile.thinking, maxExecutionTimeMs: savedLaunch.maxExecutionTimeMs, maxTokens: savedLaunch.maxTokens } : profile;
+    if (!agentConfig) {
+        return {
+            content: [{ type: "text", text: `Unknown agent for resume: ${selectedAgent}` }],
+            isError: true,
+            details: { mode: "management", results: [] },
+        };
+    }
+    saveQuestionOwner(runId, input.ctx.sessionManager.getSessionId());
+    const prior = input.deps.state.ownedRuns?.get(target.runId);
+    rememberOwnedRun(input.deps.state, {
+        runId, ownerSessionId: input.ctx.sessionManager.getSessionId(), rootRunId: prior?.rootRunId ?? target.runId,
+        predecessorRunId: target.runId, predecessorIndex: target.index,
+        source: "async", mode: "single", cwd: effectiveCwd, task: followUp, startedAt: Date.now(),
+        children: [{ agent: selectedAgent, index: 0, task: followUp, label: prior?.children.find((child) => child.index === target.index)?.label, sessionFile: target.sessionFile }],
+    });
+    const modelOverride = input.params.model;
+    const skill = normalizeSkillInput(input.params.skill);
+    const availableModels = input.ctx.modelRegistry.getAvailable().map(toModelInfo);
+    const launchInput = {
+        agent: selectedAgent,
+        task: buildRevivedAsyncTask(target, followUp, input.params.messageOrigin),
+        agentConfig,
+        ctx: {
+            pi: input.deps.pi,
+            cwd: input.requestCwd,
+            currentSessionId: input.deps.state.currentSessionId,
+            rootSessionId: resolveRootSessionId(input.ctx.sessionManager),
+            currentModelProvider: input.ctx.model?.provider,
+            projectTrusted: input.ctx.isProjectTrusted(),
+        },
+        cwd: effectiveCwd,
+        maxOutput: input.params.maxOutput ?? savedLaunch?.maxOutput,
+        artifactsDir: input.params.artifacts === false || (input.params.artifacts === undefined && savedLaunch?.artifacts === false) ? undefined : savedLaunch?.artifactsDir ?? input.deps.tempArtifactsDir,
+        shareEnabled: input.params.share ?? savedLaunch?.share ?? false,
+        sessionRoot: input.deps.getSubagentSessionRoot(parentSessionFile),
+        sessionFile: target.sessionFile,
+        maxSubagentDepth: savedLaunch?.maxSubagentDepth ?? resolveCurrentMaxSubagentDepth(input.deps.config.maxSubagentDepth),
+        worktreeSetupHook: input.deps.config.worktreeSetupHook,
+        worktreeSetupHookTimeoutMs: input.deps.config.worktreeSetupHookTimeoutMs,
+        controlConfig: resolveControlConfig(savedLaunch?.controlConfig ?? input.deps.config.control, input.params.control),
+        controlIntercomTarget: intercomBridge.orchestratorTarget,
+        childIntercomTarget: (agent, index) => resolveSubagentIntercomTarget(runId, agent, index),
+        availableModels, savedLaunch, modelOverride,
+        skills: skill,
+        acceptance: input.params.acceptance ?? acceptanceInputFromResolved(contract.effectiveAcceptance ?? savedLaunch?.effectiveAcceptance),
+        output: input.params.output ?? (generatedOutputFilename ? true : savedLaunch?.output ?? contract.output),
+        generatedOutputFilename,
+        outputMode: input.params.outputMode ?? savedLaunch?.outputMode ?? contract.outputMode,
+        outputSchema: input.params.outputSchema ?? savedLaunch?.outputSchema ?? contract.outputSchema,
+        projectTrust: savedLaunch?.projectTrust ?? resolveConfiguredChildProjectTrustPolicy(input.deps.config.projectTrust),
+    };
+    const undoCwdRequest = input.params.cwd !== undefined ? requestChildExecutionCwd(target.sessionFile, effectiveCwd) : undefined;
+    let result;
+    try {
+        result = executeAsyncSingle(runId, launchInput);
+    }
+    catch (error) {
+        undoCwdRequest?.();
+        throw error;
+    }
+    if (result.isError)
+        undoCwdRequest?.();
+    const owned = input.deps.state.ownedRuns?.get(runId);
+    if (owned)
+        rememberOwnedRun(input.deps.state, { ...owned, asyncDir: result.details.asyncDir, pid: result.details.asyncPid ?? input.deps.state.asyncJobs.get(runId)?.pid, ...(result.isError ? { error: result.content.map((part) => part.text).join("\n") } : {}) });
+    if (result.isError)
+        return result;
+    const revivedId = result.details.asyncId ?? runId;
+    const revivedTarget = resolveSubagentIntercomTarget(revivedId, selectedAgent, 0);
+    const sourceLabel = target.source;
+    const lines = [
+        `Revived ${sourceLabel} subagent from ${target.runId}.`,
+        `Run mapping: ${target.runId} -> ${revivedId}`,
+        `Revived run: ${revivedId}`,
+        `Agent: ${selectedAgent}`,
+        `Configuration: ${savedLaunch ? "saved effective launch" : "explicitly selected current profile"}${modelOverride ? `; model ${modelOverride}` : ""}`,
+        `Root: ${prior?.rootRunId ?? target.runId}`,
+        `Session: ${target.sessionFile}`,
+        result.details.asyncDir ? `Async dir: ${result.details.asyncDir}` : undefined,
+        revivedTarget ? `Intercom target: ${revivedTarget} (if registered)` : undefined,
+        `Prior pending-reply context for ${target.runId} is invalid; use the revived run and target only.`,
+        `Status if needed: ${formatRunAction("status", revivedId, {}, Boolean(nestedResolutionScopeForExecutor(input.deps)))}`,
+    ].filter((line) => Boolean(line));
+    return {
+        content: [{ type: "text", text: formatAsyncStartedMessage(lines.join("\n"), Boolean(nestedResolutionScopeForExecutor(input.deps))) }],
+        details: {
+            ...result.details,
+            managementControl: buildManagementControl({ state: "live", runId: revivedId, index: 0, intercomTarget: revivedTarget, canInterrupt: true, revivedFromRunId: target.runId }),
+        },
+    };
+}