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

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

@@ -0,0 +1,505 @@
+"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.
+ */
+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.subscribeVerbosePiEvents = exports.resolveWorkspaceRunsDir = 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.parseBabysitterCliJson = parseBabysitterCliJson;
+exports.runOrchestrationPhase = runOrchestrationPhase;
+exports.runCliOrchestration = runCliOrchestration;
+exports.resolveAndPostEffect = resolveAndPostEffect;
+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; } });
+Object.defineProperty(exports, "resolveWorkspaceRunsDir", { enumerable: true, get: function () { return internalPhase_1.resolveWorkspaceRunsDir; } });
+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");
+const utils_1 = require("../utils");
+// #949: cross-harness dispatch (agent/skill) and task auto-execution (shell/node)
+// are gated behind BABYSITTER_CROSS_SUBAGENTS / BABYSITTER_EXECUTE_TASKS (default
+// OFF). Defense-in-depth: the gate must live at this execution seam, not only at
+// the entrypoint env mutation in handleHarnessCreateRun.
+const babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+async function importOptionalModule(specifier) {
+    return Promise.resolve(`${specifier}`).then(s => __importStar(require(s)));
+}
+/**
+ * Parse a babysitter CLI `--json` stdout payload, failing loudly (and fast)
+ * when the CLI emitted a non-JSON line instead of a structured result.
+ *
+ * Bug #936 phase-2: when a delegated effect failed, `babysitter run:iterate`
+ * (or its child) could emit a bare `Error: Effect failed` line on stdout. The
+ * old code did an UNGUARDED `JSON.parse(...)`, which surfaced the cryptic
+ * `Unexpected token 'E', "Error: Effect failed" is not valid JSON` and then
+ * spun the iterate loop until the 80-minute orchestration timeout.
+ *
+ * This helper trims, attempts the parse, and on failure throws a clear
+ * {@link BabysitterRuntimeError} that includes the command, the first ~500
+ * chars of the raw non-JSON stdout AND stderr, so the failure is diagnosable
+ * immediately instead of as a SyntaxError 80 minutes later.
+ */
+function parseBabysitterCliJson(raw, context) {
+    const trimmed = (raw ?? "").trim();
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch (error) {
+        const parseMessage = error instanceof Error ? error.message : String(error);
+        const stdoutSnippet = trimmed.slice(0, 500);
+        const stderrSnippet = (context.stderr ?? "").trim().slice(0, 500);
+        throw new utils_1.BabysitterRuntimeError("BabysitterCliNonJsonOutput", `babysitter ${context.command} did not emit valid JSON on stdout under --json `
+            + `(${parseMessage}).\n--- stdout (first 500 chars) ---\n${stdoutSnippet || "<empty>"}`
+            + `\n--- stderr (first 500 chars) ---\n${stderrSnippet || "<empty>"}`, { category: utils_1.ErrorCategory.Runtime });
+    }
+}
+/**
+ * execFileSync throws on non-zero exit; the error carries `stdout`/`stderr`
+ * buffers. Surface BOTH so a failed iterate/create is diagnosable. The literal
+ * `Error: Effect failed` line that triggered #936 lands on one of these.
+ */
+function describeExecFileError(err) {
+    const e = err;
+    const decode = (v) => typeof v === "string" ? v : Buffer.isBuffer(v) ? v.toString("utf8") : "";
+    return {
+        message: err instanceof Error ? err.message : String(err),
+        stdout: decode(e?.stdout),
+        stderr: decode(e?.stderr),
+    };
+}
+async function runOrchestrationPhase(args) {
+    const externalExitCode = await (0, externalPhase_2.runExternalOrchestrationPhase)(args);
+    if (externalExitCode !== undefined) {
+        return externalExitCode;
+    }
+    return (0, internalPhase_2.runInternalOrchestrationPhase)(args);
+}
+async function runCliOrchestration(args) {
+    const { execFileSync } = await Promise.resolve().then(() => __importStar(require("node:child_process")));
+    const path = await Promise.resolve().then(() => __importStar(require("node:path")));
+    const processPath = args.processPath;
+    const workspace = args.workspace ?? process.cwd();
+    // Bug #936: when no explicit --runs-dir is provided, babysitter run:create
+    // defaults to the GLOBAL ~/.a5c/runs, so the nested run (and its completion
+    // proof) land outside <workspace>/.a5c/runs where the live-stack validator —
+    // and users — look. Default to the WORKSPACE runs dir instead. An explicit
+    // args.runsDir or a BABYSITTER_RUNS_DIR / repo-scope override still wins (see
+    // resolveWorkspaceRunsDir's precedence). The resolver walks to the workspace's
+    // repo root when present and otherwise uses the workspace itself, so a
+    // non-git-repo live-stack workspace still resolves to <workspace>/.a5c/runs.
+    const runsDir = (0, internalPhase_2.resolveWorkspaceRunsDir)(args.runsDir, workspace);
+    const prompt = args.prompt ?? "";
+    const model = args.model;
+    // Resolve babysitter CLI: prefer the SDK's dist/cli/main.js over global binary
+    let babysitterBin = "babysitter";
+    try {
+        const sdkCliPath = require.resolve("@a5c-ai/babysitter-sdk/dist/cli/main.js");
+        babysitterBin = `${process.execPath} ${sdkCliPath}`;
+    }
+    catch {
+        // Fall back to global babysitter binary
+    }
+    // Create run via CLI — pass prompt both as metadata and as process inputs
+    const fsPromises = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+    const inputsFile = path.join(workspace, `.a5c-genty-inputs-${Date.now()}.json`);
+    await fsPromises.writeFile(inputsFile, JSON.stringify({ prompt, request: prompt }));
+    const createArgs = [
+        "run:create",
+        "--entry", `${path.resolve(processPath)}#process`,
+        "--process-id", path.basename(processPath, path.extname(processPath)),
+        "--prompt", prompt,
+        "--inputs", inputsFile,
+        "--harness", "agent-core",
+        "--json",
+    ];
+    if (runsDir)
+        createArgs.push("--runs-dir", runsDir);
+    let runDir;
+    const babysitterBinParts = babysitterBin.split(" ");
+    const babysitterCmd = babysitterBinParts[0];
+    const babysitterPrefix = babysitterBinParts.slice(1);
+    try {
+        const createResult = execFileSync(babysitterCmd, [...babysitterPrefix, ...createArgs], {
+            cwd: workspace,
+            encoding: "utf8",
+            timeout: 30_000,
+            env: { ...process.env },
+        });
+        // #936: guarded parse — a non-JSON line (e.g. "Error: Effect failed") on
+        // stdout must surface a clear error, not a cryptic SyntaxError.
+        const parsed = parseBabysitterCliJson(createResult, { command: "run:create" });
+        runDir = parsed.runDir;
+        await fsPromises.unlink(inputsFile).catch(() => { });
+        if (!args.json) {
+            process.stderr.write(`\x1b[32mRun created:\x1b[0m ${runDir}\n`);
+        }
+    }
+    catch (err) {
+        await fsPromises.unlink(inputsFile).catch(() => { });
+        // execFileSync throws on non-zero exit — capture stdout/stderr buffers so
+        // the failure reason (not just "Command failed") is visible.
+        const { message, stdout, stderr } = describeExecFileError(err);
+        const detail = err instanceof utils_1.BabysitterRuntimeError
+            ? message
+            : `${message}${stdout ? `\n--- stdout ---\n${stdout.slice(0, 500)}` : ""}${stderr ? `\n--- stderr ---\n${stderr.slice(0, 500)}` : ""}`;
+        if (!args.json) {
+            process.stderr.write(`\x1b[31mFailed to create run:\x1b[0m ${detail}\n`);
+        }
+        return 1;
+    }
+    // Iterate loop — cap at 20 for CLI orchestration regardless of caller
+    const maxIterations = Math.min(args.maxIterations ?? 20, 20);
+    let consecutiveNoEffects = 0;
+    for (let i = 1; i <= maxIterations; i++) {
+        process.stderr.write(`[genty-orchestration] iteration ${i}/${maxIterations} starting\n`);
+        try {
+            const iterArgs = [...babysitterPrefix, "run:iterate", runDir, "--json", "--iteration", String(i)];
+            // #936: keep the iterate calls anchored to the same runs dir as create so
+            // the run lifecycle stays in <workspace>/.a5c/runs throughout.
+            if (runsDir)
+                iterArgs.push("--runs-dir", runsDir);
+            process.stderr.write(`[genty-orchestration] exec: ${babysitterCmd} ${iterArgs.join(" ")}\n`);
+            let iterResult;
+            try {
+                iterResult = execFileSync(babysitterCmd, iterArgs, {
+                    cwd: workspace,
+                    encoding: "utf8",
+                    timeout: 120_000,
+                    env: { ...process.env },
+                });
+            }
+            catch (execErr) {
+                // #936: run:iterate exited non-zero. FAIL FAST with the captured
+                // stdout/stderr (which carries the real failure, e.g. the
+                // "Error: Effect failed" line) instead of letting the loop spin to
+                // the 80-minute orchestration timeout. Prefer stdout for the guarded
+                // JSON parse when present so a structured failure result is honored.
+                const { message, stdout, stderr } = describeExecFileError(execErr);
+                if (stdout.trim().length > 0) {
+                    iterResult = stdout;
+                }
+                else {
+                    throw new utils_1.BabysitterRuntimeError("BabysitterIterateFailed", `babysitter run:iterate (iteration ${i}) exited non-zero: ${message}`
+                        + `\n--- stderr (first 500 chars) ---\n${stderr.trim().slice(0, 500) || "<empty>"}`, { category: utils_1.ErrorCategory.Runtime });
+                }
+            }
+            // #936: guarded parse — throws a clear BabysitterRuntimeError including
+            // the raw stdout/stderr when run:iterate emits a non-JSON line.
+            const parsed = parseBabysitterCliJson(iterResult, { command: `run:iterate (iteration ${i})` });
+            process.stderr.write(`[genty-orchestration] iterate result: status=${parsed.status} actions=${parsed.nextActions?.length ?? 0} reason=${parsed.reason ?? 'n/a'}\n`);
+            if (parsed.status === "completed") {
+                if (!args.json) {
+                    process.stderr.write(`\x1b[32mRun completed.\x1b[0m\n`);
+                }
+                return 0;
+            }
+            if (parsed.status === "failed") {
+                if (!args.json) {
+                    process.stderr.write(`\x1b[31mRun failed:\x1b[0m ${parsed.reason ?? "unknown"}\n`);
+                }
+                return 1;
+            }
+            // Handle pending effects
+            if (parsed.nextActions?.length) {
+                consecutiveNoEffects = 0;
+                process.stderr.write(`[genty-orchestration] iteration ${i}: ${parsed.nextActions.length} pending effects to resolve\n`);
+                for (const action of parsed.nextActions) {
+                    process.stderr.write(`[genty-orchestration] resolving effect ${action.effectId} (${action.kind})\n`);
+                    await resolveAndPostEffect(action, runDir, workspace, model, babysitterBin);
+                    process.stderr.write(`[genty-orchestration] effect ${action.effectId} resolved\n`);
+                }
+            }
+            else if (parsed.status === "none") {
+                consecutiveNoEffects++;
+                if (consecutiveNoEffects >= 3) {
+                    if (!args.json) {
+                        process.stderr.write(`\x1b[31mNo pending effects for ${consecutiveNoEffects} consecutive iterations — process may not be dispatching tasks.\x1b[0m\n`);
+                    }
+                    return 1;
+                }
+                if (!args.json) {
+                    process.stderr.write(`\x1b[33mNo pending effects at iteration ${i}\x1b[0m\n`);
+                }
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!args.json) {
+                process.stderr.write(`\x1b[31mIteration ${i} error:\x1b[0m ${msg}\n`);
+            }
+            return 1;
+        }
+    }
+    if (!args.json) {
+        process.stderr.write(`\x1b[31mMax iterations (${maxIterations}) reached.\x1b[0m\n`);
+    }
+    return 1;
+}
+async function resolveAndPostEffect(action, runDir, workspace, model, babysitterBin = "babysitter") {
+    // #949: gate at the execution seam. Cross-harness dispatch (agent/skill) and
+    // task auto-execution (shell/node) only run when their flags are ON. When OFF,
+    // do NOT execute and do NOT post — leave the effect pending so the next
+    // iteration re-emits it (mirrors resolveEffect's pending contract). genty's
+    // autonomous entrypoint (handleHarnessCreateRun) opts these flags ON.
+    if ((action.kind === "agent" || action.kind === "skill") && !(0, babysitter_sdk_1.crossSubagentsEnabled)()) {
+        return;
+    }
+    if ((action.kind === "shell" || action.kind === "node" || action.kind === "orchestrator_task") && !(0, babysitter_sdk_1.executeTasksEnabled)()) {
+        return;
+    }
+    const { execFileSync, execSync } = await Promise.resolve().then(() => __importStar(require("node:child_process")));
+    const { createAgentCoreSession } = await Promise.resolve().then(() => __importStar(require("../utils")));
+    const babysitterParts = babysitterBin.split(" ");
+    const bCmd = babysitterParts[0];
+    const bPrefix = babysitterParts.slice(1);
+    // #936: track the effect outcome explicitly. A delegated agent/skill prompt
+    // that fails (result.success === false) or a shell command that exits
+    // non-zero MUST be posted as `--status error` with the real error — NOT
+    // silently posted as ok with an error string as the value. Posting a poisoned
+    // "ok" value is what produced the downstream "Error: Effect failed" line and
+    // the 80-minute spin.
+    let value;
+    let postStatus = "ok";
+    let postError;
+    const tasksMuxValue = await resolveViaTasksMuxForCli(action, workspace, model);
+    if (tasksMuxValue !== undefined) {
+        value = tasksMuxValue;
+    }
+    else if (action.kind === "agent" || action.kind === "skill") {
+        const agentPrompt = action.taskDef?.agent?.prompt;
+        const prompt = typeof agentPrompt === "string"
+            ? agentPrompt
+            : agentPrompt?.instructions?.join("\n")
+                ?? action.taskDef?.title
+                ?? "Execute this task";
+        const session = createAgentCoreSession({
+            workspace,
+            model,
+            ephemeral: true,
+        });
+        try {
+            const result = await session.prompt(prompt);
+            if (result.success === false) {
+                // Delegated session failed — propagate the failure so the process can
+                // handle it, instead of posting the failure text as a successful value.
+                postStatus = "error";
+                postError = (typeof result.output === "string" && result.output.trim().length > 0)
+                    ? result.output
+                    : `Delegated ${action.kind} effect failed (exitCode=${result.exitCode ?? "unknown"})`;
+                value = JSON.stringify(result.output ?? "");
+            }
+            else {
+                value = JSON.stringify(result.output ?? "");
+            }
+        }
+        finally {
+            session.dispose();
+        }
+    }
+    else if (action.kind === "shell") {
+        const command = action.taskDef?.shell?.command ?? "echo ok";
+        try {
+            const output = execSync(command, { cwd: workspace, encoding: "utf8", timeout: 120_000 });
+            value = JSON.stringify(output);
+        }
+        catch (err) {
+            // A failed shell command is a real effect failure — post it as error.
+            const stderr = err.stderr ?? "";
+            postStatus = "error";
+            postError = stderr || (err instanceof Error ? err.message : "shell command failed");
+            value = JSON.stringify(stderr || "shell command failed");
+        }
+    }
+    else if (action.kind === "breakpoint") {
+        value = JSON.stringify("approved");
+    }
+    else {
+        value = JSON.stringify("ok");
+    }
+    // Post result
+    try {
+        const fs = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+        const path = await Promise.resolve().then(() => __importStar(require("node:path")));
+        if (postStatus === "error") {
+            // task:post --status error reads the error payload as JSON from --error
+            // <file> (see handleTaskPost -> readJsonFile). Write a structured error
+            // object, not a bare string, so the CLI commits a proper failure result.
+            const errorFile = path.join(runDir, "tasks", action.effectId, "error.json");
+            await fs.mkdir(path.dirname(errorFile), { recursive: true });
+            await fs.writeFile(errorFile, JSON.stringify({ name: "Error", message: postError ?? "Effect failed" }));
+            execFileSync(bCmd, [...bPrefix, "task:post", runDir, action.effectId, "--status", "error", "--error", errorFile, "--json"], {
+                cwd: workspace, encoding: "utf8", timeout: 30_000, env: { ...process.env },
+            });
+            return;
+        }
+        const taskDir = path.join(runDir, "tasks", action.effectId);
+        await fs.mkdir(taskDir, { recursive: true });
+        await fs.writeFile(path.join(taskDir, "output.json"), value);
+        execFileSync(bCmd, [...bPrefix, "task:post", runDir, action.effectId, "--status", "ok", "--value", `tasks/${action.effectId}/output.json`, "--json"], {
+            cwd: workspace, encoding: "utf8", timeout: 30_000, env: { ...process.env },
+        });
+    }
+    catch {
+        // Best effort
+    }
+}
+async function resolveViaTasksMuxForCli(action, workspace, model) {
+    if (action.kind !== "agent" && action.kind !== "breakpoint") {
+        return undefined;
+    }
+    let adapter;
+    try {
+        adapter = await importOptionalModule("@a5c-ai/tasks-adapter");
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof adapter.routeTask !== "function") {
+        return undefined;
+    }
+    const decision = adapter.routeTask(action.taskDef);
+    if (decision.responderType === "internal" || decision.responderType === "human") {
+        if (decision.responderType === "human") {
+            return JSON.stringify(buildCliBreakpointValue(action));
+        }
+        return undefined;
+    }
+    if (decision.responderType === "tracker") {
+        if (!decision.unavailable)
+            return undefined;
+        return JSON.stringify({
+            success: false,
+            routedThrough: "tasks-adapter",
+            responderType: "tracker",
+            error: decision.reason ?? "ExternalTrackerBackend unavailable",
+        });
+    }
+    if (decision.responderType !== "agent") {
+        return undefined;
+    }
+    const fallbackToInternal = shouldFallbackExternalAgentToInternal(action.taskDef);
+    if (typeof adapter.AgentMuxResponderBackend !== "function") {
+        if (fallbackToInternal)
+            return undefined;
+        throw new Error("tasks-adapter AgentMuxResponderBackend is unavailable");
+    }
+    const prompt = buildCliAgentPrompt(action.taskDef);
+    let breakpoint;
+    try {
+        const backend = new adapter.AgentMuxResponderBackend({
+            adapter: decision.responder?.adapter ?? decision.responder?.id,
+            model: decision.responder?.model ?? model,
+            cwd: workspace,
+        });
+        breakpoint = await backend.submitBreakpoint({
+            text: prompt,
+            context: {
+                description: action.taskDef?.title ?? action.taskId ?? action.effectId,
+                codeSnippets: [],
+                fileReferences: [],
+                tags: action.labels ?? [],
+            },
+            routing: {
+                strategy: "single",
+                targetResponders: decision.responder?.id ? [decision.responder.id] : [],
+                timeoutMs: readExternalAgentTimeoutMs(action.taskDef) ?? 300_000,
+                presentToUser: false,
+                responderType: "agent",
+                adapter: decision.responder?.adapter ?? decision.responder?.id,
+                model: decision.responder?.model ?? model,
+            },
+        });
+    }
+    catch (err) {
+        if (fallbackToInternal)
+            return undefined;
+        throw err;
+    }
+    return JSON.stringify(breakpoint.answers[0]?.text ?? "");
+}
+function buildCliBreakpointValue(action) {
+    const question = action.taskDef?.question
+        ?? action.taskDef?.title
+        ?? action.taskId
+        ?? action.effectId;
+    const approvalPrompt = (0, utils_1.createApprovalAskUserQuestion)(question);
+    const approvalKey = approvalPrompt.questions[0]?.header ?? "Decision";
+    const response = (0, utils_1.createAskUserQuestionResponse)(approvalPrompt, { [approvalKey]: "Approve" });
+    return {
+        approved: true,
+        option: "Approve",
+        askUserQuestion: response,
+    };
+}
+function buildCliAgentPrompt(taskDef) {
+    const agentPrompt = taskDef?.agent?.prompt;
+    return typeof agentPrompt === "string"
+        ? agentPrompt
+        : agentPrompt?.instructions?.join("\n")
+            ?? taskDef?.title
+            ?? "Execute this task";
+}
+function shouldFallbackExternalAgentToInternal(taskDef) {
+    const agent = isPlainRecord(taskDef?.agent) ? taskDef.agent : {};
+    const metadata = isPlainRecord(taskDef?.metadata) ? taskDef.metadata : {};
+    return agent.fallbackToInternal === true
+        || metadata.fallbackToInternal === true
+        || agent.fallbackType === "internal"
+        || metadata.fallbackType === "internal";
+}
+function readExternalAgentTimeoutMs(taskDef) {
+    const agent = isPlainRecord(taskDef?.agent) ? taskDef.agent : {};
+    return typeof agent.timeoutMs === "number" ? agent.timeoutMs : undefined;
+}
+function isPlainRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

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

