@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/runs/shared/single-output.js

@@ -1,297 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { hasErrorCode, errorMessage as errorText } from "../../shared/unknown.js";
-import { nonempty } from "./child-presence.js";
-export function normalizeSingleOutputOverride(output, defaultOutput) {
-    if (output === false || output === "false") {
-        return false;
-    }
-    if (output === true || output === "true") {
-        return defaultOutput;
-    }
-    if (typeof output === "string" && output.length > 0) {
-        return output;
-    }
-    return undefined;
-}
-export function resolveSingleOutputPath(output, runtimeCwd, requestedCwd) {
-    if (typeof output !== "string" ||
-        output.length === 0 ||
-        output === "false" ||
-        output === "true") {
-        return undefined;
-    }
-    if (path.isAbsolute(output)) {
-        return output;
-    }
-    let baseCwd = runtimeCwd;
-    if (nonempty(requestedCwd)) {
-        baseCwd = path.isAbsolute(requestedCwd) ? requestedCwd : path.resolve(runtimeCwd, requestedCwd);
-    }
-    return path.resolve(baseCwd, output);
-}
-function safeOutputSegment(value, fallback) {
-    const sanitized = value.replace(/[^\w.-]/g, "_").replace(/^\.+$/, "");
-    return sanitized.length > 0 ? sanitized : fallback;
-}
-export function materializeAgentDefaultOutputPath(params) {
-    if (typeof params.output !== "string" ||
-        params.output.length === 0 ||
-        params.output === "false" ||
-        params.output === "true") {
-        return params.output;
-    }
-    if (path.isAbsolute(params.output)) {
-        return params.output;
-    }
-    const suffix = params.index !== undefined ? `_${safeOutputSegment(String(params.index), "index")}` : "";
-    const safeAgent = safeOutputSegment(params.agent, "agent");
-    const safeBaseName = safeOutputSegment(path.basename(params.output), "output.md");
-    return path.join(params.artifactsDir, "requested-outputs", `${params.runId}_${safeAgent}${suffix}_${safeBaseName}`);
-}
-export function injectSingleOutputInstruction(task, outputPath) {
-    if (!nonempty(outputPath)) {
-        return task;
-    }
-    return `${task}\n\n---\n**Output:** Write your findings to: ${outputPath}`;
-}
-function countLines(text) {
-    if (text.length === 0) {
-        return 0;
-    }
-    const newlineMatches = text.match(/\r\n|\r|\n/g);
-    return (newlineMatches?.length ?? 0) + (/[\r\n]$/.test(text) ? 0 : 1);
-}
-function formatByteSize(bytes) {
-    if (bytes < 1024) {
-        return `${bytes} B`;
-    }
-    const units = ["KB", "MB", "GB", "TB"];
-    let value = bytes / 1024;
-    let unitIndex = 0;
-    while (value >= 1024 && unitIndex < units.length - 1) {
-        value /= 1024;
-        unitIndex++;
-    }
-    return `${value.toFixed(1)} ${units[unitIndex]}`;
-}
-export function formatSavedOutputReference(savedPath, fullOutput) {
-    const absolutePath = path.resolve(savedPath);
-    const bytes = Buffer.byteLength(fullOutput, "utf-8");
-    const lines = countLines(fullOutput);
-    return {
-        path: absolutePath,
-        bytes,
-        lines,
-        message: `Output saved to: ${absolutePath} (${formatByteSize(bytes)}, ${lines} ${lines === 1 ? "line" : "lines"}). Read this file if needed.`,
-    };
-}
-function consumedOutputStatus(cleanup) {
-    if (cleanup.action === "deleted") {
-        return "removed after capture";
-    }
-    if (cleanup.action === "already-missing") {
-        return "already absent after capture";
-    }
-    return `not removed${nonempty(cleanup.reason) ? `: ${cleanup.reason}` : ""}`;
-}
-export function formatConsumedOutputReference(outputPath, fullOutput, cleanup) {
-    const absolutePath = path.resolve(outputPath);
-    const bytes = Buffer.byteLength(fullOutput, "utf-8");
-    const lines = countLines(fullOutput);
-    const status = consumedOutputStatus(cleanup);
-    return {
-        path: absolutePath,
-        bytes,
-        lines,
-        message: `Output file consumed: ${absolutePath} (${formatByteSize(bytes)}, ${lines} ${lines === 1 ? "line" : "lines"}); ${status}.`,
-    };
-}
-export function findDuplicateOutputPath(items) {
-    const seen = new Map();
-    for (const [index, item] of items.entries()) {
-        const outputPath = item.outputPath;
-        if (!nonempty(outputPath)) {
-            continue;
-        }
-        const previous = seen.get(outputPath);
-        if (previous) {
-            return `Parallel tasks ${previous.index + 1} (${previous.agent}) and ${index + 1} (${item.agent}) resolve output to the same path: ${outputPath}. Use distinct output paths.`;
-        }
-        seen.set(outputPath, { index, agent: item.agent });
-    }
-    return undefined;
-}
-export function validateFileOnlyOutputMode(outputMode, outputPath, context) {
-    if (outputMode === "file-only" && !nonempty(outputPath)) {
-        return `${context} sets outputMode: "file-only" but does not configure an output file. Set output to a path or use outputMode: "inline".`;
-    }
-    return undefined;
-}
-export function captureSingleOutputSnapshot(outputPath) {
-    if (!nonempty(outputPath)) {
-        return undefined;
-    }
-    try {
-        const stat = fs.statSync(outputPath);
-        return {
-            exists: true,
-            mtimeMs: stat.mtimeMs,
-            ctimeMs: stat.ctimeMs,
-            size: stat.size,
-            ino: stat.ino,
-        };
-    }
-    catch {
-        // The snapshot is advisory; resolveSingleOutput reports concrete read/write failures.
-        return { exists: false };
-    }
-}
-function matchesSnapshot(stat, snapshot) {
-    return (snapshot?.exists === true &&
-        stat.mtimeMs === snapshot.mtimeMs &&
-        stat.ctimeMs === snapshot.ctimeMs &&
-        stat.size === snapshot.size &&
-        stat.ino === snapshot.ino);
-}
-function persistSingleOutput(outputPath, fullOutput) {
-    if (!nonempty(outputPath)) {
-        return {};
-    }
-    try {
-        fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-        fs.writeFileSync(outputPath, fullOutput, "utf-8");
-        return { savedPath: outputPath };
-    }
-    catch (err) {
-        return { error: errorText(err) };
-    }
-}
-export function resolveSingleOutput(outputPath, fallbackOutput, beforeRun) {
-    if (!nonempty(outputPath)) {
-        return { fullOutput: fallbackOutput };
-    }
-    try {
-        const stat = fs.statSync(outputPath);
-        if (!matchesSnapshot(stat, beforeRun)) {
-            // ponytail: acceptance and downstream prompts explicitly request this full
-            // individual output; it must fit their heap. Inspection uses readOutputPage.
-            return { fullOutput: fs.readFileSync(outputPath, "utf-8"), savedPath: outputPath };
-        }
-    }
-    catch (error) {
-        if (!hasErrorCode(error, "ENOENT") && !hasErrorCode(error, "ENOTDIR")) {
-            return {
-                fullOutput: fallbackOutput,
-                saveError: `Failed to read changed output file: ${errorText(error)}`,
-            };
-        }
-    }
-    const save = persistSingleOutput(outputPath, fallbackOutput);
-    if (nonempty(save.savedPath)) {
-        return {
-            fullOutput: fallbackOutput,
-            savedPath: save.savedPath,
-            writtenSnapshot: captureSingleOutputSnapshot(save.savedPath),
-        };
-    }
-    return { fullOutput: fallbackOutput, saveError: save.error };
-}
-function equalOutputBytes(fd, fullOutput, size) {
-    if (size !== Buffer.byteLength(fullOutput)) {
-        return false;
-    }
-    let position = 0;
-    for (let start = 0; start < fullOutput.length;) {
-        let end = Math.min(start + 16384, fullOutput.length);
-        if (end < fullOutput.length && /[\uD800-\uDBFF]/.test(fullOutput.charAt(end - 1))) {
-            end--;
-        }
-        const expected = Buffer.from(fullOutput.slice(start, end));
-        const actual = Buffer.allocUnsafe(expected.length);
-        if (fs.readSync(fd, actual, 0, actual.length, position) !== actual.length ||
-            !actual.equals(expected)) {
-            return false;
-        }
-        position += expected.length;
-        start = end;
-    }
-    return true;
-}
-function unchangedOutputIdentity(fd, outputPath, stat) {
-    const current = fs.fstatSync(fd);
-    const located = fs.statSync(outputPath);
-    return (current.ino === stat.ino &&
-        current.size === stat.size &&
-        current.ctimeMs === stat.ctimeMs &&
-        located.ino === current.ino &&
-        located.dev === current.dev &&
-        located.ctimeMs === current.ctimeMs);
-}
-export function cleanupSingleOutputFile(outputPath, fullOutput) {
-    if (!nonempty(outputPath)) {
-        return undefined;
-    }
-    const absolutePath = path.resolve(outputPath);
-    try {
-        const stat = fs.statSync(outputPath);
-        const fd = fs.openSync(outputPath, "r");
-        let equal;
-        try {
-            equal =
-                equalOutputBytes(fd, fullOutput, stat.size) &&
-                    unchangedOutputIdentity(fd, outputPath, stat);
-        }
-        finally {
-            fs.closeSync(fd);
-        }
-        if (!equal) {
-            return { path: absolutePath, action: "skipped", reason: "file changed after capture" };
-        }
-        fs.unlinkSync(outputPath);
-        return { path: absolutePath, action: "deleted" };
-    }
-    catch (error) {
-        if (hasErrorCode(error, "ENOENT") || hasErrorCode(error, "ENOTDIR")) {
-            return { path: absolutePath, action: "already-missing" };
-        }
-        return {
-            path: absolutePath,
-            action: "skipped",
-            error: errorText(error),
-        };
-    }
-}
-function successfulOutput(params, displayOutput, savedPath) {
-    const outputReference = params.outputReference ??
-        (params.cleanup && params.outputMode !== "file-only"
-            ? formatConsumedOutputReference(savedPath, params.fullOutput, params.cleanup)
-            : formatSavedOutputReference(savedPath, params.fullOutput));
-    if (params.outputMode === "file-only") {
-        return {
-            displayOutput: outputReference.message,
-            savedPath,
-            outputReference,
-        };
-    }
-    const withReference = `${displayOutput}\n\n${outputReference.message}`;
-    return {
-        displayOutput: withReference,
-        savedPath: params.cleanup ? undefined : savedPath,
-        outputReference,
-    };
-}
-export function finalizeSingleOutput(params) {
-    let displayOutput = nonempty(params.truncatedOutput) ? params.truncatedOutput : params.fullOutput;
-    if (params.exitCode !== 0) {
-        return { displayOutput };
-    }
-    if (nonempty(params.savedPath)) {
-        return successfulOutput(params, displayOutput, params.savedPath);
-    }
-    if (nonempty(params.saveError) && nonempty(params.outputPath)) {
-        displayOutput += `\n\nOutput file error: ${params.outputPath}\n${params.saveError}`;
-        return { displayOutput, saveError: params.saveError };
-    }
-    return { displayOutput };
-}

