@a5c-ai/genty-platform 5.1.1-staging.583e3d9a6ed7

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.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/effectsHelpers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=effectsHelpers.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"effectsHelpers.test.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/orchestration/effectsHelpers.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const hookDecisionEffects_1 = require("./hookDecisionEffects");
+function action(overrides = {}) {
+    return {
+        kind: "shell",
+        effectId: "effect-1",
+        taskId: "task-1",
+        taskDef: {
+            title: "Run a command",
+            metadata: {},
+        },
+        ...overrides,
+    };
+}
+(0, vitest_1.describe)("hook decision effect helpers", () => {
+    (0, vitest_1.it)("extracts hook decisions from task metadata", () => {
+        const result = (0, hookDecisionEffects_1.getHookDecisionResult)(action({
+            taskDef: {
+                metadata: {
+                    hookResult: { decision: "block", reason: "policy" },
+                },
+            },
+        }));
+        (0, vitest_1.expect)(result).toEqual({ decision: "block", reason: "policy" });
+    });
+    (0, vitest_1.it)("turns block decisions into auditable non-approval results", () => {
+        const result = (0, hookDecisionEffects_1.resolveHookDecisionResult)(action(), { decision: "block", reason: "sensitive command" });
+        (0, vitest_1.expect)(result).toMatchObject({
+            status: "error",
+            value: {
+                blocked: true,
+                reason: "sensitive command",
+                auditEvent: {
+                    kind: "hook-decision",
+                    decision: {
+                        action: "block",
+                        reason: "sensitive command",
+                        hookDecision: "block",
+                    },
+                    source: "harness",
+                },
+            },
+            stderr: "sensitive command",
+        });
+    });
+    (0, vitest_1.it)("bounds retry decisions with attempt metadata", () => {
+        const retry = (0, hookDecisionEffects_1.resolveHookDecisionResult)(action(), { decision: "retry", reason: "recover permission" }, { attempt: 1, maxRetries: 2 });
+        (0, vitest_1.expect)(retry).toMatchObject({
+            status: "ok",
+            value: {
+                retry: true,
+                exhausted: false,
+                attempt: 1,
+                maxRetries: 2,
+            },
+        });
+        const exhausted = (0, hookDecisionEffects_1.resolveHookDecisionResult)(action(), { decision: "retry", reason: "recover permission" }, { attempt: 2, maxRetries: 2 });
+        (0, vitest_1.expect)(exhausted).toMatchObject({
+            status: "error",
+            value: {
+                retry: false,
+                exhausted: true,
+                attempt: 2,
+                maxRetries: 2,
+            },
+        });
+    });
+    (0, vitest_1.it)("turns continueSession false into an abort result", () => {
+        const result = (0, hookDecisionEffects_1.resolveHookDecisionResult)(action(), { continueSession: false, stopReason: "hook stopped session" });
+        (0, vitest_1.expect)(result).toMatchObject({
+            status: "error",
+            value: {
+                aborted: true,
+                stopReason: "hook stopped session",
+            },
+            stderr: "hook stopped session",
+        });
+    });
+});

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":"AA0CA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAGzD,wBAAsB,6BAA6B,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAgUhH"}

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

