agent-cli-runtime 0.1.0-alpha.0

package/dist/detection/env.js

@@ -0,0 +1,15 @@
+import { delimiter } from "node:path";
+export function pathDirs(env, extraSearchPath = []) {
+    const seen = new Set();
+    const dirs = [...extraSearchPath, ...(env.PATH ?? "").split(delimiter)].filter(Boolean);
+    return dirs.filter((dir) => {
+        if (seen.has(dir))
+            return false;
+        seen.add(dir);
+        return true;
+    });
+}
+export function mergeEnv(...envs) {
+    return Object.assign({}, ...envs.filter(Boolean));
+}
+//# sourceMappingURL=env.js.map

package/dist/detection/env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.js","sourceRoot":"","sources":["../../src/detection/env.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC,MAAM,UAAU,QAAQ,CAAC,GAAsB,EAAE,kBAA4B,EAAE;IAC7E,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,IAAI,GAAG,CAAC,GAAG,eAAe,EAAE,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACxF,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE;QACzB,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,OAAO,KAAK,CAAC;QAChC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACd,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,GAAG,IAA+E;IACzG,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;AACpD,CAAC"}

package/dist/detection/executable-resolution.d.ts

@@ -0,0 +1,12 @@
+import type { AgentAdapterDef } from "../adapters/adapter-types.js";
+export interface ExecutableResolutionOptions {
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    searchPath?: string[];
+}
+export interface ExecutableResolution {
+    configuredOverridePath: string | null;
+    pathResolvedPath: string | null;
+    selectedPath: string | null;
+    searchedLocations: string[];
+}
+export declare function resolveExecutable(adapter: AgentAdapterDef, options?: ExecutableResolutionOptions): ExecutableResolution;

package/dist/detection/executable-resolution.js

