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

package/dist/harness/internal/createRun/planProcess/phase.js

@@ -0,0 +1,424 @@
+"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.runProcessDefinitionPhase = void 0;
+exports.runPlanProcessPhase = runPlanProcessPhase;
+const path = __importStar(require("node:path"));
+const babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+const prompts_1 = require("../prompts");
+const utils_1 = require("../utils");
+const paths_1 = require("./paths");
+const prompts_2 = require("./prompts");
+const recovery_1 = require("./recovery");
+const phaseHelpers_1 = require("./phaseHelpers");
+const runState_1 = require("./runState");
+const understandIntent_1 = require("./understandIntent");
+const validation_1 = require("./validation");
+async function runPlanProcessPhase(args) {
+    const state = {};
+    const phaseOutputs = [];
+    const sessionRef = { current: null };
+    const interactiveUiContext = args.interactive && args.rl
+        ? (0, utils_1.createReadlineAskUserQuestionUiContext)(args.rl)
+        : undefined;
+    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 mergedCustomTools = (0, phaseHelpers_1.createPlanProcessTools)({
+        ...args, state, phaseOutputs, sessionRef, writeVerboseData,
+    });
+    (0, utils_1.emitProgress)({ phase: "1", status: "started", harness: "agent-core" }, args.json, args.verbose, args.outputMode);
+    writeVerbose(`[phasePlanProcess setup] workspace=${path.resolve(args.workspace ?? process.cwd())} model=${args.model ?? "(default)"} outputDir=${path.resolve(args.outputDir)}`);
+    writeVerboseData("phasePlanProcess tools", mergedCustomTools.map((tool) => ({
+        name: tool.name,
+        label: tool.label,
+    })));
+    const workspaceAssessment = await (0, prompts_2.assessWorkspaceForExternalAuthoring)(args.workspace);
+    const externalAgents = await (0, babysitter_sdk_1.discoverExternalAgents)({
+        cwd: args.workspace,
+        timeout: 5000,
+    });
+    const promptContext = {
+        ...args.promptContext,
+        externalAgents,
+    };
+    writeVerboseData("phasePlanProcess workspace assessment", workspaceAssessment);
+    writeVerboseData("phasePlanProcess external agents", externalAgents);
+    const resolvedBackend = (0, utils_1.resolveAgentCoreBackendForHarness)(args.selectedHarnessName);
+    const isRawTextSession = !resolvedBackend;
+    let processDefinitionSystemPrompt;
+    let basePlanProcessPrompt;
+    if (isRawTextSession) {
+        // Raw agent-core session: no tool calling. Instruct the model to output
+        // the process definition as a code block in its response text.
+        processDefinitionSystemPrompt = [
+            "You are a babysitter process author. Output a SINGLE fenced code block (```javascript ... ```).",
+            "No explanations, no markdown headers, no commentary — ONLY the code block.",
+            "",
+            "The code block must be a complete ESM module following this exact pattern:",
+            "",
+            "```javascript",
+            'import { defineTask } from "@a5c-ai/babysitter-sdk";',
+            'import { writeFile, mkdir } from "node:fs/promises";',
+            'import { dirname } from "node:path";',
+            "",
+            'const mainTask = defineTask("main-task", (args) => ({',
+            '  kind: "agent",',
+            '  title: "Describe what the agent should do",',
+            '  agent: { name: "Main Agent", prompt: "Detailed instructions for the agent" },',
+            "}));",
+            "",
+            "export async function process(inputs, ctx) {",
+            "  const result = await ctx.task(mainTask, { prompt: inputs.prompt });",
+            "  // result is a plain text string returned by the agent",
+            '  const outputPath = "path/to/output.md";',
+            "  await mkdir(dirname(outputPath), { recursive: true });",
+            "  await writeFile(outputPath, String(result));",
+            '  return { status: "completed", outputPath };',
+            "}",
+            "```",
+            "",
+            "Rules:",
+            '- ALWAYS use defineTask("id", (args) => ({ ... })) — the positional form with a string ID and a function.',
+            "- Agent tasks return PLAIN TEXT strings. Use String(result) when writing to a file.",
+            "- For file creation: always use writeFile + mkdir as shown above.",
+            "- Use EXACTLY ONE agent task. Put ALL instructions into a single task prompt. Do NOT split into multiple tasks.",
+            "- Do NOT use `node` kind effects. Only use `agent` kind.",
+            '- The agent prompt MUST be a plain string, not an object. Use agent: { name: "...", prompt: "..." }.',
+        ].join("\n");
+        basePlanProcessPrompt = (0, prompts_2.buildExternalProcessDefinitionPrompt)({
+            prompt: args.prompt,
+            outputDir: args.outputDir,
+            workspace: args.workspace,
+            promptContext,
+            workspaceAssessment,
+            preferAgentOnlyTasks: args.invocationCommand === "call",
+        });
+    }
+    else {
+        processDefinitionSystemPrompt = await (0, prompts_1.buildProcessDefinitionSystemPrompt)(args.outputDir, promptContext, args.interactive);
+        basePlanProcessPrompt = (0, prompts_1.buildProcessDefinitionUserPrompt)(args.prompt, args.outputDir, {
+            interactive: args.interactive,
+            workspaceAssessment: workspaceAssessment.kind,
+            workspaceEntries: workspaceAssessment.entries,
+            preferAgentOnlyTasks: args.invocationCommand === "call",
+        });
+    }
+    const intentPrompt = (0, understandIntent_1.buildUnderstandIntentPrompt)({
+        prompt: args.prompt,
+        interactive: args.interactive,
+        workspaceAssessment,
+    });
+    writeVerboseData("phasePlanProcess system prompt", processDefinitionSystemPrompt);
+    writeVerboseData("phaseUnderstandIntent prompt", intentPrompt);
+    const planProcessToolsMode = workspaceAssessment.kind === "empty"
+        ? "default"
+        : "coding";
+    sessionRef.current = (0, utils_1.createAgentCoreSession)({
+        workspace: args.workspace,
+        model: args.model,
+        backend: resolvedBackend,
+        thinkingLevel: isRawTextSession ? undefined : "low",
+        toolsMode: isRawTextSession ? undefined : planProcessToolsMode,
+        customTools: isRawTextSession ? undefined : mergedCustomTools,
+        uiContext: isRawTextSession ? undefined : interactiveUiContext,
+        systemPrompt: processDefinitionSystemPrompt,
+        isolated: true,
+        ephemeral: true,
+    });
+    try {
+        await sessionRef.current.initialize();
+        let unsubscribe = null;
+        if (!args.json && args.outputMode !== "tui") {
+            process.stderr.write(`${utils_1.DIM}PhaseUnderstandIntent agent is analyzing the request...${utils_1.RESET}\n`);
+            unsubscribe = sessionRef.current.subscribe((event) => {
+                if (event.type === "text_delta") {
+                    const text = event.text;
+                    if (text) {
+                        process.stderr.write(text);
+                    }
+                }
+            });
+        }
+        (0, utils_1.emitProgress)({ phase: "1", status: "intent", answer: "Analyzing the user request and relevant workspace context." }, args.json, args.verbose, args.outputMode);
+        const intentResult = await (0, understandIntent_1.runUnderstandIntentPhase)({
+            session: sessionRef.current,
+            promptMessage: intentPrompt,
+            timeout: utils_1.PARENT_PROMPT_TIMEOUT_MS,
+            writeVerbose,
+            writeVerboseData,
+        });
+        phaseOutputs.push(intentResult.output);
+        writeVerboseData("phaseUnderstandIntent output", intentResult.output);
+        writeVerboseData("phaseUnderstandIntent handoff", intentResult.handoffSummary);
+        const planProcessPrompt = (0, understandIntent_1.appendIntentHandoffToPlanPrompt)(basePlanProcessPrompt, intentResult.output);
+        writeVerboseData("phasePlanProcess prompt", planProcessPrompt);
+        (0, utils_1.emitProgress)({ phase: "1", status: "planning", answer: "Authoring the process definition and preparing the run." }, args.json, args.verbose, args.outputMode);
+        if (!args.json && args.outputMode !== "tui") {
+            process.stderr.write(`${utils_1.DIM}PhasePlanProcess agent is authoring the process...${utils_1.RESET}\n`);
+        }
+        const result = await (0, phaseHelpers_1.promptPhaseSession)({
+            session: sessionRef.current,
+            message: planProcessPrompt,
+            timeout: utils_1.PARENT_PROMPT_TIMEOUT_MS,
+            label: "phasePlanProcess",
+            writeVerbose,
+            writeVerboseData,
+        });
+        phaseOutputs.push(result.output);
+        if (unsubscribe) {
+            unsubscribe();
+        }
+        if (!args.json && args.outputMode !== "tui") {
+            process.stderr.write("\n");
+        }
+        if (!result.success) {
+            writeVerboseData("phasePlanProcess agent failure output", result.output);
+            const recovered = await (0, recovery_1.recoverReportedProcessDefinition)({
+                state,
+                outputDir: args.outputDir,
+                workspace: args.workspace,
+                outputs: phaseOutputs,
+                verbose: args.verbose,
+                json: args.json,
+            });
+            if (!recovered?.processPath) {
+                throw new utils_1.BabysitterRuntimeError("ProcessDefinitionFailed", result.output, { category: utils_1.ErrorCategory.External });
+            }
+            writeVerbose("[phasePlanProcess recovery] proceeding with the reported process file after a late PI prompt failure");
+        }
+        else {
+            writeVerboseData("phasePlanProcess agent output", result.output);
+        }
+        if (!state.report?.processPath) {
+            (0, recovery_1.writeVerboseProcessDefinitionRecovery)(args.json);
+            const recoveryPrompt = [
+                "Recovery step:",
+                `- Write the process file now to the output directory ${args.outputDir} using the normal file tools with a descriptive filename.`,
+                "- Then call babysitter_report_process_definition exactly once.",
+                "- Do not just describe the process in plain text.",
+            ].join("\n");
+            writeVerboseData("phasePlanProcess recovery prompt", recoveryPrompt);
+            const recovery = await (0, phaseHelpers_1.promptPhaseSession)({
+                session: sessionRef.current,
+                message: recoveryPrompt,
+                timeout: utils_1.PARENT_PROMPT_TIMEOUT_MS,
+                label: "phasePlanProcess recovery",
+                writeVerbose,
+                writeVerboseData,
+            });
+            phaseOutputs.push(recovery.output);
+            if (!recovery.success) {
+                writeVerboseData("phasePlanProcess recovery failure output", recovery.output);
+                const recovered = await (0, recovery_1.recoverReportedProcessDefinition)({
+                    state,
+                    outputDir: args.outputDir,
+                    workspace: args.workspace,
+                    outputs: phaseOutputs,
+                    verbose: args.verbose,
+                    json: args.json,
+                });
+                if (!recovered?.processPath) {
+                    throw new utils_1.BabysitterRuntimeError("ProcessDefinitionFailed", recovery.output, { category: utils_1.ErrorCategory.External });
+                }
+                writeVerbose("[phasePlanProcess recovery] using the reported process file after the recovery prompt failed late");
+            }
+            else {
+                writeVerboseData("phasePlanProcess recovery output", recovery.output);
+            }
+        }
+        if (!state.report?.processPath) {
+            writeVerbose("[phasePlanProcess recovery] attempting host-side recovery from agent outputs");
+            await (0, recovery_1.recoverReportedProcessDefinition)({
+                state,
+                outputDir: args.outputDir,
+                workspace: args.workspace,
+                outputs: phaseOutputs,
+                verbose: args.verbose,
+                json: args.json,
+            });
+        }
+        if (!state.report?.processPath) {
+            const finalRecoveryPrompt = [
+                "Final recovery step:",
+                `- Write the process file to the output directory ${args.outputDir} using the normal file tools with a descriptive filename.`,
+                "- If you already wrote it, do not rewrite unnecessarily.",
+                "- Call babysitter_report_process_definition exactly once after the file exists.",
+                "- Do not answer with plain text only.",
+                "- If helpful, return the full JavaScript in a ```javascript fenced block, but the file must still be written and reported.",
+            ].join("\n");
+            writeVerboseData("phasePlanProcess final recovery prompt", finalRecoveryPrompt);
+            const finalRecovery = await (0, phaseHelpers_1.promptPhaseSession)({
+                session: sessionRef.current,
+                message: finalRecoveryPrompt,
+                timeout: utils_1.PARENT_PROMPT_TIMEOUT_MS,
+                label: "phasePlanProcess final recovery",
+                writeVerbose,
+                writeVerboseData,
+            });
+            phaseOutputs.push(finalRecovery.output);
+            if (!finalRecovery.success) {
+                writeVerboseData("phasePlanProcess final recovery failure output", finalRecovery.output);
+                const recovered = await (0, recovery_1.recoverReportedProcessDefinition)({
+                    state,
+                    outputDir: args.outputDir,
+                    workspace: args.workspace,
+                    outputs: phaseOutputs,
+                    verbose: args.verbose,
+                    json: args.json,
+                });
+                if (!recovered?.processPath) {
+                    throw new utils_1.BabysitterRuntimeError("ProcessDefinitionFailed", finalRecovery.output, { category: utils_1.ErrorCategory.External });
+                }
+                writeVerbose("[phasePlanProcess recovery] using the reported process file after the final recovery prompt failed late");
+            }
+            else {
+                writeVerboseData("phasePlanProcess final recovery output", finalRecovery.output);
+            }
+            await (0, recovery_1.recoverReportedProcessDefinition)({
+                state,
+                outputDir: args.outputDir,
+                workspace: args.workspace,
+                outputs: phaseOutputs,
+                verbose: args.verbose,
+                json: args.json,
+            });
+        }
+        if (!state.report?.processPath) {
+            writeVerboseData("phasePlanProcess unrecoverable outputs", phaseOutputs);
+            throw new utils_1.BabysitterRuntimeError("ProcessDefinitionReportMissing", "The process-definition agent finished without calling babysitter_report_process_definition, and no recoverable process file or code output was produced.", { category: utils_1.ErrorCategory.Runtime });
+        }
+        await (0, paths_1.waitForProcessFile)(state.report.processPath);
+        writeVerbose(`[phasePlanProcess validate] validating process export from ${path.resolve(state.report.processPath)}`);
+        for (let repairAttempt = 0; repairAttempt < 3; repairAttempt += 1) {
+            try {
+                await (0, validation_1.validateProcessExport)(state.report.processPath);
+                break;
+            }
+            catch (validationError) {
+                if (repairAttempt === 2) {
+                    throw validationError;
+                }
+                const validationMessage = validationError instanceof Error
+                    ? validationError.message
+                    : String(validationError);
+                writeVerboseData("phasePlanProcess validate error", {
+                    attempt: repairAttempt + 1,
+                    message: validationMessage,
+                });
+                const conformancePrompt = (0, prompts_2.buildInternalProcessConformancePrompt)({
+                    outputPath: state.report.processPath,
+                    prompt: args.prompt,
+                    validationError: validationMessage,
+                });
+                writeVerboseData("phasePlanProcess conformance repair prompt", conformancePrompt);
+                const repair = await (0, phaseHelpers_1.promptPhaseSession)({
+                    session: sessionRef.current,
+                    message: conformancePrompt,
+                    timeout: utils_1.PARENT_PROMPT_TIMEOUT_MS,
+                    label: "phasePlanProcess conformance repair",
+                    writeVerbose,
+                    writeVerboseData,
+                });
+                phaseOutputs.push(repair.output);
+                if (!repair.success) {
+                    writeVerboseData("phasePlanProcess conformance repair failure output", repair.output);
+                }
+                else {
+                    writeVerboseData("phasePlanProcess conformance repair output", repair.output);
+                }
+                if (await (0, recovery_1.applyRecoveredProcessDefinitionFromOutput)({
+                    processPath: state.report.processPath,
+                    output: repair.output,
+                })) {
+                    writeVerbose(`[phasePlanProcess conformance repair] recovered rewritten process source from agent output into ${path.resolve(state.report.processPath)}`);
+                }
+                await (0, paths_1.waitForProcessFile)(state.report.processPath);
+            }
+        }
+        if (args.createRunOnReport !== false && (!state.report.runId || !state.report.runDir)) {
+            const runState = await (0, runState_1.createRunAndMaybeBindFromProcessDefinition)({
+                processPath: state.report.processPath,
+                prompt: args.prompt,
+                workspace: args.workspace,
+                runsDir: args.runsDir,
+                selectedHarnessName: args.selectedHarnessName,
+                maxIterations: args.maxIterations,
+                interactive: args.interactive,
+                verbose: args.verbose,
+                json: args.json,
+                phaseSession: sessionRef.current,
+            });
+            state.report = {
+                ...state.report,
+                ...runState,
+                conversationSummary: (0, recovery_1.buildPhaseConversationSummary)(phaseOutputs),
+            };
+        }
+        if (state.report) {
+            state.report = {
+                ...state.report,
+                conversationSummary: (0, recovery_1.buildPhaseConversationSummary)(phaseOutputs),
+            };
+        }
+        (0, utils_1.emitProgress)({
+            phase: "1",
+            status: "completed",
+            processPath: state.report.processPath,
+            harness: "agent-core",
+        }, args.json, args.verbose, args.outputMode);
+        return state.report;
+    }
+    catch (error) {
+        writeVerboseData("phasePlanProcess error", error instanceof Error
+            ? {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+            }
+            : error);
+        (0, utils_1.emitProgress)({
+            phase: "1",
+            status: "failed",
+            harness: "agent-core",
+            error: error instanceof Error ? error.message : String(error),
+        }, args.json, args.verbose, args.outputMode);
+        throw error;
+    }
+    finally {
+        sessionRef.current?.dispose();
+    }
+}
+/** @deprecated Use runPlanProcessPhase instead */
+exports.runProcessDefinitionPhase = runPlanProcessPhase;