package/dist/runs/shared/stable-value.js

@@ -1,15 +0,0 @@
-/** Stable native-JSON identity for cache hashes and repeated tool-call detection. */
-export function stableStringify(value) {
-    if (value === undefined || typeof value === "function" || typeof value === "symbol") {
-        return "undefined";
-    }
-    if (value === null || typeof value !== "object") {
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-        return `[${value.map(stableStringify).join(",")}]`;
-    }
-    const entries = Object.entries(value);
-    entries.sort(([left], [right]) => (left > right ? 1 : -1));
-    return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`).join(",")}}`;
-}

package/dist/runs/shared/streaming-text.js

@@ -1,26 +0,0 @@
-function applyTextDelta(current, update) {
-    if (update?.type === "text_start") {
-        return current !== undefined && current.length > 0 ? `${current}\n\n` : "";
-    }
-    if (update?.type === "text_delta" && update.delta !== undefined) {
-        return ((current ?? "") + update.delta).slice(-8192);
-    }
-    return current;
-}
-/** Native JSON stdout sends text deltas, not cumulative message/partial snapshots. */
-export function updateStreamingText(current, event) {
-    if (event.type === "agent_start") {
-        return;
-    }
-    if (event.message?.role === "assistant") {
-        if (event.type === "message_end") {
-            return;
-        }
-        if (event.type === "message_start") {
-            return "";
-        }
-    }
-    return event.type === "message_update"
-        ? applyTextDelta(current, event.assistantMessageEvent)
-        : current;
-}

