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

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

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOrchestrationTools = createOrchestrationTools;
+const typebox_1 = require("@sinclair/typebox");
+const agent_core_1 = require("@a5c-ai/agent-core");
+const internalToolsHelpers_1 = require("./internalToolsHelpers");
+const babysitter_sdk_1 = require("@a5c-ai/babysitter-sdk");
+const utils_1 = require("../utils");
+const resumeState_1 = require("../resumeState");
+const planProcess_1 = require("../planProcess");
+const effects_1 = require("./effects");
+const taskResult_1 = require("./taskResult");
+function createOrchestrationTools(args) {
+    const customTools = [
+        createRunIterateTool(args),
+        createTaskPostResultTool(args),
+        createFinishOrchestrationTool(args),
+    ];
+    const orchestrationAgenticTools = (0, agent_core_1.createAgentCoreToolDefinitions)({
+        workspace: args.phaseArgs.workspace ?? process.cwd(),
+        interactive: args.phaseArgs.interactive ?? false,
+        askUserQuestionHandler: async (params) => {
+            const response = await (0, utils_1.askUserQuestionViaTool)(params, args.phaseArgs.interactive, args.phaseArgs.rl, undefined);
+            args.state.lastAskUserQuestionResponse = response;
+            args.writeVerboseData("phaseOrchestration tool AskUserQuestion response", response);
+            return response;
+        },
+        taskHandler: async (params) => {
+            args.writeVerboseData("phaseOrchestration tool task request", params);
+            const delegated = await (0, planProcess_1.runDelegatedHarnessTask)({
+                ...params,
+                task: String(params.task ?? ""),
+                workspace: args.phaseArgs.workspace,
+                model: typeof params.model === "string"
+                    ? String(params.model)
+                    : args.phaseArgs.model,
+                customTools,
+            });
+            args.writeVerboseData("phaseOrchestration tool task result", delegated);
+            return delegated;
+        },
+        skillHandler: async (params) => {
+            args.writeVerboseData("phaseOrchestration tool skill request", params);
+            const delegated = await (0, planProcess_1.runDelegatedHarnessTask)({
+                ...params,
+                task: String(params.task ?? ""),
+                workspace: args.phaseArgs.workspace,
+                model: typeof params.model === "string"
+                    ? String(params.model)
+                    : args.phaseArgs.model,
+                skills: Array.isArray(params.skills)
+                    ? params.skills
+                    : undefined,
+                customTools,
+            });
+            args.writeVerboseData("phaseOrchestration tool skill result", delegated);
+            return delegated;
+        },
+    });
+    const mergedTools = wrapToolExecute([...customTools, ...orchestrationAgenticTools], args.writeVerbose);
+    const tools = mergedTools;
+    const iterateTool = tools.find((tool) => tool.name === "babysitter_run_iterate");
+    const finishTool = tools.find((tool) => tool.name === "babysitter_finish_orchestration");
+    return {
+        mergedTools,
+        iterateTool,
+        finishTool,
+        invokeTool: async (tool, name, params = {}) => {
+            if (!tool?.execute) {
+                throw new utils_1.BabysitterRuntimeError("MissingSessionCreateTool", `Required orchestration tool is unavailable: ${name}`, { category: utils_1.ErrorCategory.Internal });
+            }
+            args.writeVerboseData(`phaseOrchestration host invoke ${name} request`, params);
+            const result = tool.execute(`host-${name}`, params);
+            const resolved = await Promise.resolve(result);
+            args.writeVerboseData(`phaseOrchestration host invoke ${name} result`, resolved);
+            return resolved;
+        },
+    };
+}
+function createRunIterateTool(args) {
+    return {
+        name: "babysitter_run_iterate",
+        label: "Babysitter Run Iterate",
+        description: "Run the next orchestration iteration and return pending effects or a terminal result.",
+        parameters: typebox_1.Type.Object({}),
+        execute: async () => {
+            args.writeVerbose(`[phaseOrchestration tool babysitter_run_iterate request] runDir=${args.state.runDir ?? "(missing)"} nextIteration=${args.state.iteration + 1}`);
+            if (!args.state.runDir) {
+                throw new utils_1.BabysitterRuntimeError("RunNotCreated", "Create the run before iterating it.", { category: utils_1.ErrorCategory.Validation });
+            }
+            if (args.state.iteration >= args.phaseArgs.maxIterations) {
+                args.state.lastIterationResult = {
+                    status: "failed",
+                    error: { message: `Max iterations (${args.phaseArgs.maxIterations}) reached without completion` },
+                };
+                return (0, utils_1.formatToolResult)(args.state.lastIterationResult, "Iteration limit reached.");
+            }
+            args.state.iteration += 1;
+            args.state.pendingActions.clear();
+            args.state.pendingEffectResults.clear();
+            const result = await (0, effects_1.orchestrateIterationWithProcessLoadRetry)({
+                runDir: args.state.runDir,
+                writeVerbose: args.writeVerbose,
+                writeVerboseData: args.writeVerboseData,
+            });
+            args.state.lastIterationResult = result;
+            if (result.status === "waiting") {
+                for (const action of result.nextActions) {
+                    args.state.pendingActions.set(action.effectId, action);
+                }
+            }
+            let processErrorExtra = {};
+            if (result.status === "process-error") {
+                args.state.iteration -= 1;
+                processErrorExtra = {
+                    recoverable: true,
+                    hint: "The process code has a bug. Read the error and the process-authoring reference below, fix the process file, and call babysitter_run_iterate again.",
+                    processAuthoringReference: (0, babysitter_sdk_1.composeProcessCreatePrompt)((0, babysitter_sdk_1.createPromptContextFromCatalog)('pi', { interactive: false })),
+                };
+            }
+            return (0, utils_1.formatToolResult)({ iteration: args.state.iteration, ...result, ...processErrorExtra }, result.status === "process-error"
+                ? "Process error — fix the process code and retry iteration."
+                : "Iteration completed.");
+        },
+    };
+}
+function createTaskPostResultTool(args) {
+    return {
+        name: "babysitter_task_post_result",
+        label: "Babysitter Task Post Result",
+        description: "Persist a staged result, or post an explicit effect result payload after you fulfilled the work yourself.",
+        parameters: typebox_1.Type.Object({
+            effectId: typebox_1.Type.String(),
+            status: typebox_1.Type.Optional(typebox_1.Type.Union([typebox_1.Type.Literal("ok"), typebox_1.Type.Literal("error")])),
+            valueText: typebox_1.Type.Optional(typebox_1.Type.String()),
+            valueJson: typebox_1.Type.Optional(typebox_1.Type.String()),
+            error: typebox_1.Type.Optional(typebox_1.Type.String()),
+            stdout: typebox_1.Type.Optional(typebox_1.Type.String()),
+            stderr: typebox_1.Type.Optional(typebox_1.Type.String()),
+        }),
+        execute: async (_toolCallId, params) => {
+            const effectId = String(params.effectId ?? "");
+            args.writeVerboseData("phaseOrchestration tool babysitter_task_post_result request", params);
+            if (!args.state.runDir) {
+                throw new utils_1.BabysitterRuntimeError("RunNotCreated", "Create the run before posting task results.", { category: utils_1.ErrorCategory.Validation });
+            }
+            const action = args.state.pendingActions.get(effectId);
+            if (!action) {
+                throw new utils_1.BabysitterRuntimeError("PendingEffectNotFound", `No pending effect found for ${effectId}.`, { category: utils_1.ErrorCategory.Validation });
+            }
+            const startedAt = new Date().toISOString();
+            let effectResult = args.state.pendingEffectResults.get(effectId);
+            const status = (0, taskResult_1.coerceStatus)(params.status);
+            if (status) {
+                effectResult = (0, taskResult_1.applyExplicitEffectResult)({
+                    params,
+                    effectId,
+                    status,
+                    effectResult,
+                });
+            }
+            if (!effectResult && action.kind === "breakpoint") {
+                effectResult = (0, internalToolsHelpers_1.buildBreakpointEffectResult)(args, action);
+            }
+            if (!effectResult) {
+                throw new utils_1.BabysitterRuntimeError("EffectResultMissing", `No staged effect result exists for ${effectId}.`, { category: utils_1.ErrorCategory.Runtime });
+            }
+            const finishedAt = new Date().toISOString();
+            await (0, babysitter_sdk_1.commitEffectResult)({
+                runDir: args.state.runDir,
+                effectId: action.effectId,
+                invocationKey: action.invocationKey,
+                result: {
+                    status: effectResult.status,
+                    value: effectResult.value,
+                    error: effectResult.error,
+                    stdout: effectResult.stdout,
+                    stderr: effectResult.stderr,
+                    startedAt,
+                    finishedAt,
+                },
+            });
+            args.state.pendingActions.delete(effectId);
+            args.state.pendingEffectResults.delete(effectId);
+            if (action.kind === "breakpoint") {
+                args.state.lastAskUserQuestionResponse = undefined;
+            }
+            return (0, utils_1.formatToolResult)({ effectId, status: effectResult.status }, "Task result posted.");
+        },
+    };
+}
+function createFinishOrchestrationTool(args) {
+    return {
+        name: "babysitter_finish_orchestration",
+        label: "Finish Orchestration",
+        description: "Report that the orchestration phase has reached a terminal state.",
+        parameters: typebox_1.Type.Object({
+            summary: typebox_1.Type.Optional(typebox_1.Type.String()),
+        }),
+        execute: async (_toolCallId, params) => {
+            args.writeVerboseData("phaseOrchestration tool babysitter_finish_orchestration", params);
+            if (args.state.pendingActions.size > 0) {
+                return (0, utils_1.formatToolResult)({
+                    complete: false,
+                    nextStep: "Resolve and post all pending effects before finishing orchestration.",
+                    pendingEffects: args.describePendingActions(),
+                }, "The run is not complete yet. Resolve the pending effects first.");
+            }
+            if (!args.state.runDir) {
+                return (0, utils_1.formatToolResult)({
+                    complete: false,
+                    nextStep: "Establish the run context before attempting to finish orchestration.",
+                }, "The run has not been created yet.");
+            }
+            const assessed = await (0, resumeState_1.assessRun)(args.state.runDir);
+            if (assessed.run.status !== "completed" && assessed.run.status !== "failed") {
+                const lastStatus = args.state.lastIterationResult?.status;
+                const nextStep = lastStatus === "process-error"
+                    ? "Fix the process code, save it, and call babysitter_run_iterate again."
+                    : assessed.run.status === "waiting"
+                        ? "Keep iterating and resolve the pending effects reported by the run."
+                        : "Keep iterating the run until the journal records RUN_COMPLETED or RUN_FAILED.";
+                return (0, utils_1.formatToolResult)({
+                    complete: false,
+                    nextStep,
+                    runStatus: assessed.run.status,
+                    journalLength: assessed.journalLength,
+                    lastEvent: assessed.lastEvent,
+                    pendingEffects: assessed.run.pendingEffects,
+                    lastIterationResult: args.state.lastIterationResult,
+                }, "The active run is not terminal yet.");
+            }
+            args.state.finished = {
+                summary: typeof params.summary === "string" ? params.summary : undefined,
+            };
+            return (0, utils_1.formatToolResult)(args.state.finished, "Orchestration finish recorded.");
+        },
+    };
+}
+function wrapToolExecute(rawTools, writeVerbose) {
+    return rawTools.map((tool) => {
+        const typedTool = tool;
+        const originalExecute = typedTool.execute;
+        if (typeof originalExecute !== "function") {
+            return tool;
+        }
+        return {
+            ...typedTool,
+            execute: async (...params) => {
+                try {
+                    return await originalExecute(...params);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    writeVerbose(`[phaseOrchestration tool ${String(typedTool.name)}] caught error: ${message}`);
+                    return (0, utils_1.formatToolResult)({ error: message, toolName: String(typedTool.name) }, `Tool error: ${message}`);
+                }
+            },
+        };
+    });
+}
+// buildBreakpointEffectResult extracted to internalToolsHelpers.ts

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

