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

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

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAgentPrompt = buildAgentPrompt;
+exports.buildStructuredAgentOutputInstructions = buildStructuredAgentOutputInstructions;
+exports.extractJsonObjectFromText = extractJsonObjectFromText;
+exports.coerceAgentResultValue = coerceAgentResultValue;
+const utils_1 = require("../utils");
+function buildAgentPrompt(taskDef) {
+    const agent = taskDef.agent;
+    if (!agent) {
+        return taskDef.title ?? "Execute task";
+    }
+    const structuredOutputInstructions = buildStructuredAgentOutputInstructions(agent);
+    const rawPrompt = agent.prompt;
+    if (typeof rawPrompt === "string" && rawPrompt.trim()) {
+        return [
+            "You are an autonomous agent. PERFORM the task below using your available tools.",
+            "Do not just describe what you would do. Execute the work and then summarize what you changed.",
+            ...structuredOutputInstructions,
+            "",
+            "Task:",
+            rawPrompt.trim(),
+        ].join("\n");
+    }
+    if (Array.isArray(rawPrompt) && rawPrompt.length > 0) {
+        const lines = rawPrompt
+            .filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+            .map((entry) => entry.trim());
+        if (lines.length > 0) {
+            return [
+                "You are an autonomous agent. PERFORM the task below using your available tools.",
+                "Do not just describe what you would do. Execute the work and then summarize what you changed.",
+                ...structuredOutputInstructions,
+                "",
+                "Task:",
+                ...lines,
+            ].join("\n");
+        }
+    }
+    const prompt = rawPrompt;
+    if (!prompt || typeof prompt !== "object") {
+        return taskDef.title ?? "Execute task";
+    }
+    const parts = [];
+    parts.push("You are an autonomous agent. PERFORM the task below using your available tools.", "Do not just describe what you would do. Execute the work and then summarize what you changed.", "");
+    if (typeof prompt.role === "string") {
+        parts.push(`Role: ${prompt.role}`);
+    }
+    if (typeof prompt.task === "string") {
+        parts.push(`\nTask:\n${prompt.task}`);
+    }
+    if (prompt.context) {
+        parts.push(`\nContext:\n${JSON.stringify(prompt.context, null, 2)}`);
+    }
+    if (Array.isArray(prompt.instructions)) {
+        parts.push(`\nInstructions:\n${prompt.instructions.map((item, index) => `${index + 1}. ${item}`).join("\n")}`);
+    }
+    if (typeof prompt.outputFormat === "string") {
+        parts.push(`\nOutput format: ${prompt.outputFormat}`);
+    }
+    if (structuredOutputInstructions.length > 0) {
+        parts.push(`\n${structuredOutputInstructions.join("\n")}`);
+    }
+    return parts.join("\n");
+}
+function buildStructuredAgentOutputInstructions(agent) {
+    const outputSchema = agent.outputSchema;
+    if (!outputSchema || typeof outputSchema !== "object") {
+        return [];
+    }
+    return [
+        "Return ONLY a JSON object that matches the declared output schema.",
+        "Do not wrap the JSON in markdown fences, and do not prepend or append prose.",
+        `Output schema: ${JSON.stringify(outputSchema, null, 2)}`,
+    ];
+}
+/**
+ * Scan from the first `{` (or `[`) and return the first BALANCED JSON value,
+ * respecting string literals and escapes. This tolerates trailing content after
+ * the JSON (e.g. a worker that emits `{...}` then prose/markdown that itself
+ * contains braces) which the naive first-brace/last-brace slice mishandles —
+ * the prior cause of "invalid JSON" coercion loops.
+ */
+function extractFirstBalancedJson(text) {
+    const open = text.search(/[{[]/);
+    if (open < 0) {
+        return null;
+    }
+    const openChar = text[open];
+    const closeChar = openChar === "{" ? "}" : "]";
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = open; i < text.length; i += 1) {
+        const ch = text[i];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (ch === "\\") {
+                escaped = true;
+            }
+            else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+        }
+        else if (ch === openChar) {
+            depth += 1;
+        }
+        else if (ch === closeChar) {
+            depth -= 1;
+            if (depth === 0) {
+                return text.slice(open, i + 1);
+            }
+        }
+    }
+    return null;
+}
+function extractJsonObjectFromText(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return null;
+    }
+    // Prefer a fenced ```json block when present; otherwise scan the raw text.
+    // Always extract the FIRST balanced JSON value (respecting strings/escapes)
+    // rather than naively slicing first-brace..last-brace, so trailing prose or
+    // markdown after a complete JSON object does not corrupt the parse.
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const source = fenced?.[1]?.trim() ?? trimmed;
+    const balanced = extractFirstBalancedJson(source);
+    if (balanced) {
+        return balanced;
+    }
+    // Fall back to a clean, already-bare JSON value.
+    if ((source.startsWith("{") && source.endsWith("}")) || (source.startsWith("[") && source.endsWith("]"))) {
+        return source;
+    }
+    return null;
+}
+function coerceAgentResultValue(taskDef, output) {
+    const agent = taskDef.agent;
+    if (!agent?.outputSchema || typeof agent.outputSchema !== "object") {
+        return output;
+    }
+    const candidate = extractJsonObjectFromText(output);
+    if (!candidate) {
+        throw new utils_1.BabysitterRuntimeError("AgentOutputSchemaMismatch", "Agent task declared outputSchema but did not return JSON output", { category: utils_1.ErrorCategory.External });
+    }
+    try {
+        return JSON.parse(candidate);
+    }
+    catch (error) {
+        throw new utils_1.BabysitterRuntimeError("AgentOutputSchemaMismatch", error instanceof Error
+            ? `Agent task declared outputSchema but returned invalid JSON: ${error.message}`
+            : "Agent task declared outputSchema but returned invalid JSON", { category: utils_1.ErrorCategory.External });
+    }
+}

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

