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

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

@@ -0,0 +1,98 @@
+"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.getProcessOutputDir = getProcessOutputDir;
+exports.getGeneratedProcessPath = getGeneratedProcessPath;
+exports.normalizeReportedPath = normalizeReportedPath;
+exports.extractMentionedProcessPaths = extractMentionedProcessPaths;
+exports.waitForProcessFile = waitForProcessFile;
+const path = __importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+const utils_1 = require("../utils");
+function getProcessOutputDir(workDir) {
+    return path.join(workDir, ".a5c", "processes");
+}
+/** @deprecated Use getProcessOutputDir instead */
+function getGeneratedProcessPath(workDir) {
+    return getProcessOutputDir(workDir);
+}
+function normalizeReportedPath(candidate, workspace) {
+    const trimmed = candidate.trim().replace(/^['"`]|['"`]$/g, "");
+    if (path.isAbsolute(trimmed)) {
+        return path.resolve(trimmed);
+    }
+    return path.resolve(workspace ?? process.cwd(), trimmed);
+}
+function extractMentionedProcessPaths(text, workspace) {
+    const patterns = [
+        /([A-Za-z]:[\\/][^\r\n"'`]+?\.m?js)\b/g,
+        /((?:\.{0,2}[\\/]|\/)[^\r\n"'`]+?\.m?js)\b/g,
+        /\b([A-Za-z0-9_.\-\\/]+generated-process\.m?js)\b/g,
+        /\b(\.a5c[\\/]processes[\\/][A-Za-z0-9_.-]+\.m?js)\b/g,
+    ];
+    const matches = new Set();
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(text)) !== null) {
+            const raw = match[1];
+            if (raw) {
+                matches.add(normalizeReportedPath(raw, workspace));
+            }
+        }
+    }
+    return [...matches];
+}
+const POLL_INTERVAL_MS = 1_000;
+const POLL_TIMEOUT_MS = 60_000;
+async function waitForProcessFile(filePath, timeoutMs = POLL_TIMEOUT_MS) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            await node_fs_1.promises.access(filePath);
+            return;
+        }
+        catch {
+            // keep polling
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    }
+    throw new utils_1.BabysitterRuntimeError("ProcessFileTimeoutError", `Process file was not created within ${timeoutMs / 1_000}s: ${filePath}`, {
+        category: utils_1.ErrorCategory.External,
+        nextSteps: [
+            "Check harness output for errors",
+            "Ensure the harness can write to the workspace directory",
+        ],
+    });
+}

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

@@ -0,0 +1,6 @@
+import { type ProcessDefinitionReport } from "../utils";
+export type { RunPlanProcessPhaseArgs } from "./phaseTypes";
+export declare function runPlanProcessPhase(args: import("./phaseTypes").RunPlanProcessPhaseArgs): Promise<ProcessDefinitionReport>;
+/** @deprecated Use runPlanProcessPhase instead */
+export declare const runProcessDefinitionPhase: typeof runPlanProcessPhase;
+//# sourceMappingURL=phase.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"phase.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/planProcess/phase.ts"],"names":[],"mappings":"AAQA,OAAO,EAaL,KAAK,uBAAuB,EAG7B,MAAM,UAAU,CAAC;AAqBlB,YAAY,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAE5D,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,OAAO,cAAc,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAiZhI;AAED,kDAAkD;AAClD,eAAO,MAAM,yBAAyB,4BAAsB,CAAC"}

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

@@ -0,0 +1,396 @@
+"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 global_1 = require("../../../../orchestration/global");
+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);
+    // Grant the file tools read-only access to the process-library/reference roots
+    // the planning prompt tells the agent to search (they live outside the
+    // workspace). Without this the agent loops retrying an unreachable path.
+    const readOnlyRoots = await (0, prompts_1.resolveProcessLibraryReadOnlyRoots)();
+    writeVerboseData("phasePlanProcess read-only roots", readOnlyRoots);
+    const mergedCustomTools = (0, phaseHelpers_1.createPlanProcessTools)({
+        ...args, state, phaseOutputs, sessionRef, writeVerboseData, readOnlyRoots,
+    });
+    (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);
+    let externalAgents;
+    try {
+        const agents = await (0, global_1.getGlobalRegistry)().getAgentDiscovery().discoverAgents(args.workspace ?? process.cwd());
+        externalAgents = {
+            available: agents.length > 0,
+            agents: agents.map((a) => ({
+                name: a.name,
+                displayName: a.description ?? a.name,
+                installed: true,
+                authenticated: true,
+                capabilities: [],
+            })),
+            defaultProvider: null,
+            defaultModel: null,
+        };
+    }
+    catch {
+        externalAgents = { available: false, agents: [], defaultProvider: null, defaultModel: null };
+    }
+    const promptContext = {
+        ...args.promptContext,
+        externalAgents,
+    };
+    writeVerboseData("phasePlanProcess workspace assessment", workspaceAssessment);
+    writeVerboseData("phasePlanProcess external agents", externalAgents);
+    const resolvedBackend = (0, utils_1.resolveAgentCoreBackendForHarness)(args.selectedHarnessName);
+    // genty-core's createAgentCoreSession is now genuinely tool-capable (#936): it
+    // forwards customTools/toolsMode and runs a real tool-call loop. The model
+    // authors the process by calling babysitter_report_process_definition through
+    // that loop. recovery.ts remains a safety net invoked on failure below.
+    const processDefinitionSystemPrompt = await (0, prompts_1.buildProcessDefinitionSystemPrompt)(args.outputDir, promptContext, args.interactive);
+    const basePlanProcessPrompt = (0, prompts_1.buildProcessDefinitionUserPrompt)(args.prompt, args.outputDir, {
+        interactive: args.interactive,
+        workspaceAssessment: workspaceAssessment.kind,
+        workspaceEntries: workspaceAssessment.entries,
+        preferAgentOnlyTasks: (0, prompts_1.prefersAgentOnlyTasks)(args.invocationCommand),
+    });
+    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: "low",
+        toolsMode: planProcessToolsMode,
+        customTools: mergedCustomTools,
+        uiContext: 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 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,44 @@
+import * as readline from "node:readline";
+import { type CustomToolDefinition } from "@a5c-ai/genty-core";
+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;
+    /**
+     * Absolute reference roots (process-library/reference dirs) the planning
+     * prompt tells the agent to search. Granted read-only to the file tools so
+     * the agent cannot get trapped retrying an out-of-workspace path.
+     */
+    readOnlyRoots?: string[];
+}): CustomToolDefinition[];
+//# 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;AAG1C,OAAO,EAAkC,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC/F,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;IAC7E;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B,GAAG,oBAAoB,EAAE,CAmHzB"}