@a5c-ai/agent-platform 5.0.1-staging.b436b3b3e611

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

@@ -0,0 +1,208 @@
+"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.buildExternalProcessDefinitionPrompt = buildExternalProcessDefinitionPrompt;
+exports.buildExternalProcessConformancePrompt = buildExternalProcessConformancePrompt;
+exports.buildInternalProcessConformancePrompt = buildInternalProcessConformancePrompt;
+exports.assessWorkspaceForExternalAuthoring = assessWorkspaceForExternalAuthoring;
+const path = __importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+function buildExternalProcessDefinitionPrompt(args) {
+    const workspace = path.resolve(args.workspace ?? process.cwd());
+    const installedHarnesses = args.promptContext.discoveredHarnesses
+        .filter((h) => h.installed)
+        .map((h) => h.name);
+    const installedHarnessList = installedHarnesses.length > 0
+        ? installedHarnesses.join(", ")
+        : "(none)";
+    const workspaceSummary = args.workspaceAssessment.entries.length > 0
+        ? args.workspaceAssessment.entries.join(", ")
+        : "(no files)";
+    const preferAgentOnlyTasks = args.preferAgentOnlyTasks === true;
+    const emptyWorkspaceAuthoringGuide = [
+        "",
+        "Empty-workspace authoring guide:",
+        "- Do not perform extra exploration. You already know the workspace is empty.",
+        "- Write a concrete greenfield process immediately.",
+        "- Prefer a small process with explicit milestones such as: plan the game, scaffold the project, implement the game, verify the result.",
+        preferAgentOnlyTasks
+            ? "- Use `agent` or `skill` tasks for planning, implementation, and verification. Do not generate `shell` tasks for this run shape unless the user explicitly requires an existing CLI command."
+            : "- Use `agent` tasks for planning and implementation. Use `shell` tasks only for concrete runnable commands such as dependency install, build, or test commands that the later orchestration can execute.",
+        preferAgentOnlyTasks
+            ? "- Do not generate `breakpoint` tasks for this run shape. Approval gates are process-authoring bugs unless the user explicitly asked for them."
+            : "- Add `breakpoint` tasks only when the process genuinely needs user input or sign-off.",
+        "- Keep the process practical for a brand-new directory: it should create the project, build the game, and verify that it runs or tests cleanly.",
+    ].join("\n");
+    return [
+        "You are running agent-platform create-run PhasePlanProcess on an external CLI harness in non-interactive mode.",
+        "Do the real process-authoring work in the workspace and write the actual process file to disk.",
+        "",
+        "Task:",
+        `- User request: ${args.prompt}`,
+        `- Workspace: ${workspace}`,
+        `- Process output directory: ${path.resolve(args.outputDir)}`,
+        `- Workspace assessment: ${args.workspaceAssessment.kind} (${workspaceSummary})`,
+        "",
+        "Requirements:",
+        "- Start with one quick check of the workspace contents only if you need to confirm the assessment above.",
+        args.workspaceAssessment.kind === "empty"
+            ? "- The workspace is empty. Treat this as a greenfield request and move straight to authoring the process."
+            : "- Only tailor the process to existing code when the workspace actually contains relevant project files.",
+        "- Do not inspect paths outside the workspace unless the workspace itself points to them.",
+        "- Do not use web search, browse remote repositories, or fetch external documentation for this task.",
+        args.workspaceAssessment.kind === "empty"
+            ? "- Do not inspect global skill/plugin directories, home-directory config, or unrelated repositories for examples. You already have enough context to write the process."
+            : "- Keep research tight and relevant; do not wander through unrelated global skill/plugin directories.",
+        "- Do not ask the user questions. Infer missing details from the request and repo state.",
+        "- Write a complete ESM JavaScript module that can be imported from the output path.",
+        '- Import `defineTask` from `@a5c-ai/babysitter-sdk`.',
+        "- The module must export `async function process(inputs, ctx)`.",
+        "- The process must orchestrate the work through babysitter tasks instead of doing the main implementation directly in `process(inputs, ctx)`.",
+        "- Define at least one task with `defineTask(...)`, and invoke tasks from `process(inputs, ctx)` via `await ctx.task(...)`.",
+        "- Use `agent` tasks for planning, implementation, analysis, and verification work.",
+        preferAgentOnlyTasks
+            ? "- Do not generate `shell` tasks for this run shape unless the user explicitly requires an existing CLI command. Prefer wrapped `agent` or `skill` tasks for verification too."
+            : "- Use `shell` tasks only for existing CLI tools such as tests, builds, linters, git, or package managers.",
+        preferAgentOnlyTasks
+            ? "- Do not generate `breakpoint` tasks for this run shape. Keep the process fully autonomous unless the user explicitly asked for checkpoints."
+            : "- Use `breakpoint` tasks only when the workflow truly requires user input or approval.",
+        "- Never use `node` kind effects.",
+        "- At least one defined task must be an `agent` task for the main work. Shell tasks are for concrete runnable commands only.",
+        "- Any task passed to `ctx.task(...)` must be a DefinedTask created via `defineTask(...)`; never pass plain object task definitions or ad-hoc task objects.",
+        "- Include quality gates and verification/refinement steps that fit the request.",
+        "- For this request, a good default is a process that plans the game scope, scaffolds the project, implements the game loop and UI, and verifies the result with runnable checks.",
+        "- Keep the module syntactically valid ESM. If you embed HTML/CSS/JS asset contents inside the process source, avoid raw nested template literals; prefer arrays joined with \"\\n\", String.raw, or escaped inner backticks and \\${...} sequences.",
+        "- Default every task to the internal agent-core worker. If task-level harness routing is needed, only use `task.metadata.harness` for explicit overrides to installed harness names from this list: "
+            + `${installedHarnessList}.`,
+        args.promptContext.selectedHarnessName
+            ? `- The selected orchestration harness for the session will be ${args.promptContext.selectedHarnessName}; keep ` + "`task.metadata.harness`" + " unset for default internal execution and only encode it when a task must explicitly override that default."
+            : "- No orchestration harness has been preselected; keep harness routing explicit only where it materially matters.",
+        "- Do not set `task.metadata.bashSandbox`, `task.metadata.isolated`, or `task.metadata.enableCompaction` for ordinary internal agent-core work. Leave them unset unless the task truly requires stronger guardrails or long-running compaction.",
+        "- External harnesses do not provide agent-core worker guardrails for their own tool execution. Keep security-sensitive shell work on the internal agent-core worker by using shell effects without routing them to an external harness.",
+        "",
+        "Output rules:",
+        `- Choose a descriptive kebab-case filename (e.g. "user-auth-tdd.mjs", "data-pipeline-setup.js") and write the file to the process output directory.`,
+        "- Return a short summary that confirms what you wrote and the final path.",
+        "- Do not rely on AskUserQuestion or babysitter_report_process_definition. Those tools are not available here.",
+        "- Do not return pseudocode, placeholders, or a plan without writing the file.",
+        ...(args.workspaceAssessment.kind === "empty" ? [emptyWorkspaceAuthoringGuide] : []),
+        "",
+        "Minimal shape reminder:",
+        "```javascript",
+        'import { defineTask } from "@a5c-ai/babysitter-sdk";',
+        "",
+        "export async function process(inputs, ctx) {",
+        "  // create and run tasks here",
+        "}",
+        "```",
+    ].join("\n");
+}
+function buildExternalProcessConformancePrompt(args) {
+    return [
+        "Edit one existing JavaScript workflow file so it conforms to the SDK API used by this repository.",
+        `Target file: ${path.resolve(args.outputPath)}`,
+        `Original user request: ${args.prompt}`,
+        "",
+        "Conformance requirements:",
+        "- Preserve the overall task pipeline and intent.",
+        "- Do not use web search or remote documentation. Fix the file using only the local file contents and the requirements in this prompt.",
+        "- Every task must be defined with `defineTask(\"task-id\", (args, taskCtx) => ({ ... }))`.",
+        "- Never use `defineTask({ ... })` or helper factories that hide the required signature.",
+        "- The module must orchestrate real work through those tasks; do not perform the main implementation directly in `process(inputs, ctx)`.",
+        "- Agent tasks must use `agent: { name, prompt, outputSchema }`.",
+        "- Every task returned from `defineTask(...)` must include a top-level `kind` field.",
+        "- Define at least one `agent` task for the main work. Use shell tasks only for concrete runnable commands.",
+        "- Put instructions inside `agent.prompt.task`, `agent.prompt.instructions`, and related prompt fields rather than top-level `instructions` fields.",
+        "- Agent tasks must use `kind: \"agent\"` with `agent: { name, prompt, outputSchema }`.",
+        "- Shell tasks must use `kind: \"shell\"` with `shell: { command: \"...\" }`.",
+        "- Do not introduce `kind: \"node\"` task definitions in generated or repaired processes. If logic would have been a node task, convert it to an `agent` or `skill` task instead.",
+        "- Any task passed to `ctx.task(...)` must be a DefinedTask created via `defineTask(...)`; do not pass plain object task definitions or ad-hoc task objects.",
+        "- The exported `process(inputs, ctx)` function must run tasks with `await ctx.task(definedTask, args)`; do not invent alternate task runners.",
+        "- Inside the named `process(inputs, ctx)` export, never reference Node's global process object as `process.*`; use `globalThis.process` or an imported alias like `nodeProcess` instead.",
+        "- If the process needs the workspace root, do not assume `ctx.workspaceDir` or `ctx.cwd` exists. Resolve it from the module location using `import.meta.url`, for example with `path.dirname(fileURLToPath(import.meta.url))`.",
+        "- Keep the file as ESM and preserve the target path.",
+        "- After editing, run `node --check` on the file.",
+        "",
+        "Return only a short summary of the changes and the validation result.",
+    ].join("\n");
+}
+function buildInternalProcessConformancePrompt(args) {
+    return [
+        "Repair the generated babysitter process file so it conforms to the SDK API expected by this repository.",
+        `Target file: ${path.resolve(args.outputPath)}`,
+        `Original user request: ${args.prompt}`,
+        `Validation error: ${args.validationError}`,
+        "",
+        "Repair requirements:",
+        "- Preserve the overall task pipeline and user intent.",
+        "- The module must export a named `async function process(inputs, ctx)`.",
+        '- Import `defineTask` from `@a5c-ai/babysitter-sdk`.',
+        "- Use `defineTask(\"task-id\", (args, taskCtx) => ({ ... }))` for task definitions.",
+        "- Do not use `defineTask({ ... })` or object-only process exports.",
+        "- The module must orchestrate real work through defined tasks instead of doing the main implementation directly in `process(inputs, ctx)`.",
+        "- Define at least one `agent` task for the main work. Use shell tasks only for concrete runnable commands.",
+        "- Every task returned from `defineTask(...)` must include a top-level `kind` field.",
+        "- Any task passed to `ctx.task(...)` must be a DefinedTask created via `defineTask(...)`; do not pass plain object task definitions or ad-hoc task objects.",
+        "- The rewritten module must be syntactically valid ESM and pass `node --check`.",
+        "- If the process writes HTML/CSS/JS assets, do not embed raw nested template literals inside outer template literals; prefer arrays joined with \"\\n\", String.raw, or escaped inner backticks and \\${...} sequences.",
+        "- Inside the named `process(inputs, ctx)` export, do not reference Node's global process object as `process.*`; use `globalThis.process` or an imported alias like `nodeProcess` instead.",
+        "- If the process needs the workspace root, do not assume `ctx.workspaceDir` or `ctx.cwd` exists. Resolve it from the module location using `import.meta.url`, for example with `path.dirname(fileURLToPath(import.meta.url))`.",
+        "- Agent tasks must use `kind: \"agent\"` with `agent: { name, prompt, outputSchema }`.",
+        "- Shell tasks must use `kind: \"shell\"` with `shell: { command: \"...\" }`.",
+        "- Do not introduce `kind: \"node\"` task definitions in generated or repaired processes. If logic would have been a node task, convert it to an `agent` or `skill` task instead.",
+        "- The exported `process(inputs, ctx)` function must call tasks with `await ctx.task(definedTask, args)`.",
+        "- Use the normal file tools to rewrite the process file at the target path in the output directory.",
+        "- After rewriting the file, call `babysitter_report_process_definition` exactly once with the same path.",
+        "- Do not answer with plain text only.",
+    ].join("\n");
+}
+async function assessWorkspaceForExternalAuthoring(workspace) {
+    const root = path.resolve(workspace ?? process.cwd());
+    try {
+        const entries = (await node_fs_1.promises.readdir(root))
+            .filter((entry) => entry !== "." && entry !== "..")
+            .sort();
+        return {
+            kind: entries.length === 0 ? "empty" : "non-empty",
+            entries: entries.slice(0, 12),
+        };
+    }
+    catch {
+        return {
+            kind: "empty",
+            entries: [],
+        };
+    }
+}

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

