@a5c-ai/agent-platform 5.0.1-staging.b436b3b3e611

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

@@ -0,0 +1,319 @@
+"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.runExternalOrchestrationPhase = runExternalOrchestrationPhase;
+const path = __importStar(require("node:path"));
+const babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+const utils_1 = require("../utils");
+const constants_1 = require("./constants");
+const effects_1 = require("./effects");
+const runState_1 = require("../planProcess/runState");
+const verbose_1 = require("./verbose");
+const externalPhaseHelpers_1 = require("./externalPhaseHelpers");
+async function runExternalOrchestrationPhase(args) {
+    if (!(0, utils_1.shouldUseExternalHarness)(args.selectedHarnessName)) {
+        return undefined;
+    }
+    const state = {
+        runId: args.existingRunId,
+        runDir: args.existingRunDir,
+        sessionBound: args.existingSessionBound,
+        iteration: 0,
+        pendingActions: new Map(),
+        pendingEffectResults: new Map(),
+    };
+    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();
+    };
+    (0, utils_1.emitProgress)({ phase: "2", status: "started", harness: args.selectedHarnessName }, args.json, args.verbose, args.outputMode);
+    writeVerbose(`[phaseOrchestration host setup] harness=${args.selectedHarnessName} workspace=${path.resolve(args.workspace ?? process.cwd())} model=${args.model ?? "(default)"} processPath=${path.resolve(args.processPath)}`);
+    try {
+        if (state.runId && state.runDir) {
+            (0, utils_1.emitProgress)({ phase: "2", status: "resuming", runId: state.runId, runDir: state.runDir }, args.json, args.verbose, args.outputMode);
+        }
+        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,
+            state,
+            requireBoundSession: false,
+        });
+        if (runState.createdRun) {
+            (0, utils_1.emitProgress)({ phase: "2", status: "run-created", runId: runState.runId, runDir: runState.runDir }, args.json, args.verbose, args.outputMode);
+        }
+        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);
+        }
+        if (!state.runDir) {
+            throw new utils_1.BabysitterRuntimeError("RunNotCreated", "The orchestration session could not establish a run before iteration.", { category: utils_1.ErrorCategory.Runtime });
+        }
+        let consecutiveProcessErrors = 0;
+        const runStartTime = Date.now();
+        while (state.iteration < args.maxIterations) {
+            state.iteration += 1;
+            (0, utils_1.emitProgress)({
+                phase: "2",
+                status: "iteration-start",
+                iteration: state.iteration,
+                elapsedMs: Date.now() - runStartTime,
+            }, args.json, args.verbose, args.outputMode);
+            const result = await (0, effects_1.orchestrateIterationWithProcessLoadRetry)({
+                runDir: state.runDir,
+                writeVerbose,
+                writeVerboseData,
+            });
+            state.lastIterationResult = result;
+            if (result.status === "waiting") {
+                consecutiveProcessErrors = 0;
+                (0, utils_1.emitProgress)({
+                    phase: "2",
+                    status: "iteration",
+                    iteration: state.iteration,
+                    runStatus: "waiting",
+                    pendingEffects: result.nextActions.length,
+                }, args.json, args.verbose, args.outputMode);
+                const iterationStartTime = Date.now();
+                for (const action of result.nextActions) {
+                    await resolveExternalAction({
+                        action,
+                        args,
+                        state,
+                        registerPiSession,
+                        shutdownPiSession,
+                    });
+                }
+                (0, utils_1.emitProgress)({
+                    phase: "2",
+                    status: "iteration-summary",
+                    iteration: state.iteration,
+                    effectsResolved: result.nextActions.length,
+                    elapsedMs: Date.now() - iterationStartTime,
+                }, args.json, args.verbose, args.outputMode);
+                continue;
+            }
+            if (result.status === "completed") {
+                (0, utils_1.emitProgress)({ phase: "2", status: "completed", iteration: state.iteration, runStatus: "completed" }, args.json, args.verbose, args.outputMode);
+                return 0;
+            }
+            if (result.status === "process-error") {
+                consecutiveProcessErrors += 1;
+                const errorMessage = (0, externalPhaseHelpers_1.extractErrorMessage)(result.error);
+                (0, utils_1.emitProgress)({
+                    phase: "2",
+                    status: "process-error-recovery",
+                    iteration: state.iteration,
+                    runStatus: "recovering",
+                    attempt: consecutiveProcessErrors,
+                    maxAttempts: constants_1.MAX_PROCESS_ERROR_RECOVERIES,
+                    error: errorMessage,
+                }, args.json, args.verbose, args.outputMode);
+                if (consecutiveProcessErrors > constants_1.MAX_PROCESS_ERROR_RECOVERIES) {
+                    (0, utils_1.emitProgress)({
+                        phase: "2",
+                        status: "failed",
+                        iteration: state.iteration,
+                        runStatus: "failed",
+                        error: `Process error recovery exhausted after ${constants_1.MAX_PROCESS_ERROR_RECOVERIES} attempts. Last error: ${errorMessage}`,
+                    }, args.json, args.verbose, args.outputMode);
+                    return 1;
+                }
+                await (0, externalPhaseHelpers_1.recoverExternalProcessError)({
+                    args,
+                    errorMessage,
+                    errorStack: (0, externalPhaseHelpers_1.extractErrorStack)(result.error),
+                    registerPiSession,
+                    shutdownPiSession,
+                });
+                state.iteration -= 1;
+                continue;
+            }
+            (0, utils_1.emitProgress)({
+                phase: "2",
+                status: "failed",
+                iteration: state.iteration,
+                runStatus: "failed",
+                error: (0, externalPhaseHelpers_1.extractErrorMessage)(result.error),
+            }, args.json, args.verbose, args.outputMode);
+            return 1;
+        }
+        (0, utils_1.emitProgress)({
+            phase: "2",
+            status: "failed",
+            iteration: state.iteration,
+            runStatus: "failed",
+            error: `Max iterations (${args.maxIterations}) reached without completion`,
+        }, args.json, args.verbose, args.outputMode);
+        return 1;
+    }
+    finally {
+        await Promise.allSettled(Array.from(activePiSessions).map((session) => shutdownPiSession(session)));
+    }
+}
+async function resolveExternalAction(args) {
+    const taskHarness = (0, utils_1.resolveTaskHarness)(args.action, args.args.selectedHarnessName, args.args.discovered);
+    const shouldUseHostPiWorker = (args.args.selectedHarnessName === "pi" &&
+        taskHarness === args.args.selectedHarnessName &&
+        !args.state.sessionBound);
+    (0, utils_1.emitProgress)({
+        phase: "2",
+        status: "effect-start",
+        effectId: args.action.effectId,
+        effectKind: args.action.kind,
+        effectTitle: args.action.taskDef?.title,
+        effectHarness: taskHarness,
+        iteration: args.state.iteration,
+    }, args.args.json, args.args.verbose, args.args.outputMode);
+    let workerSession = null;
+    let workerUnsub = null;
+    if (args.action.kind === "shell" ||
+        (0, utils_1.isInternalHarness)(taskHarness) ||
+        shouldUseHostPiWorker) {
+        if ((0, utils_1.isInternalHarness)(taskHarness) || args.action.kind === "shell") {
+            workerSession = args.registerPiSession((0, utils_1.createAgentCoreSession)((0, utils_1.buildPiWorkerSessionOptions)({
+                action: args.action,
+                workspace: args.args.workspace,
+                model: args.args.model,
+            })));
+            workerUnsub = (0, verbose_1.subscribeVerbosePiEvents)(workerSession, `worker:${args.action.effectId.slice(-8)}`, args.args);
+        }
+        else if (shouldUseHostPiWorker) {
+            workerSession = args.registerPiSession((0, utils_1.createAgentCoreSession)((0, utils_1.buildPiWorkerSessionOptions)({
+                action: args.action,
+                workspace: args.args.workspace,
+                model: args.args.model,
+            })));
+            workerUnsub = (0, verbose_1.subscribeVerbosePiEvents)(workerSession, `worker:${args.action.effectId.slice(-8)}`, args.args);
+        }
+    }
+    const piSessionFactory = workerSession
+        ? () => {
+            const nextSession = args.registerPiSession((0, utils_1.createAgentCoreSession)((0, utils_1.buildPiWorkerSessionOptions)({
+                action: args.action,
+                workspace: args.args.workspace,
+                model: args.args.model,
+            })));
+            workerUnsub?.();
+            workerUnsub = (0, verbose_1.subscribeVerbosePiEvents)(nextSession, `worker:${args.action.effectId.slice(-8)}`, args.args);
+            return nextSession;
+        }
+        : undefined;
+    try {
+        const effectStartTime = Date.now();
+        const streamingCallbacks = (0, utils_1.createStreamingProgressCallbacks)((0, utils_1.resolveOutputMode)(args.args.json, args.args.outputMode), taskHarness);
+        const effectResult = await (0, effects_1.resolveEffectWithRetry)(args.action, args.args.selectedHarnessName, {
+            workspace: args.args.workspace,
+            model: args.args.model,
+            interactive: args.args.interactive,
+            compressionConfig: args.args.compressionConfig,
+            streaming: streamingCallbacks,
+            runsDir: args.args.runsDir,
+            runId: args.state.runId,
+            runDir: args.state.runDir,
+            sessionId: args.state.sessionBound?.sessionId,
+            maxIterations: args.args.maxIterations,
+            verbose: args.args.verbose,
+            outputMode: args.args.outputMode,
+        }, workerSession, args.args.discovered, args.args.rl, args.args.json, piSessionFactory, args.shutdownPiSession);
+        await (0, babysitter_sdk_1.commitEffectResult)({
+            runDir: args.state.runDir,
+            effectId: args.action.effectId,
+            invocationKey: args.action.invocationKey,
+            result: {
+                status: effectResult.status,
+                value: effectResult.value,
+                error: effectResult.error,
+                stdout: effectResult.stdout,
+                stderr: effectResult.stderr,
+                startedAt: new Date().toISOString(),
+                finishedAt: new Date().toISOString(),
+            },
+        });
+        (0, utils_1.emitProgress)({
+            phase: "2",
+            status: "effect",
+            effectId: args.action.effectId,
+            effectKind: args.action.kind,
+            effectTitle: args.action.taskDef?.title,
+            effectStatus: effectResult.status,
+            elapsedMs: Date.now() - effectStartTime,
+            error: effectResult.status === "error"
+                ? (0, externalPhaseHelpers_1.extractErrorMessage)(effectResult.error)
+                : undefined,
+            output: args.action.kind === "shell"
+                ? (effectResult.stdout ?? (typeof effectResult.value === "string" ? effectResult.value : undefined))?.slice(-1500)
+                : typeof effectResult.value === "string"
+                    ? effectResult.value.slice(0, 300)
+                    : undefined,
+        }, args.args.json, args.args.verbose, args.args.outputMode);
+    }
+    finally {
+        workerUnsub?.();
+        await args.shutdownPiSession(workerSession);
+    }
+}
+// Extracted to externalPhaseHelpers.ts

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

