@voybio/ace-swarm 0.2.5 → 2.4.1

package/dist/runtime-executor.js

@@ -1,27 +1,137 @@
 import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync, } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { z } from "zod";
-import { resolveWorkspaceArtifactPath as resolveWorkspaceArtifactPathHelper, resolveWorkspaceRoot, safeRead, safeWrite, withFileLock, } from "./helpers.js";
+import { resolveWorkspaceArtifactPath as resolveWorkspaceArtifactPathHelper, resolveWorkspaceRoot, safeRead, safeWriteAsync, 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 { loadRuntimeProfile, resolveEffectiveSurgicalReadBudget, renderRuntimePromptFromSnapshot, getLivenessDefaults, } from "./runtime-profile.js";
+import { resolveLocalModelExecutionPolicy } from "./local-model-policy.js";
 import { renderAceContinuityPromptBlock, renderAceRecallPromptBlock, renderAceSnapshotPromptBlock, } from "./ace-context.js";
-import { executeRuntimeTool, listRuntimeToolSpecs, } from "./runtime-tool-specs.js";
+import { executeRuntimeTool, buildFilteredToolCatalog, SMALL_LOCAL_PRIORITY_TOOL_NAMES, } 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";
+import { createWorkspaceSessionAsync, removeWorkspaceSession, runWorkspaceSessionHook, } from "./workspace-manager.js";
 import { buildAceContinuityPacket, buildAceRecallContext, normalizeAutonomyPolicy, normalizeContinuityPolicy, } from "./ace-autonomy.js";
 import { openStore } from "./store/ace-packed-store.js";
-import { getWorkspaceStorePath, storeExistsSync, toVirtualStorePath, } from "./store/store-snapshot.js";
+import { getWorkspaceStorePath, storeExistsSync, } from "./store/store-snapshot.js";
 import { operationalArtifactVirtualPath } from "./store/store-artifacts.js";
-import { withStoreWriteQueue } from "./store/write-queue.js";
+import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
+import { LocalModelRuntimeRepository, withLocalModelRuntimeRepository, } from "./store/repositories/local-model-runtime-repository.js";
+import { proposePlanDeterministic, validatePlan } from "./plan-proposal.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 WORKSPACE_ROOT = resolveWorkspaceRoot();
+let activeWorkspaceRoot = WORKSPACE_ROOT;
+export const DEFAULT_TURN_OUTPUT_POLICY = {
+    emit_to: ["tui", "vericify"],
+    silent_unless_blocked: false,
+    require_approval_before_emit: false,
+};
+function buildToolChoiceAuditRecord(input) {
+    const priority_tools = SMALL_LOCAL_PRIORITY_TOOL_NAMES.filter((name) => input.filteredCatalog.entries.some((entry) => entry.name === name));
+    const demoted_tools = [
+        ...(input.model_class === "small_local"
+            ? input.filteredCatalog.entries
+                .filter((entry) => entry.cost_class === "heavy")
+                .map((entry) => ({
+                name: entry.name,
+                reason_code: "heavy_for_small_local",
+            }))
+            : []),
+        ...input.filteredCatalog.unavailable_tools
+            .filter((entry) => entry.reason_code === "workspace_disabled" || entry.reason_code === "policy_disabled")
+            .map((entry) => ({
+            name: entry.name,
+            reason_code: entry.reason_code,
+        })),
+    ];
+    return {
+        audit_id: randomUUID(),
+        session_id: input.session_id,
+        turn_number: input.turn_number,
+        captured_at: input.captured_at,
+        model_class: input.model_class,
+        priority_tools,
+        demoted_tools,
+        selected_budget: input.selected_budget,
+        capability_snapshot_id: input.capability_snapshot_id,
+    };
+}
+const sessionSidecarStates = new Map();
+function initSessionSidecars(sessionId) {
+    let release;
+    const gate = new Promise((resolve) => {
+        release = resolve;
+    });
+    sessionSidecarStates.set(sessionId, { chain: gate, release });
+}
+function scheduleRuntimeSidecar(sessionId, _label, fn) {
+    const state = sessionSidecarStates.get(sessionId);
+    if (!state)
+        return;
+    const next = state.chain.then(() => fn()).catch(() => undefined);
+    state.chain = next;
+}
+function releaseSidecarsAndForget(sessionId) {
+    const state = sessionSidecarStates.get(sessionId);
+    if (!state)
+        return;
+    if (state.release) {
+        state.release();
+        state.release = undefined;
+    }
+    // Let sidecars run in background; clean up state when chain completes.
+    void state.chain.finally(() => {
+        sessionSidecarStates.delete(sessionId);
+    });
+}
+async function waitForSessionSidecars(sessionId) {
+    const state = sessionSidecarStates.get(sessionId);
+    if (!state)
+        return;
+    await state.chain.catch(() => undefined);
+}
+async function delaySessionCompletedSidecarIfRequested(sessionId) {
+    const rawDelayMs = process.env.ACE_RUNTIME_EXECUTOR_TEST_SIDECAR_DELAY_MS;
+    if (!rawDelayMs)
+        return;
+    const delayMs = Number(rawDelayMs);
+    if (!Number.isFinite(delayMs) || delayMs <= 0)
+        return;
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+    const markerDir = process.env.ACE_RUNTIME_EXECUTOR_TEST_SIDECAR_MARKER_DIR;
+    if (markerDir && markerDir.trim().length > 0) {
+        mkdirSync(markerDir, { recursive: true });
+        writeFileSync(join(markerDir, `${sessionId}.done`), new Date().toISOString(), "utf-8");
+    }
+}
+function setSessionPhase(sessionId, phase, checkpoint) {
+    const active = activeSessions.get(sessionId);
+    if (active) {
+        active.phase = phase;
+        active.phase_started_at = Date.now();
+        if (checkpoint !== undefined)
+            active.last_checkpoint = checkpoint;
+    }
+}
 const activeSessions = new Map();
+async function readLocalModelRuntimeStatus(sessionId) {
+    if (!storeExistsSync(workspaceRoot()))
+        return undefined;
+    const storePath = getWorkspaceStorePath(workspaceRoot());
+    const store = await openStore(storePath);
+    try {
+        const repo = new LocalModelRuntimeRepository(store);
+        return await repo.getRuntimeStatus(sessionId);
+    }
+    finally {
+        await store.close();
+    }
+}
 const turnResponseSchema = z
     .object({
     status: z.enum(["continue", "done", "blocked", "failed"]),
@@ -45,14 +155,27 @@ function defaultRegistry() {
     };
 }
 function workspaceRoot() {
-    return resolveWorkspaceRoot();
+    return WORKSPACE_ROOT;
+}
+function runtimeProfilePath() {
+    return resolve(WORKSPACE_ROOT, "agent-state", "ACE_WORKFLOW.md");
+}
+function loadCurrentRuntimeProfile() {
+    const workspaceProfilePath = runtimeProfilePath();
+    if (existsSync(workspaceProfilePath)) {
+        const result = loadRuntimeProfile(workspaceProfilePath);
+        if (result.ok)
+            return result;
+        throw new Error(`ACE workflow runtime profile is invalid: ${result.errors.join("; ")}`);
+    }
+    const packaged = loadRuntimeProfile();
+    if (packaged.ok)
+        return packaged;
+    throw new Error(`ACE runtime profile is invalid: ${packaged.errors.join("; ")}`);
 }
 function resolveWorkspaceArtifactPath(filePath) {
     return resolveWorkspaceArtifactPathHelper(filePath, "write");
 }
-function safeWriteWorkspaceFile(filePath, content) {
-    return safeWrite(filePath, content);
-}
 function parseRegistry(raw) {
     let parsed;
     try {
@@ -69,17 +192,19 @@ function parseRegistry(raw) {
 }
 function readRegistry() {
     const raw = safeRead(RUNTIME_EXECUTOR_SESSION_REGISTRY_REL_PATH);
-    if (raw.startsWith("[FILE NOT FOUND]") || raw.startsWith("[ACCESS DENIED]")) {
+    if (raw.startsWith("[FILE NOT FOUND]") ||
+        raw.startsWith("[ACCESS DENIED]") ||
+        raw.includes("\x00")) {
         return defaultRegistry();
     }
     return parseRegistry(raw);
 }
-function writeRegistry(registry) {
+async 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));
+    return safeWriteAsync(RUNTIME_EXECUTOR_SESSION_REGISTRY_REL_PATH, JSON.stringify(registry, null, 2));
 }
 function registryPath() {
     if (storeExistsSync(workspaceRoot())) {
@@ -92,7 +217,7 @@ async function mutateRegistry(updater) {
         const registry = readRegistry();
         const result = await updater(registry);
         registry.updated_at = new Date().toISOString();
-        writeRegistry(registry);
+        await writeRegistry(registry);
         return result;
     });
 }
@@ -245,6 +370,24 @@ async function emitVericifyProcessPostForSession(session, kind, summary, toolRef
     }).catch(() => undefined);
     refreshVericifyBridgeSnapshotSafe();
 }
+async function touchRuntimeProgress(sessionId, _reason, at = Date.now()) {
+    if (!storeExistsSync(workspaceRoot()))
+        return;
+    await withLocalModelRuntimeRepository(workspaceRoot(), async (repo) => {
+        const currentStatus = await repo.getRuntimeStatus(sessionId);
+        if (!currentStatus)
+            return;
+        await repo.upsertRuntimeStatusWithTransition({
+            ...currentStatus,
+            sleep_state: currentStatus.sleep_state === "stalled" ? "awake" : currentStatus.sleep_state,
+            last_progress_at: at,
+        }, {
+            from: currentStatus.bridge_status,
+            reason: _reason,
+            evidence_refs: [`session:${sessionId}`, `progress_at:${at}`],
+        });
+    }).catch(() => undefined);
+}
 async function emitExecutorEvent(eventType, status, summary, payload) {
     await appendStatusEventSafe({
         source_module: "capability-framework",
@@ -300,7 +443,10 @@ async function persistTurnArtifacts(paths, prompt, requestPayload, responseRaw)
         };
     }
     const storePath = getWorkspaceStorePath(workspaceRoot());
-    await withStoreWriteQueue(storePath, async () => {
+    writeFileSync(paths.tempPromptPath, prompt, "utf-8");
+    writeFileSync(paths.tempRequestPath, JSON.stringify(requestPayload, null, 2), "utf-8");
+    writeFileSync(paths.tempResponsePath, responseRaw, "utf-8");
+    await withStoreWriteCoordinator(storePath, async () => {
         const store = await openStore(storePath);
         try {
             await store.setBlob(paths.promptStoreKey, prompt);
@@ -311,27 +457,31 @@ async function persistTurnArtifacts(paths, prompt, requestPayload, responseRaw)
         finally {
             await store.close();
         }
-    });
+    }, { operation_label: "runtime-executor-turn-artifacts" });
     return {
-        promptPath: toVirtualStorePath(storePath, paths.promptStoreKey),
-        requestPath: toVirtualStorePath(storePath, paths.requestStoreKey),
-        responsePath: toVirtualStorePath(storePath, paths.responseStoreKey),
+        promptPath: paths.tempPromptPath,
+        requestPath: paths.tempRequestPath,
+        responsePath: paths.tempResponsePath,
     };
 }
-async function runCleanup(sessionId, workspaceSessionId, shouldRunAfterHook) {
+async function runCleanup(sessionId, workspaceSessionId, shouldRunAfterHook, runtimeProfilePath) {
     let cleanupError;
     let cleanupStatus = "pending";
     if (shouldRunAfterHook) {
-        const afterRun = runWorkspaceSessionHook({
+        const afterRun = await runWorkspaceSessionHook({
             session_id: workspaceSessionId,
             kind: "after_run",
+            runtime_profile_path: runtimeProfilePath,
         });
         if (!afterRun.ok) {
             cleanupError = afterRun.error ?? "after_run hook failed";
             cleanupStatus = "failed";
         }
     }
-    const removal = removeWorkspaceSession({ session_id: workspaceSessionId });
+    const removal = await removeWorkspaceSession({
+        session_id: workspaceSessionId,
+        runtime_profile_path: runtimeProfilePath,
+    });
     if (removal.ok && removal.session) {
         cleanupStatus =
             removal.session.status === "archived" ? "archived" : "removed";
@@ -340,6 +490,8 @@ async function runCleanup(sessionId, workspaceSessionId, shouldRunAfterHook) {
         cleanupError = removal.error ?? "Workspace session cleanup failed";
         cleanupStatus = "failed";
     }
+    // Update the registry first (critical lane) then emit the transition record as a sidecar.
+    setSessionPhase(sessionId, "cleanup_registry_update");
     await mutateRegistry((registry) => {
         const session = findSession(registry, sessionId);
         if (!session)
@@ -352,15 +504,54 @@ async function runCleanup(sessionId, workspaceSessionId, shouldRunAfterHook) {
         if (cleanupError)
             session.cleanup_error = cleanupError;
     });
+    const capturedCleanupStatus = cleanupStatus;
+    const capturedCleanupError = cleanupError;
+    const capturedWorkspaceSessionId = workspaceSessionId;
+    scheduleRuntimeSidecar(sessionId, "cleanup-transition", async () => {
+        if (!storeExistsSync(workspaceRoot()))
+            return;
+        await withLocalModelRuntimeRepository(workspaceRoot(), async (repo) => {
+            await repo.appendTransitionRecord({
+                session_id: sessionId,
+                subject_kind: "workspace_session",
+                subject_id: capturedWorkspaceSessionId,
+                from: "active",
+                to: capturedCleanupStatus === "archived" ? "archived" : capturedCleanupStatus === "removed" ? "removed" : "failed",
+                reason: capturedCleanupError
+                    ? `Workspace session ${capturedWorkspaceSessionId} cleanup failed: ${capturedCleanupError}`
+                    : `Workspace session ${capturedWorkspaceSessionId} cleanup completed.`,
+                reason_code: capturedCleanupError ? "cleanup_failed" : "cleanup_complete",
+                evidence_refs: [capturedWorkspaceSessionId],
+            });
+        }).catch(() => undefined);
+    });
 }
-async function runSessionLoop(sessionId, context, autoCleanup) {
+function classifyTurnOutcome(responseStatus, policy, toolCallCount) {
+    if (responseStatus === "blocked" || responseStatus === "failed") {
+        return {
+            outcome: "escalation_blocker",
+            reason: `Turn ended with status=${responseStatus}; external action required`,
+        };
+    }
+    if (policy.silent_unless_blocked && toolCallCount === 0) {
+        return {
+            outcome: "no_op_success",
+            reason: "silent_unless_blocked=true and turn produced no tool calls",
+        };
+    }
+    return {
+        outcome: "meaningful_completion",
+        reason: `Turn completed normally with ${toolCallCount} tool call(s)`,
+    };
+}
+async function runSessionLoop(sessionId, context, autoCleanup, runtimeProfileSnapshot) {
     const active = activeSessions.get(sessionId);
     let shouldRunAfterHook = false;
     let workspaceSessionId = "";
     try {
-        const runtimeProfile = readRuntimeProfile();
-        const autonomyPolicy = normalizeAutonomyPolicy(runtimeProfile.autonomy);
-        const continuityPolicy = normalizeContinuityPolicy(runtimeProfile.continuity);
+        const autonomyPolicy = normalizeAutonomyPolicy(runtimeProfileSnapshot.profile.autonomy);
+        const continuityPolicy = normalizeContinuityPolicy(runtimeProfileSnapshot.profile.continuity);
+        setSessionPhase(sessionId, "registry_start");
         const registryStart = await mutateRegistry((registry) => {
             const session = findSession(registry, sessionId);
             if (!session)
@@ -374,6 +565,7 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
         if (!registryStart) {
             throw new Error(`Failed to start unattended session: ${sessionId}`);
         }
+        setSessionPhase(sessionId, "preflight");
         const preflight = runAutonomyChecks("before_run", autonomyPolicy, context);
         if (!preflight.ok) {
             const summary = `Autonomy preflight blocked execution: ${preflight.summary}`;
@@ -391,9 +583,36 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
             }
             return;
         }
-        const beforeRun = runWorkspaceSessionHook({
+        // ── Plan validation preflight (Task 6) ───────────────────────────────
+        {
+            const currentValidatedPlanId = registryStart.validated_plan_id;
+            if (!currentValidatedPlanId) {
+                const task = registryStart.current_task || registryStart.task;
+                try {
+                    const proposal = proposePlanDeterministic(task);
+                    const verdict = await validatePlan({ proposal, sessionId });
+                    if (verdict.ok) {
+                        // Persist validated_plan_id opportunistically. This is a readiness hint,
+                        // not a hard gate on unattended execution.
+                        await mutateRegistry((registry) => {
+                            const session = findSession(registry, sessionId);
+                            if (session)
+                                session.validated_plan_id = verdict.plan_id;
+                        }).catch(() => undefined);
+                    }
+                }
+                catch {
+                    // Preflight validation is best-effort. Unattended runtime should still run
+                    // even when the planner/model path or trace lookup is unavailable.
+                }
+            }
+        }
+        // ── End plan validation preflight ────────────────────────────────────
+        setSessionPhase(sessionId, "workspace_before_run");
+        const beforeRun = await runWorkspaceSessionHook({
             session_id: registryStart.workspace_session_id,
             kind: "before_run",
+            runtime_profile_path: runtimeProfileSnapshot.path,
         });
         if (!beforeRun.ok) {
             const summary = beforeRun.error ?? "before_run hook failed";
@@ -411,6 +630,56 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
         shouldRunAfterHook = true;
         let currentTask = registryStart.current_task;
         let previousToolCalls = [];
+        const runtimeStatus = storeExistsSync(workspaceRoot())
+            ? await withLocalModelRuntimeRepository(workspaceRoot(), async (repo) => repo.getRuntimeStatus(sessionId))
+            : undefined;
+        const executionPolicy = resolveLocalModelExecutionPolicy({
+            provider: "",
+            model: "",
+            role: "orchestrator",
+            task: currentTask,
+            requested_model_class: runtimeStatus?.model_class,
+        });
+        const effectiveModelClass = executionPolicy.model_class;
+        // Stall restart state — session-level, reset on successful turn.
+        // Seeded runtime status is authoritative when present.
+        let consecutiveStallRestarts = runtimeStatus?.stall_restart_count ?? 0;
+        let isStallRestart = false;
+        let stallRestartContext = "";
+        // Liveness defaults are explicit runtime policy. The resolved model class
+        // only informs the default budget profile when the caller has not already
+        // supplied a workspace/session budget or status-seeded runtime budget.
+        const livenessDefaults = getLivenessDefaults(effectiveModelClass);
+        const effectiveTurnBudgetMs = runtimeStatus?.turn_budget_ms ?? registryStart.turn_timeout_ms ?? livenessDefaults.turn_budget_ms;
+        const effectiveStallWindowMs = runtimeStatus?.stall_window_ms ?? livenessDefaults.stall_window_ms;
+        const maxStallRestarts = livenessDefaults.max_stall_restarts;
+        const initialBackoffMs = livenessDefaults.initial_backoff_ms;
+        const maxRetryBackoffMs = livenessDefaults.max_retry_backoff_ms;
+        let lastProgressAt = Date.now();
+        let queuedProgress;
+        let progressWrite;
+        const pumpProgressWrite = () => {
+            if (progressWrite)
+                return progressWrite;
+            progressWrite = (async () => {
+                while (queuedProgress) {
+                    const next = queuedProgress;
+                    queuedProgress = undefined;
+                    await touchRuntimeProgress(sessionId, next.reason, next.at).catch(() => undefined);
+                }
+            })().finally(() => {
+                progressWrite = undefined;
+            });
+            return progressWrite;
+        };
+        const noteProgress = (reason, at = Date.now()) => {
+            lastProgressAt = at;
+            queuedProgress = { reason, at };
+            void pumpProgressWrite();
+        };
+        const flushProgress = async () => {
+            await pumpProgressWrite().catch(() => undefined);
+        };
         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.`);
@@ -423,6 +692,7 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
                 }
                 return;
             }
+            setSessionPhase(sessionId, "turn_preparing", `Turn ${turnNumber}`);
             const sessionSnapshot = await mutateRegistry((registry) => {
                 const session = findSession(registry, sessionId);
                 if (!session)
@@ -435,10 +705,14 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
                 throw new Error(`Missing unattended session ${sessionId}`);
             const turnStartedAt = new Date().toISOString();
             const paths = buildTurnPaths(sessionId, sessionSnapshot.workspace_path, turnNumber);
-            const toolCatalog = listRuntimeToolSpecs().map((tool) => ({
-                name: tool.name,
-                description: tool.description,
-                input_schema: tool.input_schema,
+            // Build capability-filtered tool catalog in-memory from the resolved model class.
+            const filteredCatalog = buildFilteredToolCatalog(effectiveModelClass);
+            const capabilitySnapshotId = randomUUID();
+            const selectedBudget = resolveEffectiveSurgicalReadBudget(runtimeProfileSnapshot.profile, effectiveModelClass);
+            const toolCatalog = filteredCatalog.entries.map((e) => ({
+                name: e.name,
+                description: e.description,
+                input_schema: e.input_schema,
             }));
             const turnRecall = autonomyPolicy.recall_context
                 ? buildAceRecallContext({
@@ -452,8 +726,11 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
                     snapshot_name: resolveSnapshotName(context),
                 })
                 : undefined;
-            const prompt = renderRuntimePrompt({
-                task: currentTask,
+            const taskWithStallHint = isStallRestart
+                ? `${stallRestartContext}\n\nOriginal task: ${currentTask}`
+                : currentTask;
+            let prompt = renderRuntimePromptFromSnapshot(runtimeProfileSnapshot, {
+                task: taskWithStallHint,
                 session_id: sessionId,
                 turn_number: turnNumber,
                 workspace_path: sessionSnapshot.workspace_path,
@@ -466,6 +743,16 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
                 ace_continuity_packet_md: renderAceContinuityPromptBlock(turnContinuity),
                 ace_context_snapshot_md: renderAceSnapshotPromptBlock(turnRecall),
             });
+            if (effectiveModelClass === "small_local") {
+                prompt += [
+                    "",
+                    "## ACE-Owned Preflight Packet",
+                    `- status: ${preflight.ok ? "passed" : "blocked"}`,
+                    `- summary: ${preflight.summary}`,
+                    `- evidence_refs: agent-state/TASK.md, agent-state/STATUS.md, agent-state/QUALITY_GATES.md`,
+                    "- model_visible_tools: route_task or run_orchestrator only when delegation is needed; ACE owns recall_context, validate_framework, and get_framework_status.",
+                ].join("\n");
+            }
             const requestPayload = {
                 session_id: sessionId,
                 turn_number: turnNumber,
@@ -493,13 +780,106 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
             };
             writeFileSync(paths.tempPromptPath, prompt, "utf-8");
             writeFileSync(paths.tempRequestPath, 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),
+            // Sidecar: persist capability snapshot, tool-choice audit, turn snapshot, and TURN_STARTED event.
+            // These are audit evidence — the shell must not wait for them before starting.
+            const capturedSnapshotId = capabilitySnapshotId;
+            const capturedTurnNumber = turnNumber;
+            const capturedSnapshot = sessionSnapshot;
+            const capturedRecall = turnRecall;
+            const capturedContinuity = turnContinuity;
+            const capturedBudget = selectedBudget;
+            const capturedCatalog = filteredCatalog;
+            scheduleRuntimeSidecar(sessionId, `capability-snapshot-turn-${turnNumber}`, async () => {
+                if (!storeExistsSync(workspaceRoot()))
+                    return;
+                let toolChoiceAuditId;
+                await withLocalModelRuntimeRepository(workspaceRoot(), async (repo) => {
+                    const toolChoiceAudit = buildToolChoiceAuditRecord({
+                        session_id: sessionId,
+                        turn_number: capturedTurnNumber,
+                        captured_at: Date.now(),
+                        model_class: effectiveModelClass,
+                        capability_snapshot_id: capturedSnapshotId,
+                        filteredCatalog: capturedCatalog,
+                        selected_budget: { read_file_lines_max_lines: capturedBudget.read_file_lines_max_lines },
+                    });
+                    toolChoiceAuditId = toolChoiceAudit.audit_id;
+                    await repo.saveToolChoiceAudit(toolChoiceAudit);
+                    await repo.saveCapabilitySnapshot({
+                        snapshot_id: capturedSnapshotId,
+                        session_id: sessionId,
+                        turn_number: capturedTurnNumber,
+                        captured_at: Date.now(),
+                        model_class: effectiveModelClass,
+                        allowed_tools: capturedCatalog.entries.map((e) => e.name),
+                        unavailable_tools: capturedCatalog.unavailable_tools,
+                        tool_cost_class: capturedCatalog.tool_cost_class,
+                    });
+                    await repo.appendTransitionRecord({
+                        session_id: sessionId,
+                        subject_kind: "capability",
+                        subject_id: `${sessionId}/${capturedTurnNumber}`,
+                        from: "previous_turn",
+                        to: `model_class:${effectiveModelClass}`,
+                        reason: `Capability snapshot captured for turn ${capturedTurnNumber}`,
+                        evidence_refs: [capturedSnapshotId],
+                    });
+                }).catch(() => undefined);
+                const snapStorePath = getWorkspaceStorePath(workspaceRoot());
+                await withStoreWriteCoordinator(snapStorePath, async () => {
+                    const snapStore = await openStore(snapStorePath);
+                    try {
+                        const snapRepo = new LocalModelRuntimeRepository(snapStore);
+                        const currentStatus = await snapRepo.getRuntimeStatus(sessionId);
+                        const updatedStatus = await snapRepo.upsertRuntimeStatusWithTransition({
+                            ...(currentStatus ?? {
+                                session_id: sessionId,
+                                process_id: process.pid,
+                                turn_count: capturedTurnNumber,
+                                bridge_status: "running",
+                                preflight_state: "ready",
+                                surface_kind: "unattended_runtime",
+                            }),
+                            active_workspace_path: capturedSnapshot.workspace_path,
+                            active_workspace_session_id: registryStart.workspace_session_id,
+                            workspace_hook_health: "ok",
+                            last_progress_at: Date.now(),
+                        }, {
+                            from: currentStatus?.bridge_status,
+                            reason: `Turn ${capturedTurnNumber} snapshot captured with capability and prompt assembly state`,
+                            evidence_refs: [capturedSnapshotId, toolChoiceAuditId].filter((ref) => typeof ref === "string" && ref.length > 0),
+                        });
+                        const turnSnapshot = {
+                            snapshot_id: randomUUID(),
+                            session_id: sessionId,
+                            turn_number: capturedTurnNumber,
+                            captured_at: Date.now(),
+                            preflight: preflight,
+                            recall: (capturedRecall ?? null),
+                            continuity: (capturedContinuity ?? null),
+                            capability_snapshot_id: capturedSnapshotId,
+                            tool_choice_audit_id: toolChoiceAuditId ?? null,
+                            surface_kind: updatedStatus.surface_kind ?? currentStatus?.surface_kind ?? "tui_interactive",
+                        };
+                        await snapRepo.saveTurnSnapshot(turnSnapshot);
+                        await snapStore.commit();
+                    }
+                    finally {
+                        await snapStore.close();
+                    }
+                }, { operation_label: "runtime-executor-turn-snapshot" });
             });
-            const shellResult = await runShellCommand(runtimeProfile.executor.command ?? "", {
+            scheduleRuntimeSidecar(sessionId, `turn-started-event-${turnNumber}`, async () => {
+                await emitExecutorEvent("RUNTIME_EXECUTOR_TURN_STARTED", "in_progress", `Unattended session ${sessionId} turn ${capturedTurnNumber} started.`, {
+                    session_id: sessionId,
+                    turn_number: capturedTurnNumber,
+                    workspace_path: capturedSnapshot.workspace_path,
+                    ...vericifyPayloadForSession(capturedSnapshot),
+                });
+            });
+            noteProgress(`Turn ${turnNumber} started.`);
+            setSessionPhase(sessionId, "turn_executing", `Turn ${turnNumber} shell`);
+            const shellResult = await runShellCommand(runtimeProfileSnapshot.profile.executor.command ?? "", {
                 cwd: sessionSnapshot.workspace_path,
                 env: {
                     ...process.env,
@@ -510,31 +890,114 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
                     ACE_RUNTIME_REQUEST_FILE: paths.tempRequestPath,
                     ACE_RUNTIME_RESPONSE_FILE: paths.tempResponsePath,
                 },
-                timeout_ms: sessionSnapshot.turn_timeout_ms,
+                timeout_ms: effectiveTurnBudgetMs,
+                stall_timeout_ms: effectiveStallWindowMs,
                 on_spawn: (child) => {
                     if (active)
                         active.child = child;
                 },
+                on_progress: (event) => {
+                    noteProgress(`Executor ${event.source} progress during turn ${turnNumber}.`, event.at);
+                },
             });
             if (active)
                 active.child = undefined;
-            const finalizeTurnArtifacts = async (fallbackResponse) => {
-                const responseRaw = existsSync(paths.tempResponsePath)
-                    ? readFileSync(paths.tempResponsePath, "utf-8")
-                    : fallbackResponse;
-                const artifactPaths = await persistTurnArtifacts(paths, prompt, requestPayload, responseRaw);
+            lastProgressAt = shellResult.last_progress_at;
+            await flushProgress();
+            setSessionPhase(sessionId, "turn_persisting", `Turn ${turnNumber} response`);
+            // Stall detection is based on the inter-progress window, not the total turn budget.
+            if (shellResult.timed_out && shellResult.timeout_reason === "stall") {
+                consecutiveStallRestarts += 1;
+                // Update runtime status: sleep_state = "stalled"
                 if (storeExistsSync(workspaceRoot())) {
-                    rmSync(paths.tempDir, { recursive: true, force: true });
+                    await withLocalModelRuntimeRepository(workspaceRoot(), async (repo) => {
+                        const currentStatus = await repo.getRuntimeStatus(sessionId);
+                        if (currentStatus) {
+                            await repo.upsertRuntimeStatusWithTransition({
+                                ...currentStatus,
+                                sleep_state: "stalled",
+                                stall_restart_count: (currentStatus.stall_restart_count ?? 0) + 1,
+                                last_progress_at: lastProgressAt,
+                            }, {
+                                from: currentStatus.bridge_status,
+                                reason: `Turn ${turnNumber} exceeded stall_window_ms (${effectiveStallWindowMs}ms) without progress. Stall restart ${consecutiveStallRestarts}/${maxStallRestarts}.`,
+                                evidence_refs: [
+                                    `turn:${turnNumber}`,
+                                    `stall_window_ms:${effectiveStallWindowMs}`,
+                                    `last_progress_at:${lastProgressAt}`,
+                                ],
+                            });
+                            await repo.appendTransitionRecord({
+                                session_id: sessionId,
+                                subject_kind: "runtime_status",
+                                subject_id: sessionId,
+                                from: "running",
+                                to: "stalled",
+                                reason: `Turn ${turnNumber} exceeded stall_window_ms (${effectiveStallWindowMs}ms) without progress. Stall restart ${consecutiveStallRestarts}/${maxStallRestarts}.`,
+                                evidence_refs: [
+                                    `turn:${turnNumber}`,
+                                    `stall_window_ms:${effectiveStallWindowMs}`,
+                                    `last_progress_at:${lastProgressAt}`,
+                                ],
+                            });
+                        }
+                    }).catch(() => undefined);
                 }
-                return artifactPaths;
-            };
+                if (consecutiveStallRestarts > maxStallRestarts) {
+                    // Exhausted restarts — escalate to blocked
+                    const exhaustedSummary = `Stall restart limit exhausted after ${maxStallRestarts} attempts. Session blocked.`;
+                    if (storeExistsSync(workspaceRoot())) {
+                        await withLocalModelRuntimeRepository(workspaceRoot(), async (repo) => {
+                            const currentStatus = await repo.getRuntimeStatus(sessionId);
+                            if (currentStatus) {
+                                await repo.upsertRuntimeStatusWithTransition({
+                                    ...currentStatus,
+                                    bridge_status: "blocked",
+                                    blocked_reason: "stall_restart_exhausted",
+                                    sleep_state: "stalled",
+                                }, {
+                                    from: currentStatus.bridge_status,
+                                    reason: exhaustedSummary,
+                                    reason_code: "stall_restart_exhausted",
+                                    evidence_refs: [`stall_restarts:${consecutiveStallRestarts}`],
+                                });
+                                await repo.appendTransitionRecord({
+                                    session_id: sessionId,
+                                    subject_kind: "runtime_status",
+                                    subject_id: sessionId,
+                                    from: "stalled",
+                                    to: "blocked",
+                                    reason: exhaustedSummary,
+                                    reason_code: "stall_restart_exhausted",
+                                    evidence_refs: [`stall_restarts:${consecutiveStallRestarts}`],
+                                });
+                            }
+                        }).catch(() => undefined);
+                    }
+                    await finalizeSession(sessionId, "blocked", exhaustedSummary, exhaustedSummary);
+                    await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_FAILED", "blocked", exhaustedSummary, {
+                        session_id: sessionId,
+                        turn_number: turnNumber,
+                        blocked_reason: "stall_restart_exhausted",
+                        ...vericifyPayloadForSession(sessionSnapshot),
+                    });
+                    return;
+                }
+                // Backoff before restart
+                const backoffMs = Math.min(initialBackoffMs * Math.pow(2, consecutiveStallRestarts - 1), maxRetryBackoffMs, effectiveStallWindowMs);
+                await new Promise((resolve) => setTimeout(resolve, backoffMs));
+                // Set up restart context for the next turn
+                isStallRestart = true;
+                stallRestartContext = `The previous turn (turn ${turnNumber}) stalled after ${effectiveStallWindowMs}ms without progress inside turn_budget_ms=${effectiveTurnBudgetMs}ms; resume from current workspace state — do not restart from scratch.`;
+                continue;
+            }
+            // Reset stall state on successful turn completion
+            consecutiveStallRestarts = 0;
+            isStallRestart = false;
+            stallRestartContext = "";
             if (active?.stop_requested) {
                 const turnEndedAt = new Date().toISOString();
-                const artifactPaths = await finalizeTurnArtifacts(JSON.stringify({
-                    status: "failed",
-                    summary: `Turn ${turnNumber} stopped by request.`,
-                    tool_calls: [],
-                }, null, 2));
+                const stoppedSummary = `Turn ${turnNumber} stopped by request.`;
                 await mutateRegistry((registry) => {
                     const session = findSession(registry, sessionId);
                     if (!session)
@@ -546,10 +1009,10 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
                         ended_at: turnEndedAt,
                         status: "stopped",
                         response_status: "failed",
-                        summary: `Turn ${turnNumber} stopped by request.`,
-                        prompt_path: artifactPaths.promptPath,
-                        request_path: artifactPaths.requestPath,
-                        response_path: artifactPaths.responsePath,
+                        summary: stoppedSummary,
+                        prompt_path: paths.tempPromptPath,
+                        request_path: paths.tempRequestPath,
+                        response_path: paths.tempResponsePath,
                         exit_code: shellResult.exit_code,
                         stdout: clipOutput(shellResult.stdout),
                         stderr: clipOutput(shellResult.stderr),
@@ -559,13 +1022,12 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
                     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),
-                    });
+                scheduleRuntimeSidecar(sessionId, "session-stopped-event", async () => {
+                    if (!stopped)
+                        return;
+                    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;
@@ -575,11 +1037,6 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
                 const turnEndedAt = new Date().toISOString();
-                const artifactPaths = await finalizeTurnArtifacts(JSON.stringify({
-                    status: "failed",
-                    summary: message,
-                    tool_calls: [],
-                }, null, 2));
                 await mutateRegistry((registry) => {
                     const session = findSession(registry, sessionId);
                     if (!session)
@@ -592,9 +1049,9 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
                         status: "failed",
                         response_status: "failed",
                         summary: message,
-                        prompt_path: artifactPaths.promptPath,
-                        request_path: artifactPaths.requestPath,
-                        response_path: artifactPaths.responsePath,
+                        prompt_path: paths.tempPromptPath,
+                        request_path: paths.tempRequestPath,
+                        response_path: paths.tempResponsePath,
                         exit_code: shellResult.exit_code,
                         stdout: clipOutput(shellResult.stdout),
                         stderr: clipOutput(shellResult.stderr),
@@ -604,28 +1061,30 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
                     session.turn_count = session.turns.length;
                 });
                 const failed = await finalizeSession(sessionId, "failed", message, message);
-                if (failed) {
+                scheduleRuntimeSidecar(sessionId, "session-parse-failed-event", async () => {
+                    if (!failed)
+                        return;
                     await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_FAILED", "fail", message, {
                         session_id: sessionId,
                         turn_number: turnNumber,
                         ...vericifyPayloadForSession(failed),
                     });
-                    await emitVericifyProcessPostForSession(failed, "blocker", message, [
-                        "runtime-executor",
-                    ]);
-                }
+                    await emitVericifyProcessPostForSession(failed, "blocker", message, ["runtime-executor"]);
+                });
                 return;
             }
             const normalizedSummary = normalizeWorkspaceSummary(response.summary, sessionSnapshot.workspace_path);
-            const artifactPaths = await finalizeTurnArtifacts(readFileSync(paths.tempResponsePath, "utf-8"));
             const toolCalls = [];
             for (const toolCall of response.tool_calls) {
                 const toolStartedAt = new Date().toISOString();
+                noteProgress(`Runtime tool ${toolCall.name} started during turn ${turnNumber}.`);
                 const toolResult = await executeRuntimeTool(toolCall.name, toolCall.input, {
                     session_id: sessionId,
                     workspace_path: sessionSnapshot.workspace_path,
                     turn_number: turnNumber,
                 });
+                noteProgress(`Runtime tool ${toolCall.name} finished during turn ${turnNumber}.`);
+                await flushProgress();
                 toolCalls.push(mapToolCallResult(toolResult, toolStartedAt));
             }
             previousToolCalls = toolCalls;
@@ -635,6 +1094,9 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
                 : response.status === "failed"
                     ? "failed"
                     : "completed";
+            const effectivePolicy = sessionSnapshot.output_policy ?? DEFAULT_TURN_OUTPUT_POLICY;
+            const { outcome: turnOutcome, reason: outcomeReason } = classifyTurnOutcome(response.status, effectivePolicy, toolCalls.length);
+            // Use temp file paths for the registry turn record; the ACEPACK artifact write is a sidecar.
             await mutateRegistry((registry) => {
                 const session = findSession(registry, sessionId);
                 if (!session)
@@ -647,27 +1109,62 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
                     status: turnStatus,
                     response_status: response.status,
                     summary: normalizedSummary,
-                    prompt_path: artifactPaths.promptPath,
-                    request_path: artifactPaths.requestPath,
-                    response_path: artifactPaths.responsePath,
+                    prompt_path: paths.tempPromptPath,
+                    request_path: paths.tempRequestPath,
+                    response_path: paths.tempResponsePath,
                     exit_code: shellResult.exit_code,
                     stdout: clipOutput(shellResult.stdout),
                     stderr: clipOutput(shellResult.stderr),
                     tool_calls: toolCalls,
+                    turn_outcome: turnOutcome,
+                    outcome_reason: outcomeReason,
                 };
                 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", normalizedSummary, {
-                session_id: sessionId,
-                turn_number: turnNumber,
-                response_status: response.status,
-                tool_call_count: toolCalls.length,
-                ...vericifyPayloadForSession(sessionSnapshot),
+            // Sidecar: persist turn artifacts to ACEPACK, emit outcome transition and events.
+            const capturedTurnStatus = turnStatus;
+            const capturedTurnOutcome = turnOutcome;
+            const capturedOutcomeReason = outcomeReason;
+            const capturedToolCalls = toolCalls;
+            const capturedNormalizedSummary = normalizedSummary;
+            const capturedArtifactPaths = { promptPath: paths.tempPromptPath, requestPath: paths.tempRequestPath, responsePath: paths.tempResponsePath };
+            const capturedSnapshot2 = sessionSnapshot;
+            scheduleRuntimeSidecar(sessionId, `turn-artifacts-${turnNumber}`, async () => {
+                const responseRaw = existsSync(paths.tempResponsePath)
+                    ? readFileSync(paths.tempResponsePath, "utf-8")
+                    : JSON.stringify({ status: capturedTurnStatus, summary: capturedNormalizedSummary, tool_calls: [] }, null, 2);
+                await persistTurnArtifacts(paths, prompt, requestPayload, responseRaw).catch(() => undefined);
+            });
+            scheduleRuntimeSidecar(sessionId, `turn-outcome-transition-${turnNumber}`, async () => {
+                if (!storeExistsSync(workspaceRoot()))
+                    return;
+                await withLocalModelRuntimeRepository(workspaceRoot(), async (repo) => {
+                    await repo.appendTransitionRecord({
+                        session_id: sessionId,
+                        subject_kind: "turn",
+                        subject_id: `${sessionId}/${capturedTurnNumber}`,
+                        from: "in_progress",
+                        to: capturedTurnOutcome,
+                        reason: capturedOutcomeReason,
+                        evidence_refs: capturedToolCalls.slice(0, 3).map((tc) => tc.tool_name),
+                    });
+                }).catch(() => undefined);
+                await emitExecutorEvent(capturedTurnStatus === "failed" ? "RUNTIME_EXECUTOR_TURN_FAILED" : "RUNTIME_EXECUTOR_TURN_COMPLETED", capturedTurnStatus === "blocked" ? "blocked" : capturedTurnStatus === "failed" ? "fail" : "done", capturedNormalizedSummary, {
+                    session_id: sessionId,
+                    turn_number: capturedTurnNumber,
+                    response_status: capturedTurnStatus,
+                    tool_call_count: capturedToolCalls.length,
+                    ...vericifyPayloadForSession(capturedSnapshot2),
+                });
+                const vericifyKind = capturedTurnOutcome === "escalation_blocker"
+                    ? "blocker"
+                    : capturedTurnOutcome === "meaningful_completion"
+                        ? "completion"
+                        : "progress";
+                await emitVericifyProcessPostForSession(capturedSnapshot2, vericifyKind, `[${capturedTurnOutcome}] turn ${capturedTurnNumber}: ${capturedNormalizedSummary}`, capturedToolCalls.slice(0, 5).map((tc) => tc.tool_name), [String(capturedTurnNumber)]);
             });
             if (response.status === "continue") {
                 currentTask = response.next_task?.trim() || currentTask;
@@ -675,69 +1172,82 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
             }
             if (response.status === "blocked") {
                 await finalizeSession(sessionId, "blocked", normalizedSummary, normalizedSummary);
-                await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_BLOCKED", "blocked", normalizedSummary, {
-                    session_id: sessionId,
-                    turn_number: turnNumber,
-                    ...vericifyPayloadForSession(sessionSnapshot),
+                scheduleRuntimeSidecar(sessionId, "session-blocked-event", async () => {
+                    await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_BLOCKED", "blocked", capturedNormalizedSummary, {
+                        session_id: sessionId,
+                        turn_number: capturedTurnNumber,
+                        ...vericifyPayloadForSession(capturedSnapshot2),
+                    });
+                    await emitVericifyProcessPostForSession(capturedSnapshot2, "blocker", capturedNormalizedSummary, [
+                        "runtime-executor",
+                    ]);
                 });
-                await emitVericifyProcessPostForSession(sessionSnapshot, "blocker", normalizedSummary, [
-                    "runtime-executor",
-                ]);
                 return;
             }
             if (response.status === "failed") {
                 const failed = await finalizeSession(sessionId, "failed", normalizedSummary, normalizedSummary);
-                await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_FAILED", "fail", normalizedSummary, {
-                    session_id: sessionId,
-                    turn_number: turnNumber,
-                    ...(failed ? vericifyPayloadForSession(failed) : vericifyPayloadForSession(sessionSnapshot)),
+                scheduleRuntimeSidecar(sessionId, "session-failed-event", async () => {
+                    await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_FAILED", "fail", capturedNormalizedSummary, {
+                        session_id: sessionId,
+                        turn_number: capturedTurnNumber,
+                        ...(failed ? vericifyPayloadForSession(failed) : vericifyPayloadForSession(capturedSnapshot2)),
+                    });
+                    await emitVericifyProcessPostForSession(failed ?? capturedSnapshot2, "blocker", capturedNormalizedSummary, ["runtime-executor"]);
                 });
-                await emitVericifyProcessPostForSession(failed ?? sessionSnapshot, "blocker", normalizedSummary, ["runtime-executor"]);
                 return;
             }
             const stopCheck = runAutonomyChecks("stop", autonomyPolicy, context);
             if (!stopCheck.ok) {
                 const summary = `Autonomy stop checks failed: ${stopCheck.summary}`;
                 const blocked = await finalizeSession(sessionId, "blocked", summary, summary);
-                await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_BLOCKED", "blocked", summary, {
-                    session_id: sessionId,
-                    turn_number: turnNumber,
-                    executed_checks: stopCheck.executed_checks,
-                    skipped_checks: stopCheck.skipped_checks,
-                    ...(blocked ? vericifyPayloadForSession(blocked) : vericifyPayloadForSession(sessionSnapshot)),
+                scheduleRuntimeSidecar(sessionId, "session-stop-check-blocked-event", async () => {
+                    await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_BLOCKED", "blocked", summary, {
+                        session_id: sessionId,
+                        turn_number: capturedTurnNumber,
+                        executed_checks: stopCheck.executed_checks,
+                        skipped_checks: stopCheck.skipped_checks,
+                        ...(blocked ? vericifyPayloadForSession(blocked) : vericifyPayloadForSession(capturedSnapshot2)),
+                    });
+                    await emitVericifyProcessPostForSession(blocked ?? capturedSnapshot2, "blocker", summary, ["runtime-executor"]);
                 });
-                await emitVericifyProcessPostForSession(blocked ?? sessionSnapshot, "blocker", summary, ["runtime-executor"]);
                 return;
             }
+            // Critical: finalize session status immediately so waitForUnattendedSession resolves correctly.
             const completed = await finalizeSession(sessionId, "completed", normalizedSummary);
-            if (completed) {
-                await appendRunLedgerEntrySafe({
-                    tool: "runtime-executor",
-                    category: "major_update",
-                    message: normalizedSummary,
-                    artifacts: [
-                        RUNTIME_EXECUTOR_SESSION_REGISTRY_REL_PATH,
-                        artifactPaths.promptPath,
-                        artifactPaths.requestPath,
-                        artifactPaths.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", normalizedSummary, {
+            scheduleRuntimeSidecar(sessionId, "session-completed-events", async () => {
+                await delaySessionCompletedSidecarIfRequested(sessionId);
+                await emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_COMPLETED", "done", capturedNormalizedSummary, {
                     session_id: sessionId,
-                    turn_number: turnNumber,
-                    workspace_session_id: completed.workspace_session_id,
-                    ...vericifyPayloadForSession(completed),
+                    turn_number: capturedTurnNumber,
+                    workspace_session_id: capturedSnapshot2.workspace_session_id,
+                    ...vericifyPayloadForSession(capturedSnapshot2),
                 });
-                await emitVericifyProcessPostForSession(completed, "completion", normalizedSummary, [
-                    "runtime-executor",
-                ]);
-            }
+                if (completed) {
+                    await appendRunLedgerEntrySafe({
+                        tool: "runtime-executor",
+                        category: "major_update",
+                        message: capturedNormalizedSummary,
+                        artifacts: [
+                            RUNTIME_EXECUTOR_SESSION_REGISTRY_REL_PATH,
+                            capturedArtifactPaths.promptPath,
+                            capturedArtifactPaths.requestPath,
+                            capturedArtifactPaths.responsePath,
+                        ],
+                        metadata: {
+                            session_id: sessionId,
+                            turn_number: capturedTurnNumber,
+                            workspace_session_id: completed.workspace_session_id,
+                            ...vericifyPayloadForSession(completed),
+                        },
+                    }).catch(() => undefined);
+                    await emitVericifyProcessPostForSession(completed, "completion", capturedNormalizedSummary, [
+                        "runtime-executor",
+                    ]);
+                    if (isVericifyBridgeEnabled()) {
+                        refreshVericifyBridgeSnapshotSafe();
+                    }
+                }
+            });
             return;
         }
         const exhausted = `Unattended session ${sessionId} exceeded max_turns=${registryStart.max_turns}`;
@@ -790,10 +1300,15 @@ async function runSessionLoop(sessionId, context, autoCleanup) {
     }
     finally {
         if (workspaceSessionId && autoCleanup) {
-            await runCleanup(sessionId, workspaceSessionId, shouldRunAfterHook).catch(() => undefined);
+            setSessionPhase(sessionId, "cleanup_capturing");
+            await runCleanup(sessionId, workspaceSessionId, shouldRunAfterHook, runtimeProfileSnapshot.path).catch(() => undefined);
         }
+        // Release sidecars to run in background — do not await them.
+        // Critical-path registry and workspace writes are already complete.
+        releaseSidecarsAndForget(sessionId);
         const active = activeSessions.get(sessionId);
         if (active) {
+            active.phase = "completed";
             active.child = undefined;
             activeSessions.delete(sessionId);
         }
@@ -821,18 +1336,29 @@ export function getUnattendedSession(sessionId) {
 export function getRuntimeExecutorSessionRegistryPath() {
     return registryPath();
 }
-export function startUnattendedSession(input) {
+export async function startUnattendedSession(input) {
     const registryPathValue = registryPath();
-    const runtimeProfile = readRuntimeProfile();
+    let runtimeProfileSnapshot;
+    try {
+        runtimeProfileSnapshot = loadCurrentRuntimeProfile();
+    }
+    catch (error) {
+        return Promise.resolve({
+            ok: false,
+            registry_path: registryPathValue,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
     const storeBackedWorkspace = storeExistsSync(workspaceRoot());
-    if (runtimeProfile.runtime.mode !== "unattended") {
+    if (runtimeProfileSnapshot.profile.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) {
+    if (!runtimeProfileSnapshot.profile.executor.command ||
+        runtimeProfileSnapshot.profile.executor.command.trim().length === 0) {
         return Promise.resolve({
             ok: false,
             registry_path: registryPathValue,
@@ -848,10 +1374,11 @@ export function startUnattendedSession(input) {
             error: `Unattended session id already exists: ${sessionId}`,
         });
     }
-    const workspace = createWorkspaceSession({
+    const workspace = await createWorkspaceSessionAsync({
         source: "executor",
         workspace_name: input.workspace_name,
         workspace_path: input.workspace_path,
+        runtime_profile_path: runtimeProfileSnapshot.path,
         objective_id: input.objective_id,
         tracker_item_id: input.tracker_item_id,
     });
@@ -862,59 +1389,80 @@ export function startUnattendedSession(input) {
             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 workspaceSession = workspace.session;
+    const maxTurns = Math.max(1, input.max_turns ?? runtimeProfileSnapshot.profile.executor.max_turns ?? 6);
+    const turnTimeout = Math.max(1_000, input.turn_timeout_ms ?? runtimeProfileSnapshot.profile.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(),
+        runtime_profile_path: runtimeProfileSnapshot.path,
         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,
+        command: runtimeProfileSnapshot.profile.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",
+        output_policy: input.emit_to || input.silent_unless_blocked || input.require_approval_before_emit
+            ? {
+                emit_to: input.emit_to ?? DEFAULT_TURN_OUTPUT_POLICY.emit_to,
+                silent_unless_blocked: input.silent_unless_blocked ?? false,
+                require_approval_before_emit: input.require_approval_before_emit ?? false,
+            }
+            : undefined,
         turns: [],
     };
-    return mutateRegistry((registry) => {
+    await mutateRegistry((registry) => {
         registry.sessions.push(sessionRecord);
-    }).then(() => {
-        const active = {
-            stop_requested: false,
-        };
-        activeSessions.set(sessionId, active);
-        active.completion = runSessionLoop(sessionId, input.context, storeBackedWorkspace || input.auto_cleanup !== false).finally(() => {
-            activeSessions.delete(sessionId);
-        });
-        void emitExecutorEvent("RUNTIME_EXECUTOR_SESSION_STARTED", "started", `Unattended session ${sessionId} created.`, {
+    });
+    // Init sidecar gate BEFORE starting the loop so sidecars can be scheduled immediately.
+    // Sidecars are blocked behind a release signal and only run after the critical path completes.
+    initSessionSidecars(sessionId);
+    const active = {
+        stop_requested: false,
+        phase: "starting",
+        phase_started_at: Date.now(),
+    };
+    activeSessions.set(sessionId, active);
+    active.completion = runSessionLoop(sessionId, input.context, storeBackedWorkspace || input.auto_cleanup !== false, runtimeProfileSnapshot).finally(() => {
+        activeSessions.delete(sessionId);
+    });
+    // Schedule session-started events as sidecars; they run after the critical lane completes.
+    const capturedRecord = sessionRecord;
+    const capturedSession = workspace.session;
+    scheduleRuntimeSidecar(sessionId, "session-started-event", async () => {
+        await 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,
+            workspace_session_id: capturedSession?.session_id,
+            workspace_path: capturedSession?.workspace_path,
             max_turns: maxTurns,
-            ...vericifyPayloadForSession(sessionRecord),
+            ...vericifyPayloadForSession(capturedRecord),
         });
-        void emitVericifyProcessPostForSession(sessionRecord, "intent", `Unattended session ${sessionId} created for task: ${input.task}`, ["runtime-executor"]);
+        await emitVericifyProcessPostForSession(capturedRecord, "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,
-        };
     });
+    return {
+        ok: true,
+        registry_path: registryPathValue,
+        session: sessionRecord,
+        workspace: workspace.session,
+    };
 }
-export async function waitForUnattendedSession(sessionId, timeoutMs = 30_000) {
+export async function waitForUnattendedSession(sessionId, timeoutMsOrOptions = 30_000, options) {
     const registryPathValue = registryPath();
+    const timeoutMs = typeof timeoutMsOrOptions === "number" ? timeoutMsOrOptions : 30_000;
+    const flushSidecars = typeof timeoutMsOrOptions === "number"
+        ? options?.flush_sidecars !== false
+        : timeoutMsOrOptions.flush_sidecars !== false;
     const active = activeSessions.get(sessionId);
     if (!active?.completion) {
         const session = getUnattendedSession(sessionId);
@@ -926,14 +1474,24 @@ export async function waitForUnattendedSession(sessionId, timeoutMs = 30_000) {
                 error: `Unknown unattended session: ${sessionId}`,
             };
         }
+        if (terminalStatus(session.status)) {
+            if (flushSidecars) {
+                await waitForSessionSidecars(sessionId);
+            }
+            const freshSession = getUnattendedSession(sessionId);
+            return {
+                ok: terminalStatus(freshSession?.status ?? session.status),
+                timed_out: false,
+                registry_path: registryPathValue,
+                session: freshSession ?? session,
+            };
+        }
         return {
-            ok: terminalStatus(session.status),
+            ok: false,
             timed_out: false,
             registry_path: registryPathValue,
             session,
-            error: terminalStatus(session.status)
-                ? undefined
-                : `Session ${sessionId} is not active but has not reached a terminal state.`,
+            error: `Session ${sessionId} is not active but has not reached a terminal state.`,
         };
     }
     const timeoutPromise = new Promise((resolve) => {
@@ -943,19 +1501,26 @@ export async function waitForUnattendedSession(sessionId, timeoutMs = 30_000) {
     const outcome = await Promise.race([completion, timeoutPromise]);
     const session = getUnattendedSession(sessionId);
     if (outcome === "timeout") {
+        const phaseInfo = active.phase
+            ? ` (phase=${active.phase}${active.last_checkpoint ? `, checkpoint=${active.last_checkpoint}` : ""})`
+            : "";
         return {
             ok: false,
             timed_out: true,
             registry_path: registryPathValue,
             session,
-            error: `Timed out waiting for unattended session ${sessionId}`,
+            error: `Timed out waiting for unattended session ${sessionId}${phaseInfo}`,
         };
     }
+    if (flushSidecars) {
+        await waitForSessionSidecars(sessionId);
+    }
+    const completedSession = getUnattendedSession(sessionId);
     return {
-        ok: !!session && terminalStatus(session.status),
+        ok: !!completedSession && terminalStatus(completedSession.status),
         timed_out: false,
         registry_path: registryPathValue,
-        session,
+        session: completedSession ?? session,
     };
 }
 export async function stopUnattendedSession(sessionId) {