package/dist/runs/shared/structured-output.js

@@ -1,67 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { Compile } from "../../shared/native-typebox.js";
-import { errorMessage as errorText } from "../../shared/unknown.js";
-export const STRUCTURED_OUTPUT_SCHEMA_ENV = "PI_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA";
-export const STRUCTURED_OUTPUT_CAPTURE_ENV = "PI_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE";
-export function assertJsonSchemaObject(schema, label = "outputSchema") {
-    if (schema === null || typeof schema !== "object" || Array.isArray(schema)) {
-        throw new Error(`${label} must be a JSON Schema object.`);
-    }
-}
-export function createStructuredOutputRuntime(schema, baseDir) {
-    const rootDir = baseDir ?? os.tmpdir();
-    fs.mkdirSync(rootDir, { recursive: true });
-    const dir = fs.mkdtempSync(path.join(rootDir, "pi-subagent-structured-"));
-    const schemaPath = path.join(dir, "schema.json");
-    const outputPath = path.join(dir, "output.json");
-    fs.writeFileSync(schemaPath, JSON.stringify(schema), { mode: 0o600 });
-    return { schema, schemaPath, outputPath };
-}
-export function validateStructuredOutputValue(schema, value) {
-    let validator;
-    try {
-        validator = Compile(schema);
-    }
-    catch (error) {
-        return {
-            status: "invalid",
-            message: `invalid outputSchema: ${errorText(error)}`,
-        };
-    }
-    if (validator.Check(value)) {
-        return { status: "valid" };
-    }
-    const errors = [...validator.Errors(value)].slice(0, 8).map((error) => {
-        const pathText = error.instancePath !== undefined && error.instancePath.length > 0
-            ? error.instancePath.replace(/^\//, "").replace(/\//g, ".")
-            : "root";
-        return `${pathText}: ${error.message ?? "schema validation failed"}`;
-    });
-    return {
-        status: "invalid",
-        message: errors.length > 0 ? errors.join("; ") : "schema validation failed",
-    };
-}
-export function readStructuredOutput(runtime) {
-    if (!fs.existsSync(runtime.outputPath)) {
-        return {
-            error: "Missing structured_output call; this step has outputSchema and must finish by calling structured_output.",
-        };
-    }
-    let value;
-    try {
-        value = JSON.parse(fs.readFileSync(runtime.outputPath, "utf-8"));
-    }
-    catch (error) {
-        return {
-            error: `Failed to read structured output: ${errorText(error)}`,
-        };
-    }
-    const validation = validateStructuredOutputValue(runtime.schema, value);
-    if (validation.status === "invalid") {
-        return { error: `Structured output validation failed: ${validation.message}` };
-    }
-    return { value };
-}

package/dist/runs/shared/subagent-control.js

@@ -1,246 +0,0 @@
-import { formatRunAction } from "../../shared/status-format.js";
-import { readStatus } from "../../shared/utils.js";
-import { getRunMetadataDir } from "./supervisor-questions.js";
-export function isObsoleteIdleNotice(details) {
-    const event = details.event;
-    if (event.reason !== "idle" || event.supervisorQuestion) {
-        return false;
-    }
-    let status;
-    try {
-        status = readStatus(details.asyncDir ?? getRunMetadataDir(event.runId));
-    }
-    catch {
-        // Without readable terminal evidence, retain the actionable notice.
-        return false;
-    }
-    if (!status || status.runId !== event.runId) {
-        return false;
-    }
-    return (["complete", "failed", "blocked", "paused"].includes(status.state) ||
-        hasTerminalChild(status, event.index));
-}
-function hasTerminalChild(status, index) {
-    if (index === undefined) {
-        return false;
-    }
-    const child = status.steps?.[index];
-    return (child !== undefined &&
-        ["complete", "completed", "failed", "blocked", "paused", "timed-out"].includes(child.status));
-}
-const CONTROL_EVENT_TYPES = ["needs_attention"];
-const CONTROL_NOTIFICATION_CHANNELS = [
-    "event",
-    "async",
-    "intercom",
-];
-const DEFAULT_NOTIFY_ON = ["needs_attention"];
-export const DEFAULT_CONTROL_CONFIG = {
-    enabled: true,
-    needsAttentionAfterMs: 10 * 60_000,
-    failedToolAttemptsBeforeAttention: 3,
-    notifyOn: DEFAULT_NOTIFY_ON,
-    notifyChannels: CONTROL_NOTIFICATION_CHANNELS,
-};
-function parsePositiveInt(value) {
-    if (typeof value !== "number") {
-        return undefined;
-    }
-    if (!Number.isFinite(value) || !Number.isInteger(value) || value < 1) {
-        return undefined;
-    }
-    return value;
-}
-function parseControlList(value, allowed) {
-    if (!Array.isArray(value)) {
-        return undefined;
-    }
-    if (value.length === 0) {
-        return [];
-    }
-    const entries = value;
-    const parsed = entries.filter((entry) => typeof entry === "string" && allowed.some((candidate) => candidate === entry));
-    return parsed.length > 0 ? Array.from(new Set(parsed)) : undefined;
-}
-function parsedControlConfig(config) {
-    const input = config ?? {};
-    return {
-        enabled: input.enabled,
-        needsAttentionAfterMs: parsePositiveInt(input.needsAttentionAfterMs),
-        failedToolAttemptsBeforeAttention: parsePositiveInt(input.failedToolAttemptsBeforeAttention),
-        notifyOn: parseControlList(input.notifyOn, CONTROL_EVENT_TYPES),
-        notifyChannels: parseControlList(input.notifyChannels, CONTROL_NOTIFICATION_CHANNELS),
-    };
-}
-function controlThresholds(global, override) {
-    return {
-        needsAttentionAfterMs: override.needsAttentionAfterMs ??
-            global.needsAttentionAfterMs ??
-            DEFAULT_CONTROL_CONFIG.needsAttentionAfterMs,
-        failedToolAttemptsBeforeAttention: override.failedToolAttemptsBeforeAttention ??
-            global.failedToolAttemptsBeforeAttention ??
-            DEFAULT_CONTROL_CONFIG.failedToolAttemptsBeforeAttention,
-    };
-}
-export function resolveControlConfig(globalConfig, overrideConfig) {
-    const global = parsedControlConfig(globalConfig);
-    const override = parsedControlConfig(overrideConfig);
-    const notifyOn = override.notifyOn ?? global.notifyOn ?? DEFAULT_CONTROL_CONFIG.notifyOn;
-    const notifyChannels = override.notifyChannels ?? global.notifyChannels ?? DEFAULT_CONTROL_CONFIG.notifyChannels;
-    return {
-        enabled: override.enabled ?? global.enabled ?? DEFAULT_CONTROL_CONFIG.enabled,
-        ...controlThresholds(global, override),
-        notifyOn: [...notifyOn],
-        notifyChannels: [...notifyChannels],
-    };
-}
-export function deriveActivityState(input) {
-    if (!input.config.enabled) {
-        return undefined;
-    }
-    const now = input.now ?? Date.now();
-    const lastActivity = input.lastActivityAt ?? input.startedAt;
-    const ageMs = Math.max(0, now - lastActivity);
-    return ageMs > input.config.needsAttentionAfterMs ? "needs_attention" : undefined;
-}
-function controlObservation(input, elapsedSeconds) {
-    if (input.currentTool !== undefined && input.currentTool !== "") {
-        const duration = input.currentToolDurationMs === undefined
-            ? ""
-            : ` for ${Math.floor(input.currentToolDurationMs / 1000)}s`;
-        const elapsed = elapsedSeconds === undefined ? "" : `; no observed output/events for ${elapsedSeconds}s`;
-        return `${input.currentTool} still active${duration}${elapsed}`;
-    }
-    return elapsedSeconds === undefined ? undefined : `no observed activity for ${elapsedSeconds}s`;
-}
-function controlSignal(input) {
-    const question = input.supervisorQuestion;
-    if (!question) {
-        return `${input.agent} needs attention`;
-    }
-    return question.state === "awaiting_input"
-        ? `Waiting for supervisor input (question ${question.questionId})`
-        : `Supervisor answer saved for question ${question.questionId}; delivery unconfirmed`;
-}
-function controlMetrics(input, elapsedMs) {
-    return {
-        ...(input.turns !== undefined ? { turns: input.turns } : {}),
-        ...(input.tokens !== undefined ? { tokens: input.tokens } : {}),
-        ...(input.toolCount !== undefined ? { toolCount: input.toolCount } : {}),
-        ...(input.currentToolDurationMs !== undefined
-            ? { currentToolDurationMs: input.currentToolDurationMs }
-            : {}),
-        ...(elapsedMs !== undefined ? { elapsedMs } : {}),
-    };
-}
-function controlContext(input) {
-    return {
-        ...((input.currentTool ?? "") !== "" ? { currentTool: input.currentTool } : {}),
-        ...((input.currentPath ?? "") !== "" ? { currentPath: input.currentPath } : {}),
-        ...((input.recentFailureSummary ?? "") !== ""
-            ? { recentFailureSummary: input.recentFailureSummary }
-            : {}),
-        ...(input.supervisorQuestion ? { supervisorQuestion: input.supervisorQuestion } : {}),
-    };
-}
-function controlElapsed(input, ts) {
-    return (input.elapsedMs ??
-        (input.lastActivityAt !== undefined ? Math.max(0, ts - input.lastActivityAt) : undefined));
-}
-export function buildControlEvent(input) {
-    const ts = input.ts ?? Date.now();
-    const elapsedMs = controlElapsed(input, ts);
-    const observation = controlObservation(input, elapsedMs === undefined ? undefined : Math.floor(elapsedMs / 1000));
-    const message = input.message ??
-        `${controlSignal(input)}${observation === undefined ? "" : ` (${observation})`}`;
-    return {
-        type: input.type ?? "needs_attention",
-        ...(input.from !== undefined ? { from: input.from } : {}),
-        to: input.to,
-        ts,
-        runId: input.runId,
-        agent: input.agent,
-        ...(input.index !== undefined ? { index: input.index } : {}),
-        message,
-        reason: input.reason ?? "idle",
-        ...controlMetrics(input, elapsedMs),
-        ...controlContext(input),
-    };
-}
-export { shouldNotifyControlEvent, controlNotificationKey } from "./control-event-policy.js";
-export { claimControlNotification } from "./control-notification-owner.js";
-function failureNotice(event, childIntercomTarget) {
-    return [
-        `Subagent failed: ${event.agent}`,
-        `Run: ${event.runId}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
-        `Signal: ${event.message}`,
-        "Next: read the output artifact or session from the subagent result, then retry with a more explicit implementation prompt or handle the fix directly.",
-        childIntercomTarget !== undefined && childIntercomTarget !== ""
-            ? `Run intercom target (may be inactive): ${childIntercomTarget}`
-            : undefined,
-    ]
-        .filter((line) => line !== undefined)
-        .join("\n");
-}
-function questionNotice(event, childSafe) {
-    const question = event.supervisorQuestion;
-    if (!question) {
-        return [];
-    }
-    return [
-        `Question ID: ${question.questionId}`,
-        question.state === "answer_pending"
-            ? "The saved answer has not been confirmed delivered. Inspect the child and retry the same answer; do not assume it resumed."
-            : "Answer the saved question so the child can continue.",
-        `Questions: ${formatRunAction("questions", event.runId, {}, childSafe)}`,
-        `Answer: ${formatRunAction("answer", event.runId, { questionId: question.questionId, message: question.answer ?? "..." }, childSafe)}`,
-    ];
-}
-function liveNotice(event, childIntercomTarget, childSafe) {
-    const nudgeCommand = formatRunAction("nudge", event.runId, {
-        ...(event.index !== undefined ? { index: event.index } : {}),
-        message: "What are you blocked on? Reply with the smallest next step, or state the exact decision you need.",
-    }, childSafe);
-    const ask = childIntercomTarget !== undefined && childIntercomTarget !== ""
-        ? `Ask (blocking wait only; parent must remain alive): intercom({ action: "ask", to: "${childIntercomTarget}", delivery: "steer", message: "What are you blocked on? Reply with the smallest next step, or state the exact decision you need." })`
-        : "Ask (blocking wait only): no child message route registered";
-    return [
-        event.reason === "idle" && (event.currentTool ?? "") !== ""
-            ? "Hint: Inspect command progress. A long-running tool may still be running or hung; elapsed time alone does not prove either."
-            : "Hint: Inspect status first unless the run is clearly blocked.",
-        `Nudge (preferred live coordination): ${nudgeCommand}`,
-        ask,
-    ];
-}
-export function formatControlNoticeMessage(event, childIntercomTarget, childSafe = false) {
-    if (event.reason === "completion_guard") {
-        return failureNotice(event, childIntercomTarget);
-    }
-    return [
-        `Subagent needs attention: ${event.agent}`,
-        `Run: ${event.runId}${event.index !== undefined ? ` step ${event.index + 1}` : ""}`,
-        `Signal: ${event.message}`,
-        (event.recentFailureSummary ?? "") !== ""
-            ? `Recent failures: ${event.recentFailureSummary ?? ""}`
-            : undefined,
-        ...(event.supervisorQuestion
-            ? questionNotice(event, childSafe)
-            : liveNotice(event, childIntercomTarget, childSafe)),
-        `Status: ${formatRunAction("status", event.runId, {}, childSafe)}`,
-        `${childSafe ? "Interrupt" : "Stop"}: ${formatRunAction("interrupt", event.runId, {}, childSafe)}`,
-    ]
-        .filter((line) => line !== undefined)
-        .join("\n");
-}
-export function formatControlIntercomMessage(event, childIntercomTarget, childSafe = false) {
-    const statusLabel = event.reason === "completion_guard" ? "subagent failed" : "subagent needs attention";
-    return [
-        statusLabel,
-        "",
-        event.reason === "completion_guard"
-            ? `${event.agent} failed in run ${event.runId}.`
-            : `${event.agent} needs attention in run ${event.runId}.`,
-        "",
-        formatControlNoticeMessage(event, childIntercomTarget, childSafe),
-    ].join("\n");
-}