ace-swarm 2.0.6 → 2.0.7

package/dist/runtime-executor.js

@@ -0,0 +1,774 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { z } from "zod";
+import { resolveWorkspaceRoot, withFileLock, } from "./helpers.js";
+import { appendRunLedgerEntrySafe } from "./run-ledger.js";
+import { runShellCommand } from "./runtime-command.js";
+import { getRuntimeProfilePath, renderRuntimePrompt, readRuntimeProfile, } from "./runtime-profile.js";
+import { executeRuntimeTool, listRuntimeToolSpecs, } from "./runtime-tool-specs.js";
+import { validateRuntimeExecutorSessionRegistryPayload, } from "./schemas.js";
+import { appendStatusEventSafe } from "./status-events.js";
+import { appendVericifyProcessPostSafe, deriveVericifyRunRef, isVericifyBridgeEnabled, refreshVericifyBridgeSnapshotSafe, } from "./vericify-bridge.js";
+import { createWorkspaceSession, removeWorkspaceSession, runWorkspaceSessionHook, } from "./workspace-manager.js";
+export const RUNTIME_EXECUTOR_SESSION_REGISTRY_REL_PATH = "agent-state/runtime-executor-sessions.json";
+export const RUNTIME_EXECUTOR_SESSION_SCHEMA_REL_PATH = "agent-state/MODULES/schemas/RUNTIME_EXECUTOR_SESSION_REGISTRY.schema.json";
+export const RUNTIME_EXECUTOR_SESSION_SCHEMA_NAME = "runtime-executor-session-registry@1.0.0";
+const activeSessions = new Map();
+const turnResponseSchema = z
+    .object({
+    status: z.enum(["continue", "done", "blocked", "failed"]),
+    summary: z.string().min(1),
+    next_task: z.string().optional(),
+    tool_calls: z
+        .array(z
+        .object({
+        name: z.string().min(1),
+        input: z.unknown(),
+    })
+        .strict())
+        .default([]),
+})
+    .strict();
+function defaultRegistry() {
+    return {
+        version: 1,
+        updated_at: "1970-01-01T00:00:00.000Z",
+        sessions: [],
+    };
+}
+function resolveWorkspaceArtifactPath(filePath) {
+    return resolve(resolveWorkspaceRoot(), filePath);
+}
+function safeWriteWorkspaceFile(filePath, content) {
+    const abs = resolveWorkspaceArtifactPath(filePath);
+    mkdirSync(dirname(abs), { recursive: true });
+    const tmpPath = `${abs}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmpPath, content, "utf-8");
+    renameSync(tmpPath, abs);
+    return abs;
+}
+function parseRegistry(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Runtime executor session registry contains invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const validation = validateRuntimeExecutorSessionRegistryPayload(parsed);
+    if (!validation.ok) {
+        throw new Error(`Runtime executor session registry failed validation (${validation.schema}): ${validation.errors.join("; ")}`);
+    }
+    return parsed;
+}
+function readRegistry() {
+    const path = resolveWorkspaceArtifactPath(RUNTIME_EXECUTOR_SESSION_REGISTRY_REL_PATH);
+    if (!existsSync(path))
+        return defaultRegistry();
+    return parseRegistry(readFileSync(path, "utf-8"));
+}
+function writeRegistry(registry) {
+    const validation = validateRuntimeExecutorSessionRegistryPayload(registry);
+    if (!validation.ok) {
+        throw new Error(`Runtime executor session registry failed validation (${validation.schema}): ${validation.errors.join("; ")}`);
+    }
+    return safeWriteWorkspaceFile(RUNTIME_EXECUTOR_SESSION_REGISTRY_REL_PATH, JSON.stringify(registry, null, 2));
+}
+function registryPath() {
+    return resolveWorkspaceArtifactPath(RUNTIME_EXECUTOR_SESSION_REGISTRY_REL_PATH);
+}
+async function mutateRegistry(updater) {
+    return withFileLock(RUNTIME_EXECUTOR_SESSION_REGISTRY_REL_PATH, async () => {
+        const registry = readRegistry();
+        const result = await updater(registry);
+        registry.updated_at = new Date().toISOString();
+        writeRegistry(registry);
+        return result;
+    });
+}
+function findSession(registry, sessionId) {
+    return registry.sessions.find((session) => session.session_id === sessionId);
+}
+function buildTurnPaths(workspacePath, turnNumber) {
+    const runtimeDir = resolve(workspacePath, ".ace-runtime", "turns");
+    mkdirSync(runtimeDir, { recursive: true });
+    const stem = `turn-${String(turnNumber).padStart(4, "0")}`;
+    return {
+        promptPath: resolve(runtimeDir, `${stem}.prompt.md`),
+        requestPath: resolve(runtimeDir, `${stem}.request.json`),
+        responsePath: resolve(runtimeDir, `${stem}.response.json`),
+    };
+}
+function terminalStatus(status) {
+    return status === "completed" || status === "failed" || status === "blocked" || status === "stopped";
+}
+function clipOutput(value) {
+    const trimmed = value.trim();
+    return trimmed.length > 4000 ? `${trimmed.slice(0, 3997)}...` : trimmed;
+}
+function mapToolCallResult(result, startedAt) {
+    return {
+        tool_name: result.name,
+        ok: result.ok,
+        summary: result.summary,
+        request_path: result.request_path,
+        response_path: result.response_path,
+        started_at: startedAt,
+        ended_at: new Date().toISOString(),
+        output: result.output,
+        error: result.error,
+        validation_errors: result.validation_errors,
+    };
+}
+function vericifyPayloadForSession(session) {
+    const refs = deriveVericifyRunRef(session);
+    return {
+        run_id: refs.run_id,
+        branch_id: refs.branch_id,
+        lane_id: refs.lane_id,
+        process_id: session.session_id,
+        objective_id: session.objective_id,
+        tracker_item_id: session.tracker_item_id,
+        workspace_path: session.workspace_path,
+    };
+}
+async function emitVericifyProcessPostForSession(session, kind, summary, toolRefs = [], evidenceRefs = []) {
+    if (!isVericifyBridgeEnabled())
+        return;
+    const refs = deriveVericifyRunRef(session);
+    await appendVericifyProcessPostSafe({
+        run_id: refs.run_id,
+        branch_id: refs.branch_id,
+        lane_id: refs.lane_id,
+        agent_id: "capability-framework",
+        kind,
+        summary,
+        tool_refs: toolRefs,
+        evidence_refs: evidenceRefs,
+    }).catch(() => undefined);
+    refreshVericifyBridgeSnapshotSafe();
+}
+async function emitExecutorEvent(eventType, status, summary, payload) {
+    await appendStatusEventSafe({
+        source_module: "capability-framework",
+        event_type: eventType,
+        status,
+        summary,
+        payload,
+    }).catch(() => undefined);
+}
+async function finalizeSession(sessionId, nextStatus, summary, error) {
+    return mutateRegistry((registry) => {
+        const session = findSession(registry, sessionId);
+        if (!session)
+            return undefined;
+        session.status = nextStatus;
+        session.updated_at = new Date().toISOString();
+        session.ended_at = session.updated_at;
+        session.result_summary = summary;
+        if (error)
+            session.last_error = error;
+        return { ...session };
+    });
+}
+function readTurnResponse(responsePath) {
+    if (!existsSync(responsePath)) {
+        throw new Error(`Turn response file not found: ${responsePath}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(responsePath, "utf-8"));
+    }
+    catch (error) {
+        throw new Error(`Turn response JSON is invalid: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const validation = turnResponseSchema.safeParse(parsed);
+    if (!validation.success) {
+        throw new Error(`Turn response failed validation: ${validation.error.issues.map((issue) => issue.message).join("; ")}`);
+    }
+    return validation.data;
+}
+async function runCleanup(sessionId, workspaceSessionId, shouldRunAfterHook) {
+    let cleanupError;
+    let cleanupStatus = "pending";
+    if (shouldRunAfterHook) {
+        const afterRun = runWorkspaceSessionHook({
+            session_id: workspaceSessionId,
+            kind: "after_run",
+        });
+        if (!afterRun.ok) {
+            cleanupError = afterRun.error ?? "after_run hook failed";
+            cleanupStatus = "failed";
+        }
+    }
+    const removal = removeWorkspaceSession({ session_id: workspaceSessionId });
+    if (removal.ok && removal.session) {
+        cleanupStatus =
+            removal.session.status === "archived" ? "archived" : "removed";
+    }
+    else if (!cleanupError) {
+        cleanupError = removal.error ?? "Workspace session cleanup failed";
+        cleanupStatus = "failed";
+    }
+    await mutateRegistry((registry) => {
+        const session = findSession(registry, sessionId);
+        if (!session)
+            return;
+        session.workspace_cleanup_status = cleanupStatus;
+        session.updated_at = new Date().toISOString();
+        if (cleanupError)
+            session.cleanup_error = cleanupError;
+    });
+}
+async function runSessionLoop(sessionId, context, autoCleanup) {
+    const active = activeSessions.get(sessionId);
+    let shouldRunAfterHook = false;
+    let workspaceSessionId = "";
+    try {
+        const runtimeProfile = readRuntimeProfile();
+        const registryStart = await mutateRegistry((registry) => {
+            const session = findSession(registry, sessionId);
+            if (!session)
+                throw new Error(`Session disappeared before execution: ${sessionId}`);
+            session.status = "running";
+            session.started_at = new Date().toISOString();
+            session.updated_at = session.started_at;
+            workspaceSessionId = session.workspace_session_id;
+            return { ...session };
+        });
+        if (!registryStart) {
+            throw new Error(`Failed to start unattended session: ${sessionId}`);
+        }
+        const beforeRun = runWorkspaceSessionHook({
+            session_id: registryStart.workspace_session_id,
+            kind: "before_run",
+        });
+        if (!beforeRun.ok) {
+            const summary = beforeRun.error ?? "before_run hook failed";
+            await finalizeSession(sessionId, "failed", summary, summary);
+            await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_FAILED", "fail", summary, {
+                session_id: sessionId,
+                workspace_session_id: registryStart.workspace_session_id,
+                ...vericifyPayloadForSession(registryStart),
+            });
+            await emitVericifyProcessPostForSession(registryStart, "blocker", summary, [
+                "runtime-executor",
+            ]);
+            return;
+        }
+        shouldRunAfterHook = true;
+        let currentTask = registryStart.current_task;
+        let previousToolCalls = [];
+        for (let turnNumber = 1; turnNumber <= registryStart.max_turns; turnNumber += 1) {
+            if (active?.stop_requested) {
+                const stopped = await finalizeSession(sessionId, "stopped", `Unattended session ${sessionId} stopped by request.`);
+                if (stopped) {
+                    await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_STOPPED", "done", stopped.result_summary ?? `Unattended session ${sessionId} stopped by request.`, {
+                        session_id: sessionId,
+                        ...vericifyPayloadForSession(stopped),
+                    });
+                    await emitVericifyProcessPostForSession(stopped, "progress", stopped.result_summary ?? `Unattended session ${sessionId} stopped by request.`, ["runtime-executor"]);
+                }
+                return;
+            }
+            const sessionSnapshot = await mutateRegistry((registry) => {
+                const session = findSession(registry, sessionId);
+                if (!session)
+                    throw new Error(`Missing unattended session ${sessionId}`);
+                session.current_task = currentTask;
+                session.updated_at = new Date().toISOString();
+                return { ...session };
+            });
+            if (!sessionSnapshot)
+                throw new Error(`Missing unattended session ${sessionId}`);
+            const turnStartedAt = new Date().toISOString();
+            const paths = buildTurnPaths(sessionSnapshot.workspace_path, turnNumber);
+            const toolCatalog = listRuntimeToolSpecs().map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                input_schema: tool.input_schema,
+            }));
+            const prompt = renderRuntimePrompt({
+                task: currentTask,
+                session_id: sessionId,
+                turn_number: turnNumber,
+                workspace_path: sessionSnapshot.workspace_path,
+                runtime_tools: JSON.stringify(toolCatalog, null, 2),
+            });
+            writeFileSync(paths.promptPath, prompt, "utf-8");
+            const requestPayload = {
+                session_id: sessionId,
+                turn_number: turnNumber,
+                task: currentTask,
+                prompt,
+                context: context ?? {},
+                prior_turns: sessionSnapshot.turns.map((turn) => ({
+                    turn_number: turn.turn_number,
+                    status: turn.status,
+                    summary: turn.summary,
+                    response_status: turn.response_status,
+                })),
+                previous_tool_calls: previousToolCalls.map((tool) => ({
+                    tool_name: tool.tool_name,
+                    ok: tool.ok,
+                    summary: tool.summary,
+                    output: tool.output,
+                    error: tool.error,
+                })),
+                available_tools: toolCatalog,
+            };
+            writeFileSync(paths.requestPath, JSON.stringify(requestPayload, null, 2), "utf-8");
+            await emitExecutorEvent("RUNTIME_EXECUTOR_TURN_STARTED", "in_progress", `Unattended session ${sessionId} turn ${turnNumber} started.`, {
+                session_id: sessionId,
+                turn_number: turnNumber,
+                workspace_path: sessionSnapshot.workspace_path,
+                ...vericifyPayloadForSession(sessionSnapshot),
+            });
+            const shellResult = await runShellCommand(runtimeProfile.executor.command ?? "", {
+                cwd: sessionSnapshot.workspace_path,
+                env: {
+                    ...process.env,
+                    ACE_RUNTIME_SESSION_ID: sessionId,
+                    ACE_RUNTIME_TURN: String(turnNumber),
+                    ACE_RUNTIME_WORKSPACE_PATH: sessionSnapshot.workspace_path,
+                    ACE_RUNTIME_PROMPT_FILE: paths.promptPath,
+                    ACE_RUNTIME_REQUEST_FILE: paths.requestPath,
+                    ACE_RUNTIME_RESPONSE_FILE: paths.responsePath,
+                },
+                timeout_ms: sessionSnapshot.turn_timeout_ms,
+                on_spawn: (child) => {
+                    if (active)
+                        active.child = child;
+                },
+            });
+            if (active)
+                active.child = undefined;
+            if (active?.stop_requested) {
+                const turnEndedAt = new Date().toISOString();
+                await mutateRegistry((registry) => {
+                    const session = findSession(registry, sessionId);
+                    if (!session)
+                        return;
+                    const turnRecord = {
+                        turn_number: turnNumber,
+                        task: currentTask,
+                        started_at: turnStartedAt,
+                        ended_at: turnEndedAt,
+                        status: "stopped",
+                        response_status: "failed",
+                        summary: `Turn ${turnNumber} stopped by request.`,
+                        prompt_path: paths.promptPath,
+                        request_path: paths.requestPath,
+                        response_path: paths.responsePath,
+                        exit_code: shellResult.exit_code,
+                        stdout: clipOutput(shellResult.stdout),
+                        stderr: clipOutput(shellResult.stderr),
+                        tool_calls: [],
+                    };
+                    session.turns.push(turnRecord);
+                    session.turn_count = session.turns.length;
+                });
+                const stopped = await finalizeSession(sessionId, "stopped", `Unattended session ${sessionId} stopped by request.`);
+                if (stopped) {
+                    await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_STOPPED", "done", stopped.result_summary ?? `Unattended session ${sessionId} stopped by request.`, {
+                        session_id: sessionId,
+                        ...vericifyPayloadForSession(stopped),
+                    });
+                    await emitVericifyProcessPostForSession(stopped, "progress", stopped.result_summary ?? `Unattended session ${sessionId} stopped by request.`, ["runtime-executor"]);
+                }
+                return;
+            }
+            let response;
+            try {
+                response = readTurnResponse(paths.responsePath);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const turnEndedAt = new Date().toISOString();
+                await mutateRegistry((registry) => {
+                    const session = findSession(registry, sessionId);
+                    if (!session)
+                        return;
+                    const turnRecord = {
+                        turn_number: turnNumber,
+                        task: currentTask,
+                        started_at: turnStartedAt,
+                        ended_at: turnEndedAt,
+                        status: "failed",
+                        response_status: "failed",
+                        summary: message,
+                        prompt_path: paths.promptPath,
+                        request_path: paths.requestPath,
+                        response_path: paths.responsePath,
+                        exit_code: shellResult.exit_code,
+                        stdout: clipOutput(shellResult.stdout),
+                        stderr: clipOutput(shellResult.stderr),
+                        tool_calls: [],
+                    };
+                    session.turns.push(turnRecord);
+                    session.turn_count = session.turns.length;
+                });
+                const failed = await finalizeSession(sessionId, "failed", message, message);
+                if (failed) {
+                    await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_FAILED", "fail", message, {
+                        session_id: sessionId,
+                        turn_number: turnNumber,
+                        ...vericifyPayloadForSession(failed),
+                    });
+                    await emitVericifyProcessPostForSession(failed, "blocker", message, [
+                        "runtime-executor",
+                    ]);
+                }
+                return;
+            }
+            const toolCalls = [];
+            for (const toolCall of response.tool_calls) {
+                const toolStartedAt = new Date().toISOString();
+                const toolResult = await executeRuntimeTool(toolCall.name, toolCall.input, {
+                    session_id: sessionId,
+                    workspace_path: sessionSnapshot.workspace_path,
+                    turn_number: turnNumber,
+                });
+                toolCalls.push(mapToolCallResult(toolResult, toolStartedAt));
+            }
+            previousToolCalls = toolCalls;
+            const turnEndedAt = new Date().toISOString();
+            const turnStatus = response.status === "blocked"
+                ? "blocked"
+                : response.status === "failed"
+                    ? "failed"
+                    : "completed";
+            await mutateRegistry((registry) => {
+                const session = findSession(registry, sessionId);
+                if (!session)
+                    return;
+                const turnRecord = {
+                    turn_number: turnNumber,
+                    task: currentTask,
+                    started_at: turnStartedAt,
+                    ended_at: turnEndedAt,
+                    status: turnStatus,
+                    response_status: response.status,
+                    summary: response.summary,
+                    prompt_path: paths.promptPath,
+                    request_path: paths.requestPath,
+                    response_path: paths.responsePath,
+                    exit_code: shellResult.exit_code,
+                    stdout: clipOutput(shellResult.stdout),
+                    stderr: clipOutput(shellResult.stderr),
+                    tool_calls: toolCalls,
+                };
+                session.turns.push(turnRecord);
+                session.turn_count = session.turns.length;
+                session.current_task = response.next_task?.trim() || currentTask;
+                session.updated_at = turnEndedAt;
+            });
+            await emitExecutorEvent(response.status === "failed"
+                ? "RUNTIME_EXECUTOR_TURN_FAILED"
+                : "RUNTIME_EXECUTOR_TURN_COMPLETED", response.status === "blocked" ? "blocked" : response.status === "failed" ? "fail" : "done", response.summary, {
+                session_id: sessionId,
+                turn_number: turnNumber,
+                response_status: response.status,
+                tool_call_count: toolCalls.length,
+                ...vericifyPayloadForSession(sessionSnapshot),
+            });
+            if (response.status === "continue") {
+                currentTask = response.next_task?.trim() || currentTask;
+                continue;
+            }
+            if (response.status === "blocked") {
+                await finalizeSession(sessionId, "blocked", response.summary, response.summary);
+                await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_BLOCKED", "blocked", response.summary, {
+                    session_id: sessionId,
+                    turn_number: turnNumber,
+                    ...vericifyPayloadForSession(sessionSnapshot),
+                });
+                await emitVericifyProcessPostForSession(sessionSnapshot, "blocker", response.summary, [
+                    "runtime-executor",
+                ]);
+                return;
+            }
+            if (response.status === "failed") {
+                const failed = await finalizeSession(sessionId, "failed", response.summary, response.summary);
+                await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_FAILED", "fail", response.summary, {
+                    session_id: sessionId,
+                    turn_number: turnNumber,
+                    ...(failed ? vericifyPayloadForSession(failed) : vericifyPayloadForSession(sessionSnapshot)),
+                });
+                await emitVericifyProcessPostForSession(failed ?? sessionSnapshot, "blocker", response.summary, ["runtime-executor"]);
+                return;
+            }
+            const completed = await finalizeSession(sessionId, "completed", response.summary);
+            if (completed) {
+                await appendRunLedgerEntrySafe({
+                    tool: "runtime-executor",
+                    category: "major_update",
+                    message: response.summary,
+                    artifacts: [
+                        RUNTIME_EXECUTOR_SESSION_REGISTRY_REL_PATH,
+                        paths.promptPath,
+                        paths.requestPath,
+                        paths.responsePath,
+                    ],
+                    metadata: {
+                        session_id: sessionId,
+                        turn_number: turnNumber,
+                        workspace_session_id: completed.workspace_session_id,
+                        ...vericifyPayloadForSession(completed),
+                    },
+                }).catch(() => undefined);
+                await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_COMPLETED", "done", response.summary, {
+                    session_id: sessionId,
+                    turn_number: turnNumber,
+                    workspace_session_id: completed.workspace_session_id,
+                    ...vericifyPayloadForSession(completed),
+                });
+                await emitVericifyProcessPostForSession(completed, "completion", response.summary, [
+                    "runtime-executor",
+                ]);
+            }
+            return;
+        }
+        const exhausted = `Unattended session ${sessionId} exceeded max_turns=${registryStart.max_turns}`;
+        const failed = await finalizeSession(sessionId, "failed", exhausted, exhausted);
+        if (failed) {
+            await appendRunLedgerEntrySafe({
+                tool: "runtime-executor",
+                category: "regression",
+                message: exhausted,
+                artifacts: [RUNTIME_EXECUTOR_SESSION_REGISTRY_REL_PATH],
+                metadata: {
+                    session_id: sessionId,
+                    workspace_session_id: failed.workspace_session_id,
+                    ...vericifyPayloadForSession(failed),
+                },
+            }).catch(() => undefined);
+            await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_FAILED", "fail", exhausted, {
+                session_id: sessionId,
+                reason: "max_turns_exceeded",
+                ...vericifyPayloadForSession(failed),
+            });
+            await emitVericifyProcessPostForSession(failed, "blocker", exhausted, [
+                "runtime-executor",
+            ]);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const failed = await finalizeSession(sessionId, "failed", message, message);
+        await appendRunLedgerEntrySafe({
+            tool: "runtime-executor",
+            category: "regression",
+            message,
+            artifacts: [RUNTIME_EXECUTOR_SESSION_REGISTRY_REL_PATH],
+            metadata: {
+                session_id: sessionId,
+                ...(failed ? vericifyPayloadForSession(failed) : {}),
+            },
+        }).catch(() => undefined);
+        await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_FAILED", "fail", message, {
+            session_id: sessionId,
+            workspace_session_id: failed?.workspace_session_id,
+            ...(failed ? vericifyPayloadForSession(failed) : {}),
+        });
+        if (failed) {
+            await emitVericifyProcessPostForSession(failed, "blocker", message, [
+                "runtime-executor",
+            ]);
+        }
+    }
+    finally {
+        if (workspaceSessionId && autoCleanup) {
+            await runCleanup(sessionId, workspaceSessionId, shouldRunAfterHook).catch(() => undefined);
+        }
+        const active = activeSessions.get(sessionId);
+        if (active) {
+            active.child = undefined;
+            activeSessions.delete(sessionId);
+        }
+    }
+}
+export function validateRuntimeExecutorSessionRegistryContent(raw) {
+    try {
+        parseRegistry(raw);
+        return { ok: true, schema: RUNTIME_EXECUTOR_SESSION_SCHEMA_NAME };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            schema: RUNTIME_EXECUTOR_SESSION_SCHEMA_NAME,
+            errors: [error instanceof Error ? error.message : String(error)],
+        };
+    }
+}
+export function listUnattendedSessions() {
+    return readRegistry();
+}
+export function getUnattendedSession(sessionId) {
+    return findSession(readRegistry(), sessionId);
+}
+export function getRuntimeExecutorSessionRegistryPath() {
+    return registryPath();
+}
+export function startUnattendedSession(input) {
+    const registryPathValue = registryPath();
+    const runtimeProfile = readRuntimeProfile();
+    if (runtimeProfile.runtime.mode !== "unattended") {
+        return Promise.resolve({
+            ok: false,
+            registry_path: registryPathValue,
+            error: "ACE_WORKFLOW.md runtime.mode must be \"unattended\" before starting an unattended session.",
+        });
+    }
+    if (!runtimeProfile.executor.command || runtimeProfile.executor.command.trim().length === 0) {
+        return Promise.resolve({
+            ok: false,
+            registry_path: registryPathValue,
+            error: "ACE_WORKFLOW.md executor.command must be configured before starting an unattended session.",
+        });
+    }
+    const sessionId = input.session_id?.trim() || randomUUID();
+    const duplicate = findSession(readRegistry(), sessionId);
+    if (duplicate) {
+        return Promise.resolve({
+            ok: false,
+            registry_path: registryPathValue,
+            error: `Unattended session id already exists: ${sessionId}`,
+        });
+    }
+    const workspace = createWorkspaceSession({
+        source: "executor",
+        workspace_name: input.workspace_name,
+        workspace_path: input.workspace_path,
+        objective_id: input.objective_id,
+        tracker_item_id: input.tracker_item_id,
+    });
+    if (!workspace.ok || !workspace.session) {
+        return Promise.resolve({
+            ok: false,
+            registry_path: registryPathValue,
+            error: workspace.error ?? "Failed to create managed workspace session.",
+        });
+    }
+    const maxTurns = Math.max(1, input.max_turns ?? runtimeProfile.executor.max_turns ?? 6);
+    const turnTimeout = Math.max(1_000, input.turn_timeout_ms ?? runtimeProfile.executor.turn_timeout_ms ?? 300_000);
+    const now = new Date().toISOString();
+    const sessionRecord = {
+        session_id: sessionId,
+        status: "starting",
+        task: input.task,
+        current_task: input.task,
+        runtime_profile_path: getRuntimeProfilePath(),
+        workspace_session_id: workspace.session.session_id,
+        workspace_path: workspace.session.workspace_path,
+        objective_id: input.objective_id,
+        tracker_item_id: input.tracker_item_id,
+        command: runtimeProfile.executor.command,
+        max_turns: maxTurns,
+        turn_timeout_ms: turnTimeout,
+        turn_count: 0,
+        created_at: now,
+        updated_at: now,
+        workspace_cleanup_status: input.auto_cleanup === false ? "pending" : "pending",
+        turns: [],
+    };
+    return mutateRegistry((registry) => {
+        registry.sessions.push(sessionRecord);
+    }).then(() => {
+        const active = {
+            stop_requested: false,
+        };
+        activeSessions.set(sessionId, active);
+        active.completion = runSessionLoop(sessionId, input.context, input.auto_cleanup !== false).finally(() => {
+            activeSessions.delete(sessionId);
+        });
+        void emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_STARTED", "started", `Unattended session ${sessionId} created.`, {
+            session_id: sessionId,
+            workspace_session_id: workspace.session?.session_id,
+            workspace_path: workspace.session?.workspace_path,
+            max_turns: maxTurns,
+            ...vericifyPayloadForSession(sessionRecord),
+        });
+        void emitVericifyProcessPostForSession(sessionRecord, "intent", `Unattended session ${sessionId} created for task: ${input.task}`, ["runtime-executor"]);
+        if (isVericifyBridgeEnabled()) {
+            refreshVericifyBridgeSnapshotSafe();
+        }
+        return {
+            ok: true,
+            registry_path: registryPathValue,
+            session: sessionRecord,
+            workspace: workspace.session,
+        };
+    });
+}
+export async function waitForUnattendedSession(sessionId, timeoutMs = 30_000) {
+    const registryPathValue = registryPath();
+    const active = activeSessions.get(sessionId);
+    if (!active?.completion) {
+        const session = getUnattendedSession(sessionId);
+        if (!session) {
+            return {
+                ok: false,
+                timed_out: false,
+                registry_path: registryPathValue,
+                error: `Unknown unattended session: ${sessionId}`,
+            };
+        }
+        return {
+            ok: terminalStatus(session.status),
+            timed_out: false,
+            registry_path: registryPathValue,
+            session,
+            error: terminalStatus(session.status)
+                ? undefined
+                : `Session ${sessionId} is not active but has not reached a terminal state.`,
+        };
+    }
+    const timeoutPromise = new Promise((resolve) => {
+        setTimeout(() => resolve("timeout"), timeoutMs);
+    });
+    const completion = active.completion.then(() => "done");
+    const outcome = await Promise.race([completion, timeoutPromise]);
+    const session = getUnattendedSession(sessionId);
+    if (outcome === "timeout") {
+        return {
+            ok: false,
+            timed_out: true,
+            registry_path: registryPathValue,
+            session,
+            error: `Timed out waiting for unattended session ${sessionId}`,
+        };
+    }
+    return {
+        ok: !!session && terminalStatus(session.status),
+        timed_out: false,
+        registry_path: registryPathValue,
+        session,
+    };
+}
+export async function stopUnattendedSession(sessionId) {
+    const registryPathValue = registryPath();
+    const active = activeSessions.get(sessionId);
+    if (!active) {
+        const session = getUnattendedSession(sessionId);
+        return {
+            ok: false,
+            registry_path: registryPathValue,
+            session,
+            error: session
+                ? `Session ${sessionId} is not currently active.`
+                : `Unknown unattended session: ${sessionId}`,
+        };
+    }
+    active.stop_requested = true;
+    active.child?.kill("SIGTERM");
+    const waited = await waitForUnattendedSession(sessionId, 15_000);
+    return {
+        ok: waited.ok,
+        registry_path: registryPathValue,
+        session: waited.session,
+        error: waited.ok ? undefined : waited.error,
+    };
+}
+//# sourceMappingURL=runtime-executor.js.map