@a5c-ai/genty-platform 5.1.1-staging.00ceebd28cf2

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

@@ -0,0 +1,656 @@
+"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.runInternalOrchestrationPhase = runInternalOrchestrationPhase;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const utils_1 = require("../utils");
+const prompts_1 = require("../prompts");
+const constants_1 = require("./constants");
+const effects_1 = require("./effects");
+const internalTools_1 = require("./internalTools");
+const runState_1 = require("../planProcess/runState");
+const planProcess_1 = require("../planProcess");
+const resumeState_1 = require("../resumeState");
+const verbose_1 = require("./verbose");
+const tasks_1 = require("../../../../tasks");
+const history_1 = require("../../../../session/history");
+const gentySessionContext_1 = require("../../../gentySessionContext");
+const gentySessionIntegration_1 = require("../../../gentySessionIntegration");
+const extensionToolBridge_1 = require("../../../extensionToolBridge");
+async function runInternalOrchestrationPhase(args) {
+    const state = {
+        runId: args.existingRunId,
+        runDir: args.existingRunDir,
+        sessionBound: args.existingSessionBound,
+        iteration: 0,
+        pendingActions: new Map(),
+        pendingEffectResults: new Map(),
+    };
+    let orchestrationSession = null;
+    // Initialize genty session context — wires trust, extensions, instructions, steering, model switch
+    let gentyCtx = null;
+    try {
+        gentyCtx = await (0, gentySessionContext_1.createGentySessionContext)({
+            workspace: args.workspace ?? process.cwd(),
+            sessionId: (0, node_crypto_1.randomUUID)(),
+            model: args.model,
+            agentId: `genty-orchestrator-${Date.now()}`,
+        });
+    }
+    catch {
+        // Genty context is optional; orchestration works without it
+    }
+    if (gentyCtx) {
+        args.gentyContext = gentyCtx;
+    }
+    const activePiSessions = new Set();
+    const writeVerbose = (message) => {
+        (0, utils_1.writeVerboseLine)(args.verbose, args.json, message, args.outputMode);
+    };
+    const writeVerboseData = (label, value, maxChars) => {
+        (0, utils_1.writeVerboseBlock)(args.verbose, args.json, label, value, maxChars, args.outputMode);
+    };
+    const registerPiSession = (session) => {
+        activePiSessions.add(session);
+        return session;
+    };
+    const shutdownPiSession = async (session) => {
+        if (!session) {
+            return;
+        }
+        activePiSessions.delete(session);
+        const maybeAbort = session;
+        if (typeof maybeAbort.abort === "function") {
+            await maybeAbort.abort().catch(() => undefined);
+        }
+        session.dispose();
+    };
+    const describePendingActions = () => Array.from(state.pendingActions.values()).map((action) => ({
+        effectId: action.effectId,
+        kind: action.kind,
+        title: action.taskDef?.title,
+        harness: (0, utils_1.resolveTaskHarness)(action, args.selectedHarnessName, args.discovered),
+    }));
+    const ensureTerminalResult = () => {
+        if (state.lastIterationResult?.status === "completed")
+            return 0;
+        if (state.lastIterationResult?.status === "failed")
+            return 1;
+        return null;
+    };
+    const captureProgressSnapshot = () => ({
+        runId: state.runId,
+        runDir: state.runDir,
+        sessionBound: Boolean(state.sessionBound),
+        iteration: state.iteration,
+        pendingActionIds: Array.from(state.pendingActions.keys()).sort().join(","),
+        pendingResultIds: Array.from(state.pendingEffectResults.keys()).sort().join(","),
+        lastStatus: state.lastIterationResult?.status,
+        hasAskUserQuestionResponse: Boolean(state.lastAskUserQuestionResponse),
+        finished: Boolean(state.finished),
+        processFileFingerprint: (0, effects_1.readProcessFileFingerprint)(args.processPath),
+    });
+    const orchestrationStateAdvanced = (before) => {
+        const after = captureProgressSnapshot();
+        return Object.keys(after).some((key) => after[key]
+            !== before[key]);
+    };
+    const protectedRunEntries = new Set();
+    let runSummaryRecorded = false;
+    const recordRunSummary = async (status, outcome) => {
+        const stateFile = state.sessionBound?.stateFile;
+        const sessionId = state.sessionBound?.sessionId;
+        if (runSummaryRecorded || !stateFile || !sessionId || !state.runId) {
+            return;
+        }
+        const recordedAt = new Date().toISOString();
+        await (0, history_1.addRunSummary)(path.dirname(stateFile), sessionId, {
+            runId: state.runId,
+            processId: path.basename(args.processPath, path.extname(args.processPath)),
+            status,
+            startedAt: recordedAt,
+            completedAt: recordedAt,
+            outcome,
+        });
+        runSummaryRecorded = true;
+    };
+    const snapshotProtectedRunEntries = async () => {
+        if (!args.runsDir) {
+            return;
+        }
+        let entries = [];
+        try {
+            entries = await node_fs_1.promises.readdir(args.runsDir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            protectedRunEntries.add(entry);
+        }
+    };
+    const cleanupUnexpectedRunSiblings = async () => {
+        if (!args.runsDir || !state.runId) {
+            return;
+        }
+        let entries = [];
+        try {
+            entries = await node_fs_1.promises.readdir(args.runsDir);
+        }
+        catch {
+            return;
+        }
+        const removed = [];
+        for (const entry of entries) {
+            if (entry === state.runId || protectedRunEntries.has(entry)) {
+                continue;
+            }
+            try {
+                const target = path.join(args.runsDir, entry);
+                const stat = await node_fs_1.promises.stat(target);
+                if (!stat.isDirectory()) {
+                    continue;
+                }
+                await node_fs_1.promises.rm(target, { recursive: true, force: true });
+                removed.push(entry);
+            }
+            catch {
+                // Best-effort cleanup only; don't derail the orchestration loop.
+            }
+        }
+        if (removed.length > 0) {
+            writeVerboseData("phaseOrchestration host cleaned stray run dirs", {
+                runId: state.runId,
+                removed,
+            });
+        }
+    };
+    const syncStateFromRunArtifacts = async () => {
+        if (!state.runDir) {
+            return { runStatus: null, synchronized: false };
+        }
+        const before = captureProgressSnapshot();
+        const assessed = await (0, resumeState_1.assessRun)(state.runDir).catch(() => null);
+        if (!assessed) {
+            return { runStatus: null, synchronized: false };
+        }
+        const pendingTasks = await (0, tasks_1.listTasks)(state.runDir, { status: "requested" }).catch(() => []);
+        state.runId = assessed.run.runId;
+        state.pendingActions.clear();
+        for (const task of pendingTasks) {
+            const detail = await (0, tasks_1.readTask)(state.runDir, task.effectId).catch(() => null);
+            if (!detail) {
+                continue;
+            }
+            const definition = detail.definition;
+            const io = typeof definition.io === "object" && definition.io !== null
+                ? definition.io
+                : undefined;
+            const action = {
+                effectId: task.effectId,
+                invocationKey: String(definition.invocationKey ?? task.effectId),
+                kind: task.kind,
+                label: task.title,
+                labels: task.labels,
+                taskDef: detail.definition,
+                taskId: task.taskId,
+                stepId: typeof definition.stepId === "string" ? definition.stepId : undefined,
+                taskDefRef: `tasks/${task.effectId}/task.json`,
+                inputsRef: typeof io?.inputJsonPath === "string" ? String(io.inputJsonPath) : undefined,
+                requestedAt: task.requestedAt,
+            };
+            state.pendingActions.set(task.effectId, action);
+        }
+        if (assessed.run.status === "completed") {
+            state.lastIterationResult = { status: "completed", output: undefined };
+        }
+        else if (assessed.run.status === "failed") {
+            state.lastIterationResult = {
+                status: "failed",
+                error: { message: "Run failed" },
+            };
+        }
+        else if (state.pendingActions.size > 0) {
+            state.lastIterationResult = {
+                status: "waiting",
+                nextActions: Array.from(state.pendingActions.values()),
+            };
+        }
+        const synchronized = orchestrationStateAdvanced(before);
+        if (synchronized) {
+            writeVerboseData("phaseOrchestration synced run state", {
+                runStatus: assessed.run.status,
+                pendingEffects: Array.from(state.pendingActions.keys()),
+                journalLength: assessed.journalLength,
+                lastEvent: assessed.lastEvent,
+            });
+        }
+        return { runStatus: assessed.run.status, synchronized };
+    };
+    const { mergedTools, iterateTool, taskPostTool, finishTool, invokeTool } = (0, internalTools_1.createOrchestrationTools)({
+        phaseArgs: args,
+        state,
+        describePendingActions,
+        writeVerbose,
+        writeVerboseData,
+    });
+    const ensureBoundRunContext = async () => {
+        const runState = await (0, runState_1.ensureRunAndMaybeBindFromProcessDefinition)({
+            processPath: args.processPath,
+            prompt: args.prompt ?? "",
+            workspace: args.workspace,
+            runsDir: args.runsDir,
+            selectedHarnessName: args.selectedHarnessName,
+            maxIterations: args.maxIterations,
+            interactive: args.interactive,
+            verbose: args.verbose,
+            json: args.json,
+            phaseSession: orchestrationSession,
+            state,
+        });
+        if (runState.createdRun) {
+            (0, utils_1.emitProgress)({ phase: "2", status: "run-created", runId: runState.runId, runDir: runState.runDir }, args.json, args.verbose, args.outputMode);
+            writeVerboseData("phaseOrchestration host run state", runState);
+        }
+        if (runState.boundSession && runState.sessionBound) {
+            (0, utils_1.emitProgress)({
+                phase: "2",
+                status: "bound",
+                runId: runState.runId,
+                runDir: runState.runDir,
+                harness: runState.sessionBound.harness,
+                sessionId: runState.sessionBound.sessionId,
+                error: runState.sessionBound.error,
+            }, args.json, args.verbose, args.outputMode);
+        }
+    };
+    const promptOrchestrationAgent = async (message, label = "phaseOrchestration") => {
+        if (!orchestrationSession) {
+            throw new utils_1.BabysitterRuntimeError("OrchestrationSessionMissing", "The orchestration PI session has not been created.", { category: utils_1.ErrorCategory.Runtime });
+        }
+        if (!args.json && args.verbose && args.outputMode !== "tui") {
+            process.stderr.write(`\n${utils_1.DIM}[${label}] agent turn\n`);
+        }
+        writeVerboseData(`${label} prompt`, message);
+        const progressSnapshot = captureProgressSnapshot();
+        let result;
+        try {
+            result = await (0, utils_1.promptPiWithRetry)({
+                session: orchestrationSession,
+                message: (0, utils_1.compressInternalHarnessPrompt)(message, args.compressionConfig, "agent"),
+                timeout: utils_1.PARENT_PROMPT_TIMEOUT_MS,
+                label,
+                writeVerbose,
+                writeVerboseData,
+            });
+        }
+        catch (err) {
+            const isTimeout = err instanceof utils_1.BabysitterRuntimeError
+                && (err.name === "PiTimeoutError" || err.message.includes("timed out"));
+            if (!isTimeout) {
+                throw err;
+            }
+            result = {
+                success: false,
+                output: `Pi prompt timed out: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        if (!result.success) {
+            writeVerboseData(`${label} agent failure output`, result.output);
+            if (!orchestrationStateAdvanced(progressSnapshot)) {
+                throw new utils_1.BabysitterRuntimeError("OrchestrationAgentFailed", result.output, {
+                    category: utils_1.ErrorCategory.External,
+                });
+            }
+            if (state.lastIterationResult?.status !== "process-error" &&
+                !(0, utils_1.isIgnorablePiPromptFailure)(result.output)) {
+                throw new utils_1.BabysitterRuntimeError("OrchestrationAgentFailed", result.output, {
+                    category: utils_1.ErrorCategory.External,
+                });
+            }
+            return;
+        }
+        writeVerbose(`[phaseOrchestration agent] ${summarizeAgentText(result.output)}`);
+    };
+    // Build orchestration system prompt, then layer in genty context (instructions, extensions)
+    const orchestrationSystemPrompt = (0, prompts_1.buildOrchestrationSystemPrompt)(args.selectedHarnessName, args.promptContext, args.interactive, args.invocationCommand === "call");
+    const appendSystemPrompt = [orchestrationSystemPrompt];
+    let sessionCustomTools = mergedTools;
+    if (gentyCtx) {
+        // Apply AGENTS.md / SYSTEM.md instructions
+        if (gentyCtx.instructions.agentInstructions.length > 0) {
+            appendSystemPrompt.push(...gentyCtx.instructions.agentInstructions);
+        }
+        if (gentyCtx.instructions.systemPromptMode === 'append' && gentyCtx.instructions.systemPrompt) {
+            appendSystemPrompt.push(gentyCtx.instructions.systemPrompt);
+        }
+        // Bridge extension tools into the custom tools array
+        const extensionTools = (0, extensionToolBridge_1.bridgeExtensionTools)(gentyCtx.extensionRegistry);
+        if (extensionTools.length > 0) {
+            sessionCustomTools = [...mergedTools, ...extensionTools];
+        }
+    }
+    orchestrationSession = registerPiSession((0, utils_1.createAgentCoreSession)({
+        workspace: args.workspace,
+        model: gentyCtx?.modelSwitch.currentModel ?? args.model,
+        backend: (0, utils_1.resolveAgentCoreBackendForHarness)(args.selectedHarnessName),
+        toolsMode: "coding",
+        customTools: sessionCustomTools,
+        uiContext: args.interactive && args.rl
+            ? (0, utils_1.createReadlineAskUserQuestionUiContext)(args.rl)
+            : undefined,
+        appendSystemPrompt,
+        ephemeral: true,
+        ...(gentyCtx?.instructions.systemPromptMode === 'replace' && gentyCtx.instructions.systemPrompt
+            ? { systemPrompt: gentyCtx.instructions.systemPrompt }
+            : {}),
+    }));
+    (0, utils_1.emitProgress)({ phase: "2", status: "started", harness: args.selectedHarnessName }, args.json, args.verbose, args.outputMode);
+    let unsubscribe = null;
+    try {
+        await orchestrationSession.initialize();
+        if (gentyCtx) {
+            await gentyCtx.extensionRegistry.emit({
+                type: 'sessionStart',
+                timestamp: new Date().toISOString(),
+                data: { model: gentyCtx.modelSwitch.currentModel, extensions: gentyCtx.extensionLoadResult },
+            });
+        }
+        if (!args.json && args.verbose && args.outputMode !== "tui") {
+            unsubscribe = (0, verbose_1.subscribeVerbosePiEvents)(orchestrationSession, "orchestrator", args);
+        }
+        await ensureBoundRunContext();
+        if (!state.runId || !state.runDir) {
+            throw new utils_1.BabysitterRuntimeError("RunNotCreated", "The orchestration session could not establish a run before iteration.", { category: utils_1.ErrorCategory.Runtime });
+        }
+        await snapshotProtectedRunEntries();
+        let consecutiveTimeouts = 0;
+        let consecutiveStalls = 0;
+        let consecutiveProcessErrorStalls = 0;
+        while (state.iteration < args.maxIterations) {
+            const observed = await syncStateFromRunArtifacts();
+            const terminal = ensureTerminalResult();
+            if (terminal !== null) {
+                break;
+            }
+            if ((state.lastIterationResult?.status === "waiting"
+                && state.pendingActions.size === 0)
+                || observed.runStatus === "created"
+                || observed.runStatus === "in-progress") {
+                writeVerbose(observed.runStatus === "created"
+                    ? "[phaseOrchestration host] bootstrapping the freshly created run"
+                    : "[phaseOrchestration host] all pending effects were posted; auto-advancing the run");
+                await invokeTool(iterateTool, "babysitter_run_iterate");
+                if (ensureTerminalResult() !== null) {
+                    break;
+                }
+                consecutiveTimeouts = 0;
+                consecutiveStalls = 0;
+                consecutiveProcessErrorStalls = 0;
+                continue;
+            }
+            // Auto-execute effects in the host — models struggle with the babysitter tool protocol.
+            // Handle shell effects via child_process, all other non-breakpoint effects via delegation.
+            if (state.pendingActions.size > 0) {
+                let effectsResolved = 0;
+                for (const [effectId, action] of state.pendingActions) {
+                    if (action.kind === 'breakpoint')
+                        continue;
+                    if (action.kind === 'shell') {
+                        const shell = action.shell ?? action.taskDef?.shell;
+                        if (!shell?.command)
+                            continue;
+                        writeVerbose(`[phaseOrchestration host] auto-executing shell effect ${effectId}: ${shell.command} ${(shell.args || []).slice(0, 2).join(' ')}`);
+                        try {
+                            const { execFileSync } = await Promise.resolve().then(() => __importStar(require('node:child_process')));
+                            const stdout = execFileSync(shell.command, shell.args || [], {
+                                cwd: args.workspace,
+                                timeout: shell.timeout || 30_000,
+                                encoding: 'utf8',
+                                stdio: ['pipe', 'pipe', 'pipe'],
+                            });
+                            await invokeTool(taskPostTool, 'babysitter_task_post_result', {
+                                effectId,
+                                status: 'ok',
+                                valueText: stdout,
+                            });
+                            effectsResolved++;
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            writeVerbose(`[phaseOrchestration host] shell effect ${effectId} failed: ${msg}`);
+                            await invokeTool(taskPostTool, 'babysitter_task_post_result', {
+                                effectId,
+                                status: 'error',
+                                valueText: msg,
+                            });
+                            effectsResolved++;
+                        }
+                    }
+                    else {
+                        const agentSpec = action.agent ?? action.taskDef?.agent;
+                        const prompt = typeof agentSpec?.prompt === 'string'
+                            ? agentSpec.prompt
+                            : JSON.stringify(agentSpec?.prompt ?? action.title ?? action.label ?? 'Execute this task');
+                        writeVerbose(`[phaseOrchestration host] auto-delegating ${action.kind} effect ${effectId}: ${(action.title ?? action.label ?? '').slice(0, 80)}`);
+                        try {
+                            const delegated = await (0, planProcess_1.runDelegatedHarnessTask)({
+                                task: prompt,
+                                workspace: args.workspace,
+                                model: args.model,
+                                timeout: 180_000,
+                            });
+                            await invokeTool(taskPostTool, 'babysitter_task_post_result', {
+                                effectId,
+                                status: 'ok',
+                                valueJson: typeof delegated === 'string' ? delegated : JSON.stringify(delegated),
+                            });
+                            effectsResolved++;
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            writeVerbose(`[phaseOrchestration host] ${action.kind} effect ${effectId} failed: ${msg}`);
+                            await invokeTool(taskPostTool, 'babysitter_task_post_result', {
+                                effectId,
+                                status: 'error',
+                                valueText: msg,
+                            });
+                            effectsResolved++;
+                        }
+                    }
+                }
+                if (effectsResolved > 0) {
+                    const totalPending = state.pendingActions.size;
+                    writeVerbose(`[phaseOrchestration host] auto-resolved ${effectsResolved} effects (${totalPending} still pending)`);
+                    consecutiveStalls = 0;
+                    // If all effects resolved, auto-advance the run without prompting the model.
+                    if (totalPending === 0) {
+                        writeVerbose('[phaseOrchestration host] all effects auto-resolved — auto-advancing run');
+                        await invokeTool(iterateTool, "babysitter_run_iterate");
+                        if (ensureTerminalResult() !== null)
+                            break;
+                        consecutiveTimeouts = 0;
+                        consecutiveProcessErrorStalls = 0;
+                    }
+                    continue;
+                }
+            }
+            const progressBeforeTurn = captureProgressSnapshot();
+            // Drain any mid-execution steering messages and prepend to prompt
+            const steeringContent = gentyCtx ? (0, gentySessionIntegration_1.drainSteeringMessages)(gentyCtx) : undefined;
+            // Emit extension turnStart event
+            if (gentyCtx) {
+                await gentyCtx.extensionRegistry.emit({
+                    type: 'turnStart',
+                    timestamp: new Date().toISOString(),
+                    data: { iteration: state.iteration, runId: state.runId },
+                });
+            }
+            try {
+                let turnPrompt = (0, prompts_1.buildOrchestrationTurnPrompt)({
+                    processPath: path.resolve(args.processPath),
+                    userPrompt: args.prompt,
+                    planningConversationSummary: args.planningConversationSummary,
+                    maxIterations: args.maxIterations,
+                    currentIteration: state.iteration,
+                    runId: state.runId,
+                    runDir: state.runDir,
+                    lastStatus: state.lastIterationResult?.status,
+                    lastError: state.lastIterationResult?.status === "process-error"
+                        ? extractIterationError(state.lastIterationResult.error)
+                        : undefined,
+                    pendingEffects: describePendingActions(),
+                });
+                if (steeringContent) {
+                    turnPrompt = `[Steering messages from user]\n${steeringContent}\n\n${turnPrompt}`;
+                }
+                await promptOrchestrationAgent(turnPrompt, `phaseOrchestration iteration ${state.iteration + 1}`);
+            }
+            catch (err) {
+                const isTimeoutFailure = err instanceof utils_1.BabysitterRuntimeError
+                    && err.name === "OrchestrationAgentFailed"
+                    && (err.message.includes("timed out") || err.message.includes("PiTimeoutError"));
+                if (!isTimeoutFailure) {
+                    throw err;
+                }
+                consecutiveTimeouts += 1;
+                if (consecutiveTimeouts >= constants_1.MAX_CONSECUTIVE_TIMEOUTS) {
+                    throw new utils_1.BabysitterRuntimeError("OrchestrationAgentTimedOut", `Pi prompt timed out ${consecutiveTimeouts} consecutive times — aborting orchestration.`, { category: utils_1.ErrorCategory.External });
+                }
+                continue;
+            }
+            // Emit extension turnEnd event
+            if (gentyCtx) {
+                await gentyCtx.extensionRegistry.emit({
+                    type: 'turnEnd',
+                    timestamp: new Date().toISOString(),
+                    data: { iteration: state.iteration, runId: state.runId },
+                });
+            }
+            await cleanupUnexpectedRunSiblings();
+            if (ensureTerminalResult() !== null) {
+                break;
+            }
+            if (!orchestrationStateAdvanced(progressBeforeTurn)) {
+                await syncStateFromRunArtifacts();
+            }
+            if (orchestrationStateAdvanced(progressBeforeTurn)) {
+                consecutiveTimeouts = 0;
+                consecutiveStalls = 0;
+                consecutiveProcessErrorStalls = 0;
+                continue;
+            }
+            if (state.lastIterationResult?.status === "process-error") {
+                consecutiveProcessErrorStalls += 1;
+                if (consecutiveProcessErrorStalls >= constants_1.MAX_CONSECUTIVE_PROCESS_ERROR_STALLS) {
+                    throw new utils_1.BabysitterRuntimeError("OrchestrationAgentStalled", `The orchestration agent did not retry the run or repair the process after ${consecutiveProcessErrorStalls} consecutive recovery prompts.`, { category: utils_1.ErrorCategory.Runtime });
+                }
+                continue;
+            }
+            consecutiveStalls += 1;
+            if (consecutiveStalls >= constants_1.MAX_CONSECUTIVE_STALLS) {
+                throw new utils_1.BabysitterRuntimeError("OrchestrationAgentStalled", `The orchestration agent did not advance the run or resolve pending effects for ${consecutiveStalls} consecutive turns.`, { category: utils_1.ErrorCategory.Runtime });
+            }
+        }
+        if (state.lastIterationResult?.status === "completed" || state.lastIterationResult?.status === "failed") {
+            await recordRunSummary(state.lastIterationResult.status, state.lastIterationResult.status === "completed"
+                ? `Run ${state.runId} completed after ${state.iteration} iterations.`
+                : `Run ${state.runId} failed after ${state.iteration} iterations.`);
+            if (!state.finished) {
+                await invokeTool(finishTool, "babysitter_finish_orchestration", {
+                    summary: state.lastIterationResult.status === "completed"
+                        ? `Run ${state.runId} completed after ${state.iteration} iterations.`
+                        : `Run ${state.runId} failed after ${state.iteration} iterations.`,
+                });
+            }
+        }
+        const terminalResult = ensureTerminalResult();
+        if (terminalResult !== null) {
+            return terminalResult;
+        }
+        await recordRunSummary("failed", `Max iterations (${args.maxIterations}) reached without completion.`);
+        return 1;
+    }
+    catch (error) {
+        await recordRunSummary("failed", error instanceof Error ? error.message : String(error));
+        writeVerboseData("phaseOrchestration error", error instanceof Error
+            ? {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+                runId: state.runId,
+                runDir: state.runDir,
+                iteration: state.iteration,
+                pendingEffects: describePendingActions(),
+                lastIterationResult: state.lastIterationResult,
+            }
+            : error);
+        (0, utils_1.emitProgress)({
+            phase: "2",
+            status: "failed",
+            runId: state.runId,
+            runDir: state.runDir,
+            iteration: state.iteration,
+            error: error instanceof Error ? error.message : String(error),
+        }, args.json, args.verbose, args.outputMode);
+        return 1;
+    }
+    finally {
+        unsubscribe?.();
+        await Promise.allSettled(Array.from(activePiSessions).map((session) => shutdownPiSession(session)));
+        if (gentyCtx) {
+            await gentyCtx.extensionRegistry.emit({
+                type: 'sessionEnd',
+                timestamp: new Date().toISOString(),
+                data: { runId: state.runId },
+            });
+            await (0, gentySessionContext_1.destroyGentySessionContext)(gentyCtx).catch(() => { });
+        }
+    }
+}
+function summarizeAgentText(text) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (!normalized) {
+        return "(no summary emitted)";
+    }
+    return normalized.length > 240 ? `${normalized.slice(0, 237)}...` : normalized;
+}
+function extractIterationError(error) {
+    return typeof error === "object" && error !== null && "message" in error
+        ? String(error.message)
+        : String(error);
+}

package/dist/harness/internal/createRun/orchestration/internalTools.d.ts

@@ -0,0 +1,27 @@
+import { type OrchestrationState, type ToolResultShape } from "../utils";
+import type { OrchestrationWriteVerbose, OrchestrationWriteVerboseData, RunOrchestrationPhaseArgs } from "./types";
+type ToolExecute = (toolCallId: string, params: Record<string, unknown>) => Promise<ToolResultShape> | ToolResultShape;
+export type OrchestrationNamedTool = {
+    name: string;
+    execute?: ToolExecute;
+};
+export declare function createOrchestrationTools(args: {
+    phaseArgs: RunOrchestrationPhaseArgs;
+    state: OrchestrationState;
+    describePendingActions: () => Array<{
+        effectId: string;
+        kind: string;
+        title?: string;
+        harness?: string;
+    }>;
+    writeVerbose: OrchestrationWriteVerbose;
+    writeVerboseData: OrchestrationWriteVerboseData;
+}): {
+    mergedTools: unknown[];
+    iterateTool: OrchestrationNamedTool | undefined;
+    taskPostTool: OrchestrationNamedTool | undefined;
+    finishTool: OrchestrationNamedTool | undefined;
+    invokeTool: (tool: OrchestrationNamedTool | undefined, name: string, params?: Record<string, unknown>) => Promise<ToolResultShape>;
+};
+export {};
+//# sourceMappingURL=internalTools.d.ts.map