package/dist/harness/internal/createRun/planProcess/phaseHelpers.d.ts

@@ -0,0 +1,37 @@
+import * as readline from "node:readline";
+import { type OutputMode, type AgentCoreSessionHandle, type ProcessDefinitionReport } from "../utils";
+export declare function promptPhaseSession(args: {
+    session: AgentCoreSessionHandle;
+    message: string;
+    label: string;
+    timeout: number;
+    writeVerbose: (message: string) => void;
+    writeVerboseData: (label: string, value: unknown, maxChars?: number) => void;
+}): Promise<{
+    success: boolean;
+    output: string;
+}>;
+export declare function createPlanProcessTools(args: {
+    prompt: string;
+    outputDir: string;
+    workspace?: string;
+    model?: string;
+    runsDir: string;
+    maxIterations: number;
+    createRunOnReport?: boolean;
+    interactive: boolean;
+    rl: readline.Interface | null;
+    json: boolean;
+    verbose: boolean;
+    outputMode?: OutputMode;
+    selectedHarnessName: string;
+    state: {
+        report?: ProcessDefinitionReport;
+    };
+    phaseOutputs: string[];
+    sessionRef: {
+        current: AgentCoreSessionHandle | null;
+    };
+    writeVerboseData: (label: string, value: unknown, maxChars?: number) => void;
+}): unknown[];
+//# sourceMappingURL=phaseHelpers.d.ts.map