@@ -0,0 +1,399 @@
+"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 compaction_1 = require("../../../../compression/compaction");
+const effectCost_1 = require("../../../../cost/effectCost");
+const history_1 = require("../../../../session/history");
+const utils_1 = require("../utils");
+const constants_1 = require("./constants");
+/** Max characters of shell output tail included in progress events. */
+const MAX_SHELL_OUTPUT_TAIL_CHARS = 1500;
+/** Max characters of non-shell output head included in progress events. */
+const MAX_NON_SHELL_OUTPUT_HEAD_CHARS = 300;
+const effects_1 = require("./effects");
+const dispatch_1 = require("./dispatch");
+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();
+                await (0, dispatch_1.dispatchEffectActions)({
+                    actions: result.nextActions,
+                    concurrentEffects: (0, dispatch_1.harnessSupportsConcurrentEffects)(args.selectedHarnessName, args.discovered),
+                    resolveAction: (action) => resolveExternalAction({
+                        action,
+                        args,
+                        state,
+                        registerPiSession,
+                        shutdownPiSession,
+                    }),
+                    commitAction: async ({ action, result: effectResult, startedAt, finishedAt }) => {
+                        await (0, babysitter_sdk_1.commitEffectResult)({
+                            runDir: state.runDir,
+                            effectId: action.effectId,
+                            invocationKey: action.invocationKey,
+                            result: {
+                                status: effectResult.status,
+                                value: effectResult.value,
+                                error: effectResult.error,
+                                stdout: effectResult.stdout,
+                                stderr: effectResult.stderr,
+                                startedAt,
+                                finishedAt,
+                            },
+                        });
+                        const stateDir = state.sessionBound?.stateFile
+                            ? path.dirname(state.sessionBound.stateFile)
+                            : undefined;
+                        const costResult = await (0, babysitter_sdk_1.buildEffectIndex)({ runDir: state.runDir })
+                            .then(effectCost_1.computeEffectCosts)
+                            .catch(() => undefined);
+                        const overlays = await (0, effects_1.applyPostEffectOrchestrationOverlays)({
+                            runId: state.runId,
+                            runDir: state.runDir,
+                            runsDir: args.runsDir ?? path.dirname(state.runDir),
+                            stateDir,
+                            sessionId: state.sessionBound?.sessionId,
+                            effectCost: costResult && costResult.effects.length > 0
+                                ? {
+                                    totalCostUsd: costResult.totalCostUsd,
+                                    inputTokens: costResult.effects.reduce((sum, effect) => sum + effect.inputTokens, 0),
+                                    outputTokens: costResult.effects.reduce((sum, effect) => sum + effect.outputTokens, 0),
+                                }
+                                : undefined,
+                            estimatedStateTokens: Math.ceil(JSON.stringify({
+                                iteration: state.iteration,
+                                lastEffect: action.effectId,
+                                output: effectResult.stdout ?? effectResult.stderr ?? effectResult.value,
+                            }).length / 4),
+                            compactionConfig: compaction_1.DEFAULT_COMPACTION_CONFIG,
+                            effectSummary: {
+                                effectId: action.effectId,
+                                taskId: action.taskId,
+                                kind: action.kind,
+                                title: action.taskDef?.title,
+                                status: effectResult.status,
+                            },
+                        });
+                        if (overlays.budgetEnforcement?.paused) {
+                            const error = overlays.budgetEnforcement.pauseReason ?? "Session cost budget pause requested";
+                            (0, utils_1.emitProgress)({
+                                phase: "2",
+                                status: "failed",
+                                iteration: state.iteration,
+                                runStatus: "failed",
+                                error,
+                            }, args.json, args.verbose, args.outputMode);
+                            throw new utils_1.BabysitterRuntimeError("SessionBudgetPaused", error, { category: utils_1.ErrorCategory.Runtime });
+                        }
+                    },
+                });
+                (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") {
+                await recordExternalRunSummary(state, args, "completed", "Run 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;
+            }
+            const errorMessage = result.status === "halted"
+                ? result.reason
+                : "error" in result
+                    ? (0, externalPhaseHelpers_1.extractErrorMessage)(result.error)
+                    : "unknown error";
+            (0, utils_1.emitProgress)({
+                phase: "2",
+                status: "failed",
+                iteration: state.iteration,
+                runStatus: "failed",
+                error: errorMessage,
+            }, args.json, args.verbose, args.outputMode);
+            await recordExternalRunSummary(state, args, "failed", errorMessage);
+            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);
+        await recordExternalRunSummary(state, args, "failed", `Max iterations (${args.maxIterations}) reached without completion`);
+        return 1;
+    }
+    finally {
+        await Promise.allSettled(Array.from(activePiSessions).map((session) => shutdownPiSession(session)));
+    }
+}
+async function recordExternalRunSummary(state, args, status, outcome) {
+    const stateFile = state.sessionBound?.stateFile;
+    const sessionId = state.sessionBound?.sessionId;
+    if (!stateFile || !sessionId || !state.runId) {
+        return;
+    }
+    await (0, history_1.addRunSummary)(path.dirname(stateFile), sessionId, {
+        runId: state.runId,
+        processId: path.basename(args.processPath, path.extname(args.processPath)),
+        status,
+        startedAt: new Date().toISOString(),
+        completedAt: new Date().toISOString(),
+        outcome,
+    });
+}
+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) /* last 8 chars of ULID for human-readable label */}`, 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) /* last 8 chars of ULID for human-readable label */}`, 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) /* last 8 chars of ULID for human-readable label */}`, 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);
+        (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(-MAX_SHELL_OUTPUT_TAIL_CHARS)
+                : typeof effectResult.value === "string"
+                    ? effectResult.value.slice(0, MAX_NON_SHELL_OUTPUT_HEAD_CHARS)
+                    : undefined,
+        }, args.args.json, args.args.verbose, args.args.outputMode);
+        return effectResult;
+    }
+    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"}