@@ -0,0 +1,33 @@
+import { type CustomToolDefinition } from "@a5c-ai/genty-core";
+import { type AgentCoreSessionOptions } from "../utils";
+export declare function runDelegatedHarnessTask(args: {
+    task: string;
+    workspace?: string;
+    model?: string;
+    harness?: string;
+    timeout?: number;
+    toolsMode?: AgentCoreSessionOptions["toolsMode"];
+    thinkingLevel?: AgentCoreSessionOptions["thinkingLevel"] | "none";
+    bashSandbox?: AgentCoreSessionOptions["bashSandbox"];
+    skills?: string[];
+    customTools?: CustomToolDefinition[];
+    /**
+     * When the delegated task declares a JSON output schema, enforce it on the
+     * built-in agent-core worker via the provider's structured-output mode
+     * (`response_format: json_schema`). This guarantees the worker returns
+     * schema-conforming JSON instead of free-form prose/markdown, so the caller's
+     * result coercion cannot fail in a retry loop. Only honored for the built-in
+     * agent-core harness; external CLI harnesses ignore it.
+     */
+    outputSchema?: AgentCoreSessionOptions["outputSchema"];
+}): Promise<{
+    success: boolean;
+    output: string;
+    harness: string;
+}>;
+export declare function execShellEffect(command: string, args: string[], cwd?: string): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
+//# sourceMappingURL=delegation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delegation.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/planProcess/delegation.ts"],"names":[],"mappings":"AAGA,OAAO,EAA+B,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE5F,OAAO,EAIL,KAAK,uBAAuB,EAC7B,MAAM,UAAU,CAAC;AAgElB,wBAAsB,uBAAuB,CAAC,IAAI,EAAE;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,uBAAuB,CAAC,WAAW,CAAC,CAAC;IACjD,aAAa,CAAC,EAAE,uBAAuB,CAAC,eAAe,CAAC,GAAG,MAAM,CAAC;IAClE,WAAW,CAAC,EAAE,uBAAuB,CAAC,aAAa,CAAC,CAAC;IACrD,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACrC;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,uBAAuB,CAAC,cAAc,CAAC,CAAC;CACxD,GAAG,OAAO,CAAC;IACV,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC,CAsFD;AAED,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAyB/D"}

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

