@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/runs/foreground/run-async-path.js

@@ -1,217 +0,0 @@
-import * as path from "node:path";
-import { resolveRootSessionId } from "../../shared/session-identity.js";
-import { toModelInfo } from "../../shared/model-info.js";
-import { resolveStepBehavior } from "../../shared/settings.js";
-import { normalizeSkillInput } from "../../agents/skills.js";
-import { executeAsyncChain, executeAsyncSingle } from "../background/async-execution.js";
-import { resolveConfiguredChildProjectTrustPolicy } from "../shared/pi-args.js";
-import { wrapChainTasksForAgentContext, wrapTaskForAgentContext, } from "../../shared/agent-context-policy.js";
-import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
-import { resolveTopLevelParallelConcurrency, resolveTopLevelParallelMaxTasks, resolveChildMaxSubagentDepth, resolveCurrentMaxSubagentDepth, } from "../../shared/types.js";
-import { maxParallelTasksMessage, resolveTopLevelOutputOverride, usesAgentDefaultOutput, } from "./subagent-params.js";
-import { buildChainWorktreeTaskCwdError, buildParallelModeError, buildParallelWorktreeTaskCwdError, collectChainSessionFiles, findDuplicateAbsoluteParallelOutputPath, findDuplicateParallelOutputPath, } from "./execution-input.js";
-/** Validate mode constraints before constructing or handing off an async launch. */
-function validateChainMode(data) {
-    const { params, effectiveCwd } = data;
-    if (params.chain !== undefined && params.chain.length > 0) {
-        const error = buildChainWorktreeTaskCwdError(params.chain, effectiveCwd);
-        if (error !== undefined && error.length > 0) {
-            return {
-                content: [{ type: "text", text: error }],
-                isError: true,
-                details: { mode: "chain", results: [] },
-            };
-        }
-    }
-    return undefined;
-}
-function validateParallelMode(data, deps) {
-    const { params, effectiveCwd } = data;
-    if (params.tasks !== undefined && params.tasks.length > 0) {
-        const maxTasks = resolveTopLevelParallelMaxTasks(deps.config.parallel?.maxTasks);
-        if (params.tasks.length > maxTasks) {
-            return buildParallelModeError(maxParallelTasksMessage(maxTasks));
-        }
-        const error = params.worktree === true
-            ? buildParallelWorktreeTaskCwdError(params.tasks, effectiveCwd)
-            : undefined;
-        if (error !== undefined && error.length > 0) {
-            return buildParallelModeError(error);
-        }
-    }
-    return undefined;
-}
-function commonLaunchOptions(data, deps) {
-    const sessionId = deps.state.currentSessionId;
-    if (sessionId === null) {
-        throw new Error("Cannot launch an async run without an owning session.");
-    }
-    return {
-        ctx: {
-            pi: deps.pi,
-            cwd: data.ctx.cwd,
-            currentSessionId: sessionId,
-            rootSessionId: resolveRootSessionId(data.ctx.sessionManager),
-            currentModelProvider: data.ctx.model?.provider,
-            projectTrusted: data.ctx.isProjectTrusted(),
-        },
-        availableModels: data.ctx.modelRegistry.getAvailable().map(toModelInfo),
-        cwd: data.effectiveCwd,
-        maxOutput: data.params.maxOutput,
-        timeoutMs: data.foregroundTimeoutMs,
-        artifactsDir: data.artifactsEnabled ? data.artifactsDir : undefined,
-        shareEnabled: data.shareEnabled,
-        sessionRoot: data.sessionRoot,
-        maxSubagentDepth: resolveCurrentMaxSubagentDepth(deps.config.maxSubagentDepth),
-        worktreeSetupHook: deps.config.worktreeSetupHook,
-        worktreeSetupHookTimeoutMs: deps.config.worktreeSetupHookTimeoutMs,
-        controlConfig: data.controlConfig,
-        controlIntercomTarget: data.intercomBridge.orchestratorTarget,
-        childIntercomTarget: (agent, index) => resolveSubagentIntercomTarget(data.runId, agent, index),
-        nestedRoute: data.nestedRoute,
-        projectTrust: resolveConfiguredChildProjectTrustPolicy(deps.config.projectTrust),
-    };
-}
-export function runAsyncPath(data, deps) {
-    const invalid = validateChainMode(data) ?? validateParallelMode(data, deps);
-    if (invalid) {
-        return invalid;
-    }
-    const common = commonLaunchOptions(data, deps);
-    const { params } = data;
-    if (params.tasks !== undefined && params.tasks.length > 0) {
-        return launchParallel(data, deps, common, params.tasks);
-    }
-    if (params.chain !== undefined && params.chain.length > 0) {
-        return launchChain(data, deps, common, params.chain);
-    }
-    if (params.agent !== undefined && params.agent.length > 0) {
-        return launchSingle(data, common, params.agent);
-    }
-    return null;
-}
-/** Preserve optional-property presence and agent-default output provenance for runner planning. */
-function taskOutputOptions(task, output) {
-    return {
-        ...(output !== undefined ? { output } : {}),
-        ...(task.outputMode !== undefined ? { outputMode: task.outputMode } : {}),
-        ...(usesAgentDefaultOutput(task.output) && output !== undefined
-            ? { outputFromAgentDefault: true }
-            : {}),
-        ...(task.outputSchema !== undefined ? { outputSchema: task.outputSchema } : {}),
-        ...(task.reads !== undefined && task.reads !== true ? { reads: task.reads } : {}),
-        ...(task.progress !== undefined ? { progress: task.progress } : {}),
-        ...(task.acceptance !== undefined ? { acceptance: task.acceptance } : {}),
-    };
-}
-function parallelTask(data, task, profile, index) {
-    const output = resolveTopLevelOutputOverride({
-        requestedOutput: task.output,
-        agentDefaultOutput: profile.output,
-        artifactsDir: data.artifactsDir,
-        runId: data.runId,
-        agent: task.agent,
-        index,
-    });
-    const skill = normalizeSkillInput(task.skill);
-    return {
-        agent: task.agent,
-        task: wrapTaskForAgentContext(task.task, data.params.context, task.agent, data.agents),
-        cwd: task.cwd,
-        ...(task.model !== undefined && task.model.length > 0 ? { model: task.model } : {}),
-        ...(skill !== undefined ? { skill } : {}),
-        ...taskOutputOptions(task, output),
-    };
-}
-function launchParallel(data, deps, common, tasks) {
-    const planned = tasks.map((task, index) => {
-        const profile = data.agents.find((agent) => agent.name === task.agent);
-        if (!profile) {
-            throw new Error(`Unknown agent: ${task.agent}`);
-        }
-        const step = parallelTask(data, task, profile, index);
-        return {
-            step,
-            behavior: resolveStepBehavior(profile, {
-                ...(step.output !== undefined ? { output: step.output } : {}),
-                ...(step.outputMode !== undefined ? { outputMode: step.outputMode } : {}),
-            }),
-        };
-    });
-    const parallelTasks = planned.map(({ step }) => step);
-    const behaviors = planned.map(({ behavior }) => behavior);
-    const duplicate = data.params.worktree === true
-        ? findDuplicateAbsoluteParallelOutputPath({ tasks: parallelTasks, behaviors })
-        : findDuplicateParallelOutputPath({
-            tasks: parallelTasks,
-            behaviors,
-            paramsCwd: data.effectiveCwd,
-            ctxCwd: data.ctx.cwd,
-        });
-    if (duplicate !== undefined && duplicate.length > 0) {
-        return buildParallelModeError(duplicate);
-    }
-    return executeAsyncChain(data.runId, {
-        ...common,
-        agents: data.agents,
-        chain: [
-            {
-                parallel: parallelTasks,
-                concurrency: resolveTopLevelParallelConcurrency(data.params.concurrency, deps.config.parallel?.concurrency),
-                worktree: data.params.worktree,
-            },
-        ],
-        resultMode: "parallel",
-        chainSkills: [],
-        sessionFilesByFlatIndex: tasks.map((_, index) => data.sessionFileForIndex(index)),
-    });
-}
-function launchChain(data, deps, common, steps) {
-    const chain = wrapChainTasksForAgentContext(steps, data.params.context, data.agents);
-    return executeAsyncChain(data.runId, {
-        ...common,
-        agents: data.agents,
-        chain,
-        task: data.params.task,
-        chainDir: data.params.chainDir,
-        chainSkills: normalizeSkillInput(data.params.skill) ?? [],
-        sessionFilesByFlatIndex: collectChainSessionFiles(chain, data.sessionFileForIndex, data.sessionFileForAgentIndex, deps.config.chain?.dynamicFanout?.maxItems),
-        dynamicFanoutMaxItems: deps.config.chain?.dynamicFanout?.maxItems,
-    });
-}
-function launchSingle(data, common, agent) {
-    const profile = data.agents.find((candidate) => candidate.name === agent);
-    if (!profile) {
-        return {
-            content: [{ type: "text", text: `Unknown agent: ${agent}` }],
-            isError: true,
-            details: { mode: "single", results: [] },
-        };
-    }
-    const { params } = data;
-    return executeAsyncSingle(data.runId, {
-        ...common,
-        agent,
-        agentConfig: profile,
-        task: wrapTaskForAgentContext(params.task ?? "", params.context, agent, data.agents),
-        sessionFile: data.sessionFileForIndex(0),
-        skills: normalizeSkillInput(params.skill),
-        output: resolveTopLevelOutputOverride({
-            requestedOutput: params.output,
-            agentDefaultOutput: profile.output,
-            artifactsDir: data.artifactsDir,
-            runId: data.runId,
-            agent,
-            index: 0,
-        }),
-        outputFromAgentDefault: usesAgentDefaultOutput(params.output) &&
-            typeof profile.output === "string" &&
-            !path.isAbsolute(profile.output),
-        outputMode: params.outputMode ?? "inline",
-        outputSchema: params.outputSchema,
-        modelOverride: params.model,
-        maxSubagentDepth: resolveChildMaxSubagentDepth(common.maxSubagentDepth, profile.maxSubagentDepth),
-        acceptance: params.acceptance,
-        progress: params.progress,
-    });
-}