@@ -0,0 +1,50 @@
+import { accessSync, constants, existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { pathDirs } from "./env.js";
+export function resolveExecutable(adapter, options = {}) {
+    const env = options.env ?? process.env;
+    const configuredOverridePath = adapter.binEnvVar ? executablePath(env[adapter.binEnvVar]) : null;
+    const candidates = [adapter.bin, ...(adapter.fallbackBins ?? [])];
+    const searchedLocations = [];
+    let pathResolvedPath = null;
+    for (const dir of pathDirs(env, options.searchPath)) {
+        for (const candidate of candidates) {
+            for (const ext of executableExtensions()) {
+                const full = path.join(dir, `${candidate}${ext}`);
+                searchedLocations.push(full);
+                if (!pathResolvedPath && executablePath(full))
+                    pathResolvedPath = full;
+            }
+        }
+    }
+    return {
+        configuredOverridePath,
+        pathResolvedPath,
+        selectedPath: configuredOverridePath ?? pathResolvedPath,
+        searchedLocations,
+    };
+}
+function executablePath(raw) {
+    if (typeof raw !== "string" || raw.trim() === "")
+        return null;
+    const candidate = raw.trim();
+    if (!path.isAbsolute(candidate))
+        return null;
+    try {
+        if (!existsSync(candidate) || !statSync(candidate).isFile())
+            return null;
+        if (process.platform === "win32")
+            return candidate;
+        accessSync(candidate, constants.X_OK);
+        return candidate;
+    }
+    catch {
+        return null;
+    }
+}
+function executableExtensions() {
+    if (process.platform !== "win32")
+        return [""];
+    return (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").map((ext) => ext.toLowerCase());
+}
+//# sourceMappingURL=executable-resolution.js.map

package/dist/detection/executable-resolution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executable-resolution.js","sourceRoot":"","sources":["../../src/detection/executable-resolution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtE,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAcpC,MAAM,UAAU,iBAAiB,CAAC,OAAwB,EAAE,UAAuC,EAAE;IACnG,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC;IACvC,MAAM,sBAAsB,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACjG,MAAM,UAAU,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,OAAO,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC,CAAC;IAClE,MAAM,iBAAiB,GAAa,EAAE,CAAC;IACvC,IAAI,gBAAgB,GAAkB,IAAI,CAAC;IAC3C,KAAK,MAAM,GAAG,IAAI,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;QACpD,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,KAAK,MAAM,GAAG,IAAI,oBAAoB,EAAE,EAAE,CAAC;gBACzC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,GAAG,GAAG,EAAE,CAAC,CAAC;gBAClD,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAC7B,IAAI,CAAC,gBAAgB,IAAI,cAAc,CAAC,IAAI,CAAC;oBAAE,gBAAgB,GAAG,IAAI,CAAC;YACzE,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO;QACL,sBAAsB;QACtB,gBAAgB;QAChB,YAAY,EAAE,sBAAsB,IAAI,gBAAgB;QACxD,iBAAiB;KAClB,CAAC;AACJ,CAAC;AAED,SAAS,cAAc,CAAC,GAAY;IAClC,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IAC9D,MAAM,SAAS,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;IAC7B,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7C,IAAI,CAAC;QACH,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE;YAAE,OAAO,IAAI,CAAC;QACzE,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO;YAAE,OAAO,SAAS,CAAC;QACnD,UAAU,CAAC,SAAS,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QACtC,OAAO,SAAS,CAAC;IACnB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,SAAS,oBAAoB;IAC3B,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO;QAAE,OAAO,CAAC,EAAE,CAAC,CAAC;IAC9C,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,IAAI,gBAAgB,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC;AAC9F,CAAC"}

package/dist/detection/invocation.d.ts

@@ -0,0 +1,9 @@
+export interface ProbeResult {
+    stdout: string;
+    stderr: string;
+    cwd: string;
+}
+export declare function execProbe(command: string, args: string[], options?: {
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+}): Promise<ProbeResult>;

package/dist/detection/invocation.js

@@ -0,0 +1,22 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFileP = promisify(execFile);
+export async function execProbe(command, args, options = {}) {
+    const cwd = await mkdtemp(path.join(os.tmpdir(), "agent-runtime-probe-"));
+    try {
+        const { stdout, stderr } = await execFileP(command, args, {
+            cwd,
+            env: options.env,
+            timeout: options.timeoutMs ?? 3_000,
+            maxBuffer: 8 * 1024 * 1024,
+        });
+        return { stdout: String(stdout), stderr: String(stderr), cwd };
+    }
+    finally {
+        await rm(cwd, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=invocation.js.map

package/dist/detection/invocation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invocation.js","sourceRoot":"","sources":["../../src/detection/invocation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC,MAAM,SAAS,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;AAQtC,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,OAAe,EAAE,IAAc,EAAE,UAA2D,EAAE;IAC5H,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,sBAAsB,CAAC,CAAC,CAAC;IAC1E,IAAI,CAAC;QACH,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE;YACxD,GAAG;YACH,GAAG,EAAE,OAAO,CAAC,GAAG;YAChB,OAAO,EAAE,OAAO,CAAC,SAAS,IAAI,KAAK;YACnC,SAAS,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI;SAC3B,CAAC,CAAC;QACH,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC;IACjE,CAAC;YAAS,CAAC;QACT,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IAClD,CAAC;AACH,CAAC"}

package/dist/goals/goal-scheduler.d.ts

@@ -0,0 +1,31 @@
+import { GoalStore } from "./goal-store.js";
+import type { CreateGoalRequest, GoalHandle } from "./goal-types.js";
+import type { RunScheduler } from "../runs/run-scheduler.js";
+export declare class GoalScheduler {
+    private readonly runScheduler;
+    private readonly store;
+    private readonly options;
+    private readonly currentRuns;
+    private readonly cancelRequested;
+    constructor(runScheduler: RunScheduler, store?: GoalStore, options?: {
+        maxConcurrentTasks?: number;
+    });
+    createGoal(request: CreateGoalRequest): Promise<GoalHandle>;
+    cancelGoal(goalId: string): Promise<void>;
+    shutdown(reason?: string, graceMs?: number): Promise<void>;
+    private execute;
+    private runReadyQueue;
+    private runTask;
+    private runTaskAttempt;
+    private runAndCollectText;
+    private cancelPending;
+    private cancelPendingExceptBlocked;
+    private cancelPendingFromStore;
+    private blockDependents;
+    private blockUnavailableDependents;
+    private setCurrentRun;
+    private clearCurrentRun;
+    private cancelCurrentRuns;
+    private updateAttemptEvidence;
+    private finish;
+}

package/dist/goals/goal-scheduler.js

@@ -0,0 +1,518 @@
+import { GoalStore } from "./goal-store.js";
+import { createPlannerPrompt, createTaskPrompt } from "./planner-prompts.js";
+import { parsePlannerOutput, TaskGraphError, validateTaskGraph } from "./task-graph.js";
+import { runValidationCommands } from "./validation-runner.js";
+import { diagnostic } from "../core/diagnostics.js";
+export class GoalScheduler {
+    runScheduler;
+    store;
+    options;
+    currentRuns = new Map();
+    cancelRequested = new Set();
+    constructor(runScheduler, store = new GoalStore(), options = {}) {
+        this.runScheduler = runScheduler;
+        this.store = store;
+        this.options = options;
+    }
+    async createGoal(request) {
+        const goal = this.store.create(request);
+        const events = this.store.events(goal.id);
+        const handle = {
+            goalId: goal.id,
+            events,
+            cancel: async () => this.cancelGoal(goal.id),
+        };
+        void this.execute(goal.id, request).catch((error) => {
+            if (this.store.isTerminal(goal.id))
+                return;
+            if (this.cancelRequested.has(goal.id)) {
+                this.cancelPendingFromStore(goal.id);
+                this.finish(goal.id, { result: "cancelled", reason: "canceled", errorCode: "AGENT_CANCELLED" });
+                return;
+            }
+            const code = error instanceof TaskGraphError ? error.code : "AGENT_EXECUTION_FAILED";
+            this.store.emit(goal.id, {
+                type: "scheduler_error",
+                code,
+                message: error instanceof Error ? error.message : String(error),
+                retryable: false,
+            });
+            this.finish(goal.id, { result: "failed", reason: terminalReasonFromErrorCode(code), errorCode: code });
+        });
+        return handle;
+    }
+    async cancelGoal(goalId) {
+        this.cancelRequested.add(goalId);
+        this.cancelPendingFromStore(goalId);
+        await this.cancelCurrentRuns(goalId);
+    }
+    async shutdown(reason = "Runtime shutdown", graceMs = 2_000) {
+        const goalIds = this.store.list({ status: "active" }).map((goal) => goal.id);
+        await Promise.all(goalIds.map((goalId) => this.cancelGoal(goalId)));
+        await Promise.race([
+            waitFor(() => goalIds.every((goalId) => this.store.isTerminal(goalId))),
+            delay(graceMs),
+        ]);
+        for (const goalId of goalIds) {
+            if (this.store.isTerminal(goalId))
+                continue;
+            this.store.emit(goalId, {
+                type: "scheduler_error",
+                code: "AGENT_CANCELLED",
+                message: reason,
+                retryable: false,
+            });
+            this.cancelPendingFromStore(goalId);
+            this.finish(goalId, { result: "cancelled", reason: "canceled", errorCode: "AGENT_CANCELLED" });
+        }
+    }
+    async execute(goalId, request) {
+        this.store.emit(goalId, { type: "goal_started", goalId, objective: request.objective });
+        if (this.store.isTerminal(goalId))
+            return;
+        const plannerText = await this.runAndCollectText(goalId, undefined, {
+            agentId: request.plannerAgentId ?? request.defaultAgentId,
+            cwd: request.cwd,
+            prompt: createPlannerPrompt(request),
+            permissionPolicy: request.permissionPolicy,
+            model: request.model,
+            reasoning: request.reasoning,
+            contextBlocks: request.contextBlocks,
+            env: request.env,
+            timeoutMs: request.timeoutMs,
+        });
+        if (this.cancelRequested.has(goalId))
+            return this.finish(goalId, { result: "cancelled", reason: "canceled", errorCode: "AGENT_CANCELLED" });
+        const tasks = validateTaskGraph(parsePlannerOutput(plannerText), request);
+        this.store.setTasks(goalId, tasks);
+        for (const task of tasks)
+            this.store.emit(goalId, { type: "task_created", goalId, task });
+        if (this.store.isTerminal(goalId))
+            return;
+        this.store.setStatus(goalId, "running");
+        if (this.store.isTerminal(goalId))
+            return;
+        const outcome = await this.runReadyQueue(goalId, request, tasks);
+        this.finish(goalId, outcome);
+    }
+    async runReadyQueue(goalId, request, tasks) {
+        const maxConcurrentTasks = normalizeMaxConcurrentTasks(request.maxConcurrentTasks ?? this.options.maxConcurrentTasks);
+        const running = new Map();
+        let terminalOutcome = { result: "success", reason: "success" };
+        let stopScheduling = false;
+        const launchReady = () => {
+            while (!stopScheduling && !this.cancelRequested.has(goalId) && running.size < maxConcurrentTasks) {
+                const task = tasks.find((candidate) => candidate.status === "pending" && dependenciesSucceeded(candidate, tasks));
+                if (!task)
+                    return;
+                task.status = "running";
+                this.store.updateTask(goalId, task);
+                const promise = this.runTask(goalId, request, task)
+                    .then((outcome) => ({ task, outcome }));
+                running.set(task.id, promise);
+            }
+        };
+        while (true) {
+            if (this.cancelRequested.has(goalId)) {
+                terminalOutcome = { result: "cancelled", reason: "canceled", errorCode: "AGENT_CANCELLED" };
+                stopScheduling = true;
+                this.cancelPending(goalId, tasks);
+                await this.cancelCurrentRuns(goalId);
+            }
+            launchReady();
+            if (running.size === 0) {
+                this.blockUnavailableDependents(goalId, tasks);
+                if (tasks.every((task) => task.status !== "pending" && task.status !== "running"))
+                    break;
+                const hasReady = tasks.some((task) => task.status === "pending" && dependenciesSucceeded(task, tasks));
+                if (!hasReady) {
+                    for (const task of tasks) {
+                        if (task.status === "pending") {
+                            task.status = "blocked";
+                            this.store.updateTask(goalId, task);
+                        }
+                    }
+                    if (terminalOutcome.result === "success")
+                        terminalOutcome = { result: "failed", reason: "failed" };
+                    break;
+                }
+            }
+            if (running.size === 0)
+                continue;
+            const settled = await Promise.race(running.values());
+            running.delete(settled.task.id);
+            if (settled.outcome.result === "failed")
+                terminalOutcome = settled.outcome;
+            if (settled.outcome.result === "cancelled" && terminalOutcome.result !== "failed")
+                terminalOutcome = settled.outcome;
+            if (settled.outcome.result !== "success" && !request.continueOnFailure) {
+                stopScheduling = true;
+                if (settled.outcome.result === "failed") {
+                    this.blockDependents(goalId, tasks, settled.task.id);
+                    this.cancelPendingExceptBlocked(goalId, tasks);
+                    await this.cancelCurrentRuns(goalId);
+                }
+                else {
+                    this.cancelPending(goalId, tasks);
+                    await this.cancelCurrentRuns(goalId);
+                }
+            }
+            else if (settled.outcome.result !== "success") {
+                this.blockDependents(goalId, tasks, settled.task.id);
+            }
+        }
+        if (terminalOutcome.result === "success" && tasks.some((task) => task.status === "failed" || task.status === "blocked")) {
+            return { result: "failed", reason: "failed" };
+        }
+        if (terminalOutcome.result === "success" && tasks.some((task) => task.status === "canceled")) {
+            return { result: "cancelled", reason: "canceled", errorCode: "AGENT_CANCELLED" };
+        }
+        return terminalOutcome;
+    }
+    async runTask(goalId, request, task) {
+        const retryPolicy = normalizeRetryPolicy(task.retryPolicy ?? request.retryPolicy);
+        const attempts = task.evidence?.attempts ? [...task.evidence.attempts] : [];
+        let finalResult = "failed";
+        let finalReason = "failed";
+        let validationResults = [];
+        let lastErrorCode;
+        for (let attemptNumber = 1; attemptNumber <= retryPolicy.maxAttempts; attemptNumber += 1) {
+            if (this.cancelRequested.has(goalId)) {
+                finalResult = "cancelled";
+                break;
+            }
+            const attempt = await this.runTaskAttempt(goalId, request, task, attemptNumber, attempts);
+            finalResult = attempt.result;
+            finalReason = attempt.reason;
+            lastErrorCode = attempt.errorCode;
+            if (attempt.result === "success" && task.validationCommands?.length) {
+                validationResults = await runValidationCommands({
+                    commands: task.validationCommands,
+                    cwd: task.cwd,
+                    env: request.env,
+                    timeoutMs: request.validationTimeoutMs,
+                });
+                const failedValidation = validationResults.find((validation) => !validation.passed);
+                if (failedValidation) {
+                    finalResult = "failed";
+                    finalReason = failedValidation.classification === "timeout" ? "timeout" : "validation_failed";
+                    lastErrorCode = failedValidation.classification === "timeout" ? "AGENT_TIMEOUT" : "AGENT_EXECUTION_FAILED";
+                    attempt.evidence.result = "failed";
+                    attempt.evidence.diagnostics = [
+                        ...attempt.evidence.diagnostics,
+                        diagnostic(lastErrorCode, `Task ${task.id} validation ${failedValidation.classification}.`, {
+                            retryable: isRetryable(lastErrorCode, retryPolicy),
+                            exitCode: failedValidation.exitCode,
+                            signal: failedValidation.signal,
+                        }),
+                    ];
+                    this.updateAttemptEvidence(goalId, task, attempts, attempt.evidence, finalResult, validationResults);
+                }
+            }
+            const retryable = !this.cancelRequested.has(goalId)
+                && finalResult !== "success"
+                && attemptNumber < retryPolicy.maxAttempts
+                && isRetryable(lastErrorCode, retryPolicy);
+            this.store.emit(goalId, {
+                type: "task_attempt_finished",
+                goalId,
+                taskId: task.id,
+                attemptId: attempt.evidence.attemptId,
+                attemptNumber,
+                runId: attempt.evidence.runId,
+                result: finalResult,
+                retryable,
+                reason: finalReason,
+                errorCode: lastErrorCode,
+            });
+            if (!retryable)
+                break;
+            if (retryPolicy.backoffMs > 0)
+                await delay(retryPolicy.backoffMs);
+        }
+        if (this.cancelRequested.has(goalId)) {
+            finalResult = "cancelled";
+            finalReason = "canceled";
+            lastErrorCode = "AGENT_CANCELLED";
+        }
+        task.status = finalResult === "success" ? "succeeded" : finalResult === "cancelled" ? "canceled" : "failed";
+        task.evidence = {
+            runId: task.evidence?.runId,
+            result: finalResult,
+            attempts,
+            validationCommands: task.validationCommands ?? [],
+            validationResults,
+            summary: evidenceSummary(task.id, finalResult, attempts, validationResults),
+        };
+        this.store.updateTask(goalId, task);
+        if (!this.store.isTerminal(goalId)) {
+            this.store.emit(goalId, { type: "task_finished", goalId, taskId: task.id, result: finalResult, reason: finalReason, errorCode: lastErrorCode });
+        }
+        return { result: finalResult, reason: finalReason, errorCode: lastErrorCode };
+    }
+    async runTaskAttempt(goalId, request, task, attemptNumber, attempts) {
+        let result = "failed";
+        let runRecord = null;
+        const prompt = createTaskPrompt(request.objective, task);
+        const handle = await this.runScheduler.startRun({
+            agentId: task.agentId ?? request.defaultAgentId,
+            cwd: request.cwd,
+            prompt,
+            permissionPolicy: task.permissionPolicy,
+            model: request.model,
+            reasoning: request.reasoning,
+            env: request.env,
+            timeoutMs: request.taskTimeoutMs ?? request.timeoutMs,
+        });
+        const attemptEvidence = {
+            attemptId: `${task.id}:attempt:${attemptNumber}`,
+            runId: handle.runId,
+            startedAt: Date.now(),
+            diagnostics: [],
+        };
+        attempts.push(attemptEvidence);
+        task.evidence = {
+            runId: handle.runId,
+            attempts,
+            validationCommands: task.validationCommands ?? [],
+            summary: "",
+        };
+        this.store.updateTask(goalId, task);
+        this.setCurrentRun(goalId, task.id, handle.runId);
+        this.store.emit(goalId, { type: "task_attempt_started", goalId, taskId: task.id, attemptId: attemptEvidence.attemptId, attemptNumber, runId: handle.runId });
+        this.store.emit(goalId, { type: "task_started", goalId, taskId: task.id, runId: handle.runId });
+        if (this.store.isTerminal(goalId)) {
+            await handle.cancel();
+            return { result: "failed", reason: "failed", evidence: attemptEvidence };
+        }
+        try {
+            for await (const event of handle.events) {
+                this.store.emit(goalId, { type: "run_event", goalId, taskId: task.id, runId: handle.runId, event });
+                if (this.store.isTerminal(goalId)) {
+                    await handle.cancel();
+                    break;
+                }
+                if (event.type === "run_finished")
+                    result = event.result;
+            }
+        }
+        finally {
+            this.clearCurrentRun(goalId, task.id);
+        }
+        runRecord = await this.runScheduler.getRun(handle.runId);
+        attemptEvidence.finishedAt = Date.now();
+        attemptEvidence.result = this.cancelRequested.has(goalId) ? "cancelled" : result;
+        attemptEvidence.diagnostics = summarizeAttemptDiagnostics(runRecord);
+        this.updateAttemptEvidence(goalId, task, attempts, attemptEvidence, attemptEvidence.result, []);
+        return {
+            result: attemptEvidence.result,
+            reason: terminalReasonFromRunRecord(runRecord, attemptEvidence.result),
+            errorCode: runRecord?.errorCode ?? firstDiagnosticCode(attemptEvidence.diagnostics),
+            evidence: attemptEvidence,
+        };
+    }
+    async runAndCollectText(goalId, taskId, request) {
+        const handle = await this.runScheduler.startRun(request);
+        this.setCurrentRun(goalId, taskId ?? "__planner__", handle.runId);
+        let text = "";
+        let result = "failed";
+        try {
+            for await (const event of handle.events) {
+                this.store.emit(goalId, { type: "run_event", goalId, taskId, runId: handle.runId, event });
+                if (this.store.isTerminal(goalId)) {
+                    await handle.cancel();
+                    break;
+                }
+                if (event.type === "text_delta")
+                    text += event.text;
+                if (event.type === "run_finished")
+                    result = event.result;
+            }
+        }
+        finally {
+            this.clearCurrentRun(goalId, taskId ?? "__planner__");
+        }
+        if (this.cancelRequested.has(goalId))
+            return "";
+        if (result !== "success")
+            throw new Error(`Planner run failed with ${result}`);
+        return text;
+    }
+    cancelPending(goalId, tasks) {
+        for (const task of tasks) {
+            if (task.status === "pending") {
+                task.status = "canceled";
+                this.store.updateTask(goalId, task);
+            }
+        }
+    }
+    cancelPendingExceptBlocked(goalId, tasks) {
+        for (const task of tasks) {
+            if (task.status === "pending") {
+                task.status = "canceled";
+                this.store.updateTask(goalId, task);
+            }
+        }
+    }
+    cancelPendingFromStore(goalId) {
+        const goal = this.store.get(goalId);
+        if (!goal)
+            return;
+        this.cancelPending(goalId, goal.tasks);
+    }
+    blockDependents(goalId, tasks, failedTaskId) {
+        let changed = true;
+        const blocked = new Set([failedTaskId]);
+        while (changed) {
+            changed = false;
+            for (const task of tasks) {
+                if (task.status !== "pending" || !task.dependencies.some((dep) => blocked.has(dep)))
+                    continue;
+                task.status = "blocked";
+                blocked.add(task.id);
+                this.store.updateTask(goalId, task);
+                changed = true;
+            }
+        }
+    }
+    blockUnavailableDependents(goalId, tasks) {
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const task of tasks) {
+                if (task.status !== "pending")
+                    continue;
+                const hasUnavailableDependency = task.dependencies.some((dep) => {
+                    const dependency = tasks.find((candidate) => candidate.id === dep);
+                    return dependency?.status === "failed" || dependency?.status === "blocked";
+                });
+                if (!hasUnavailableDependency)
+                    continue;
+                task.status = "blocked";
+                this.store.updateTask(goalId, task);
+                changed = true;
+            }
+        }
+    }
+    setCurrentRun(goalId, taskId, runId) {
+        const runs = this.currentRuns.get(goalId) ?? new Map();
+        runs.set(taskId, runId);
+        this.currentRuns.set(goalId, runs);
+    }
+    clearCurrentRun(goalId, taskId) {
+        const runs = this.currentRuns.get(goalId);
+        if (!runs)
+            return;
+        runs.delete(taskId);
+        if (runs.size === 0)
+            this.currentRuns.delete(goalId);
+    }
+    async cancelCurrentRuns(goalId) {
+        const runs = [...(this.currentRuns.get(goalId)?.values() ?? [])];
+        await Promise.all(runs.map((runId) => this.runScheduler.cancelRun(runId)));
+    }
+    updateAttemptEvidence(goalId, task, attempts, attempt, result, validationResults) {
+        const index = attempts.findIndex((candidate) => candidate.attemptId === attempt.attemptId);
+        if (index >= 0)
+            attempts[index] = attempt;
+        task.evidence = {
+            runId: attempt.runId,
+            result,
+            attempts,
+            validationCommands: task.validationCommands ?? [],
+            validationResults,
+            summary: evidenceSummary(task.id, result, attempts, validationResults),
+        };
+        this.store.updateTask(goalId, task);
+    }
+    finish(goalId, outcome) {
+        if (this.store.isTerminal(goalId))
+            return;
+        const result = outcome.result;
+        this.store.setStatus(goalId, result === "success" ? "succeeded" : result === "cancelled" ? "canceled" : "failed", result);
+        this.store.emit(goalId, { type: "goal_finished", goalId, result, reason: outcome.reason, errorCode: outcome.errorCode });
+        this.currentRuns.delete(goalId);
+        this.cancelRequested.delete(goalId);
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        timer.unref?.();
+    });
+}
+async function waitFor(predicate) {
+    while (!predicate())
+        await delay(20);
+}
+function normalizeMaxConcurrentTasks(value) {
+    if (!value || !Number.isFinite(value) || value < 1)
+        return 1;
+    return Math.floor(value);
+}
+function normalizeRetryPolicy(policy) {
+    return {
+        maxAttempts: Math.max(1, Math.floor(policy?.maxAttempts ?? 1)),
+        retryableErrorCodes: policy?.retryableErrorCodes ?? [],
+        backoffMs: Math.max(0, Math.floor(policy?.backoffMs ?? 0)),
+    };
+}
+function dependenciesSucceeded(task, tasks) {
+    return task.dependencies.every((dependencyId) => tasks.find((candidate) => candidate.id === dependencyId)?.status === "succeeded");
+}
+function isRetryable(errorCode, policy) {
+    return Boolean(errorCode && policy.retryableErrorCodes.includes(errorCode));
+}
+function terminalReasonFromRunRecord(run, result) {
+    if (result === "success")
+        return "success";
+    if (result === "cancelled")
+        return "canceled";
+    return terminalReasonFromErrorCode(run?.errorCode ?? firstDiagnosticCode(summarizeAttemptDiagnostics(run)));
+}
+function terminalReasonFromErrorCode(errorCode) {
+    if (errorCode === "AGENT_TIMEOUT")
+        return "timeout";
+    if (errorCode === "AGENT_CANCELLED")
+        return "canceled";
+    if (errorCode === "AGENT_RUNTIME_INTERRUPTED")
+        return "interrupted";
+    if (errorCode === "AGENT_TASK_GRAPH_INVALID")
+        return "task_graph_invalid";
+    if (errorCode === "AGENT_AUTH_REQUIRED" || errorCode === "auth_missing")
+        return "auth_missing";
+    if (errorCode === "AGENT_UNAVAILABLE" || errorCode === "AGENT_NOT_EXECUTABLE" || errorCode === "AGENT_MODEL_UNAVAILABLE")
+        return "unavailable";
+    if (errorCode === "AGENT_PROMPT_TOO_LARGE" || errorCode === "PERMISSION_POLICY_UNSUPPORTED")
+        return "validation_failed";
+    if (errorCode === "AGENT_EXECUTION_FAILED" || errorCode === "AGENT_STREAM_PARSE_FAILED" || errorCode === "AGENT_EVENT_PERSIST_FAILED")
+        return "execution_failed";
+    return "failed";
+}
+function summarizeAttemptDiagnostics(run) {
+    if (!run)
+        return [];
+    if (run.diagnostics.length > 0)
+        return run.diagnostics.map((item) => ({ ...item }));
+    if (!run.errorCode)
+        return [];
+    return [
+        diagnostic(run.errorCode, run.error ?? `Run ${run.id} finished with ${run.status}.`, {
+            exitCode: run.exitCode,
+            signal: run.signal,
+            retryable: false,
+        }),
+    ];
+}
+function firstDiagnosticCode(diagnostics) {
+    return diagnostics[0]?.code;
+}
+function evidenceSummary(taskId, result, attempts, validationResults) {
+    const attemptSummary = `${attempts.length} attempt${attempts.length === 1 ? "" : "s"}`;
+    if (validationResults.length > 0) {
+        const passed = validationResults.filter((validation) => validation.passed).length;
+        return `Task ${taskId} finished with ${result} after ${attemptSummary}; ${passed}/${validationResults.length} validation commands passed.`;
+    }
+    return `Task ${taskId} finished with ${result} after ${attemptSummary}.`;
+}
+//# sourceMappingURL=goal-scheduler.js.map