@@ -0,0 +1,22 @@
+import type { RunOrchestrationPhaseArgs } from "./types";
+export declare function runInternalOrchestrationPhase(args: RunOrchestrationPhaseArgs): Promise<number>;
+/**
+ * Resolve the runs directory for genty's internal (in-process) execution.
+ *
+ * Precedence (highest first):
+ *   1. An explicit runsDir passed by the caller (CLI --runs-dir).
+ *   2. The BABYSITTER_RUNS_DIR / BABYSITTER_RUNS_SCOPE env overrides, honored
+ *      via the SDK's resolveRunsDir({ cwd }).
+ *   3. The WORKSPACE repo runs dir (<repoRoot>/.a5c/runs) — NOT the global
+ *      ~/.a5c/runs. The SDK defaults to global scope when nothing is set, which
+ *      means a plain `genty call` never materializes the workspace .a5c/runs/.
+ *      Forcing the workspace dir here makes the internal path establish the run
+ *      lifecycle where downstream tooling (and the live-stack verification)
+ *      expects it. See #936 bug 2.
+ *
+ * The SDK is loaded lazily (sync require, only when this is actually called) to
+ * avoid eagerly pulling the heavy SDK + atlas index into the module graph, per
+ * the #936 default-provider lazy-load decision.
+ */
+export declare function resolveWorkspaceRunsDir(explicitRunsDir: string | undefined, workspace: string | undefined): string;
+//# 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":"AAuCA,OAAO,KAAK,EAAiC,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAQxF,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,yBAAyB,GAC9B,OAAO,CAAC,MAAM,CAAC,CAyvBjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CACrC,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,MAAM,CAgCR"}