@voybio/ace-swarm 0.2.5 → 2.4.1

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,7 +64,10 @@ export interface UnattendedSessionRecord {
     last_error?: string;
     cleanup_error?: string;
     workspace_cleanup_status: "pending" | "removed" | "archived" | "failed";
+    output_policy?: TurnOutputPolicy;
     turns: UnattendedTurnRecord[];
+    /** Set after propose_plan + validate_plan succeed in the before_run preflight. */
+    validated_plan_id?: string;
 }
 export interface UnattendedSessionRegistry {
     version: 1;
@@ -64,6 +76,7 @@ export interface UnattendedSessionRegistry {
 }
 export interface StartUnattendedSessionInput {
     session_id?: string;
+    workspace_root?: string;
     task: string;
     context?: Record<string, unknown>;
     workspace_name?: string;
@@ -73,6 +86,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;
@@ -94,11 +110,14 @@ export interface WaitForUnattendedSessionResult {
     session?: UnattendedSessionRecord;
     error?: string;
 }
+export interface WaitForUnattendedSessionOptions {
+    flush_sidecars?: boolean;
+}
 export declare function validateRuntimeExecutorSessionRegistryContent(raw: string): ValidationResult;
 export declare function listUnattendedSessions(): UnattendedSessionRegistry;
 export declare function getUnattendedSession(sessionId: string): UnattendedSessionRecord | undefined;
 export declare function getRuntimeExecutorSessionRegistryPath(): string;
 export declare function startUnattendedSession(input: StartUnattendedSessionInput): Promise<StartUnattendedSessionResult>;
-export declare function waitForUnattendedSession(sessionId: string, timeoutMs?: number): Promise<WaitForUnattendedSessionResult>;
+export declare function waitForUnattendedSession(sessionId: string, timeoutMsOrOptions?: number | WaitForUnattendedSessionOptions, options?: WaitForUnattendedSessionOptions): Promise<WaitForUnattendedSessionResult>;
 export declare function stopUnattendedSession(sessionId: string): Promise<StopUnattendedSessionResult>;
 //# sourceMappingURL=runtime-executor.d.ts.map