package/dist/harness/internal/createRun/planProcess/phaseHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phaseHelpers.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/planProcess/phaseHelpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAI1C,OAAO,EAML,KAAK,UAAU,EACf,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAI7B,MAAM,UAAU,CAAC;AAMlB,wBAAsB,kBAAkB,CAAC,IAAI,EAAE;IAC7C,OAAO,EAAE,sBAAsB,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9E,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAqBhD;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,WAAW,EAAE,OAAO,CAAC;IACrB,EAAE,EAAE,QAAQ,CAAC,SAAS,GAAG,IAAI,CAAC;IAC9B,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE;QAAE,MAAM,CAAC,EAAE,uBAAuB,CAAA;KAAE,CAAC;IAC5C,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,EAAE;QAAE,OAAO,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAE,CAAC;IACvD,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9E,GAAG,OAAO,EAAE,CAiHZ"}

package/dist/harness/internal/createRun/planProcess/phaseHelpers.js

@@ -0,0 +1,159 @@
+"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.promptPhaseSession = promptPhaseSession;
+exports.createPlanProcessTools = createPlanProcessTools;
+const path = __importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+const typebox_1 = require("@sinclair/typebox");
+const genty_core_1 = require("@a5c-ai/genty-core");
+const utils_1 = require("../utils");
+const delegation_1 = require("./delegation");
+const paths_1 = require("./paths");
+const recovery_1 = require("./recovery");
+const runState_1 = require("./runState");
+async function promptPhaseSession(args) {
+    return (0, utils_1.promptPiWithRetry)({
+        session: args.session,
+        message: args.message,
+        timeout: args.timeout,
+        label: args.label,
+        writeVerbose: args.writeVerbose,
+        writeVerboseData: args.writeVerboseData,
+    }).catch((error) => {
+        const isTimeout = error instanceof utils_1.BabysitterRuntimeError &&
+            (error.name === "PiTimeoutError" || (error.message ?? "").includes("timed out"));
+        if (isTimeout) {
+            args.writeVerbose(`[${args.label}] Pi prompt timed out, converting to failure result`);
+            return {
+                success: false,
+                output: `Pi prompt timed out: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+        throw error;
+    });
+}
+function createPlanProcessTools(args) {
+    let mergedCustomTools = [];
+    const customTools = [
+        {
+            name: "babysitter_report_process_definition",
+            label: "Report Process Definition",
+            description: "Report that the process definition is ready after writing it with the normal file tools. This also creates the run and binds the current session when possible.",
+            parameters: typebox_1.Type.Object({
+                processPath: typebox_1.Type.String(),
+                summary: typebox_1.Type.Optional(typebox_1.Type.String()),
+            }),
+            execute: async (_toolCallId, params) => {
+                args.writeVerboseData("phasePlanProcess tool babysitter_report_process_definition", params);
+                const normalizedProcessPath = (0, paths_1.normalizeReportedPath)(params.processPath, args.workspace ?? process.cwd());
+                const resolvedOutputDir = path.resolve(args.outputDir);
+                if (!normalizedProcessPath.startsWith(`${resolvedOutputDir}${path.sep}`) && normalizedProcessPath !== resolvedOutputDir) {
+                    throw new utils_1.BabysitterRuntimeError("ProcessDefinitionInvalidPath", `Reported process path must stay within ${resolvedOutputDir}, got ${normalizedProcessPath}`, { category: utils_1.ErrorCategory.Validation });
+                }
+                await node_fs_1.promises.access(normalizedProcessPath);
+                const runState = args.createRunOnReport === false
+                    ? undefined
+                    : await (0, runState_1.createRunAndMaybeBindFromProcessDefinition)({
+                        processPath: normalizedProcessPath,
+                        prompt: args.prompt,
+                        workspace: args.workspace,
+                        runsDir: args.runsDir,
+                        selectedHarnessName: args.selectedHarnessName,
+                        maxIterations: args.maxIterations,
+                        interactive: args.interactive,
+                        verbose: args.verbose,
+                        json: args.json,
+                        phaseSession: args.sessionRef.current,
+                    });
+                args.state.report = {
+                    processPath: normalizedProcessPath,
+                    summary: params.summary,
+                    ...runState,
+                    conversationSummary: (0, recovery_1.buildPhaseConversationSummary)(args.phaseOutputs),
+                };
+                setTimeout(() => {
+                    if (args.sessionRef.current?.isStreaming) {
+                        void args.sessionRef.current.abort().catch(() => { });
+                    }
+                }, 0);
+                return (0, utils_1.formatToolResult)(args.state.report, "Process definition reported.");
+            },
+        },
+    ];
+    const agenticTools = (0, genty_core_1.createAgentCoreToolDefinitions)({
+        workspace: args.workspace ?? process.cwd(),
+        interactive: args.interactive ?? false,
+        askUserQuestionHandler: async (params) => {
+            const response = await (0, utils_1.askUserQuestionViaTool)(params, args.interactive, args.rl, undefined);
+            args.writeVerboseData("phasePlanProcess tool AskUserQuestion response", response);
+            (0, utils_1.emitProgress)({
+                phase: "1",
+                status: "interview",
+                answer: JSON.stringify(response.answers),
+            }, args.json, args.verbose, args.outputMode);
+            return response;
+        },
+        taskHandler: async (params) => {
+            args.writeVerboseData("phasePlanProcess tool task request", params);
+            return (0, delegation_1.runDelegatedHarnessTask)({
+                ...params,
+                task: String(params.task ?? ""),
+                workspace: args.workspace,
+                model: typeof params.model === "string"
+                    ? String(params.model)
+                    : args.model,
+                customTools: mergedCustomTools,
+            });
+        },
+        skillHandler: async (params) => {
+            args.writeVerboseData("phasePlanProcess tool skill request", params);
+            return (0, delegation_1.runDelegatedHarnessTask)({
+                ...params,
+                task: String(params.task ?? ""),
+                workspace: args.workspace,
+                model: typeof params.model === "string"
+                    ? String(params.model)
+                    : args.model,
+                skills: Array.isArray(params.skills)
+                    ? params.skills
+                    : undefined,
+                customTools: mergedCustomTools,
+            });
+        },
+    });
+    mergedCustomTools = [...customTools, ...agenticTools];
+    return mergedCustomTools;
+}

package/dist/harness/internal/createRun/planProcess/phaseTypes.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Type definitions for plan process phase.
+ * Extracted from phase.ts for max-lines compliance.
+ */
+import type * as readline from "node:readline";
+import type { CompressionConfig, HarnessPromptContext as SessionCreatePromptContext, OutputMode } from "../utils";
+export interface RunPlanProcessPhaseArgs {
+    invocationCommand?: string;
+    prompt: string;
+    outputDir: string;
+    workspace?: string;
+    model?: string;
+    runsDir: string;
+    maxIterations: number;
+    createRunOnReport?: boolean;
+    interactive: boolean;
+    rl: readline.Interface | null;
+    json: boolean;
+    verbose: boolean;
+    compressionConfig: CompressionConfig | null;
+    promptContext: SessionCreatePromptContext;
+    selectedHarnessName: string;
+    outputMode?: OutputMode;
+}
+//# sourceMappingURL=phaseTypes.d.ts.map

package/dist/harness/internal/createRun/planProcess/phaseTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phaseTypes.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/planProcess/phaseTypes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EACV,iBAAiB,EACjB,oBAAoB,IAAI,0BAA0B,EAClD,UAAU,EACX,MAAM,UAAU,CAAC;AAElB,MAAM,WAAW,uBAAuB;IACtC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,WAAW,EAAE,OAAO,CAAC;IACrB,EAAE,EAAE,QAAQ,CAAC,SAAS,GAAG,IAAI,CAAC;IAC9B,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC5C,aAAa,EAAE,0BAA0B,CAAC;IAC1C,mBAAmB,EAAE,MAAM,CAAC;IAC5B,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB"}

package/dist/harness/internal/createRun/planProcess/phaseTypes.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Type definitions for plan process phase.
+ * Extracted from phase.ts for max-lines compliance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });