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

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

@@ -0,0 +1,490 @@
+"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.resolveEffectWithRetry = resolveEffectWithRetry;
+exports.orchestrateIterationWithProcessLoadRetry = orchestrateIterationWithProcessLoadRetry;
+const path = __importStar(require("node:path"));
+const effectsHelpers_1 = require("./effectsHelpers");
+var effectsHelpers_2 = require("./effectsHelpers");
+Object.defineProperty(exports, "readProcessFileFingerprint", { enumerable: true, get: function () { return effectsHelpers_2.readProcessFileFingerprint; } });
+const babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+const utils_1 = require("../utils");
+const planProcess_1 = require("../planProcess");
+const constants_1 = require("./constants");
+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 kind = action.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 question = action.taskDef?.question
+            ?? action.taskDef?.title
+            ?? "Breakpoint reached. Continue?";
+        const approvalPrompt = (0, utils_1.createApprovalAskUserQuestion)(question);
+        const approvalKey = approvalPrompt.questions[0]?.header ?? "Decision";
+        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);
+    }
+    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 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.PI_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);
+}
+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;
+    }
+    const maybeAbort = session;
+    if (typeof maybeAbort.abort === "function") {
+        await maybeAbort.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, babysitter_sdk_1.createRun)({
+        runsDir: options.runsDir,
+        harness: childHarness,
+        process: {
+            processId: spec.processId,
+            importPath: spec.processPath,
+            ...(spec.exportName ? { exportName: spec.exportName } : {}),
+        },
+        prompt: spec.prompt,
+        inputs: spec.inputs,
+        inputSchema: spec.inputSchema,
+        outputSchema: spec.outputSchema,
+        metadata: spec.metadata,
+        nested: {
+            parentRunId: options.runId,
+            parentEffectId: action.effectId,
+            parentInvocationKey: action.invocationKey,
+            ...(spec.shareSession && options.sessionId ? { sessionId: options.sessionId } : {}),
+            shareSession: spec.shareSession,
+            skipRunStartHook: true,
+        },
+    });
+    (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") {
+            for (const childAction of iterationResult.nextActions) {
+                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 createWorkerSession = () => (0, utils_1.createAgentCoreSession)((0, utils_1.buildPiWorkerSessionOptions)({
+                        action: childAction,
+                        workspace: options.workspace,
+                        model: childModel,
+                    }));
+                    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,
+                    }, workerSession, discovered, rl, json, workerSessionFactory, disposeWorkerSession, askUserQuestionHandler);
+                    await (0, babysitter_sdk_1.commitEffectResult)({
+                        runDir: childRun.runDir,
+                        effectId: childAction.effectId,
+                        invocationKey: childAction.invocationKey,
+                        result: {
+                            status: childEffectResult.status,
+                            value: childEffectResult.value,
+                            error: childEffectResult.error,
+                            stdout: childEffectResult.stdout,
+                            stderr: childEffectResult.stderr,
+                            startedAt: new Date().toISOString(),
+                            finishedAt: new Date().toISOString(),
+                        },
+                    });
+                }
+                finally {
+                    await disposeWorkerSession(workerSession);
+                }
+            }
+            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.error instanceof Error
+            ? iterationResult.error.message
+            : summarizeSubprocessValue(iterationResult.error);
+        (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)),
+            };
+        }
+        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;
+            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));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Helper functions for effect resolution.
+ * Extracted from effects.ts for max-lines compliance.
+ */
+import type { StreamingOutputOptions } from "../../../types";
+import { type AgentCoreSessionHandle, type AskUserQuestionResponse, type CompressionConfig, type EffectAction, type ResolveEffectResult } from "../utils";
+export declare function readProcessFileFingerprint(processPath: string): string | undefined;
+export declare function isRetryableEffectError(error: unknown): boolean;
+export declare function buildBreakpointResult(response: AskUserQuestionResponse, approvalKey: string): ResolveEffectResult;
+export declare function invokePromptEffect(action: EffectAction, taskHarness: string, prompt: string, options: {
+    workspace?: string;
+    model?: string;
+    compressionConfig?: CompressionConfig | null;
+    streaming?: StreamingOutputOptions;
+}, piSession?: AgentCoreSessionHandle | null): Promise<ResolveEffectResult>;
+export declare function invokeAgentHarness(action: EffectAction, taskHarness: string, prompt: string, options: {
+    workspace?: string;
+    model?: string;
+}): Promise<ResolveEffectResult>;
+//# sourceMappingURL=effectsHelpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"effectsHelpers.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/orchestration/effectsHelpers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAKL,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACzB,MAAM,UAAU,CAAC;AAGlB,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOlF;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAa9D;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,uBAAuB,EAAE,WAAW,EAAE,MAAM,GACrD,mBAAmB,CAGrB;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EACzD,OAAO,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,iBAAiB,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAAC,SAAS,CAAC,EAAE,sBAAsB,CAAA;CAAE,EACjI,SAAS,CAAC,EAAE,sBAAsB,GAAG,IAAI,GACxC,OAAO,CAAC,mBAAmB,CAAC,CAwB9B;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EACzD,OAAO,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9C,OAAO,CAAC,mBAAmB,CAAC,CAa9B"}

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

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Helper functions for effect resolution.
+ * Extracted from effects.ts for max-lines compliance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readProcessFileFingerprint = readProcessFileFingerprint;
+exports.isRetryableEffectError = isRetryableEffectError;
+exports.buildBreakpointResult = buildBreakpointResult;
+exports.invokePromptEffect = invokePromptEffect;
+exports.invokeAgentHarness = invokeAgentHarness;
+const node_fs_1 = require("node:fs");
+const invoker_1 = require("../../../invoker");
+const utils_1 = require("../utils");
+const planProcess_1 = require("../planProcess");
+function readProcessFileFingerprint(processPath) {
+    try {
+        const stat = (0, node_fs_1.statSync)(processPath);
+        return `${stat.size}:${Math.trunc(stat.mtimeMs)}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isRetryableEffectError(error) {
+    const message = typeof error === "string"
+        ? error : error instanceof Error ? error.message : String(error);
+    const lower = message.toLowerCase();
+    return (lower.includes("timeout") || lower.includes("timed out") ||
+        lower.includes("econnreset") || lower.includes("econnrefused") ||
+        lower.includes("epipe") || lower.includes("rate limit") ||
+        lower.includes("too many requests") || lower.includes("server had an error") ||
+        lower.includes("temporarily unavailable") || lower.includes("please retry") ||
+        lower.includes("killed") || lower.includes("signal") ||
+        lower.includes("already processing"));
+}
+function buildBreakpointResult(response, approvalKey) {
+    const option = response.answers[approvalKey] ?? "Reject";
+    return { status: "ok", value: { approved: option === "Approve", option, askUserQuestion: response } };
+}
+async function invokePromptEffect(action, taskHarness, prompt, options, piSession) {
+    if (((0, utils_1.isInternalHarness)(taskHarness) || taskHarness === "pi") && piSession) {
+        const piResult = await (0, utils_1.promptPiWithRetry)({
+            session: piSession,
+            message: (0, utils_1.compressInternalHarnessPrompt)(prompt, options.compressionConfig, "skill"),
+            timeout: utils_1.PI_WORKER_TIMEOUT_MS, label: `effect ${action.effectId}`,
+        });
+        return {
+            status: piResult.success ? "ok" : "error",
+            value: piResult.success ? piResult.output : undefined,
+            error: piResult.success ? undefined : new Error(piResult.output),
+            stdout: piResult.output,
+        };
+    }
+    const result = await (0, invoker_1.invokeHarness)(taskHarness, {
+        prompt: (0, utils_1.compressInternalHarnessPrompt)(prompt, options.compressionConfig, "skill"),
+        workspace: options.workspace, model: options.model, streaming: options.streaming,
+    });
+    return {
+        status: result.success ? "ok" : "error",
+        value: result.success ? result.output : undefined,
+        error: result.success ? undefined : new Error(result.output),
+        stdout: result.output,
+    };
+}
+async function invokeAgentHarness(action, taskHarness, prompt, options) {
+    const result = await (0, invoker_1.invokeHarness)(taskHarness, {
+        prompt: (0, utils_1.compressInternalHarnessPrompt)(prompt, null, "agent"),
+        workspace: options.workspace, model: options.model,
+    });
+    return {
+        status: result.success ? "ok" : "error",
+        value: result.success
+            ? (0, planProcess_1.coerceAgentResultValue)(action.taskDef, result.output)
+            : undefined,
+        error: result.success ? undefined : new Error(result.output),
+        stdout: result.output,
+    };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"externalPhase.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/orchestration/externalPhase.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAGzD,wBAAsB,6BAA6B,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CA8OhH"}