@@ -0,0 +1,17 @@
+/**
+ * Helper functions for internal tools.
+ * Extracted from internalTools.ts for max-lines compliance.
+ */
+import { type OrchestrationState } from "../utils";
+import type { RunOrchestrationPhaseArgs } from "./types";
+interface PendingEffectResult {
+    status: "ok" | "error";
+    value?: unknown;
+    error?: string;
+}
+export declare function buildBreakpointEffectResult(args: {
+    phaseArgs: RunOrchestrationPhaseArgs;
+    state: OrchestrationState;
+}, action: OrchestrationState["pendingActions"] extends Map<string, infer T> ? T : never): PendingEffectResult;
+export {};
+//# sourceMappingURL=internalToolsHelpers.d.ts.map

package/dist/harness/internal/createRun/orchestration/internalToolsHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalToolsHelpers.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/orchestration/internalToolsHelpers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAKL,KAAK,kBAAkB,EACxB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEzD,UAAU,mBAAmB;IAC3B,MAAM,EAAE,IAAI,GAAG,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE;IACJ,SAAS,EAAE,yBAAyB,CAAC;IACrC,KAAK,EAAE,kBAAkB,CAAC;CAC3B,EACD,MAAM,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,GACpF,mBAAmB,CAqBrB"}

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

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Helper functions for internal tools.
+ * Extracted from internalTools.ts for max-lines compliance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBreakpointEffectResult = buildBreakpointEffectResult;
+const utils_1 = require("../utils");
+function buildBreakpointEffectResult(args, action) {
+    if (args.phaseArgs.interactive && !args.state.lastAskUserQuestionResponse) {
+        throw new utils_1.BabysitterRuntimeError("InteractiveBreakpointDecisionMissing", "Interactive breakpoint results require AskUserQuestion before babysitter_task_post_result.", { category: utils_1.ErrorCategory.Runtime });
+    }
+    const question = action.taskDef?.question
+        ?? action.taskDef?.title
+        ?? "Breakpoint reached. Continue?";
+    const askResponse = args.state.lastAskUserQuestionResponse
+        ?? (0, utils_1.createAskUserQuestionResponse)((0, utils_1.createApprovalAskUserQuestion)(question), { Decision: "Approve" });
+    const option = askResponse.answers.Decision ?? "Approve";
+    return {
+        status: "ok",
+        value: { approved: option === "Approve", option, askUserQuestion: askResponse },
+    };
+}

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

