@fitchmultz/pi-subagents 0.49.0 → 0.50.0

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

@@ -1,355 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
-import { sendLiveSubagentMessage } from "../../intercom/live-intercom.ts";
-import { resolveAsyncResumeTarget } from "../background/async-resume.ts";
-import { resolveSubagentRunId } from "../background/run-id-resolver.ts";
-import { inspectSubagentStatus } from "../background/run-status.ts";
-import { ownedRunStatusResult, ownedRunView, resolveOwnedRun } from "../shared/run-records.ts";
-import { buildManagementControl, formatRunAction } from "../../shared/status-format.ts";
-import { errorMessage } from "../../shared/unknown.ts";
-import type {
-  NestedRunSummary,
-  ManagementRunState,
-  OwnedRun,
-  SubagentExecutionResult,
-} from "../../shared/types.ts";
-import { nestedResolutionScopeForExecutor } from "./execution-routing.ts";
-import {
-  rememberedForegroundStatusResult,
-  resolveRememberedForegroundRun,
-} from "./foreground-memory.ts";
-import { getAsyncInterruptTarget } from "./run-interrupt.ts";
-import type { ExecutorReadDeps, SubagentParamsLike } from "./subagent-params.ts";
-
-type Target = {
-  readonly kind: "target";
-  readonly runId: string;
-  readonly agent: string;
-  readonly index: number;
-  readonly target: string;
-};
-type Resolution = Target | { readonly kind: "result"; readonly result: SubagentExecutionResult };
-function resolvedResult(result: SubagentExecutionResult): Resolution {
-  return { kind: "result", result };
-}
-function failure(text: string): SubagentExecutionResult {
-  return {
-    content: [{ type: "text", text }],
-    isError: true,
-    details: { mode: "management", results: [] },
-  };
-}
-function terminalOwnedNudge(
-  owned: OwnedRun,
-  deps: ExecutorReadDeps,
-): SubagentExecutionResult | undefined {
-  const result = ownedRunStatusResult(owned, deps.state, undefined, {
-    childSafe: nestedResolutionScopeForExecutor(deps) !== undefined,
-  });
-  const state = result.details.run?.state;
-  if (state === undefined || state === "live") {
-    return;
-  }
-  const outcome = state === "unknown" ? "completion is unconfirmed" : `run is already ${state}`;
-  return {
-    ...result,
-    content: [
-      {
-        type: "text",
-        text: `Nudge not sent: ${outcome}. No child was restarted.\n\n${result.content.map((part) => (part.type === "text" ? part.text : "")).join("\n")}`,
-      },
-    ],
-  };
-}
-function terminalNudgeResult(
-  runId: string,
-  deps: ExecutorReadDeps,
-): SubagentExecutionResult | undefined {
-  const owned = resolveOwnedRun(deps.state, runId);
-  const childSafe = nestedResolutionScopeForExecutor(deps) !== undefined;
-  if (owned) {
-    return terminalOwnedNudge(owned, deps);
-  }
-  const remembered = deps.state.foregroundRuns?.get(runId);
-  const result = remembered
-    ? rememberedForegroundStatusResult(remembered, childSafe)
-    : inspectSubagentStatus(
-        { id: runId },
-        { state: deps.state, nested: nestedResolutionScopeForExecutor(deps) },
-      );
-  const state = result.details.managementControl?.state;
-  if (result.isError === true || state === undefined || state === "live" || state === "unknown") {
-    return;
-  }
-  return {
-    ...result,
-    content: [
-      {
-        type: "text",
-        text: `Nudge not sent: run is already ${state}. No child was restarted.\n\n${result.content
-          .filter((part) => part.type === "text")
-          .map((part) => part.text)
-          .join("\n")}`,
-      },
-    ],
-  };
-}
-function ownedTarget(
-  run: OwnedRun,
-  params: SubagentParamsLike,
-  deps: ExecutorReadDeps,
-): Resolution {
-  const terminal = terminalNudgeResult(run.runId, deps);
-  if (terminal) {
-    return resolvedResult(terminal);
-  }
-  const children = ownedRunView(run, deps.state).children.filter(
-    (child) =>
-      child.state === "live" && (params.index === undefined || params.index === child.index),
-  );
-  const child = children.at(0);
-  if (children.length !== 1 || !child) {
-    throw new Error(
-      `Run '${run.runId}' has ${children.length} matching live children. Provide index to choose one.`,
-    );
-  }
-  if (child.activity?.status === "pending") {
-    throw new Error(
-      `Child ${child.index} is waiting to start in run ${run.runId}. No message was sent and no continuation was started.`,
-    );
-  }
-  return {
-    kind: "target",
-    runId: run.runId,
-    agent: child.agent,
-    index: child.index,
-    target: resolveSubagentIntercomTarget(run.runId, child.agent, child.index),
-  };
-}
-function nestedState(run: NestedRunSummary): ManagementRunState {
-  switch (run.state) {
-    case "running":
-    case "queued":
-      return "live";
-    case "complete":
-      return "completed";
-    case "paused":
-    case "blocked":
-    case "failed":
-      return run.state;
-  }
-}
-function nestedNudgeResult(run: NestedRunSummary, deps: ExecutorReadDeps): SubagentExecutionResult {
-  const state = nestedState(run),
-    childSafe = nestedResolutionScopeForExecutor(deps) !== undefined;
-  const intercomTarget = run.intercomTarget ?? run.leafIntercomTarget;
-  const resumable =
-    state === "live" || (run.sessionFile !== undefined && run.sessionFile.length > 0);
-  const valid = [formatRunAction("status", run.id, {}, childSafe)];
-  if (resumable) {
-    valid.push(formatRunAction("resume", run.id, { message: "..." }, childSafe));
-  }
-  if (state === "live") {
-    valid.push(formatRunAction("interrupt", run.id, {}, childSafe));
-  }
-  const address =
-    intercomTarget !== undefined && intercomTarget.length > 0
-      ? `. Intercom target: ${intercomTarget}`
-      : ".";
-  return {
-    content: [
-      {
-        type: "text",
-        text: `Nested run ${run.id} cannot be nudged. Valid actions: ${valid.join(" or ")}${address}`,
-      },
-    ],
-    isError: true,
-    details: {
-      mode: "management",
-      results: [],
-      managementControl: buildManagementControl({
-        state,
-        runId: run.id,
-        intercomTarget,
-        canNudge: false,
-        canResume: resumable,
-        canInterrupt: state === "live",
-        unavailableActions: {
-          nudge:
-            "Nested runs do not support nudge; use an advertised exact action or intercom target.",
-        },
-      }),
-    },
-  };
-}
-function unownedTarget(params: SubagentParamsLike, deps: ExecutorReadDeps): Resolution {
-  const requested = params.id ?? params.runId;
-  const resolved = resolveNudgeId(requested, deps);
-  const remembered = rememberedNudgeRun(requested, resolved !== undefined, deps);
-  const resolvedId = resolved?.id ?? remembered?.runId;
-  const terminal = resolvedId !== undefined ? terminalNudgeResult(resolvedId, deps) : undefined;
-  if (terminal) {
-    return resolvedResult(terminal);
-  }
-  if (resolved?.kind === "nested") {
-    return resolvedResult(nestedNudgeResult(resolved.match.run, deps));
-  }
-  if (remembered) {
-    return resolvedResult(
-      rememberedForegroundStatusResult(
-        remembered,
-        nestedResolutionScopeForExecutor(deps) !== undefined,
-      ),
-    );
-  }
-  return resolveAsyncNudge(params, deps, resolvedId);
-}
-function resolveNudgeId(
-  requested: string | undefined,
-  deps: ExecutorReadDeps,
-): ReturnType<typeof resolveSubagentRunId> {
-  if (requested === undefined || requested.length === 0) {
-    return;
-  }
-  return resolveSubagentRunId(requested, {
-    state: deps.state,
-    nested: nestedResolutionScopeForExecutor(deps),
-  });
-}
-function rememberedNudgeRun(
-  requested: string | undefined,
-  resolved: boolean,
-  deps: ExecutorReadDeps,
-): ReturnType<typeof resolveRememberedForegroundRun> {
-  if (resolved || requested === undefined || requested.length === 0) {
-    return;
-  }
-  return resolveRememberedForegroundRun(requested, deps.state);
-}
-function resolveAsyncNudge(
-  params: SubagentParamsLike,
-  deps: ExecutorReadDeps,
-  resolvedId: string | undefined,
-): Resolution {
-  try {
-    return asyncTarget(params, deps);
-  } catch (error) {
-    return resolvedResult(
-      (resolvedId !== undefined ? terminalNudgeResult(resolvedId, deps) : undefined) ??
-        failure(errorMessage(error)),
-    );
-  }
-}
-function asyncTarget(params: SubagentParamsLike, deps: ExecutorReadDeps): Resolution {
-  const requested = params.id ?? params.runId;
-  const target = resolveAsyncResumeTarget({
-    id:
-      params.id ??
-      (requested === undefined || requested.length === 0
-        ? getAsyncInterruptTarget(deps.state)?.asyncId
-        : undefined),
-    runId: params.runId,
-    dir: params.dir,
-    index: params.index,
-  });
-  if (target.kind !== "live") {
-    return resolvedResult(
-      terminalNudgeResult(target.runId, deps) ??
-        inspectSubagentStatus(
-          { id: target.runId },
-          { state: deps.state, nested: nestedResolutionScopeForExecutor(deps) },
-        ),
-    );
-  }
-  return {
-    kind: "target",
-    runId: target.runId,
-    agent: target.agent,
-    index: target.index,
-    target: target.intercomTarget,
-  };
-}
-function resolveOwnedNudge(
-  params: SubagentParamsLike,
-  deps: ExecutorReadDeps,
-): OwnedRun | undefined {
-  if (params.dir !== undefined && params.dir.length > 0) {
-    return;
-  }
-  const requested =
-    params.id ?? params.runId ?? getAsyncInterruptTarget(deps.state)?.asyncId ?? "latest";
-  return resolveOwnedRun(deps.state, requested);
-}
-function resolveNudge(params: SubagentParamsLike, deps: ExecutorReadDeps): Resolution {
-  let runId: string | undefined;
-  try {
-    const owned = resolveOwnedNudge(params, deps);
-    runId = owned?.runId;
-    return owned ? ownedTarget(owned, params, deps) : unownedTarget(params, deps);
-  } catch (error) {
-    return resolvedResult(
-      (runId !== undefined ? terminalNudgeResult(runId, deps) : undefined) ??
-        failure(errorMessage(error)),
-    );
-  }
-}
-/** Resolve only live ownership, send once, then re-check terminal facts if delivery failed. */
-export async function nudgeSubagentRun(input: {
-  readonly params: SubagentParamsLike;
-  readonly deps: ExecutorReadDeps;
-  readonly ctx?: ExtensionContext;
-}): Promise<SubagentExecutionResult> {
-  const resolution = resolveNudge(input.params, input.deps);
-  if (resolution.kind === "result") {
-    return resolution.result;
-  }
-  const { runId, agent, index, target } = resolution;
-  const requestedMessage = input.params.message?.trim() ?? "";
-  const message =
-    requestedMessage.length > 0
-      ? requestedMessage
-      : "What are you blocked on? Reply with the smallest next step, or state the exact decision you need.";
-  const result = await sendLiveSubagentMessage(input.deps.pi.events, {
-    to: target,
-    message: `Nudge for subagent run ${runId} (${agent} 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;
-    }
-    const lines = ["Nudge was not delivered.", `Run: ${runId}`, `Intercom target: ${target}`];
-    if (result.reason !== undefined && result.reason.length > 0) {
-      lines.push(`Reason: ${result.reason}`);
-    }
-    return failure(lines.join("\n"));
-  }
-  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,
-      }),
-    },
-  };
-}

package/src/runs/foreground/saved-revival.ts

@@ -1,356 +0,0 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { resolveExecutionAgentScope } from "../../agents/agent-scope.ts";
-import { normalizeSkillInput } from "../../agents/skills.ts";
-import { providerQualifiedModelId, toModelInfo } from "../../shared/model-info.ts";
-import { resolveCurrentSessionId, resolveRootSessionId } from "../../shared/session-identity.ts";
-import {
-  resolveIntercomBridge,
-  resolveIntercomSessionTarget,
-  resolveOrchestratorIntercomTarget,
-  resolveSubagentIntercomTarget,
-} from "../../intercom/intercom-bridge.ts";
-import { executeAsyncSingle, formatAsyncStartedMessage } from "../background/async-execution.ts";
-import { buildRevivedAsyncTask } from "../background/async-resume.ts";
-import { requestChildExecutionCwd } from "../shared/child-execution-cwd.ts";
-import {
-  readQuestionContract,
-  saveQuestionOwner,
-  type SupervisorRunContract,
-} from "../shared/supervisor-questions.ts";
-import { rememberOwnedRun } from "../shared/run-records.ts";
-import { resolveRevivalLaunchPolicy } from "./revival-launch-policy.ts";
-import { buildManagementControl, formatRunAction } from "../../shared/status-format.ts";
-import {
-  checkSubagentDepth,
-  type AgentConfig,
-  type OwnedRun,
-  type SubagentState,
-  type SavedLaunchConfig,
-  type ReadonlyInput,
-  type SubagentExecutionResult,
-} from "../../shared/types.ts";
-import { nestedResolutionScopeForExecutor } from "./execution-routing.ts";
-import type { ExecutorDeps, ExecutorReadDeps, SubagentParamsLike } from "./subagent-params.ts";
-
-export interface RevivalInput {
-  readonly params: SubagentParamsLike;
-  readonly requestCwd: string;
-  readonly ctx: ExtensionContext;
-  readonly deps: ExecutorDeps;
-}
-export type RevivalTarget = ReadonlyInput<SupervisorRunContract> & {
-  readonly runId: string;
-  readonly agent: string;
-  readonly index: number;
-  readonly source: string;
-  readonly cwd?: string;
-  readonly sessionFile?: string;
-  readonly model?: string;
-};
-type ReadRevivalInput = Readonly<Omit<RevivalInput, "deps">> & { readonly deps: ExecutorReadDeps };
-interface RevivalPlan {
-  readonly controlIntercomTarget: string;
-  readonly contract: ReadonlyInput<SupervisorRunContract>;
-  readonly savedLaunch?: SavedLaunchConfig;
-  readonly generatedOutputFilename?: string;
-  readonly cwd: string;
-  readonly selectedAgent: string;
-  readonly agentConfig: AgentConfig;
-}
-function failure(text: string): SubagentExecutionResult {
-  return {
-    content: [{ type: "text", text }],
-    isError: true,
-    details: { mode: "management", results: [] },
-  };
-}
-function resolveProfile(
-  input: ReadRevivalInput,
-  target: RevivalTarget,
-): RevivalPlan | SubagentExecutionResult {
-  const contract = readQuestionContract(target.runId, target.index) ?? target;
-  const savedLaunch = savedConfiguration(input.params, contract);
-  if (!canReconstruct(input.params, savedLaunch)) {
-    return failure(
-      `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.`,
-    );
-  }
-  const cwd = revivalCwd(input, target, savedLaunch);
-  const discovered = savedLaunch
-    ? [savedLaunch.agent]
-    : input.deps.discoverAgents(cwd, resolveExecutionAgentScope(input.params.agentScope), {
-        projectTrusted: input.ctx.isProjectTrusted(),
-      }).agents;
-  const fallback = resolveIntercomSessionTarget(
-    input.deps.pi.getSessionName(),
-    input.ctx.sessionManager.getSessionId(),
-  );
-  const bridge = resolveIntercomBridge(
-    resolveOrchestratorIntercomTarget(input.deps.pi.events, fallback),
-  );
-  const inherited = providerQualifiedModelId(input.ctx.model?.provider, input.ctx.model?.id);
-  const selectedAgent = input.params.agent ?? target.agent;
-  const profile = discovered.find((agent) => agent.name === selectedAgent);
-  if (!profile) {
-    return failure(`Unknown agent for resume: ${selectedAgent}`);
-  }
-  const configured = configuredProfile(profile, savedLaunch, inherited);
-  return {
-    controlIntercomTarget: bridge.orchestratorTarget,
-    contract,
-    savedLaunch,
-    generatedOutputFilename:
-      input.params.output === undefined ? contract.launch?.generatedOutputFilename : undefined,
-    cwd,
-    selectedAgent,
-    agentConfig: configured,
-  };
-}
-function savedConfiguration(
-  params: SubagentParamsLike,
-  contract: ReadonlyInput<SupervisorRunContract>,
-): SavedLaunchConfig | undefined {
-  return params.agent === undefined && contract.launch
-    ? { ...contract.launch, ...contract.effectiveConfiguration }
-    : undefined;
-}
-function canReconstruct(params: SubagentParamsLike, saved: SavedLaunchConfig | undefined): boolean {
-  return saved !== undefined || (params.agent !== undefined && params.agent.length > 0);
-}
-function revivalCwd(
-  input: ReadResumeCwd,
-  target: RevivalTarget,
-  saved: SavedLaunchConfig | undefined,
-): string {
-  return input.params.cwd ?? saved?.cwd ?? target.cwd ?? input.requestCwd;
-}
-type ReadResumeCwd = Readonly<Pick<RevivalInput, "params" | "requestCwd">>;
-function configuredProfile(
-  profile: AgentConfig,
-  saved: SavedLaunchConfig | undefined,
-  inherited: string | undefined,
-): AgentConfig {
-  return saved
-    ? {
-        ...profile,
-        thinking: saved.thinking ?? profile.thinking,
-        maxExecutionTimeMs: saved.maxExecutionTimeMs,
-        maxTokens: saved.maxTokens,
-      }
-    : inheritProfileModel(profile, inherited);
-}
-function inheritProfileModel(profile: AgentConfig, model: string | undefined): AgentConfig {
-  return (profile.model !== undefined && profile.model.length > 0) ||
-    model === undefined ||
-    model.length === 0
-    ? profile
-    : { ...profile, model };
-}
-function launchOptions(
-  input: ReadRevivalInput & { readonly parentSessionFile: string | null },
-  target: RevivalTarget,
-  plan: RevivalPlan,
-  runId: string,
-): Parameters<typeof executeAsyncSingle>[1] {
-  const { params, ctx, deps } = input;
-  const followUp = (params.message ?? params.task ?? "").trim();
-
-  return {
-    agent: plan.selectedAgent,
-    task: buildRevivedAsyncTask(target, followUp, params.messageOrigin),
-    agentConfig: plan.agentConfig,
-    ctx: revivalContext(input),
-    cwd: plan.cwd,
-    sessionRoot: deps.getSubagentSessionRoot(input.parentSessionFile),
-    sessionFile: target.sessionFile,
-    controlIntercomTarget: plan.controlIntercomTarget,
-    childIntercomTarget: (agent, index) => resolveSubagentIntercomTarget(runId, agent, index),
-    availableModels: ctx.modelRegistry.getAvailable().map(toModelInfo),
-    savedLaunch: plan.savedLaunch,
-    modelOverride: params.model,
-    skills: normalizeSkillInput(params.skill),
-    ...resolveRevivalLaunchPolicy({
-      params,
-      contract: plan.contract,
-      saved: plan.savedLaunch,
-      generatedOutputFilename: plan.generatedOutputFilename,
-      config: deps.config,
-      tempArtifactsDir: deps.tempArtifactsDir,
-    }),
-  };
-}
-function revivalContext(input: ReadRevivalInput): Parameters<typeof executeAsyncSingle>[1]["ctx"] {
-  const currentSessionId = input.deps.state.currentSessionId;
-  if (currentSessionId === null) {
-    throw new Error("Resume lost its current session identity before launch.");
-  }
-  return {
-    pi: input.deps.pi,
-    cwd: input.requestCwd,
-    currentSessionId,
-    rootSessionId: resolveRootSessionId(input.ctx.sessionManager),
-    currentModelProvider: input.ctx.model?.provider,
-    projectTrusted: input.ctx.isProjectTrusted(),
-  };
-}
-function launchContinuation(
-  runId: string,
-  options: Parameters<typeof executeAsyncSingle>[1],
-  undo?: () => void,
-): SubagentExecutionResult {
-  try {
-    const result = executeAsyncSingle(runId, options);
-    if (result.isError === true) {
-      undo?.();
-    }
-    return result;
-  } catch (error) {
-    undo?.();
-    throw error;
-  }
-}
-function revivalReceipt(
-  input: ReadRevivalInput,
-  target: RevivalTarget,
-  plan: RevivalPlan,
-  receipt: { readonly result: SubagentExecutionResult; readonly runId: string },
-): SubagentExecutionResult {
-  const { result } = receipt;
-  const revivedId = result.details.asyncId ?? receipt.runId;
-  const revivedTarget = resolveSubagentIntercomTarget(revivedId, plan.selectedAgent, 0);
-  const childSafe = nestedResolutionScopeForExecutor(input.deps) !== undefined;
-  const prior = input.deps.state.ownedRuns?.get(target.runId);
-  const configLabel = configurationLabel(plan.savedLaunch, input.params.model);
-  const lines = [
-    `Revived ${target.source} subagent from ${target.runId}.`,
-    `Run mapping: ${target.runId} -> ${revivedId}`,
-    `Revived run: ${revivedId}`,
-    `Agent: ${plan.selectedAgent}`,
-    `Configuration: ${configLabel}`,
-    `Root: ${prior?.rootRunId ?? target.runId}`,
-    `Session: ${target.sessionFile ?? "none"}`,
-  ];
-  if (result.details.asyncDir !== undefined && result.details.asyncDir.length > 0) {
-    lines.push(`Async dir: ${result.details.asyncDir}`);
-  }
-  lines.push(
-    `Intercom target: ${revivedTarget} (if registered)`,
-    `Prior pending-reply context for ${target.runId} is invalid; use the revived run and target only.`,
-    `Status if needed: ${formatRunAction("status", revivedId, {}, childSafe)}`,
-  );
-  return {
-    content: [{ type: "text", text: formatAsyncStartedMessage(lines.join("\n"), childSafe) }],
-    details: {
-      ...result.details,
-      managementControl: buildManagementControl({
-        state: "live",
-        runId: revivedId,
-        index: 0,
-        intercomTarget: revivedTarget,
-        canInterrupt: true,
-        revivedFromRunId: target.runId,
-      }),
-    },
-  };
-}
-function usableSessionFile(file: string): boolean {
-  return file.length > 0 && path.extname(file) === ".jsonl" && fs.existsSync(file);
-}
-function initialRevivalRecord(
-  input: ReadRevivalInput,
-  target: RevivalTarget,
-  plan: RevivalPlan,
-  receipt: { readonly runId: string; readonly sessionFile: string },
-): OwnedRun {
-  const prior = input.deps.state.ownedRuns?.get(target.runId);
-  const followUp = (input.params.message ?? input.params.task ?? "").trim();
-  return {
-    runId: receipt.runId,
-    ownerSessionId: input.ctx.sessionManager.getSessionId(),
-    rootRunId: prior?.rootRunId ?? target.runId,
-    predecessorRunId: target.runId,
-    predecessorIndex: target.index,
-    source: "async",
-    mode: "single",
-    cwd: plan.cwd,
-    task: followUp,
-    startedAt: Date.now(),
-    children: [
-      {
-        agent: plan.selectedAgent,
-        index: 0,
-        task: followUp,
-        label: prior?.children.find((child) => child.index === target.index)?.label,
-        sessionFile: receipt.sessionFile,
-      },
-    ],
-  };
-}
-function rememberRevivalReceipt(
-  // This persistence boundary updates the actual session-owned run record after launch settles.
-  state: SubagentState,
-  runId: string,
-  result: SubagentExecutionResult,
-): void {
-  const owned = state.ownedRuns?.get(runId);
-  if (owned) {
-    rememberOwnedRun(state, {
-      ...owned,
-      asyncDir: result.details.asyncDir,
-      pid: result.details.asyncPid ?? state.asyncJobs.get(runId)?.pid,
-      ...(result.isError === true
-        ? {
-            error: result.content.map((part) => (part.type === "text" ? part.text : "")).join("\n"),
-          }
-        : {}),
-    });
-  }
-}
-function configurationLabel(
-  saved: SavedLaunchConfig | undefined,
-  model: string | undefined,
-): string {
-  const label = saved ? "saved effective launch" : "explicitly selected current profile";
-  return model !== undefined && model.length > 0 ? `${label}; model ${model}` : label;
-}
-/** Validate the saved session, persist ownership, launch once, and roll back only the cwd request on failure. */
-export function reviveSavedSubagent(
-  // Revival owns session identity and durable launch/receipt updates in this dependency boundary.
-  input: RevivalInput,
-  target: RevivalTarget,
-  runId: string = randomUUID(),
-): SubagentExecutionResult {
-  const parentSessionFile = input.ctx.sessionManager.getSessionFile() ?? null;
-  const sessionFile = target.sessionFile;
-  if (sessionFile === undefined || !usableSessionFile(sessionFile)) {
-    return failure(
-      `Saved child session file is unavailable: ${sessionFile ?? "none"}. No child was started; any saved answer remains pending.`,
-    );
-  }
-  const { blocked, depth, maxDepth } = checkSubagentDepth(input.deps.config.maxSubagentDepth);
-  if (blocked) {
-    return failure(
-      `Nested subagent resume blocked (depth=${depth}, max=${maxDepth}). Complete the follow-up directly instead.`,
-    );
-  }
-  const state = input.deps.state;
-  state.currentSessionId = resolveCurrentSessionId(input.ctx.sessionManager);
-  const plan = resolveProfile(input, target);
-  if ("details" in plan) {
-    return plan;
-  }
-  saveQuestionOwner(runId, input.ctx.sessionManager.getSessionId());
-  rememberOwnedRun(state, initialRevivalRecord(input, target, plan, { runId, sessionFile }));
-  const options = launchOptions({ ...input, parentSessionFile }, target, plan, runId);
-  const undo =
-    input.params.cwd !== undefined ? requestChildExecutionCwd(sessionFile, plan.cwd) : undefined;
-  const result = launchContinuation(runId, options, undo);
-  rememberRevivalReceipt(state, runId, result);
-  if (result.isError === true) {
-    return result;
-  }
-  return revivalReceipt(input, target, plan, { result, runId });
-}