package/dist/runs/foreground/run-interrupt.js

@@ -1,164 +0,0 @@
-import * as path from "node:path";
-import { writeAsyncControlRequest, writeAsyncInterruptRequest, } from "../background/async-control.js";
-import { questionProcessAlive, readRunJson } from "../shared/supervisor-questions.js";
-import { readStatus } from "../../shared/utils.js";
-import { resolveOwnedRun } from "../shared/run-records.js";
-import { buildManagementControl } from "../../shared/status-format.js";
-import { errorMessage, isRecord } from "../../shared/unknown.js";
-function requestedTarget(state, runId) {
-    const direct = state.asyncJobs.get(runId);
-    if (direct) {
-        return { asyncId: direct.asyncId, asyncDir: direct.asyncDir };
-    }
-    const owned = resolveOwnedRun(state, runId);
-    return owned?.asyncDir !== undefined && owned.asyncDir.length > 0
-        ? { asyncId: owned.runId, asyncDir: owned.asyncDir }
-        : undefined;
-}
-function newestTrackedTarget(state) {
-    let newest;
-    for (const job of state.asyncJobs.values()) {
-        if (job.status !== "running") {
-            continue;
-        }
-        const updatedAt = job.updatedAt ?? 0;
-        if (!newest || updatedAt > newest.updatedAt) {
-            newest = { asyncId: job.asyncId, asyncDir: job.asyncDir, updatedAt };
-        }
-    }
-    return newest;
-}
-function ownedProducerAlive(run) {
-    const status = readStatus(run.asyncDir);
-    if (status) {
-        return status.state === "running" || status.state === "queued";
-    }
-    return run.pid !== undefined && run.pid !== 0 && questionProcessAlive({ pid: run.pid });
-}
-function newestOwnedTarget(state, tracked) {
-    let newest = tracked;
-    for (const run of state.ownedRuns?.values() ?? []) {
-        const dir = run.asyncDir;
-        if (dir === undefined || dir.length === 0 || (newest && run.startedAt <= newest.updatedAt)) {
-            continue;
-        }
-        if (ownedProducerAlive({ asyncDir: dir, pid: run.pid })) {
-            newest = { asyncId: run.runId, asyncDir: dir, updatedAt: run.startedAt };
-        }
-    }
-    return newest;
-}
-export function getAsyncInterruptTarget(state, runId) {
-    if (runId !== undefined && runId.length > 0) {
-        return requestedTarget(state, runId);
-    }
-    const newest = newestOwnedTarget(state, newestTrackedTarget(state));
-    return newest ? { asyncId: newest.asyncId, asyncDir: newest.asyncDir } : undefined;
-}
-function failure(text) {
-    return {
-        content: [{ type: "text", text }],
-        isError: true,
-        details: { mode: "management", results: [] },
-    };
-}
-function extendable(target) {
-    const status = readStatus(target.asyncDir);
-    if (status) {
-        return (status.runtimeVersion === 2 &&
-            status.state === "running" &&
-            status.timedOut !== true &&
-            (status.timeoutAt ?? 0) !== 0);
-    }
-    const launch = readRunJson(path.join(target.asyncDir, "launch.json"));
-    return (isRecord(launch) &&
-        launch.runtimeVersion === 2 &&
-        typeof launch.timeoutMs === "number" &&
-        Number.isFinite(launch.timeoutMs) &&
-        launch.timeoutMs > 0);
-}
-export function extendAsyncTimeoutResult(state, runId, extendMs) {
-    const target = getAsyncInterruptTarget(state, runId);
-    if (!target || !extendable(target)) {
-        return failure("No live run with an extendable timeout was found. No extension was requested.");
-    }
-    try {
-        writeAsyncControlRequest(target.asyncDir, target.asyncId, "extend", { 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 failure(errorMessage(error));
-    }
-}
-function runningChild(status, index) {
-    return Number.isSafeInteger(index) && index >= 0 && status.steps?.at(index)?.status === "running";
-}
-function selectedChildError(status, id, index) {
-    if (index === undefined) {
-        return;
-    }
-    if (status.indexedControl !== true && (status.steps?.length ?? 0) > 1) {
-        return "This older runner does not support selected-child stop. No stop was sent; whole-run stop remains an explicit separate action.";
-    }
-    if (!runningChild(status, index)) {
-        return `Async run ${id} has no running child at index ${index}. No siblings were stopped.`;
-    }
-    return;
-}
-export function interruptAsyncRun(
-// This control boundary owns the tracked job activity reset after publishing a stop request.
-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 failure(`No running async run with a matching control channel was found for '${runId ?? "current"}'.`);
-    }
-    const invalid = selectedChildError(status, target.asyncId, index);
-    if (invalid !== undefined) {
-        return failure(invalid);
-    }
-    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) {
-        return failure(`Failed to interrupt async run ${target.asyncId}: ${errorMessage(error)}`);
-    }
-}