@@ -0,0 +1,10 @@
+import { type OrchestrationState } from "../utils";
+export type PendingEffectResult = OrchestrationState["pendingEffectResults"] extends Map<string, infer T> ? T : never;
+export declare function applyExplicitEffectResult(args: {
+    params: Record<string, unknown>;
+    effectId: string;
+    status: "ok" | "error";
+    effectResult: PendingEffectResult | undefined;
+}): PendingEffectResult;
+export declare function coerceStatus(value: unknown): "ok" | "error" | undefined;
+//# sourceMappingURL=taskResult.d.ts.map

package/dist/harness/internal/createRun/orchestration/taskResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskResult.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/orchestration/taskResult.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,UAAU,CAAC;AAElB,MAAM,MAAM,mBAAmB,GAAG,kBAAkB,CAAC,sBAAsB,CAAC,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACrG,CAAC,GACD,KAAK,CAAC;AAEV,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,IAAI,GAAG,OAAO,CAAC;IACvB,YAAY,EAAE,mBAAmB,GAAG,SAAS,CAAC;CAC/C,GAAG,mBAAmB,CAwDtB;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,GAAG,SAAS,CAEvE"}

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyExplicitEffectResult = applyExplicitEffectResult;
+exports.coerceStatus = coerceStatus;
+const utils_1 = require("../utils");
+function applyExplicitEffectResult(args) {
+    const explicitValueProvided = args.params.valueJson !== undefined || args.params.valueText !== undefined;
+    const explicitValue = explicitValueProvided
+        ? parseExplicitToolResultValue({
+            valueJson: typeof args.params.valueJson === "string" ? args.params.valueJson : undefined,
+            valueText: typeof args.params.valueText === "string" ? args.params.valueText : undefined,
+        })
+        : undefined;
+    const hasExplicitPayload = explicitValueProvided
+        || args.params.error !== undefined
+        || args.params.stdout !== undefined
+        || args.params.stderr !== undefined;
+    if (!args.effectResult || hasExplicitPayload) {
+        const nextValue = explicitValueProvided ? explicitValue : args.effectResult?.value;
+        if (args.status === "ok" && nextValue === undefined) {
+            throw new utils_1.BabysitterRuntimeError("EffectResultValueMissing", `Explicit ok result for ${args.effectId} is missing a value payload.`, { category: utils_1.ErrorCategory.Validation });
+        }
+        return {
+            status: args.status,
+            value: nextValue,
+            error: args.status === "error"
+                ? new Error(typeof args.params.error === "string"
+                    ? args.params.error
+                    : args.effectResult?.error instanceof Error
+                        ? args.effectResult.error.message
+                        : "Effect failed")
+                : undefined,
+            stdout: typeof args.params.stdout === "string" ? args.params.stdout : args.effectResult?.stdout,
+            stderr: typeof args.params.stderr === "string" ? args.params.stderr : args.effectResult?.stderr,
+        };
+    }
+    if (args.status !== args.effectResult.status) {
+        return {
+            ...args.effectResult,
+            status: args.status,
+            error: args.status === "error"
+                ? new Error(typeof args.params.error === "string"
+                    ? args.params.error
+                    : args.effectResult.error instanceof Error
+                        ? args.effectResult.error.message
+                        : "Effect failed")
+                : undefined,
+        };
+    }
+    return args.effectResult;
+}
+function coerceStatus(value) {
+    return value === "ok" || value === "error" ? value : undefined;
+}
+function parseExplicitToolResultValue(args) {
+    if (typeof args.valueJson === "string" && args.valueJson.trim().length > 0) {
+        try {
+            return JSON.parse(args.valueJson);
+        }
+        catch (error) {
+            throw new utils_1.BabysitterRuntimeError("InvalidToolResultValueJson", error instanceof Error
+                ? `valueJson is not valid JSON: ${error.message}`
+                : "valueJson is not valid JSON", { category: utils_1.ErrorCategory.Validation });
+        }
+    }
+    return typeof args.valueText === "string" ? args.valueText : undefined;
+}

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