@@ -0,0 +1,18 @@
+import { type ProcessDefinitionReport } from "../utils";
+export declare function buildPhaseConversationSummary(outputs: string[]): string;
+export declare function applyRecoveredProcessDefinitionFromOutput(args: {
+    output: string;
+    processPath: string;
+}): Promise<boolean>;
+export declare function recoverReportedProcessDefinition(args: {
+    state: {
+        report?: ProcessDefinitionReport;
+    };
+    outputDir: string;
+    workspace?: string;
+    outputs: string[];
+    verbose: boolean;
+    json: boolean;
+}): Promise<ProcessDefinitionReport | undefined>;
+export declare function writeVerboseProcessDefinitionRecovery(json: boolean): void;
+//# sourceMappingURL=recovery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/planProcess/recovery.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,uBAAuB,EAE7B,MAAM,UAAU,CAAC;AA8FlB,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CASvE;AAyCD,wBAAsB,yCAAyC,CAAC,IAAI,EAAE;IACpE,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,OAAO,CAAC,CAUnB;AAED,wBAAsB,gCAAgC,CAAC,IAAI,EAAE;IAC3D,KAAK,EAAE;QAAE,MAAM,CAAC,EAAE,uBAAuB,CAAA;KAAE,CAAC;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;CACf,GAAG,OAAO,CAAC,uBAAuB,GAAG,SAAS,CAAC,CAe/C;AAED,wBAAgB,qCAAqC,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAIzE"}

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

