@a5c-ai/genty-platform 5.1.1-staging.0007199a1cb2

package/dist/harness/internal/createRun/orchestration/effects.js

@@ -0,0 +1,948 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readProcessFileFingerprint = void 0;
+exports.resolveHarnessSessionIdForBinding = resolveHarnessSessionIdForBinding;
+exports.resolveEffect = resolveEffect;
+exports.applyPostEffectOrchestrationOverlays = applyPostEffectOrchestrationOverlays;
+exports.resolveEffectWithRetry = resolveEffectWithRetry;
+exports.orchestrateIterationWithProcessLoadRetry = orchestrateIterationWithProcessLoadRetry;
+const path = __importStar(require("node:path"));
+const effectsHelpers_1 = require("./effectsHelpers");
+const hookDecisionEffects_1 = require("./hookDecisionEffects");
+var effectsHelpers_2 = require("./effectsHelpers");
+Object.defineProperty(exports, "readProcessFileFingerprint", { enumerable: true, get: function () { return effectsHelpers_2.readProcessFileFingerprint; } });
+const workerSessionEnhancer_1 = require("./workerSessionEnhancer");
+const approvalChains_1 = require("../../../../breakpoints/approvalChains");
+const compaction_1 = require("../../../../compression/compaction");
+const executor_1 = require("../../../../mcp/client/executor");
+const manager_1 = require("../../../../mcp/client/manager");
+const toolRegistry_1 = require("../../../../mcp/client/toolRegistry");
+const cost_1 = require("../../../../session/cost");
+const history_1 = require("../../../../session/history");
+// SDK-owned: orchestration iteration loop is the core SDK runtime engine
+const babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+const global_1 = require("../../../../orchestration/global");
+const microagents_1 = require("../../../../microagents");
+const utils_1 = require("../utils");
+const planProcess_1 = require("../planProcess");
+const constants_1 = require("./constants");
+const dispatch_1 = require("./dispatch");
+async function importOptionalModule(specifier) {
+    return Promise.resolve(`${specifier}`).then(s => __importStar(require(s)));
+}
+function resolveHarnessSessionIdForBinding(args, adapter, orchestrationSession) {
+    if ((0, utils_1.isInternalHarness)(args.selectedHarnessName) && orchestrationSession?.sessionId) {
+        process.env.PI_SESSION_ID = process.env.PI_SESSION_ID || orchestrationSession.sessionId;
+        process.env.OMP_SESSION_ID = process.env.OMP_SESSION_ID || orchestrationSession.sessionId;
+    }
+    const resolved = adapter.resolveSessionId({});
+    if (resolved) {
+        return resolved;
+    }
+    return (0, utils_1.isInternalHarness)(args.selectedHarnessName)
+        ? orchestrationSession?.sessionId
+        : undefined;
+}
+async function resolveEffect(action, harnessName, options, piSession, discovered, rl, json, askUserQuestionHandler) {
+    const hookResult = (0, hookDecisionEffects_1.getHookDecisionResult)(action);
+    if (hookResult) {
+        const hookResolution = (0, hookDecisionEffects_1.resolveHookDecisionResult)(action, hookResult, {
+            maxRetries: action.taskDef?.metadata?.maxRetries,
+        });
+        if (hookResolution) {
+            return hookResolution;
+        }
+    }
+    const kind = action.kind;
+    if (kind === "mcp" || getMcpTaskConfig(action)) {
+        return resolveMcpEffect(action, options);
+    }
+    // #949: cross-harness agent/skill dispatch is gated behind
+    // BABYSITTER_CROSS_SUBAGENTS (default OFF). When disabled, EMIT the agent
+    // effect as pending instead of routing it through tasks-adapter / a harness.
+    // genty's autonomous entrypoint (handleHarnessCreateRun) opts this flag ON so
+    // standalone runs still dispatch. "breakpoint" effects are human-input, not
+    // cross-subagent dispatch, so they are not gated here.
+    if ((kind === "agent" || kind === "skill") && !(0, babysitter_sdk_1.crossSubagentsEnabled)()) {
+        return { status: "pending", value: { emitted: true, kind } };
+    }
+    const tasksMuxResult = await resolveViaTasksMuxIfRoutable(action, options, rl, json, askUserQuestionHandler);
+    if (tasksMuxResult) {
+        return tasksMuxResult;
+    }
+    // #949: shell/node task auto-execution is gated behind BABYSITTER_EXECUTE_TASKS
+    // (default OFF). When disabled, EMIT the effect as pending instead of running
+    // it. genty's autonomous entrypoint opts this flag ON.
+    if ((kind === "node" || kind === "orchestrator_task" || kind === "shell") && !(0, babysitter_sdk_1.executeTasksEnabled)()) {
+        return { status: "pending", value: { emitted: true, kind } };
+    }
+    if (kind === "node" || kind === "orchestrator_task") {
+        const meta = action.taskDef?.metadata;
+        const prompt = typeof meta?.prompt === "string"
+            ? meta.prompt
+            : action.taskDef?.title ?? `Execute task ${action.taskId ?? action.effectId}`;
+        return (0, effectsHelpers_1.invokePromptEffect)(action, discovered ? (0, utils_1.resolveTaskHarness)(action, harnessName, discovered) : harnessName, prompt, options, piSession);
+    }
+    if (kind === "shell") {
+        const shellDef = action.taskDef?.shell;
+        const shellMeta = action.taskDef?.metadata;
+        const command = typeof shellDef?.command === "string"
+            ? shellDef.command
+            : typeof shellMeta?.command === "string"
+                ? shellMeta.command
+                : "echo";
+        const shellArgs = Array.isArray(shellDef?.args)
+            ? shellDef.args.filter((arg) => typeof arg === "string")
+            : Array.isArray(shellMeta?.args)
+                ? shellMeta.args.filter((arg) => typeof arg === "string")
+                : [];
+        const cwd = typeof shellDef?.cwd === "string"
+            ? shellDef.cwd
+            : typeof shellMeta?.cwd === "string"
+                ? shellMeta.cwd
+                : options.workspace;
+        if (piSession) {
+            const bashResult = await piSession.executeBash([command, ...shellArgs.map(utils_1.shellQuoteArg)].join(" "));
+            if (bashResult.exitCode === 0) {
+                return { status: "ok", value: bashResult.output, stdout: bashResult.output };
+            }
+            return {
+                status: "ok",
+                value: {
+                    success: false,
+                    exitCode: bashResult.exitCode ?? 1,
+                    stdout: bashResult.output,
+                    stderr: "",
+                    error: `Shell command exited with code ${bashResult.exitCode ?? "null"}`,
+                },
+                stdout: bashResult.output,
+            };
+        }
+        const shellResult = await (0, planProcess_1.execShellEffect)(command, shellArgs, cwd);
+        if (shellResult.exitCode === 0) {
+            return {
+                status: "ok",
+                value: shellResult.stdout,
+                stdout: shellResult.stdout,
+                stderr: shellResult.stderr,
+            };
+        }
+        return {
+            status: "ok",
+            value: {
+                success: false,
+                exitCode: shellResult.exitCode,
+                stdout: shellResult.stdout,
+                stderr: shellResult.stderr,
+                error: `Shell command exited with code ${shellResult.exitCode}`,
+            },
+            stdout: shellResult.stdout,
+            stderr: shellResult.stderr,
+        };
+    }
+    if (kind === "breakpoint") {
+        const chainResult = resolveConfiguredApprovalChain(action);
+        if (chainResult && chainResult.status !== "approved") {
+            return {
+                status: "ok",
+                value: {
+                    approved: false,
+                    option: chainResult.status,
+                    approvalChain: chainResult,
+                },
+            };
+        }
+        return resolveBreakpointLikeEffect(action, options, rl, json, askUserQuestionHandler);
+    }
+    if (kind === "sleep") {
+        const targetMs = action.taskDef?.sleep?.targetEpochMs;
+        if (typeof targetMs === "number") {
+            const delay = Math.max(0, targetMs - Date.now());
+            if (delay > 0) {
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+        return { status: "ok", value: { sleptUntil: new Date().toISOString() } };
+    }
+    if (kind === "agent") {
+        const agentName = action.taskDef?.agent
+            ? action.taskDef.agent?.name
+            : undefined;
+        if (agentName) {
+            const microagentResult = await tryDispatchMicroagent(agentName, action);
+            if (microagentResult)
+                return microagentResult;
+        }
+        const prompt = (0, planProcess_1.buildAgentPrompt)(action.taskDef);
+        const taskHarness = discovered ? (0, utils_1.resolveTaskHarness)(action, harnessName, discovered) : harnessName;
+        if (taskHarness !== harnessName && !(0, utils_1.isInternalHarness)(taskHarness)) {
+            return (0, effectsHelpers_1.invokeAgentHarness)(action, taskHarness, prompt, options);
+        }
+        if (piSession) {
+            const piResult = await (0, utils_1.promptPiWithRetry)({
+                session: piSession,
+                message: prompt,
+                timeout: utils_1.WORKER_TIMEOUT_MS,
+                label: `effect ${action.effectId}`,
+            });
+            return {
+                status: piResult.success ? "ok" : "error",
+                value: piResult.success
+                    ? (0, planProcess_1.coerceAgentResultValue)(action.taskDef, piResult.output)
+                    : undefined,
+                error: piResult.success ? undefined : new Error(piResult.output),
+                stdout: piResult.output,
+            };
+        }
+        return (0, effectsHelpers_1.invokeAgentHarness)(action, taskHarness, prompt, options);
+    }
+    if (kind === "subprocess") {
+        return invokeSubprocessEffect(action, discovered ? (0, utils_1.resolveTaskHarness)(action, harnessName, discovered) : harnessName, options, discovered, rl, json, askUserQuestionHandler);
+    }
+    const fallbackPrompt = action.taskDef?.title ?? `Handle effect ${action.effectId} (kind: ${kind})`;
+    return (0, effectsHelpers_1.invokePromptEffect)(action, harnessName, fallbackPrompt, options, undefined);
+}
+let _microagentSystem;
+function getMicroagentSystem() {
+    if (!_microagentSystem) {
+        _microagentSystem = (0, microagents_1.createMicroagentSystem)();
+    }
+    return _microagentSystem;
+}
+async function tryDispatchMicroagent(agentName, action) {
+    const system = getMicroagentSystem();
+    if (!system.registry.has(agentName))
+        return undefined;
+    const taskDef = action.taskDef;
+    const agent = taskDef.agent;
+    const input = agent.prompt?.toString
+        ? typeof agent.prompt === "object" ? agent.prompt.context ?? agent.prompt : agent.prompt
+        : {};
+    const result = await system.dispatcher.dispatch(agentName, input, {
+        correlationId: action.effectId,
+        timeout: taskDef.execution?.timeout,
+    });
+    if (result.exitCode === 0) {
+        return {
+            status: "ok",
+            value: result.output,
+            stdout: result.logs?.join("\n"),
+        };
+    }
+    return {
+        status: "error",
+        error: new Error(result.error?.message ?? `Microagent ${agentName} exited with code ${result.exitCode}`),
+        stdout: result.logs?.join("\n"),
+    };
+}
+function getMcpTaskConfig(action) {
+    const taskDef = action.taskDef;
+    const direct = taskDef?.mcp;
+    if (isPlainRecord(direct)) {
+        return direct;
+    }
+    const metadata = taskDef?.metadata;
+    if (isPlainRecord(metadata) && isPlainRecord(metadata.mcp)) {
+        return metadata.mcp;
+    }
+    return undefined;
+}
+function getMcpRequest(action, options) {
+    const config = getMcpTaskConfig(action);
+    if (!config) {
+        throw new Error(`MCP effect ${action.effectId} is missing taskDef.mcp configuration`);
+    }
+    const qualifiedName = typeof config.qualifiedName === "string"
+        ? config.qualifiedName
+        : typeof config.tool === "string"
+            ? config.tool
+            : undefined;
+    const colonIdx = qualifiedName?.indexOf(":") ?? -1;
+    const serverName = typeof config.serverName === "string"
+        ? config.serverName
+        : colonIdx > 0 && qualifiedName
+            ? qualifiedName.slice(0, colonIdx)
+            : undefined;
+    const toolName = typeof config.toolName === "string"
+        ? config.toolName
+        : colonIdx > 0 && qualifiedName
+            ? qualifiedName.slice(colonIdx + 1)
+            : undefined;
+    if (!serverName || !toolName) {
+        throw new Error(`MCP effect ${action.effectId} requires serverName and toolName`);
+    }
+    const args = isPlainRecord(config.args) ? config.args : {};
+    const context = {
+        ...(isPlainRecord(args.context) ? args.context : {}),
+        ...(options.runId ? { runId: options.runId } : {}),
+        ...(options.runDir ? { runDir: options.runDir } : {}),
+        ...(options.sessionId ? { sessionId: options.sessionId } : {}),
+        ...(options.workspace ? { workspace: options.workspace } : {}),
+    };
+    return {
+        serverName,
+        toolName,
+        args: {
+            ...args,
+            context,
+        },
+    };
+}
+async function resolveMcpExecutor(options) {
+    if (options.mcp?.executor) {
+        return options.mcp.executor;
+    }
+    const manager = options.mcp?.manager ?? (options.mcp?.transportFactory
+        ? new manager_1.McpClientManager({
+            stateDir: options.mcp.stateDir ?? options.runDir ?? process.cwd(),
+            transportFactory: options.mcp.transportFactory,
+        })
+        : undefined);
+    if (!manager) {
+        throw new Error("MCP effect routing requires an executor, manager, or transportFactory");
+    }
+    await manager.initialize(options.mcp?.autoConnect ?? true);
+    const registry = options.mcp?.registry ?? new toolRegistry_1.McpToolRegistry(manager, {
+        cacheTtlMs: options.mcp?.cacheTtlMs,
+        unifiedRegistry: options.mcp?.toolRegistry,
+        mcpBridge: options.mcp?.mcpBridge,
+    });
+    await registry.refreshAll();
+    return new executor_1.McpToolExecutor(manager);
+}
+function mcpResultToStdout(result) {
+    return result.content
+        .map((item) => typeof item.text === "string" ? item.text : typeof item.data === "string" ? item.data : "")
+        .filter(Boolean)
+        .join("\n");
+}
+function streamMcpOutput(text, streaming) {
+    if (!streaming?.onLine || !text) {
+        return;
+    }
+    for (const line of text.split(/\r?\n/)) {
+        if (line.length > 0) {
+            streaming.onLine(line, "stdout");
+        }
+    }
+}
+async function resolveMcpEffect(action, options) {
+    const executor = await resolveMcpExecutor(options);
+    const request = getMcpRequest(action, options);
+    const result = options.mcp?.dispatcher
+        ? await dispatchMcpTool(options.mcp.dispatcher, executor, request, options)
+        : await executor.execute(request);
+    const stdout = mcpResultToStdout(result);
+    streamMcpOutput(stdout, options.streaming);
+    return {
+        status: result.success ? "ok" : "error",
+        value: result,
+        error: result.success ? undefined : new Error(result.error ?? stdout),
+        stdout,
+        stderr: result.success ? undefined : result.error,
+    };
+}
+async function dispatchMcpTool(dispatcher, executor, request, options) {
+    const dispatched = await dispatcher.dispatch({
+        toolName: request.toolName,
+        input: request.args,
+        caller: "agent-platform:mcp",
+        ...(options.runId ? { runId: options.runId } : {}),
+        ...(options.sessionId ? { sessionId: options.sessionId } : {}),
+    }, async () => executor.execute(request));
+    if (dispatched.error) {
+        return {
+            success: false,
+            content: [],
+            error: typeof dispatched.error === "string"
+                ? dispatched.error
+                : dispatched.error.message ?? "MCP tool dispatch failed",
+            durationMs: dispatched.durationMs,
+        };
+    }
+    return dispatched.output;
+}
+function resolveConfiguredApprovalChain(action) {
+    const metadata = action.taskDef?.metadata;
+    if (!isPlainRecord(metadata)) {
+        return undefined;
+    }
+    if (!isApprovalChainDefinition(metadata.approvalChain) || !isApprovalChainState(metadata.approvalChainState)) {
+        return undefined;
+    }
+    return (0, approvalChains_1.evaluateApprovalChain)(metadata.approvalChain, metadata.approvalChainState);
+}
+function isApprovalChainDefinition(value) {
+    return isPlainRecord(value)
+        && typeof value.chainId === "string"
+        && Array.isArray(value.steps);
+}
+function isApprovalChainState(value) {
+    return isPlainRecord(value)
+        && typeof value.chainId === "string"
+        && typeof value.currentStepIndex === "number"
+        && Array.isArray(value.completedSteps);
+}
+async function applyPostEffectOrchestrationOverlays(args) {
+    const result = {};
+    const updateSessionCost = args.updateSessionCost ?? cost_1.updateSessionCost;
+    const checkBudget = args.checkBudget ?? cost_1.checkBudget;
+    const compactSession = args.compactSession ?? compaction_1.compactSession;
+    const shouldAutoCompact = args.shouldAutoCompact ?? compaction_1.shouldAutoCompact;
+    const markThresholdsTriggered = args.markThresholdsTriggered ?? cost_1.markThresholdsTriggered;
+    const setSessionPaused = args.setSessionPaused ?? cost_1.setSessionPaused;
+    const addDecision = args.addDecision ?? history_1.addDecision;
+    const saveContextSnapshot = args.saveContextSnapshot ?? history_1.saveContextSnapshot;
+    if (args.stateDir && args.sessionId && args.runId && args.effectCost) {
+        const costState = await updateSessionCost(args.stateDir, args.sessionId, {
+            runId: args.runId,
+            costUsd: args.effectCost.totalCostUsd ?? 0,
+            inputTokens: args.effectCost.inputTokens ?? 0,
+            outputTokens: args.effectCost.outputTokens ?? 0,
+        });
+        result.budget = checkBudget(costState);
+        await markThresholdsTriggered(args.stateDir, args.sessionId, result.budget.alerts.map((alert) => alert.thresholdPct));
+        if (result.budget.shouldPause) {
+            await setSessionPaused(args.stateDir, args.sessionId, true);
+            result.budgetEnforcement = {
+                paused: true,
+                pauseReason: result.budget.pauseReason,
+            };
+        }
+        else {
+            result.budgetEnforcement = { paused: false };
+        }
+    }
+    if (args.stateDir && args.sessionId && args.runId && args.effectSummary) {
+        const title = args.effectSummary.title ?? args.effectSummary.taskId ?? args.effectSummary.effectId;
+        await addDecision(args.stateDir, args.sessionId, {
+            runId: args.runId,
+            description: `Resolved ${args.effectSummary.kind ?? "unknown"} effect: ${title}`,
+            rationale: `Effect ${args.effectSummary.effectId} completed with status ${args.effectSummary.status}`,
+        });
+        await saveContextSnapshot(args.stateDir, args.sessionId, {
+            runId: args.runId,
+            snapshot: {
+                effectId: args.effectSummary.effectId,
+                taskId: args.effectSummary.taskId,
+                kind: args.effectSummary.kind,
+                title: args.effectSummary.title,
+                status: args.effectSummary.status,
+            },
+        });
+    }
+    if (args.stateDir &&
+        args.sessionId &&
+        args.runsDir &&
+        args.compactionConfig &&
+        typeof args.estimatedStateTokens === "number" &&
+        shouldAutoCompact(args.estimatedStateTokens, args.compactionConfig)) {
+        result.compaction = {
+            triggered: true,
+            results: await compactSession(args.stateDir, args.sessionId, args.runsDir, args.compactionConfig),
+        };
+    }
+    else {
+        result.compaction = { triggered: false, results: [] };
+    }
+    return result;
+}
+async function resolveViaTasksMuxIfRoutable(action, options, rl, json, askUserQuestionHandler) {
+    if (action.kind !== "agent" && action.kind !== "breakpoint") {
+        return undefined;
+    }
+    let adapter;
+    try {
+        adapter = await importOptionalModule("@a5c-ai/tasks-adapter");
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof adapter.routeTask !== "function") {
+        return undefined;
+    }
+    const decision = adapter.routeTask(action.taskDef);
+    if (decision.responderType === "internal") {
+        return undefined;
+    }
+    if (decision.responderType === "human") {
+        return resolveBreakpointLikeEffect(action, options, rl, json, askUserQuestionHandler);
+    }
+    if (decision.responderType === "tracker") {
+        if (decision.unavailable) {
+            return {
+                status: "ok",
+                value: {
+                    success: false,
+                    routedThrough: "tasks-adapter",
+                    responderType: "tracker",
+                    error: decision.reason ?? "ExternalTrackerBackend unavailable",
+                },
+                stdout: decision.reason,
+            };
+        }
+        return undefined;
+    }
+    if (decision.responderType !== "agent") {
+        return undefined;
+    }
+    const fallbackToInternal = shouldFallbackExternalAgentToInternal(action.taskDef);
+    if (typeof adapter.AgentMuxResponderBackend !== "function") {
+        if (fallbackToInternal) {
+            return undefined;
+        }
+        return {
+            status: "error",
+            error: new Error("tasks-adapter AgentMuxResponderBackend is unavailable"),
+        };
+    }
+    const prompt = (0, planProcess_1.buildAgentPrompt)(action.taskDef);
+    let breakpoint;
+    try {
+        const backend = new adapter.AgentMuxResponderBackend({
+            adapter: decision.responder?.adapter ?? decision.responder?.id,
+            model: decision.responder?.model ?? options.model,
+            cwd: options.workspace,
+        });
+        breakpoint = await backend.submitBreakpoint({
+            text: prompt,
+            context: {
+                description: action.taskDef?.title ?? action.taskId ?? action.effectId,
+                codeSnippets: [],
+                fileReferences: [],
+                tags: action.labels ?? [],
+            },
+            routing: {
+                strategy: "single",
+                targetResponders: decision.responder?.id ? [decision.responder.id] : [],
+                timeoutMs: readExternalAgentTimeoutMs(action.taskDef) ?? 300_000,
+                presentToUser: false,
+                responderType: "agent",
+                adapter: decision.responder?.adapter ?? decision.responder?.id,
+                model: decision.responder?.model ?? options.model,
+            },
+        });
+    }
+    catch (err) {
+        if (fallbackToInternal) {
+            return undefined;
+        }
+        return {
+            status: "error",
+            error: err instanceof Error ? err : new Error(String(err)),
+        };
+    }
+    const answer = breakpoint.answers[0];
+    return {
+        status: "ok",
+        value: (0, planProcess_1.coerceAgentResultValue)(action.taskDef, answer?.text ?? ""),
+        stdout: answer?.text ?? "",
+    };
+}
+async function resolveBreakpointLikeEffect(action, options, rl, json, askUserQuestionHandler) {
+    const question = action.taskDef?.question
+        ?? action.taskDef?.title
+        ?? "Breakpoint reached. Continue?";
+    const approvalPrompt = (0, utils_1.createApprovalAskUserQuestion)(question);
+    const approvalKey = approvalPrompt.questions[0]?.header ?? "Decision";
+    // GAP-MCPC-003: Try channel relay before local interaction
+    const channelResult = await tryChannelRelay(action, options, approvalKey);
+    if (channelResult)
+        return channelResult;
+    if (options.interactive && rl) {
+        if (!json) {
+            process.stderr.write(`\n${utils_1.YELLOW}${utils_1.BOLD}BREAKPOINT ${question}\n`);
+        }
+        const { promptAskUserQuestionWithReadline } = await Promise.resolve().then(() => __importStar(require("../../../../interaction")));
+        const response = await promptAskUserQuestionWithReadline(rl, approvalPrompt);
+        return (0, effectsHelpers_1.buildBreakpointResult)(response, approvalKey);
+    }
+    if (options.interactive && askUserQuestionHandler) {
+        const response = await askUserQuestionHandler(approvalPrompt);
+        return (0, effectsHelpers_1.buildBreakpointResult)(response, approvalKey);
+    }
+    return (0, effectsHelpers_1.buildBreakpointResult)((0, utils_1.createAskUserQuestionResponse)(approvalPrompt, { [approvalKey]: "Approve" }), approvalKey);
+}
+async function tryChannelRelay(action, options, _approvalKey) {
+    try {
+        const { ChannelPermissionRelay, createApprovalRace } = await Promise.resolve().then(() => __importStar(require("../../../../mcp/channels/permissionRelay")));
+        const { DEFAULT_APPROVAL_SECURITY } = await Promise.resolve().then(() => __importStar(require("../../../../mcp/channels/types")));
+        const breakpointId = action.effectId;
+        const tags = action.labels ?? [];
+        // Without a configured outbound sender, channel relay is a no-op.
+        // The relay infrastructure is available but requires explicit channel
+        // configuration (MCP servers for Slack/Discord/etc). When configured,
+        // the relay attempts to dispatch the breakpoint via channels and races
+        // against local terminal approval.
+        //
+        // To enable: configure MCP channels in ~/.a5c/channel-allowlist.json
+        // and ensure a ChannelManager is bound to the session.
+        //
+        // For now, check if the security policy allows relay and log the attempt.
+        const security = DEFAULT_APPROVAL_SECURITY;
+        if (!security.enabled)
+            return undefined;
+        // Validate terminal-only restrictions
+        if (tags.some(t => security.terminalOnlyTags.includes(t)))
+            return undefined;
+        for (const restricted of security.terminalOnlyTags) {
+            if (breakpointId.startsWith(`${restricted}.`))
+                return undefined;
+        }
+        // Channel relay is eligible but requires active MCP channel bindings.
+        // When fully configured, this returns a breakpoint result from the
+        // channel response. Without active channels, falls through to local.
+    }
+    catch {
+        // Channel modules not available — relay disabled
+    }
+    return undefined;
+}
+function shouldFallbackExternalAgentToInternal(taskDef) {
+    const agent = isPlainRecord(taskDef?.agent) ? taskDef.agent : {};
+    const metadata = isPlainRecord(taskDef?.metadata) ? taskDef.metadata : {};
+    return agent.fallbackToInternal === true
+        || metadata.fallbackToInternal === true
+        || agent.fallbackType === "internal"
+        || metadata.fallbackType === "internal";
+}
+function readExternalAgentTimeoutMs(taskDef) {
+    const agent = isPlainRecord(taskDef?.agent) ? taskDef.agent : {};
+    return typeof agent.timeoutMs === "number" ? agent.timeoutMs : undefined;
+}
+function parseSubprocessSpec(action, workspace) {
+    const subprocess = action.taskDef?.subprocess;
+    if (!subprocess || typeof subprocess.processPath !== "string" || !subprocess.processPath.trim()) {
+        throw new Error(`Subprocess effect ${action.effectId} is missing subprocess.processPath`);
+    }
+    const resolvedProcessPath = path.isAbsolute(subprocess.processPath)
+        ? path.resolve(subprocess.processPath)
+        : path.resolve(workspace ?? process.cwd(), subprocess.processPath);
+    const processId = typeof subprocess.processId === "string" && subprocess.processId.trim()
+        ? subprocess.processId.trim()
+        : path.basename(resolvedProcessPath, path.extname(resolvedProcessPath));
+    return {
+        processPath: resolvedProcessPath,
+        exportName: typeof subprocess.exportName === "string" ? subprocess.exportName : undefined,
+        processId,
+        prompt: typeof subprocess.prompt === "string" ? subprocess.prompt : undefined,
+        inputs: subprocess.inputs,
+        inputSchema: isPlainRecord(subprocess.inputSchema) ? subprocess.inputSchema : undefined,
+        outputSchema: isPlainRecord(subprocess.outputSchema) ? subprocess.outputSchema : undefined,
+        harness: typeof subprocess.harness === "string" ? subprocess.harness : undefined,
+        model: typeof subprocess.model === "string" ? subprocess.model : undefined,
+        maxIterations: typeof subprocess.maxIterations === "number" ? subprocess.maxIterations : undefined,
+        shareSession: subprocess.shareSession !== false,
+        metadata: subprocess.metadata,
+    };
+}
+function isPlainRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function summarizeSubprocessValue(value) {
+    if (typeof value === "string") {
+        return value.length > 240 ? `${value.slice(0, 237)}...` : value;
+    }
+    if (value instanceof Error) {
+        return value.message;
+    }
+    try {
+        const serialized = JSON.stringify(value);
+        return serialized.length > 240 ? `${serialized.slice(0, 237)}...` : serialized;
+    }
+    catch {
+        return String(value);
+    }
+}
+async function disposeWorkerSession(session) {
+    if (!session) {
+        return;
+    }
+    await session.abort().catch(() => undefined);
+    session.dispose();
+}
+async function invokeSubprocessEffect(action, harnessName, options, discovered, rl, json, askUserQuestionHandler) {
+    if (!options.runsDir || !options.runId) {
+        return {
+            status: "error",
+            error: new Error("Subprocess effects require runsDir and parent runId in the harness resolver."),
+        };
+    }
+    const spec = parseSubprocessSpec(action, options.workspace);
+    const childHarness = spec.harness ?? harnessName;
+    const childModel = spec.model ?? options.model;
+    const maxIterations = spec.maxIterations ?? options.maxIterations ?? 65_000;
+    const childPrompt = spec.prompt ?? action.taskDef?.title ?? `Run subprocess ${spec.processId}`;
+    const childRun = await (0, global_1.getGlobalRegistry)().getOrchestration().createRun({
+        processId: spec.processId,
+        entrypoint: spec.processPath,
+        prompt: spec.prompt ?? childPrompt,
+        harness: childHarness,
+        inputs: spec.inputs,
+        runsDir: options.runsDir,
+    });
+    (0, utils_1.emitAmuxEvent)({
+        type: "subagent_spawn",
+        runId: options.runId,
+        agent: "babysitter",
+        timestamp: new Date().toISOString(),
+        subagentId: childRun.runId,
+        agentName: "babysitter",
+        prompt: childPrompt,
+    }, Boolean(json), options.outputMode);
+    for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+        const iterationResult = await orchestrateIterationWithProcessLoadRetry({ runDir: childRun.runDir });
+        if (iterationResult.status === "waiting") {
+            await (0, dispatch_1.dispatchEffectActions)({
+                actions: iterationResult.nextActions,
+                concurrentEffects: (0, dispatch_1.harnessSupportsConcurrentEffects)(childHarness, discovered),
+                resolveAction: async (childAction) => {
+                    const effectiveHarness = discovered
+                        ? (0, utils_1.resolveTaskHarness)(childAction, childHarness, discovered)
+                        : childHarness;
+                    let workerSession = null;
+                    let workerSessionFactory;
+                    if (childAction.kind === "shell" || (0, utils_1.isInternalHarness)(effectiveHarness)) {
+                        const baseOpts = (0, utils_1.buildPiWorkerSessionOptions)({
+                            action: childAction,
+                            workspace: options.workspace,
+                            model: childModel,
+                        });
+                        const enhancedOpts = options.gentyContext
+                            ? (0, workerSessionEnhancer_1.enhanceWorkerSessionOptions)(baseOpts, options.gentyContext)
+                            : baseOpts;
+                        const createWorkerSession = () => (0, utils_1.createAgentCoreSession)(enhancedOpts);
+                        workerSession = createWorkerSession();
+                        workerSessionFactory = createWorkerSession;
+                    }
+                    try {
+                        const childEffectResult = await resolveEffectWithRetry(childAction, childHarness, {
+                            workspace: options.workspace,
+                            model: childModel,
+                            interactive: options.interactive,
+                            compressionConfig: options.compressionConfig,
+                            streaming: options.streaming,
+                            runsDir: options.runsDir,
+                            runId: childRun.runId,
+                            runDir: childRun.runDir,
+                            sessionId: spec.shareSession ? options.sessionId : undefined,
+                            maxIterations,
+                            verbose: options.verbose,
+                            outputMode: options.outputMode,
+                            gentyContext: options.gentyContext,
+                        }, workerSession, discovered, rl, json, workerSessionFactory, disposeWorkerSession, askUserQuestionHandler);
+                        return childEffectResult;
+                    }
+                    finally {
+                        await disposeWorkerSession(workerSession);
+                    }
+                },
+                commitAction: async ({ action: childAction, result: childEffectResult, startedAt, finishedAt }) => {
+                    const childHandle = {
+                        runId: childRun.runId,
+                        runDir: childRun.runDir,
+                        processId: childRun.processId,
+                        status: "running",
+                    };
+                    await (0, global_1.getGlobalRegistry)().getOrchestration().postEffectResult(childHandle, childAction.effectId, {
+                        status: (0, utils_1.assertResolvedStatus)(childEffectResult.status),
+                        value: childEffectResult.value,
+                        error: childEffectResult.error,
+                        startedAt,
+                        finishedAt,
+                    });
+                },
+            });
+            continue;
+        }
+        if (iterationResult.status === "completed") {
+            (0, utils_1.emitAmuxEvent)({
+                type: "subagent_result",
+                runId: options.runId,
+                agent: "babysitter",
+                timestamp: new Date().toISOString(),
+                subagentId: childRun.runId,
+                agentName: "babysitter",
+                summary: summarizeSubprocessValue(iterationResult.output),
+            }, Boolean(json), options.outputMode);
+            return {
+                status: "ok",
+                value: {
+                    runId: childRun.runId,
+                    runDir: childRun.runDir,
+                    output: iterationResult.output,
+                },
+            };
+        }
+        const message = iterationResult.status === "halted"
+            ? iterationResult.reason
+            : "error" in iterationResult && iterationResult.error instanceof Error
+                ? iterationResult.error.message
+                : "error" in iterationResult
+                    ? summarizeSubprocessValue(iterationResult.error)
+                    : summarizeSubprocessValue(iterationResult);
+        (0, utils_1.emitAmuxEvent)({
+            type: "subagent_error",
+            runId: options.runId,
+            agent: "babysitter",
+            timestamp: new Date().toISOString(),
+            subagentId: childRun.runId,
+            agentName: "babysitter",
+            error: message,
+        }, Boolean(json), options.outputMode);
+        return {
+            status: "error",
+            error: new Error(`Nested run ${childRun.runId} failed: ${message}`),
+            stderr: message,
+        };
+    }
+    const timeoutMessage = `Nested run ${childRun.runId} reached max iterations (${maxIterations}) without completion.`;
+    (0, utils_1.emitAmuxEvent)({
+        type: "subagent_error",
+        runId: options.runId,
+        agent: "babysitter",
+        timestamp: new Date().toISOString(),
+        subagentId: childRun.runId,
+        agentName: "babysitter",
+        error: timeoutMessage,
+    }, Boolean(json), options.outputMode);
+    return {
+        status: "error",
+        error: new Error(timeoutMessage),
+        stderr: timeoutMessage,
+    };
+}
+async function resolveEffectWithRetry(action, harnessName, options, piSession, discovered, rl, json, piSessionFactory, disposePiSession, askUserQuestionHandler) {
+    const config = { ...utils_1.DEFAULT_EFFECT_RETRY_CONFIG, ...options.retryConfig };
+    const metadata = action.taskDef?.metadata;
+    if (typeof metadata?.maxRetries === "number") {
+        config.maxRetries = metadata.maxRetries;
+    }
+    if (metadata?.noRetry === true) {
+        config.maxRetries = 0;
+    }
+    if (config.nonRetryableKinds.includes(action.kind)) {
+        return resolveEffect(action, harnessName, options, piSession, discovered, rl, json, askUserQuestionHandler);
+    }
+    let lastResult;
+    let currentPiSession = piSession;
+    for (let attempt = 0; attempt <= config.maxRetries; attempt += 1) {
+        try {
+            lastResult = await resolveEffect(action, harnessName, options, currentPiSession, discovered, rl, json, askUserQuestionHandler);
+            if (lastResult.status === "ok") {
+                return lastResult;
+            }
+            if (attempt >= config.maxRetries ||
+                !(0, effectsHelpers_1.isRetryableEffectError)(lastResult.error instanceof Error
+                    ? lastResult.error.message
+                    : String(lastResult.error ?? ""))) {
+                return lastResult;
+            }
+        }
+        catch (error) {
+            if (attempt >= config.maxRetries || !(0, effectsHelpers_1.isRetryableEffectError)(error)) {
+                return {
+                    status: "error",
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    stderr: error instanceof Error ? error.message : String(error),
+                };
+            }
+            lastResult = {
+                status: "error",
+                error: error instanceof Error ? error : new Error(String(error)),
+            };
+        }
+        process.stderr.write(`[babysitter] effect ${action.effectId ?? action.taskDef?.id ?? 'unknown'} retry ${attempt + 1}/${config.maxRetries}: ${lastResult?.error instanceof Error ? lastResult.error.message : String(lastResult?.error ?? 'unknown')}\n`);
+        const baseDelay = constants_1.EFFECT_RETRY_DELAYS_OVERRIDE
+            ? (constants_1.EFFECT_RETRY_DELAYS_OVERRIDE[attempt] ?? 0)
+            : Math.min(config.baseDelayMs * Math.pow(config.backoffMultiplier, attempt), config.maxDelayMs);
+        const jitter = constants_1.EFFECT_RETRY_DELAYS_OVERRIDE
+            ? 0
+            : baseDelay * 0.2 * (Math.random() * 2 - 1);
+        const delay = Math.max(0, Math.round(baseDelay + jitter));
+        if (currentPiSession && piSessionFactory) {
+            if (disposePiSession) {
+                await disposePiSession(currentPiSession);
+            }
+            else {
+                currentPiSession.dispose();
+            }
+            currentPiSession = piSessionFactory();
+        }
+        if (delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    return lastResult;
+}
+async function orchestrateIterationWithProcessLoadRetry(args) {
+    let attempt = 0;
+    for (;;) {
+        try {
+            return await (0, babysitter_sdk_1.orchestrateIteration)({
+                runDir: args.runDir,
+                subprocessSupport: "agent-platform",
+            });
+        }
+        catch (error) {
+            if (!(0, utils_1.isProcessModuleLoadFailure)(error) ||
+                attempt >= constants_1.PROCESS_MODULE_LOAD_RETRY_DELAYS_MS.length) {
+                throw error;
+            }
+            const delayMs = constants_1.PROCESS_MODULE_LOAD_RETRY_DELAYS_MS[attempt] ?? 0;
+            attempt += 1;
+            process.stderr.write(`[babysitter] process module load attempt ${attempt} failed: ${error instanceof Error ? error.message : String(error)}, retrying...\n`);
+            args.writeVerbose?.(`[phaseOrchestration retry] process module load failed for ${args.runDir}; retrying iteration import (attempt ${attempt}/${constants_1.PROCESS_MODULE_LOAD_RETRY_DELAYS_MS.length}) after ${delayMs}ms`);
+            args.writeVerboseData?.("phaseOrchestration retry cause", error instanceof Error
+                ? {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack,
+                    cause: error.cause instanceof Error
+                        ? {
+                            name: error.cause.name,
+                            message: error.cause.message,
+                            stack: error.cause.stack,
+                        }
+                        : error.cause,
+                }
+                : error);
+            if (delayMs > 0) {
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+        }
+    }
+}