@@ -0,0 +1,202 @@
+"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.runDelegatedHarnessTask = runDelegatedHarnessTask;
+exports.execShellEffect = execShellEffect;
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const genty_core_1 = require("@a5c-ai/genty-core");
+const invoker_1 = require("../../../invoker");
+const utils_1 = require("../utils");
+const builtInHarness_1 = require("../../../builtInHarness");
+function resolveSkillFileCandidates(workspace, skillRef) {
+    const trimmed = skillRef.trim();
+    if (!trimmed) {
+        return [];
+    }
+    const candidates = new Set();
+    const add = (candidate) => {
+        if (!candidate) {
+            return;
+        }
+        candidates.add(path.resolve(workspace, candidate));
+    };
+    if (path.isAbsolute(trimmed)) {
+        candidates.add(path.resolve(trimmed));
+    }
+    else {
+        add(trimmed);
+    }
+    if (/SKILL\.md$/i.test(trimmed)) {
+        add(trimmed);
+    }
+    else {
+        add(path.join(trimmed, "SKILL.md"));
+        add(path.join(".a5c", "skills", trimmed, "SKILL.md"));
+        const parts = trimmed.split(":").filter(Boolean);
+        if (parts.length >= 2) {
+            const [pluginName, ...skillParts] = parts;
+            add(path.join("plugins", pluginName, "skills", ...skillParts, "SKILL.md"));
+        }
+    }
+    return Array.from(candidates);
+}
+function loadSkillInstructions(workspace, skillRefs) {
+    if (!skillRefs?.length) {
+        return [];
+    }
+    const instructions = [];
+    for (const skillRef of skillRefs) {
+        const candidates = resolveSkillFileCandidates(workspace, skillRef);
+        for (const candidate of candidates) {
+            if (!(0, node_fs_1.existsSync)(candidate)) {
+                continue;
+            }
+            try {
+                instructions.push((0, node_fs_1.readFileSync)(candidate, "utf8"));
+                break;
+            }
+            catch {
+                // Ignore unreadable skill files and continue searching.
+            }
+        }
+    }
+    return instructions;
+}
+async function runDelegatedHarnessTask(args) {
+    const workspace = path.resolve(args.workspace ?? process.cwd());
+    const skillInstructions = loadSkillInstructions(workspace, args.skills);
+    const prompt = skillInstructions.length > 0
+        ? [
+            "Follow the loaded skill instructions below while performing the task.",
+            "",
+            ...skillInstructions,
+            "",
+            "--- Task ---",
+            args.task,
+        ].join("\n")
+        : args.task;
+    const harnessName = (0, builtInHarness_1.normalizeBuiltInHarnessName)(args.harness?.trim() || "agent-core");
+    if ((0, builtInHarness_1.isBuiltInHarnessName)(harnessName)) {
+        const effectiveToolsMode = args.toolsMode ?? "coding";
+        // genty-core's session does NOT auto-build a tool surface from `toolsMode`;
+        // it only exposes the tools passed via `customTools`. Without this, the
+        // delegated worker is TOOLLESS — it cannot read/write files and instead
+        // returns a description (e.g. a `cmd` string) of work it never performed,
+        // so the file is never created. Build the focused coding/readonly file +
+        // bash tools so the worker can actually act. Caller-supplied customTools
+        // (e.g. the planning-phase babysitter tools) are appended.
+        const workerTools = effectiveToolsMode === "default"
+            ? args.customTools
+            : [
+                ...(0, genty_core_1.createCodingToolDefinitions)({ workspace, interactive: false }, effectiveToolsMode === "readonly" ? "readonly" : "coding"),
+                ...(args.customTools ?? []),
+            ];
+        const session = (0, utils_1.createAgentCoreSession)({
+            workspace,
+            model: args.model,
+            timeout: args.timeout,
+            toolsMode: effectiveToolsMode,
+            ...(workerTools?.length ? { customTools: workerTools } : {}),
+            ephemeral: true,
+            ...(args.outputSchema
+                ? {
+                    outputFormat: "json_schema",
+                    outputSchema: args.outputSchema,
+                    // Non-strict: process-authored schemas often omit the
+                    // `additionalProperties:false` / fully-required shape that
+                    // provider strict mode demands. We only need a conforming JSON
+                    // object, which non-strict json_schema still guarantees.
+                    outputSchemaStrict: false,
+                }
+                : {}),
+            ...(args.bashSandbox ? { bashSandbox: args.bashSandbox } : {}),
+            ...(args.thinkingLevel && args.thinkingLevel !== "none"
+                ? { thinkingLevel: args.thinkingLevel }
+                : {}),
+            ...(skillInstructions.length > 0 ? { appendSystemPrompt: [skillInstructions.join("\n\n---\n\n")] } : {}),
+        });
+        try {
+            await session.initialize();
+            const result = await (0, utils_1.promptPiWithRetry)({
+                session,
+                message: prompt,
+                timeout: args.timeout ?? utils_1.PARENT_PROMPT_TIMEOUT_MS,
+                label: "delegated-task",
+            });
+            return {
+                success: result.success,
+                output: result.output,
+                harness: harnessName,
+            };
+        }
+        finally {
+            session.dispose();
+        }
+    }
+    const result = await (0, invoker_1.invokeHarness)(harnessName, {
+        prompt,
+        workspace,
+        model: args.model,
+        timeout: args.timeout,
+    });
+    return {
+        success: result.success,
+        output: result.output,
+        harness: harnessName,
+    };
+}
+function execShellEffect(command, args, cwd) {
+    return new Promise((resolve) => {
+        (0, node_child_process_1.execFile)(command, args, {
+            cwd,
+            timeout: 300_000,
+            windowsHide: true,
+            maxBuffer: 10 * 1024 * 1024,
+        }, (error, stdout, stderr) => {
+            let exitCode = 0;
+            if (error) {
+                const execError = error;
+                exitCode = typeof execError.status === "number" ? execError.status : 1;
+            }
+            resolve({
+                stdout: String(stdout),
+                stderr: String(stderr),
+                exitCode,
+            });
+        });
+    });
+}

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