package/dist/runs/foreground/run-nudge.js

@@ -1,278 +0,0 @@
-import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
-import { sendLiveSubagentMessage } from "../../intercom/live-intercom.js";
-import { resolveAsyncResumeTarget } from "../background/async-resume.js";
-import { resolveSubagentRunId } from "../background/run-id-resolver.js";
-import { inspectSubagentStatus } from "../background/run-status.js";
-import { ownedRunStatusResult, ownedRunView, resolveOwnedRun } from "../shared/run-records.js";
-import { buildManagementControl, formatRunAction } from "../../shared/status-format.js";
-import { errorMessage } from "../../shared/unknown.js";
-import { nestedResolutionScopeForExecutor } from "./execution-routing.js";
-import { rememberedForegroundStatusResult, resolveRememberedForegroundRun, } from "./foreground-memory.js";
-import { getAsyncInterruptTarget } from "./run-interrupt.js";
-function resolvedResult(result) {
-    return { kind: "result", result };
-}
-function failure(text) {
-    return {
-        content: [{ type: "text", text }],
-        isError: true,
-        details: { mode: "management", results: [] },
-    };
-}
-function terminalOwnedNudge(owned, deps) {
-    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, deps) {
-    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, params, deps) {
-    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) {
-    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, deps) {
-    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, deps) {
-    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, deps) {
-    if (requested === undefined || requested.length === 0) {
-        return;
-    }
-    return resolveSubagentRunId(requested, {
-        state: deps.state,
-        nested: nestedResolutionScopeForExecutor(deps),
-    });
-}
-function rememberedNudgeRun(requested, resolved, deps) {
-    if (resolved || requested === undefined || requested.length === 0) {
-        return;
-    }
-    return resolveRememberedForegroundRun(requested, deps.state);
-}
-function resolveAsyncNudge(params, deps, resolvedId) {
-    try {
-        return asyncTarget(params, deps);
-    }
-    catch (error) {
-        return resolvedResult((resolvedId !== undefined ? terminalNudgeResult(resolvedId, deps) : undefined) ??
-            failure(errorMessage(error)));
-    }
-}
-function asyncTarget(params, deps) {
-    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, deps) {
-    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, deps) {
-    let runId;
-    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) {
-    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,
-            }),
-        },
-    };
-}