@@ -0,0 +1,188 @@
+"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.buildPhaseConversationSummary = buildPhaseConversationSummary;
+exports.applyRecoveredProcessDefinitionFromOutput = applyRecoveredProcessDefinitionFromOutput;
+exports.recoverReportedProcessDefinition = recoverReportedProcessDefinition;
+exports.writeVerboseProcessDefinitionRecovery = writeVerboseProcessDefinitionRecovery;
+const path = __importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+const utils_1 = require("../utils");
+const paths_1 = require("./paths");
+function looksLikeProcessDefinitionSource(source) {
+    const normalized = source.trim();
+    if (!normalized) {
+        return false;
+    }
+    return (normalized.includes("defineTask(") ||
+        /export\s+async\s+function\s+process\s*\(/.test(normalized) ||
+        /export\s+default\s+async\s+function/.test(normalized) ||
+        /export\s*\{\s*process\s*\}/.test(normalized));
+}
+function extractProcessDefinitionCodeBlock(text) {
+    const codeBlockPattern = /```(?:javascript|js|mjs|ts)?\s*([\s\S]*?)```/gi;
+    let match;
+    let fallback = null;
+    while ((match = codeBlockPattern.exec(text)) !== null) {
+        const candidate = match[1]?.trim();
+        if (!candidate) {
+            continue;
+        }
+        if (looksLikeProcessDefinitionSource(candidate)) {
+            return candidate;
+        }
+        fallback ??= candidate;
+    }
+    return fallback;
+}
+function extractProcessDefinitionHeredoc(text) {
+    const heredocPattern = /<<-?\s*['"]?([A-Za-z_][A-Za-z0-9_]*)['"]?\r?\n([\s\S]*?)\r?\n\1\b/g;
+    let match;
+    let fallback = null;
+    while ((match = heredocPattern.exec(text)) !== null) {
+        const candidate = match[2]?.trim();
+        if (!candidate) {
+            continue;
+        }
+        if (looksLikeProcessDefinitionSource(candidate)) {
+            return candidate;
+        }
+        fallback ??= candidate;
+    }
+    return fallback;
+}
+function looksLikeStandaloneProcessDefinitionSource(source) {
+    const normalized = source.trim();
+    if (!looksLikeProcessDefinitionSource(normalized)) {
+        return false;
+    }
+    const suspiciousTranscriptMarkers = [
+        "to=bash",
+        "to=read",
+        "to=write",
+        "to=edit",
+        "\"stdout\":",
+        "\"stderr\":",
+        "\"exitCode\":",
+        "[phase",
+    ];
+    if (suspiciousTranscriptMarkers.some((marker) => normalized.includes(marker))) {
+        return false;
+    }
+    return /^(?:#!.*\r?\n)?(?:\s*\/\*\*[\s\S]*?\*\/\s*)?(?:import\s|const\s+\w+\s*=\s*defineTask\(|export\s+async\s+function\s+process\b|async\s+function\s+process\b)/.test(normalized);
+}
+function extractRecoverableProcessDefinitionSource(output) {
+    const codeBlock = extractProcessDefinitionCodeBlock(output);
+    if (codeBlock && looksLikeProcessDefinitionSource(codeBlock)) {
+        return codeBlock;
+    }
+    const heredoc = extractProcessDefinitionHeredoc(output);
+    if (heredoc && looksLikeProcessDefinitionSource(heredoc)) {
+        return heredoc;
+    }
+    return looksLikeStandaloneProcessDefinitionSource(output) ? output.trim() : null;
+}
+function buildPhaseConversationSummary(outputs) {
+    const trimmedOutputs = outputs
+        .map((output) => output.replace(/\s+/g, " ").trim())
+        .filter((output) => output.length > 0);
+    if (trimmedOutputs.length === 0) {
+        return "";
+    }
+    const joined = trimmedOutputs.slice(-3).join("\n\n---\n\n");
+    return joined.length > 4_000 ? `${joined.slice(0, 3_997)}...` : joined;
+}
+async function recoverProcessDefinitionFromOutputs(args) {
+    const resolvedDir = path.resolve(args.outputDir);
+    for (const output of args.outputs) {
+        for (const candidatePath of (0, paths_1.extractMentionedProcessPaths)(output, args.workspace)) {
+            try {
+                await (0, paths_1.waitForProcessFile)(candidatePath, 1_000);
+                return {
+                    processPath: candidatePath,
+                    summary: "Recovered process-definition output by using a path mentioned by the agent.",
+                };
+            }
+            catch {
+                // keep trying
+            }
+        }
+    }
+    for (const output of args.outputs) {
+        const extracted = extractRecoverableProcessDefinitionSource(output);
+        if (!extracted) {
+            continue;
+        }
+        const recoveredName = `recovered-process-${Date.now()}.mjs`;
+        const recoveredPath = path.join(resolvedDir, recoveredName);
+        await node_fs_1.promises.mkdir(resolvedDir, { recursive: true });
+        await node_fs_1.promises.writeFile(recoveredPath, extracted, "utf8");
+        return {
+            processPath: recoveredPath,
+            summary: "Recovered process-definition output by writing recoverable JavaScript source returned by the agent.",
+        };
+    }
+    return null;
+}
+async function applyRecoveredProcessDefinitionFromOutput(args) {
+    const extracted = extractRecoverableProcessDefinitionSource(args.output);
+    if (!extracted) {
+        return false;
+    }
+    const resolvedPath = path.resolve(args.processPath);
+    await node_fs_1.promises.mkdir(path.dirname(resolvedPath), { recursive: true });
+    await node_fs_1.promises.writeFile(resolvedPath, extracted, "utf8");
+    return true;
+}
+async function recoverReportedProcessDefinition(args) {
+    if (args.state.report?.processPath) {
+        return args.state.report;
+    }
+    const recovered = await recoverProcessDefinitionFromOutputs({
+        outputDir: args.outputDir,
+        workspace: args.workspace,
+        outputs: args.outputs,
+    });
+    if (recovered) {
+        args.state.report = recovered;
+        (0, utils_1.writeVerboseBlock)(args.verbose, args.json, "phasePlanProcess recovered report", recovered);
+    }
+    return recovered ?? undefined;
+}
+function writeVerboseProcessDefinitionRecovery(json) {
+    if (!json) {
+        process.stderr.write(`${utils_1.DIM}PhasePlanProcess recovery: the agent did not report the process file, retrying with an explicit write-and-report instruction...${utils_1.RESET}\n`);
+    }
+}

package/dist/harness/internal/createRun/planProcess/recovery.test.d.ts

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

package/dist/harness/internal/createRun/planProcess/recovery.test.d.ts.map

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

package/dist/harness/internal/createRun/planProcess/recovery.test.js

@@ -0,0 +1,68 @@
+"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 });
+const vitest_1 = require("vitest");
+const node_fs_1 = require("node:fs");
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const recovery_1 = require("./recovery");
+(0, vitest_1.describe)("recoverReportedProcessDefinition", () => {
+    const tempDirs = [];
+    (0, vitest_1.afterEach)(async () => {
+        await Promise.all(tempDirs.map(async (dir) => {
+            await node_fs_1.promises.rm(dir, { recursive: true, force: true });
+        }));
+        tempDirs.length = 0;
+    });
+    (0, vitest_1.it)("does not reuse unrelated preexisting process files from the output directory", async () => {
+        const workspace = await node_fs_1.promises.mkdtemp(path.join(os.tmpdir(), "plan-process-recovery-"));
+        tempDirs.push(workspace);
+        const outputDir = path.join(workspace, ".a5c", "processes");
+        const staleProcessPath = path.join(outputDir, "add-hook-discovery.js");
+        await node_fs_1.promises.mkdir(outputDir, { recursive: true });
+        await node_fs_1.promises.writeFile(staleProcessPath, 'export async function process() { return "stale"; }\n', "utf8");
+        const state = {};
+        const recovered = await (0, recovery_1.recoverReportedProcessDefinition)({
+            state,
+            outputDir,
+            workspace,
+            outputs: ["I thought about the process, but I did not write or report one."],
+            verbose: false,
+            json: false,
+        });
+        (0, vitest_1.expect)(recovered).toBeUndefined();
+        (0, vitest_1.expect)(state.report).toBeUndefined();
+    });
+});

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

@@ -0,0 +1,40 @@
+import { type OrchestrationState, type SessionBindResult, AgentCoreSessionHandle } from "../utils";
+type EnsureRunAndMaybeBindArgs = {
+    processPath: string;
+    prompt: string;
+    workspace?: string;
+    runsDir: string;
+    selectedHarnessName: string;
+    maxIterations: number;
+    interactive: boolean;
+    verbose: boolean;
+    json: boolean;
+    phaseSession?: AgentCoreSessionHandle | null;
+    state?: OrchestrationState;
+    requireBoundSession?: boolean;
+};
+export declare function ensureRunAndMaybeBindFromProcessDefinition(args: EnsureRunAndMaybeBindArgs): Promise<{
+    runId: string;
+    runDir: string;
+    sessionBound?: SessionBindResult;
+    createdRun: boolean;
+    boundSession: boolean;
+}>;
+export declare function createRunAndMaybeBindFromProcessDefinition(args: {
+    processPath: string;
+    prompt: string;
+    workspace?: string;
+    runsDir: string;
+    selectedHarnessName: string;
+    maxIterations: number;
+    interactive: boolean;
+    verbose: boolean;
+    json: boolean;
+    phaseSession: AgentCoreSessionHandle | null;
+}): Promise<{
+    runId: string;
+    runDir: string;
+    sessionBound?: SessionBindResult;
+}>;
+export {};
+//# sourceMappingURL=runState.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runState.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/planProcess/runState.ts"],"names":[],"mappings":"AAMA,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,sBAAsB,EACvB,MAAM,UAAU,CAAC;AAGlB,KAAK,yBAAyB,GAAG;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAC;IAC7C,KAAK,CAAC,EAAE,kBAAkB,CAAC;IAC3B,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AAoDF,wBAAsB,0CAA0C,CAC9D,IAAI,EAAE,yBAAyB,GAC9B,OAAO,CAAC;IACT,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC,CAiGD;AAED,wBAAsB,0CAA0C,CAAC,IAAI,EAAE;IACrE,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,sBAAsB,GAAG,IAAI,CAAC;CAC7C,GAAG,OAAO,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAClC,CAAC,CAGD"}