@@ -0,0 +1,46 @@
+import * as readline from "node:readline";
+import type { CompressionConfig, HarnessDiscoveryResult, HarnessPromptContext as SessionCreatePromptContext, OrchestrationState, OutputMode } from "../utils";
+import type { SessionBindResult } from "../../../types";
+export type RunOrchestrationPhaseArgs = {
+    invocationCommand?: string;
+    processPath: string;
+    prompt?: string;
+    workspace?: string;
+    model?: string;
+    runsDir: string;
+    maxIterations: number;
+    json: boolean;
+    verbose: boolean;
+    interactive: boolean;
+    rl: readline.Interface | null;
+    selectedHarnessName: string;
+    discovered: HarnessDiscoveryResult[];
+    compressionConfig: CompressionConfig | null;
+    promptContext: SessionCreatePromptContext;
+    existingRunId?: string;
+    existingRunDir?: string;
+    existingSessionBound?: SessionBindResult;
+    planningConversationSummary?: string;
+    outputMode?: OutputMode;
+};
+export type OrchestrationWriteVerbose = (message: string) => void;
+export type OrchestrationWriteVerboseData = (label: string, value: unknown, maxChars?: number) => void;
+export type OrchestrationLoggers = {
+    writeVerbose: OrchestrationWriteVerbose;
+    writeVerboseData: OrchestrationWriteVerboseData;
+};
+export type OrchestrationProgressSnapshot = {
+    runId?: string;
+    runDir?: string;
+    sessionBound: boolean;
+    iteration: number;
+    pendingActionIds: string;
+    pendingResultIds: string;
+    lastStatus?: OrchestrationState["lastIterationResult"] extends {
+        status: infer T;
+    } | undefined ? T : never;
+    hasAskUserQuestionResponse: boolean;
+    finished: boolean;
+    processFileFingerprint?: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/harness/internal/createRun/orchestration/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/orchestration/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EACV,iBAAiB,EACjB,sBAAsB,EACtB,oBAAoB,IAAI,0BAA0B,EAClD,kBAAkB,EAClB,UAAU,EACX,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,MAAM,MAAM,yBAAyB,GAAG;IACtC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,EAAE,EAAE,QAAQ,CAAC,SAAS,GAAG,IAAI,CAAC;IAC9B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,UAAU,EAAE,sBAAsB,EAAE,CAAC;IACrC,iBAAiB,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC5C,aAAa,EAAE,0BAA0B,CAAC;IAC1C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oBAAoB,CAAC,EAAE,iBAAiB,CAAC;IACzC,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAElE,MAAM,MAAM,6BAA6B,GAAG,CAC1C,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,OAAO,EACd,QAAQ,CAAC,EAAE,MAAM,KACd,IAAI,CAAC;AAEV,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,EAAE,yBAAyB,CAAC;IACxC,gBAAgB,EAAE,6BAA6B,CAAC;CACjD,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,kBAAkB,CAAC,qBAAqB,CAAC,SAClD;QAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,GACnB,SAAS,GACT,CAAC,GACD,KAAK,CAAC;IACV,0BAA0B,EAAE,OAAO,CAAC;IACpC,QAAQ,EAAE,OAAO,CAAC;IAClB,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC,CAAC"}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,7 @@
+import { AgentCoreSessionHandle, type OutputMode } from "../utils";
+export declare function subscribeVerbosePiEvents(session: AgentCoreSessionHandle, label: string, opts: {
+    verbose: boolean;
+    json: boolean;
+    outputMode?: OutputMode;
+}): (() => void) | null;
+//# sourceMappingURL=verbose.d.ts.map

package/dist/harness/internal/createRun/orchestration/verbose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verbose.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/orchestration/verbose.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,sBAAsB,EAEtB,KAAK,UAAU,EAEhB,MAAM,UAAU,CAAC;AAElB,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,sBAAsB,EAC/B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,UAAU,CAAA;CAAE,GACjE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CA4HrB"}