@voybio/ace-swarm 0.2.4 → 2.4.0

package/dist/job-scheduler.js

@@ -9,7 +9,7 @@ import { openStore } from "./store/ace-packed-store.js";
 import { ProjectionManager } from "./store/materializers/projection-manager.js";
 import { SchedulerRepository } from "./store/repositories/scheduler-repository.js";
 import { getWorkspaceStorePath, readStoreJsonSync, storeExistsSync, } from "./store/store-snapshot.js";
-import { withStoreWriteQueue } from "./store/write-queue.js";
+import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
 // ── Buffered transition-event infrastructure ────────────────────────
 // Events are collected during the scheduler lock and flushed after
 // the lock is released.  Emission is failure-tolerant: a broken
@@ -319,7 +319,7 @@ async function persistSchedulerState(input) {
         return;
     }
     const storePath = getWorkspaceStorePath(root);
-    await withStoreWriteQueue(storePath, async () => {
+    await withStoreWriteCoordinator(storePath, async () => {
         const store = await openStore(storePath);
         try {
             const repo = new SchedulerRepository(store);
@@ -331,7 +331,7 @@ async function persistSchedulerState(input) {
         finally {
             await store.close();
         }
-    });
+    }, { operation_label: "persistSchedulerState" });
 }
 function compareJobs(a, b) {
     const priorityCmp = PRIORITY_WEIGHT[a.priority] - PRIORITY_WEIGHT[b.priority];

package/dist/local-model-runtime.js

@@ -18,6 +18,14 @@ function extractTextContent(result) {
         .filter(Boolean)
         .join("\n");
 }
+function extractRoutedRole(result) {
+    const structured = result?.structuredContent;
+    if (!structured || typeof structured !== "object")
+        return undefined;
+    const suggestedRole = structured
+        .suggested_execution_role;
+    return typeof suggestedRole === "string" ? normalizeRoleCandidate(suggestedRole) : undefined;
+}
 function normalizeRoleCandidate(input) {
     if (!input)
         return undefined;
@@ -37,7 +45,10 @@ async function resolveRole(task, sessionId, requestedRole) {
     }
     const routing = await executeAceInternalTool("route_task", { description: task, domain: "unknown" }, sessionId);
     const routingSummary = extractTextContent(routing);
-    return { role: fallbackRoleForTask(), routingSummary };
+    return {
+        role: extractRoutedRole(routing) ?? fallbackRoleForTask(),
+        routingSummary,
+    };
 }
 function resolveTier(requested, provider, model, role) {
     if (requested && requested !== "auto")

package/dist/model-bridge.d.ts

@@ -11,6 +11,11 @@ export interface BridgeToolResult {
     summary: string;
     isError: boolean;
 }
+export interface BridgeProgressEvent {
+    kind: "model_chunk" | "tool_start" | "tool_finish" | "process_post" | "output" | "thinking";
+    at: number;
+    detail?: Record<string, unknown>;
+}
 export interface BridgeResult {
     bridge_id: string;
     role: string;
@@ -19,6 +24,7 @@ export interface BridgeResult {
     turns: number;
     tool_calls: BridgeToolResult[];
     child_results: BridgeResult[];
+    evidence_refs?: string[];
 }
 export interface ModelBridgeClients {
     ollama: Pick<OllamaClient, "chat" | "abort">;
@@ -39,6 +45,7 @@ export interface ModelBridgeRunOptions {
     onToolResult?: (tool: string, result: BridgeToolResult) => void;
     onOutput?: (text: string) => void;
     onThinking?: (text: string) => void;
+    onProgress?: (event: BridgeProgressEvent) => void;
 }
 export declare class ModelBridge {
     private clients;

package/dist/model-bridge.js

@@ -68,8 +68,8 @@ function parseEnvelope(raw) {
     }
     catch {
         return {
-            status: "message",
-            message: raw.trim(),
+            status: "parse_error",
+            message: summarizeSnippet(raw.trim() || "[empty response]", 240),
         };
     }
 }
@@ -232,13 +232,21 @@ async function collectOllamaResponse(client, model, messages, options) {
             num_ctx: options?.num_ctx ?? 8192,
         },
     })) {
-        combined += chunk.message?.content ?? "";
+        const text = chunk.message?.content ?? "";
+        combined += text;
+        if (text || chunk.done) {
+            options?.onProgress?.({
+                kind: "model_chunk",
+                at: Date.now(),
+                detail: { provider: "ollama", done: Boolean(chunk.done), bytes: Buffer.byteLength(text) },
+            });
+        }
         if (chunk.done)
             break;
     }
     return combined;
 }
-async function collectOpenAiCompatibleResponse(client, provider, model, messages) {
+async function collectOpenAiCompatibleResponse(client, provider, model, messages, onProgress) {
     let combined = "";
     for await (const chunk of client.chat({
         provider,
@@ -248,6 +256,17 @@ async function collectOpenAiCompatibleResponse(client, provider, model, messages
         topP: 0.9,
     })) {
         combined += chunk.text;
+        if (chunk.text || chunk.done) {
+            onProgress?.({
+                kind: "model_chunk",
+                at: Date.now(),
+                detail: {
+                    provider,
+                    done: Boolean(chunk.done),
+                    bytes: Buffer.byteLength(chunk.text),
+                },
+            });
+        }
         if (chunk.done)
             break;
     }
@@ -257,8 +276,9 @@ async function collectProviderResponse(clients, provider, options) {
     return provider.client === "ollama"
         ? collectOllamaResponse(clients.ollama, options.model, options.messages, {
             num_ctx: options.numCtx,
+            onProgress: options.onProgress,
         })
-        : collectOpenAiCompatibleResponse(clients.openai, provider.display, options.model, options.messages);
+        : collectOpenAiCompatibleResponse(clients.openai, provider.display, options.model, options.messages, options.onProgress);
 }
 async function collectProviderResponseWithRetry(clients, provider, options, onThinking) {
     try {
@@ -269,6 +289,11 @@ async function collectProviderResponseWithRetry(clients, provider, options, onTh
             throw error;
         }
         onThinking?.(`Provider error, retrying once: ${formatErrorMessage(error)}`);
+        options.onProgress?.({
+            kind: "thinking",
+            at: Date.now(),
+            detail: { reason: "provider_retry" },
+        });
         return collectProviderResponse(clients, provider, options);
     }
 }
@@ -404,6 +429,9 @@ export class ModelBridge {
         const availableTools = new Set(listAceInternalToolCatalog().map((tool) => tool.name));
         const allowedTools = new Set(aceContext.tools.map((tool) => tool.name));
         this.currentRunChildResults = childResults;
+        const noteProgress = (kind, detail) => {
+            options.onProgress?.({ kind, at: Date.now(), detail });
+        };
         try {
             await appendVericifyProcessPostSafe({
                 run_id: refs.run_id,
@@ -414,24 +442,52 @@ export class ModelBridge {
                 summary: `Bridge started for ${role} via ${provider.display}: ${options.task}`,
                 tool_refs: aceContext.tools.map((tool) => tool.name),
             });
+            noteProgress("process_post", { kind: "intent" });
             for (let turn = 1; turn <= options.maxTurns; turn += 1) {
                 const compressed = compressConversationHistory(messages, numCtx);
                 if (compressed.compressed) {
                     messages.splice(0, messages.length, ...compressed.messages);
                     options.onThinking?.(`Context window compressed to ~${compressed.promptTokens} tokens.`);
+                    noteProgress("thinking", { reason: "context_compressed", turn });
                 }
                 this.activeProviderClient = provider.client;
                 const rawResponse = await collectProviderResponseWithRetry(this.clients, provider, {
                     model: options.model,
                     messages,
                     numCtx,
+                    onProgress: options.onProgress,
                 }, options.onThinking);
                 this.activeProviderClient = null;
                 const envelope = parseEnvelope(rawResponse);
                 if (envelope.thinking) {
                     options.onThinking?.(envelope.thinking);
+                    noteProgress("thinking", { turn });
                 }
                 messages.push({ role: "assistant", content: rawResponse });
+                if (envelope.status === "parse_error") {
+                    const summary = `Model bridge returned malformed or non-JSON output: ${envelope.message ?? "[empty response]"}`;
+                    options.onOutput?.(summary);
+                    noteProgress("output", { status: "parse_error" });
+                    await appendVericifyProcessPostSafe({
+                        run_id: refs.run_id,
+                        branch_id: refs.branch_id,
+                        lane_id: refs.lane_id,
+                        agent_id: `agent-${role}`,
+                        kind: "blocker",
+                        summary,
+                        tool_refs: toolResults.map((entry) => entry.tool),
+                    });
+                    noteProgress("process_post", { kind: "blocker" });
+                    return {
+                        bridge_id: this.bridgeId,
+                        role,
+                        status: "failed",
+                        summary,
+                        turns: turn,
+                        tool_calls: toolResults,
+                        child_results: childResults,
+                    };
+                }
                 if (envelope.status === "tool" &&
                     Array.isArray(envelope.tool_calls) &&
                     envelope.tool_calls.length > 0) {
@@ -460,6 +516,11 @@ export class ModelBridge {
                                     : `Tool '${toolCall.tool}' is not available in the active ACE catalog.`,
                             };
                             options.onToolResult?.(toolCall.tool, result);
+                            noteProgress("tool_finish", {
+                                tool: toolCall.tool,
+                                ok: false,
+                                blocked: true,
+                            });
                             toolResults.push(result);
                             return result;
                         });
@@ -472,6 +533,7 @@ export class ModelBridge {
                     const executed = await Promise.all(envelope.tool_calls.map(async (toolCall) => {
                         const args = toolCall.input ?? {};
                         options.onToolCall?.(toolCall.tool, args);
+                        noteProgress("tool_start", { tool: toolCall.tool });
                         const rawToolResult = await executeAceInternalTool(toolCall.tool, args, sessionId);
                         const result = truncateToolResult({
                             tool: toolCall.tool,
@@ -480,6 +542,7 @@ export class ModelBridge {
                             summary: summarizeToolText(rawToolResult),
                         }, options.workspace);
                         options.onToolResult?.(toolCall.tool, result);
+                        noteProgress("tool_finish", { tool: toolCall.tool, ok: result.ok });
                         toolResults.push(result);
                         return result;
                     }));
@@ -494,6 +557,7 @@ export class ModelBridge {
                 if (envelope.status === "message") {
                     const message = envelope.message?.trim() || rawResponse.trim();
                     options.onOutput?.(message);
+                    noteProgress("output", { status: "message" });
                     await appendVericifyProcessPostSafe({
                         run_id: refs.run_id,
                         branch_id: refs.branch_id,
@@ -503,6 +567,7 @@ export class ModelBridge {
                         summary: message,
                         tool_refs: [],
                     });
+                    noteProgress("process_post", { kind: "progress" });
                     return {
                         bridge_id: this.bridgeId,
                         role,
@@ -516,6 +581,7 @@ export class ModelBridge {
                 if (envelope.status === "need_input") {
                     const message = envelope.message?.trim() || "Additional operator input required.";
                     options.onOutput?.(message);
+                    noteProgress("output", { status: "need_input" });
                     await appendVericifyProcessPostSafe({
                         run_id: refs.run_id,
                         branch_id: refs.branch_id,
@@ -525,6 +591,7 @@ export class ModelBridge {
                         summary: message,
                         tool_refs: [],
                     });
+                    noteProgress("process_post", { kind: "blocker" });
                     return {
                         bridge_id: this.bridgeId,
                         role,
@@ -538,6 +605,7 @@ export class ModelBridge {
                 if (envelope.status === "complete") {
                     const summary = envelope.summary?.trim() || "Bridge completed.";
                     options.onOutput?.(summary);
+                    noteProgress("output", { status: "complete" });
                     await appendVericifyProcessPostSafe({
                         run_id: refs.run_id,
                         branch_id: refs.branch_id,
@@ -547,6 +615,7 @@ export class ModelBridge {
                         summary,
                         tool_refs: toolResults.map((entry) => entry.tool),
                     });
+                    noteProgress("process_post", { kind: "completion" });
                     return {
                         bridge_id: this.bridgeId,
                         role,
@@ -568,6 +637,7 @@ export class ModelBridge {
                 summary,
                 tool_refs: toolResults.map((entry) => entry.tool),
             });
+            noteProgress("process_post", { kind: "blocker" });
             return {
                 bridge_id: this.bridgeId,
                 role,

package/dist/orchestrator-supervisor.d.ts

@@ -1,4 +1,5 @@
 import type { BridgeResult } from "./model-bridge.js";
+import type { LocalModelRuntimeRepository } from "./store/repositories/local-model-runtime-repository.js";
 export type TaskStepStatus = "planned" | "running" | "done" | "failed" | "skipped" | "blocked";
 export type TaskPlanStatus = "planning" | "executing" | "reviewing" | "blocked" | "done" | "failed";
 export interface TaskStep {
@@ -14,6 +15,11 @@ export interface TaskStep {
     job_id?: string;
     handoff_id?: string;
     blocked_reason?: string;
+    upstream_outputs?: {
+        step_id: string;
+        result_summary: string;
+        evidence_refs: string[];
+    }[];
 }
 export interface TaskPlan {
     plan_id: string;
@@ -36,6 +42,7 @@ export interface TaskPlanAmendment {
     reorder_step_ids?: string[];
     execution_mode?: TaskPlan["execution_mode"];
     vcx_cursor?: string;
+    evidence_refs?: string[];
 }
 export interface SupervisorHooks {
     spawnStep: (step: TaskStep, plan: TaskPlan) => Promise<BridgeResult>;
@@ -92,6 +99,13 @@ export declare function getReadyTaskSteps(plan: TaskPlan): TaskStep[];
 export declare function markTaskStepStatus(plan: TaskPlan, stepId: string, status: TaskStepStatus, patch?: Partial<Omit<TaskStep, "step_id" | "status">>): TaskPlan;
 export declare function applyBridgeResultToStep(plan: TaskPlan, stepId: string, result: BridgeResult): TaskPlan;
 export declare function amendTaskPlan(plan: TaskPlan, amendment: TaskPlanAmendment): TaskPlan;
+export declare function collectUpstreamOutputs(plan: TaskPlan, step: TaskStep): {
+    step_id: string;
+    result_summary: string;
+    evidence_refs: string[];
+}[];
+export declare function applyBridgeResultToStepWithTransition(plan: TaskPlan, stepId: string, result: BridgeResult, repo?: LocalModelRuntimeRepository): Promise<TaskPlan>;
+export declare function amendTaskPlanWithTransition(plan: TaskPlan, amendment: TaskPlanAmendment, repo?: LocalModelRuntimeRepository, reason?: string, reason_code?: string): Promise<TaskPlan>;
 export declare function promoteParallelGroupToScheduler(plan: TaskPlan, parallelGroup: string, owner?: string): Promise<{
     plan: TaskPlan;
     job_ids: string[];

package/dist/orchestrator-supervisor.js

@@ -212,6 +212,56 @@ export function amendTaskPlan(plan, amendment) {
         vcx_cursor: amendment.vcx_cursor ?? plan.vcx_cursor,
     });
 }
+export function collectUpstreamOutputs(plan, step) {
+    if (!step.depends_on || step.depends_on.length === 0)
+        return [];
+    return step.depends_on
+        .map((depId) => plan.steps.find((s) => s.step_id === depId))
+        .filter((dep) => dep?.status === "done")
+        .map((dep) => ({
+        step_id: dep.step_id,
+        result_summary: dep.result_summary ?? "",
+        evidence_refs: dep.evidence_refs ?? [],
+    }));
+}
+export async function applyBridgeResultToStepWithTransition(plan, stepId, result, repo) {
+    const updated = applyBridgeResultToStep(plan, stepId, result);
+    if (repo && plan.plan_id) {
+        const step = plan.steps.find((s) => s.step_id === stepId);
+        const updatedStep = updated.steps.find((s) => s.step_id === stepId);
+        if (step && updatedStep) {
+            await repo.appendTransitionRecord({
+                subject_kind: "plan_step",
+                subject_id: `${plan.plan_id}/${stepId}`,
+                from: step.status,
+                to: updatedStep.status,
+                reason: result.summary ?? "(bridge result applied)",
+                reason_code: updatedStep.status === "done"
+                    ? "step_completed"
+                    : updatedStep.status === "blocked"
+                        ? "step_blocked"
+                        : "step_failed",
+                evidence_refs: result.evidence_refs ?? [],
+            });
+        }
+    }
+    return updated;
+}
+export async function amendTaskPlanWithTransition(plan, amendment, repo, reason, reason_code) {
+    const updated = amendTaskPlan(plan, amendment);
+    if (repo && plan.plan_id) {
+        await repo.appendTransitionRecord({
+            subject_kind: "plan_step",
+            subject_id: plan.plan_id,
+            from: plan.status,
+            to: updated.status,
+            reason: reason ?? "(plan amended)",
+            reason_code: reason_code ?? "manual_amendment",
+            evidence_refs: amendment.evidence_refs ?? [],
+        });
+    }
+    return updated;
+}
 export async function promoteParallelGroupToScheduler(plan, parallelGroup, owner = "capability-ops") {
     const readySteps = getReadyTaskSteps(plan).filter((step) => step.parallel_group === parallelGroup);
     if (readySteps.length === 0) {
@@ -311,7 +361,10 @@ export async function superviseTaskPlan(inputPlan, hooks) {
             }
         }
         const currentStep = readySteps[0];
-        plan = markTaskStepStatus(plan, currentStep.step_id, "running");
+        const upstreamOutputs = collectUpstreamOutputs(plan, currentStep);
+        plan = markTaskStepStatus(plan, currentStep.step_id, "running", {
+            upstream_outputs: upstreamOutputs.length > 0 ? upstreamOutputs : undefined,
+        });
         await hooks.emitStatusEvent?.({
             status: "in_progress",
             summary: `Running ${currentStep.step_id}: ${currentStep.task}`,
@@ -372,6 +425,24 @@ export async function superviseTaskPlan(inputPlan, hooks) {
     }
     if (plan.steps.length > 0 && plan.steps.every((step) => step.status === "done" || step.status === "skipped")) {
         const finalGate = await hooks.executeGates?.(plan);
+        if (finalGate && typeof finalGate === "object" && finalGate.ok === false) {
+            const blockedPlan = {
+                ...plan,
+                status: "blocked",
+            };
+            await hooks.contextSnapshot?.(blockedPlan);
+            await hooks.emitStatusEvent?.({
+                status: "blocked",
+                summary: `Task plan ${plan.plan_id} blocked by failing gates`,
+            });
+            return {
+                plan: blockedPlan,
+                handoff_ids: handoffIds,
+                job_ids: jobIds,
+                circuit_opened: false,
+                final_gate: finalGate,
+            };
+        }
         await hooks.contextSnapshot?.(plan);
         await hooks.emitStatusEvent?.({
             status: "done",

package/dist/run-ledger.js

@@ -4,7 +4,7 @@ import { isReadError } from "./shared.js";
 import { openStore } from "./store/ace-packed-store.js";
 import { ProjectionManager } from "./store/materializers/projection-manager.js";
 import { LedgerRepository } from "./store/repositories/ledger-repository.js";
-import { withStoreWriteQueue } from "./store/write-queue.js";
+import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
 import { getWorkspaceStorePath, listStoreKeysSync, readStoreJsonSync, storeExistsSync, } from "./store/store-snapshot.js";
 import { operationalArtifactVirtualPath } from "./store/store-artifacts.js";
 /** Maximum entries kept in run-ledger.json before rotation. */
@@ -216,7 +216,7 @@ export async function appendRunLedgerEntrySafe(input) {
         return withFileLock(RUN_LEDGER_REL, () => appendRunLedgerEntry(input));
     }
     return withFileLock(RUN_LEDGER_REL, async () => {
-        return withStoreWriteQueue(storePath, async () => {
+        return withStoreWriteCoordinator(storePath, async () => {
             const store = await openStore(storePath);
             try {
                 const ledger = new LedgerRepository(store);
@@ -244,7 +244,7 @@ export async function appendRunLedgerEntrySafe(input) {
             finally {
                 await store.close();
             }
-        });
+        }, { operation_label: "appendRunLedgerEntrySafe" });
     });
 }
 export function getRunLedgerPath() {

package/dist/runtime-command.d.ts

@@ -5,14 +5,22 @@ export interface ShellCommandResult {
     stdout: string;
     stderr: string;
     timed_out: boolean;
+    timeout_reason?: "turn_budget" | "stall";
     duration_ms: number;
+    last_progress_at: number;
+}
+export interface ShellCommandProgressEvent {
+    source: "spawn" | "stdout" | "stderr";
+    at: number;
 }
 export interface RunShellCommandOptions {
     cwd: string;
     env?: NodeJS.ProcessEnv;
     timeout_ms: number;
+    stall_timeout_ms?: number;
     max_output_bytes?: number;
     on_spawn?: (child: ChildProcess) => void;
+    on_progress?: (event: ShellCommandProgressEvent) => void;
 }
 export declare function runShellCommand(command: string, options: RunShellCommandOptions): Promise<ShellCommandResult>;
 //# sourceMappingURL=runtime-command.d.ts.map

package/dist/runtime-command.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+const STALL_TIMEOUT_SCHEDULER_GRACE_MS = 50;
 function appendChunk(buffer, chunk, maxBytes) {
     const next = buffer + chunk;
     if (Buffer.byteLength(next, "utf8") <= maxBytes) {
@@ -14,7 +15,10 @@ export async function runShellCommand(command, options) {
         let stdout = "";
         let stderr = "";
         let timedOut = false;
+        let timeoutReason;
         let finished = false;
+        let lastProgressAt = startedAt;
+        let stallTimer;
         let forcedKillTimer;
         let child;
         try {
@@ -29,32 +33,58 @@ export async function runShellCommand(command, options) {
             return;
         }
         options.on_spawn?.(child);
+        const requestTimeout = (reason) => {
+            if (finished || timedOut)
+                return;
+            timedOut = true;
+            timeoutReason = reason;
+            child.kill("SIGTERM");
+            forcedKillTimer = setTimeout(() => {
+                if (!finished)
+                    child.kill("SIGKILL");
+            }, 500);
+        };
+        const resetStallTimer = () => {
+            if (stallTimer)
+                clearTimeout(stallTimer);
+            const stallTimeoutMs = options.stall_timeout_ms;
+            if (!stallTimeoutMs || stallTimeoutMs <= 0)
+                return;
+            stallTimer = setTimeout(() => requestTimeout("stall"), stallTimeoutMs + STALL_TIMEOUT_SCHEDULER_GRACE_MS);
+        };
+        const recordProgress = (source) => {
+            lastProgressAt = Date.now();
+            options.on_progress?.({ source, at: lastProgressAt });
+            resetStallTimer();
+        };
         const finish = (result) => {
             if (finished)
                 return;
             finished = true;
+            if (stallTimer)
+                clearTimeout(stallTimer);
             if (forcedKillTimer)
                 clearTimeout(forcedKillTimer);
             resolve(result);
         };
         const timeout = setTimeout(() => {
-            timedOut = true;
-            child.kill("SIGTERM");
-            forcedKillTimer = setTimeout(() => {
-                if (!finished)
-                    child.kill("SIGKILL");
-            }, 500);
+            requestTimeout("turn_budget");
         }, options.timeout_ms);
+        recordProgress("spawn");
         child.stdout?.setEncoding("utf8");
         child.stdout?.on("data", (chunk) => {
             stdout = appendChunk(stdout, String(chunk), maxOutputBytes);
+            recordProgress("stdout");
         });
         child.stderr?.setEncoding("utf8");
         child.stderr?.on("data", (chunk) => {
             stderr = appendChunk(stderr, String(chunk), maxOutputBytes);
+            recordProgress("stderr");
         });
         child.on("error", (error) => {
             clearTimeout(timeout);
+            if (stallTimer)
+                clearTimeout(stallTimer);
             if (forcedKillTimer)
                 clearTimeout(forcedKillTimer);
             if (!finished)
@@ -68,7 +98,9 @@ export async function runShellCommand(command, options) {
                 stdout,
                 stderr,
                 timed_out: timedOut,
+                timeout_reason: timeoutReason,
                 duration_ms: Date.now() - startedAt,
+                last_progress_at: lastProgressAt,
             });
         });
     });

package/dist/runtime-executor.d.ts

@@ -5,6 +5,13 @@ export declare const RUNTIME_EXECUTOR_SESSION_SCHEMA_REL_PATH = "agent-state/MOD
 export declare const RUNTIME_EXECUTOR_SESSION_SCHEMA_NAME = "runtime-executor-session-registry@1.0.0";
 export type UnattendedSessionStatus = "starting" | "running" | "completed" | "failed" | "blocked" | "stopped";
 export type UnattendedTurnStatus = "completed" | "failed" | "blocked" | "stopped";
+export type TurnOutcome = "no_op_success" | "meaningful_completion" | "escalation_blocker";
+export interface TurnOutputPolicy {
+    emit_to: ("tui" | "tracker" | "handoff" | "vericify")[];
+    silent_unless_blocked: boolean;
+    require_approval_before_emit: boolean;
+}
+export declare const DEFAULT_TURN_OUTPUT_POLICY: TurnOutputPolicy;
 export interface UnattendedToolCallRecord {
     tool_name: string;
     ok: boolean;
@@ -32,6 +39,8 @@ export interface UnattendedTurnRecord {
     stdout: string;
     stderr: string;
     tool_calls: UnattendedToolCallRecord[];
+    turn_outcome?: TurnOutcome;
+    outcome_reason?: string;
 }
 export interface UnattendedSessionRecord {
     session_id: string;
@@ -55,6 +64,7 @@ export interface UnattendedSessionRecord {
     last_error?: string;
     cleanup_error?: string;
     workspace_cleanup_status: "pending" | "removed" | "archived" | "failed";
+    output_policy?: TurnOutputPolicy;
     turns: UnattendedTurnRecord[];
 }
 export interface UnattendedSessionRegistry {
@@ -64,6 +74,7 @@ export interface UnattendedSessionRegistry {
 }
 export interface StartUnattendedSessionInput {
     session_id?: string;
+    workspace_root?: string;
     task: string;
     context?: Record<string, unknown>;
     workspace_name?: string;
@@ -73,6 +84,9 @@ export interface StartUnattendedSessionInput {
     max_turns?: number;
     turn_timeout_ms?: number;
     auto_cleanup?: boolean;
+    emit_to?: TurnOutputPolicy["emit_to"];
+    silent_unless_blocked?: boolean;
+    require_approval_before_emit?: boolean;
 }
 export interface StartUnattendedSessionResult {
     ok: boolean;