@@ -0,0 +1,14 @@
+import { type HarnessPromptContext as SessionCreatePromptContext, type OutputMode } from "../utils";
+export declare function runExternalProcessDefinitionPhase(args: {
+    invocationCommand?: string;
+    prompt: string;
+    outputDir: string;
+    workspace?: string;
+    model?: string;
+    json: boolean;
+    verbose: boolean;
+    selectedHarnessName: string;
+    promptContext: SessionCreatePromptContext;
+    outputMode?: OutputMode;
+}): Promise<string>;
+//# sourceMappingURL=external.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"external.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/planProcess/external.ts"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,oBAAoB,IAAI,0BAA0B,EACvD,KAAK,UAAU,EAIhB,MAAM,UAAU,CAAC;AAUlB,wBAAsB,iCAAiC,CAAC,IAAI,EAAE;IAC5D,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,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,0BAA0B,CAAC;IAC1C,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,GAAG,OAAO,CAAC,MAAM,CAAC,CA+IlB"}

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

@@ -0,0 +1,140 @@
+"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.runExternalProcessDefinitionPhase = runExternalProcessDefinitionPhase;
+const path = __importStar(require("node:path"));
+const invoker_1 = require("../../../invoker");
+const utils_1 = require("../utils");
+const prompts_1 = require("./prompts");
+const prompts_2 = require("../prompts");
+const recovery_1 = require("./recovery");
+const validation_1 = require("./validation");
+async function runExternalProcessDefinitionPhase(args) {
+    const phaseOutputs = [];
+    const state = {};
+    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);
+    };
+    (0, utils_1.emitProgress)({ phase: "1", status: "started", harness: `${args.selectedHarnessName} (headless)` }, 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)} harness=${args.selectedHarnessName}`);
+    const workspaceAssessment = await (0, prompts_1.assessWorkspaceForExternalAuthoring)(args.workspace);
+    writeVerboseData("phasePlanProcess workspace assessment", workspaceAssessment);
+    const invokeProcessAuthor = async (label, prompt, timeout) => {
+        writeVerboseData(`${label} prompt`, prompt);
+        const result = await (0, invoker_1.invokeHarness)(args.selectedHarnessName, {
+            prompt,
+            workspace: args.workspace,
+            model: args.model,
+            timeout,
+        });
+        if (!result.success) {
+            writeVerboseData(`${label} failure output`, result.output);
+            throw new utils_1.BabysitterRuntimeError("ProcessDefinitionFailed", result.output, { category: utils_1.ErrorCategory.External });
+        }
+        phaseOutputs.push(result.output);
+        writeVerboseData(`${label} output`, result.output);
+    };
+    await invokeProcessAuthor("phasePlanProcess initial", (0, prompts_1.buildExternalProcessDefinitionPrompt)({
+        prompt: args.prompt,
+        outputDir: args.outputDir,
+        workspace: args.workspace,
+        promptContext: args.promptContext,
+        workspaceAssessment,
+        preferAgentOnlyTasks: (0, prompts_2.prefersAgentOnlyTasks)(args.invocationCommand),
+    }), 900_000);
+    if (!state.report?.processPath) {
+        await (0, recovery_1.recoverReportedProcessDefinition)({
+            state,
+            outputDir: args.outputDir,
+            workspace: args.workspace,
+            outputs: phaseOutputs,
+            verbose: args.verbose,
+            json: args.json,
+        });
+    }
+    if (!state.report?.processPath) {
+        await invokeProcessAuthor("phasePlanProcess recovery", [
+            `Write the full process file now to the output directory ${args.outputDir}.`,
+            "Choose a descriptive kebab-case filename (e.g. recovered-process.mjs).",
+            "Do not describe the plan only; materialize the file in the workspace.",
+            "After writing it, return either a concise summary or the full file in a ```javascript fenced block.",
+        ].join("\n"), 300_000);
+        await (0, recovery_1.recoverReportedProcessDefinition)({
+            state,
+            outputDir: args.outputDir,
+            workspace: args.workspace,
+            outputs: phaseOutputs,
+            verbose: args.verbose,
+            json: args.json,
+        });
+    }
+    if (!state.report?.processPath) {
+        await invokeProcessAuthor("phasePlanProcess final recovery", [
+            `Final recovery step: write the complete JavaScript process file to the output directory ${args.outputDir}.`,
+            "Return the full file in a ```javascript fenced block after it exists on disk.",
+            "Do not omit the file write.",
+        ].join("\n"), 300_000);
+        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 harness did not produce a valid process file or recoverable JavaScript output.", { category: utils_1.ErrorCategory.Runtime });
+    }
+    await invokeProcessAuthor("phasePlanProcess sdk conformance", (0, prompts_1.buildExternalProcessConformancePrompt)({
+        outputPath: state.report.processPath,
+        prompt: args.prompt,
+    }), 300_000);
+    await (0, validation_1.validateProcessExport)(state.report.processPath);
+    (0, utils_1.emitProgress)({
+        phase: "1",
+        status: "completed",
+        harness: `${args.selectedHarnessName} (headless)`,
+        processPath: state.report.processPath,
+    }, args.json, args.verbose, args.outputMode);
+    if (!args.json && args.outputMode !== "tui") {
+        process.stderr.write(`${utils_1.GREEN}PhasePlanProcess complete:${utils_1.RESET} process=${utils_1.CYAN}${state.report.processPath}${utils_1.RESET}\n`);
+    }
+    return state.report.processPath;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Compatibility surface for PhasePlanProcess helpers.
+ *
+ * The implementation lives under ./planProcess/ to keep planning
+ * helpers grouped by responsibility instead of accumulating more flat command
+ * siblings.
+ */
+export { getGeneratedProcessPath, getProcessOutputDir, } from "./paths";
+export { execShellEffect, runDelegatedHarnessTask, } from "./delegation";
+export { buildAgentPrompt, buildStructuredAgentOutputInstructions, coerceAgentResultValue, extractJsonObjectFromText, } from "./agentOutput";
+export { runPlanProcessPhase, runProcessDefinitionPhase, } from "./phase";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/planProcess/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,eAAe,EACf,uBAAuB,GACxB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,gBAAgB,EAChB,sCAAsC,EACtC,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,mBAAmB,EACnB,yBAAyB,GAC1B,MAAM,SAAS,CAAC"}

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

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Compatibility surface for PhasePlanProcess helpers.
+ *
+ * The implementation lives under ./planProcess/ to keep planning
+ * helpers grouped by responsibility instead of accumulating more flat command
+ * siblings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProcessDefinitionPhase = exports.runPlanProcessPhase = exports.extractJsonObjectFromText = exports.coerceAgentResultValue = exports.buildStructuredAgentOutputInstructions = exports.buildAgentPrompt = exports.runDelegatedHarnessTask = exports.execShellEffect = exports.getProcessOutputDir = exports.getGeneratedProcessPath = void 0;
+var paths_1 = require("./paths");
+Object.defineProperty(exports, "getGeneratedProcessPath", { enumerable: true, get: function () { return paths_1.getGeneratedProcessPath; } });
+Object.defineProperty(exports, "getProcessOutputDir", { enumerable: true, get: function () { return paths_1.getProcessOutputDir; } });
+var delegation_1 = require("./delegation");
+Object.defineProperty(exports, "execShellEffect", { enumerable: true, get: function () { return delegation_1.execShellEffect; } });
+Object.defineProperty(exports, "runDelegatedHarnessTask", { enumerable: true, get: function () { return delegation_1.runDelegatedHarnessTask; } });
+var agentOutput_1 = require("./agentOutput");
+Object.defineProperty(exports, "buildAgentPrompt", { enumerable: true, get: function () { return agentOutput_1.buildAgentPrompt; } });
+Object.defineProperty(exports, "buildStructuredAgentOutputInstructions", { enumerable: true, get: function () { return agentOutput_1.buildStructuredAgentOutputInstructions; } });
+Object.defineProperty(exports, "coerceAgentResultValue", { enumerable: true, get: function () { return agentOutput_1.coerceAgentResultValue; } });
+Object.defineProperty(exports, "extractJsonObjectFromText", { enumerable: true, get: function () { return agentOutput_1.extractJsonObjectFromText; } });
+var phase_1 = require("./phase");
+Object.defineProperty(exports, "runPlanProcessPhase", { enumerable: true, get: function () { return phase_1.runPlanProcessPhase; } });
+Object.defineProperty(exports, "runProcessDefinitionPhase", { enumerable: true, get: function () { return phase_1.runProcessDefinitionPhase; } });

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

@@ -0,0 +1,7 @@
+export declare function getProcessOutputDir(workDir: string): string;
+/** @deprecated Use getProcessOutputDir instead */
+export declare function getGeneratedProcessPath(workDir: string): string;
+export declare function normalizeReportedPath(candidate: string, workspace?: string): string;
+export declare function extractMentionedProcessPaths(text: string, workspace?: string): string[];
+export declare function waitForProcessFile(filePath: string, timeoutMs?: number): Promise<void>;
+//# sourceMappingURL=paths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/planProcess/paths.ts"],"names":[],"mappings":"AAOA,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,kDAAkD;AAClD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAMnF;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAoBvF;AAKD,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,MAAwB,GAClC,OAAO,CAAC,IAAI,CAAC,CAuBf"}