@@ -0,0 +1,16 @@
+/**
+ * Helper functions for external orchestration phase.
+ * Extracted from externalPhase.ts for max-lines compliance.
+ */
+import { createAgentCoreSession } from "../utils";
+import type { RunOrchestrationPhaseArgs } from "./types";
+export declare function extractErrorMessage(error: unknown): string;
+export declare function extractErrorStack(error: unknown): string | undefined;
+export declare function recoverExternalProcessError(args: {
+    args: RunOrchestrationPhaseArgs;
+    errorMessage: string;
+    errorStack?: string;
+    registerPiSession: (session: ReturnType<typeof createAgentCoreSession>) => ReturnType<typeof createAgentCoreSession>;
+    shutdownPiSession: (session: ReturnType<typeof createAgentCoreSession> | null | undefined) => Promise<void>;
+}): Promise<void>;
+//# sourceMappingURL=externalPhaseHelpers.d.ts.map

package/dist/harness/internal/createRun/orchestration/externalPhaseHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"externalPhaseHelpers.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/orchestration/externalPhaseHelpers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EAEL,sBAAsB,EAIvB,MAAM,UAAU,CAAC;AAElB,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEzD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAM1D;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAIpE;AAED,wBAAsB,2BAA2B,CAAC,IAAI,EAAE;IACtD,IAAI,EAAE,yBAAyB,CAAC;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,KAAK,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;IACrH,iBAAiB,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,GAAG,IAAI,GAAG,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7G,GAAG,OAAO,CAAC,IAAI,CAAC,CA2ChB"}

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

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Helper functions for external orchestration phase.
+ * Extracted from externalPhase.ts for max-lines compliance.
+ */
+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.extractErrorMessage = extractErrorMessage;
+exports.extractErrorStack = extractErrorStack;
+exports.recoverExternalProcessError = recoverExternalProcessError;
+const path = __importStar(require("node:path"));
+const babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+const utils_1 = require("../utils");
+const verbose_1 = require("./verbose");
+function extractErrorMessage(error) {
+    return error instanceof Error
+        ? error.message
+        : typeof error === "object" && error !== null && "message" in error
+            ? String(error.message)
+            : String(error);
+}
+function extractErrorStack(error) {
+    return typeof error === "object" && error !== null && "stack" in error
+        ? String(error.stack)
+        : undefined;
+}
+async function recoverExternalProcessError(args) {
+    const recoverySession = args.registerPiSession((0, utils_1.createAgentCoreSession)((0, utils_1.buildPiWorkerSessionOptions)({
+        action: {
+            effectId: "process-error-recovery",
+            invocationKey: "",
+            kind: "node",
+            taskDef: { title: "Fix process error" },
+        },
+        workspace: args.args.workspace,
+        model: args.args.model,
+    })));
+    const recoveryUnsub = (0, verbose_1.subscribeVerbosePiEvents)(recoverySession, "recovery", args.args);
+    try {
+        const guidelines = (0, babysitter_sdk_1.composeProcessCreatePrompt)((0, babysitter_sdk_1.createPromptContextFromCatalog)('pi', { interactive: false }));
+        const recoveryPrompt = [
+            `The babysitter process at ${path.resolve(args.args.processPath)} threw an error during execution:`,
+            "",
+            `Error: ${args.errorMessage}`,
+            args.errorStack ? `\nStack trace:\n${args.errorStack}` : "",
+            "",
+            "This is a bug in the process code, not in the babysitter runtime.",
+            "Read the process file, understand the error, and fix the code so the next iteration succeeds.",
+            "",
+            "--- Process Authoring Reference ---",
+            "",
+            guidelines,
+            "",
+            "--- End Reference ---",
+            "",
+            "Fix the process file and save it. The orchestrator will retry automatically.",
+        ].join("\n");
+        await (0, utils_1.promptPiWithRetry)({
+            session: recoverySession,
+            message: recoveryPrompt,
+            timeout: utils_1.PI_WORKER_TIMEOUT_MS,
+            label: "process-error-recovery",
+        });
+    }
+    catch {
+        return;
+    }
+    finally {
+        recoveryUnsub?.();
+        await args.shutdownPiSession(recoverySession);
+    }
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Compatibility surface for PhaseOrchestration helpers.
+ *
+ * The implementation lives under ./orchestration/ so the command stays
+ * split by responsibility instead of accreting more top-level helper files.
+ */
+export { MAX_CONSECUTIVE_PROCESS_ERROR_STALLS, MAX_CONSECUTIVE_STALLS, MAX_CONSECUTIVE_TIMEOUTS, MAX_PROCESS_ERROR_RECOVERIES, } from "./constants";
+export { orchestrateIterationWithProcessLoadRetry, readProcessFileFingerprint, resolveEffect, resolveEffectWithRetry, resolveHarnessSessionIdForBinding, } from "./effects";
+export { runExternalOrchestrationPhase } from "./externalPhase";
+export { runInternalOrchestrationPhase } from "./internalPhase";
+export { subscribeVerbosePiEvents } from "./verbose";
+import type { RunOrchestrationPhaseArgs } from "./types";
+export declare function runOrchestrationPhase(args: RunOrchestrationPhaseArgs): Promise<number>;
+//# sourceMappingURL=index.d.ts.map

package/dist/harness/internal/createRun/orchestration/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/orchestration/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,oCAAoC,EACpC,sBAAsB,EACtB,wBAAwB,EACxB,4BAA4B,GAC7B,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,wCAAwC,EACxC,0BAA0B,EAC1B,aAAa,EACb,sBAAsB,EACtB,iCAAiC,GAClC,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,6BAA6B,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EAAE,6BAA6B,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAErD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAIzD,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,yBAAyB,GAC9B,OAAO,CAAC,MAAM,CAAC,CAMjB"}

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

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Compatibility surface for PhaseOrchestration helpers.
+ *
+ * The implementation lives under ./orchestration/ so the command stays
+ * split by responsibility instead of accreting more top-level helper files.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeVerbosePiEvents = exports.runInternalOrchestrationPhase = exports.runExternalOrchestrationPhase = exports.resolveHarnessSessionIdForBinding = exports.resolveEffectWithRetry = exports.resolveEffect = exports.readProcessFileFingerprint = exports.orchestrateIterationWithProcessLoadRetry = exports.MAX_PROCESS_ERROR_RECOVERIES = exports.MAX_CONSECUTIVE_TIMEOUTS = exports.MAX_CONSECUTIVE_STALLS = exports.MAX_CONSECUTIVE_PROCESS_ERROR_STALLS = void 0;
+exports.runOrchestrationPhase = runOrchestrationPhase;
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "MAX_CONSECUTIVE_PROCESS_ERROR_STALLS", { enumerable: true, get: function () { return constants_1.MAX_CONSECUTIVE_PROCESS_ERROR_STALLS; } });
+Object.defineProperty(exports, "MAX_CONSECUTIVE_STALLS", { enumerable: true, get: function () { return constants_1.MAX_CONSECUTIVE_STALLS; } });
+Object.defineProperty(exports, "MAX_CONSECUTIVE_TIMEOUTS", { enumerable: true, get: function () { return constants_1.MAX_CONSECUTIVE_TIMEOUTS; } });
+Object.defineProperty(exports, "MAX_PROCESS_ERROR_RECOVERIES", { enumerable: true, get: function () { return constants_1.MAX_PROCESS_ERROR_RECOVERIES; } });
+var effects_1 = require("./effects");
+Object.defineProperty(exports, "orchestrateIterationWithProcessLoadRetry", { enumerable: true, get: function () { return effects_1.orchestrateIterationWithProcessLoadRetry; } });
+Object.defineProperty(exports, "readProcessFileFingerprint", { enumerable: true, get: function () { return effects_1.readProcessFileFingerprint; } });
+Object.defineProperty(exports, "resolveEffect", { enumerable: true, get: function () { return effects_1.resolveEffect; } });
+Object.defineProperty(exports, "resolveEffectWithRetry", { enumerable: true, get: function () { return effects_1.resolveEffectWithRetry; } });
+Object.defineProperty(exports, "resolveHarnessSessionIdForBinding", { enumerable: true, get: function () { return effects_1.resolveHarnessSessionIdForBinding; } });
+var externalPhase_1 = require("./externalPhase");
+Object.defineProperty(exports, "runExternalOrchestrationPhase", { enumerable: true, get: function () { return externalPhase_1.runExternalOrchestrationPhase; } });
+var internalPhase_1 = require("./internalPhase");
+Object.defineProperty(exports, "runInternalOrchestrationPhase", { enumerable: true, get: function () { return internalPhase_1.runInternalOrchestrationPhase; } });
+var verbose_1 = require("./verbose");
+Object.defineProperty(exports, "subscribeVerbosePiEvents", { enumerable: true, get: function () { return verbose_1.subscribeVerbosePiEvents; } });
+const externalPhase_2 = require("./externalPhase");
+const internalPhase_2 = require("./internalPhase");
+async function runOrchestrationPhase(args) {
+    const externalExitCode = await (0, externalPhase_2.runExternalOrchestrationPhase)(args);
+    if (externalExitCode !== undefined) {
+        return externalExitCode;
+    }
+    return (0, internalPhase_2.runInternalOrchestrationPhase)(args);
+}

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

@@ -0,0 +1,3 @@
+import type { RunOrchestrationPhaseArgs } from "./types";
+export declare function runInternalOrchestrationPhase(args: RunOrchestrationPhaseArgs): Promise<number>;
+//# sourceMappingURL=internalPhase.d.ts.map

package/dist/harness/internal/createRun/orchestration/internalPhase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalPhase.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/orchestration/internalPhase.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAAiC,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAIxF,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,yBAAyB,GAC9B,OAAO,CAAC,MAAM,CAAC,CA6djB"}