@voybio/ace-swarm 0.2.4 → 2.4.0

package/dist/schemas.js

@@ -186,6 +186,8 @@ const workspaceSessionRecordSchema = z
     last_error: z.string().optional(),
     created_at: z.string().datetime({ offset: true }),
     updated_at: z.string().datetime({ offset: true }),
+    hook_health: z.enum(["ok", "degraded", "failed"]).optional(),
+    hook_summary: z.string().optional(),
     hooks: z
         .object({
         after_create: workspaceHookStateSchema,
@@ -352,6 +354,15 @@ const unattendedTurnRecordSchema = z
     stdout: z.string(),
     stderr: z.string(),
     tool_calls: z.array(unattendedToolCallRecordSchema),
+    turn_outcome: z.enum(["no_op_success", "meaningful_completion", "escalation_blocker"]).optional(),
+    outcome_reason: z.string().optional(),
+})
+    .strict();
+const runtimeOutputPolicySchema = z
+    .object({
+    emit_to: z.array(z.enum(["tui", "tracker", "handoff", "vericify"])),
+    silent_unless_blocked: z.boolean(),
+    require_approval_before_emit: z.boolean(),
 })
     .strict();
 const runtimeExecutorSessionRecordSchema = z
@@ -377,6 +388,7 @@ const runtimeExecutorSessionRecordSchema = z
     last_error: z.string().optional(),
     cleanup_error: z.string().optional(),
     workspace_cleanup_status: z.enum(["pending", "removed", "archived", "failed"]),
+    output_policy: runtimeOutputPolicySchema.optional(),
     turns: z.array(unattendedTurnRecordSchema),
 })
     .strict();
@@ -453,6 +465,13 @@ const vericifyBridgeSnapshotSchema = z
     })
         .strict(),
     active_run_refs: z.array(vericifyBridgeActiveRunRefSchema),
+    ace_runtime_enrichment: z
+        .object({
+        live_session_id: z.string().optional(),
+        last_turn_outcome: z.string().optional(),
+        last_turn_outcome_reason: z.string().optional(),
+    })
+        .optional(),
 })
     .strict();
 /**

package/dist/shared.d.ts

@@ -19,10 +19,10 @@ export declare function looksLikeSwarmHandoffPath(path: string): boolean;
 export declare const ROLE_TITLES: Record<string, string>;
 export declare function getRoleTitle(role: string): string;
 export declare const MCP_CLIENT_ENUM: z.ZodEnum<{
-    claude: "claude";
-    cursor: "cursor";
     codex: "codex";
     vscode: "vscode";
+    claude: "claude";
+    cursor: "cursor";
     antigravity: "antigravity";
 }>;
 export declare const ROLE_ENUM: z.ZodEnum<{

package/dist/status-events.js

@@ -8,7 +8,7 @@ import { ProjectionManager } from "./store/materializers/projection-manager.js";
 import { TrackerRepository } from "./store/repositories/tracker-repository.js";
 import { getWorkspaceStorePath, listStoreKeysSync, readStoreJsonSync, 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";
 export const STATUS_EVENTS_REL_PATH = "agent-state/STATUS_EVENTS.ndjson";
 const STATUS_EVENTS_ARCHIVE_REL = "agent-state/STATUS_EVENTS-archive.ndjson";
 const MAX_EVENT_LINES = 2000;
@@ -94,7 +94,7 @@ async function mirrorStatusEventToStore(root, event) {
     const storePath = getWorkspaceStorePath(root);
     if (!existsSync(storePath))
         return;
-    await withStoreWriteQueue(storePath, async () => {
+    await withStoreWriteCoordinator(storePath, async () => {
         const store = await openStore(storePath);
         try {
             const tracker = new TrackerRepository(store);
@@ -120,7 +120,7 @@ async function mirrorStatusEventToStore(root, event) {
         finally {
             await store.close();
         }
-    });
+    }, { operation_label: "mirrorStatusEventToStore" });
 }
 function scheduleStatusEventMirror(event) {
     const root = workspaceRoot();
@@ -135,7 +135,7 @@ export async function waitForPendingStatusEventMirrors() {
 }
 async function appendStatusEventStoreBacked(root, event) {
     const storePath = getWorkspaceStorePath(root);
-    return withStoreWriteQueue(storePath, async () => {
+    return withStoreWriteCoordinator(storePath, async () => {
         const store = await openStore(storePath);
         try {
             const tracker = new TrackerRepository(store);
@@ -165,9 +165,10 @@ async function appendStatusEventStoreBacked(root, event) {
         finally {
             await store.close();
         }
-    });
+    }, { operation_label: "appendStatusEventStoreBacked" });
 }
 export function appendStatusEvent(input) {
+    const root = workspaceRoot();
     const event = buildStatusEvent(input);
     validateStatusEvent(event);
     // Atomic append under file lock to prevent lost writes under parallelism
@@ -176,7 +177,9 @@ export function appendStatusEvent(input) {
     const combined = existing.length > 0 ? `${existing}\n${line}\n` : `${line}\n`;
     const next = rotateIfNeeded(combined);
     const path = safeWriteWorkspaceFile(STATUS_EVENTS_REL_PATH, next);
-    scheduleStatusEventMirror(event);
+    if (storeExistsSync(root)) {
+        scheduleStatusEventMirror(event);
+    }
     return { path, event };
 }
 /**

package/dist/store/ace-packed-store.d.ts

@@ -59,6 +59,9 @@ export declare class AcePackedStore implements IAcePackedStore {
     private fh;
     private kvIndex;
     private kvChunkEnd;
+    private pendingKv;
+    private pendingDeletes;
+    private dirty;
     private committed;
     private pending;
     private evtBaseId;
@@ -67,8 +70,6 @@ export declare class AcePackedStore implements IAcePackedStore {
     }): Promise<void>;
     private _initNew;
     private _loadExisting;
-    /** Read a KV blob directly from a loaded file buffer (used during migration). */
-    private _readKvBlobDirect;
     commit(): Promise<void>;
     /**
      * Compacts the KV chunk region — removes dead space left by overwritten keys.

package/dist/store/ace-packed-store.js

@@ -56,6 +56,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from "
 import { open as fsOpen } from "node:fs/promises";
 import { dirname } from "node:path";
 import { MAGIC, STORE_VERSION, HEADER_SIZE, HEADER_SIZE_V1, ContentSource, EntityKind, } from "./types.js";
+import { invalidateStoreSnapshotCache } from "./store-snapshot.js";
 // ── Constants ─────────────────────────────────────────────────────────────────
 // Header field byte offsets (big-endian throughout)
 const H_KV_IDX_OFF = 16; // uint64: KV index offset
@@ -204,6 +205,69 @@ function deserializeEventSection(buf) {
         blob: DECODE.decode(buf.slice(poolStart + payOffs[i], poolStart + payOffs[i] + payLens[i])),
     }));
 }
+function readKvBlobFromBytes(file, index, key) {
+    const entry = index.get(key);
+    if (!entry)
+        return undefined;
+    const start = entry.offset + 4;
+    const end = start + entry.length;
+    if (start < 0 || end > file.length) {
+        throw new Error(`AcePackedStore: KV entry for '${key}' exceeds file bounds`);
+    }
+    return file.slice(start, end);
+}
+function loadCommittedStateFromBytes(file) {
+    if (file.length < HEADER_SIZE_V1)
+        throw new Error("AcePackedStore: file too short");
+    const hdr = readHeaderV2(file.slice(0, Math.max(HEADER_SIZE, file.length)));
+    const isV1 = hdr.version < 2;
+    const idxRaw = file.slice(hdr.kvIndexOffset, hdr.kvIndexOffset + hdr.kvIndexLength);
+    const idxObj = JSON.parse(DECODE.decode(idxRaw));
+    const kvIndex = new Map(Object.entries(idxObj));
+    if (isV1) {
+        const logKeys = [...kvIndex.keys()]
+            .filter((key) => key.startsWith("core/log/") && key !== "core/log/__seq")
+            .sort();
+        const committed = [];
+        for (const key of logKeys) {
+            const entry = readKvBlobFromBytes(file, kvIndex, key);
+            if (!entry)
+                continue;
+            try {
+                const parsed = JSON.parse(DECODE.decode(entry));
+                committed.push({
+                    ts: parsed.ts,
+                    kind: parsed.kind,
+                    source: parsed.content_source,
+                    flags: parsed.flags ?? 0,
+                    blob: JSON.stringify({ key: parsed.key, payload: parsed.payload, parent_id: parsed.parent_id }),
+                });
+            }
+            catch {
+                // Skip malformed legacy events during migration.
+            }
+        }
+        for (const key of [...kvIndex.keys()]) {
+            if (key.startsWith("core/log/") || key === "meta/log_entry_seq") {
+                kvIndex.delete(key);
+            }
+        }
+        return {
+            kvIndex,
+            kvChunkEnd: hdr.kvChunkEnd,
+            committed,
+            evtBaseId: 0,
+        };
+    }
+    return {
+        kvIndex,
+        kvChunkEnd: hdr.kvChunkEnd,
+        committed: hdr.evtLength > 0
+            ? deserializeEventSection(file.slice(hdr.evtOffset, hdr.evtOffset + hdr.evtLength))
+            : [],
+        evtBaseId: hdr.evtBaseId,
+    };
+}
 // ── File I/O helpers ──────────────────────────────────────────────────────────
 async function readExact(fh, buf, position) {
     let off = 0;
@@ -214,15 +278,6 @@ async function readExact(fh, buf, position) {
         off += bytesRead;
     }
 }
-async function writeExact(fh, data, position) {
-    let off = 0;
-    while (off < data.length) {
-        const { bytesWritten } = await fh.write(data, off, data.length - off, position + off);
-        if (bytesWritten <= 0)
-            throw new Error("AcePackedStore: write failed");
-        off += bytesWritten;
-    }
-}
 // ── AcePackedStore ────────────────────────────────────────────────────────────
 export class AcePackedStore {
     storePath = "";
@@ -231,6 +286,9 @@ export class AcePackedStore {
     // KV region
     kvIndex = new Map();
     kvChunkEnd = HEADER_SIZE; // end of KV chunk region in file
+    pendingKv = new Map();
+    pendingDeletes = new Set();
+    dirty = false;
     // Event log (in-memory)
     committed = []; // loaded from file
     pending = []; // written since last commit
@@ -276,101 +334,90 @@ export class AcePackedStore {
         this.committed = [];
         this.pending = [];
         this.evtBaseId = 0;
+        this.pendingKv.clear();
+        this.pendingDeletes.clear();
+        this.dirty = false;
     }
     async _loadExisting(path) {
         const file = readFileSync(path);
-        if (file.length < HEADER_SIZE_V1)
-            throw new Error("AcePackedStore: file too short");
-        const hdr = readHeaderV2(file.slice(0, Math.max(HEADER_SIZE, file.length)));
-        const isV1 = hdr.version < 2;
-        // Load KV index
-        const idxRaw = file.slice(hdr.kvIndexOffset, hdr.kvIndexOffset + hdr.kvIndexLength);
-        const idxObj = JSON.parse(DECODE.decode(idxRaw));
-        this.kvIndex = new Map(Object.entries(idxObj));
-        this.kvChunkEnd = hdr.kvChunkEnd;
-        if (isV1) {
-            // v1 → v2 migration: pull events from core/log/ KV entries
-            const logKeys = [...this.kvIndex.keys()]
-                .filter(k => k.startsWith("core/log/") && k !== "core/log/__seq")
-                .sort();
-            this.committed = [];
-            for (const lk of logKeys) {
-                const entry = await this._readKvBlobDirect(file, lk);
-                if (!entry)
-                    continue;
-                try {
-                    const e = JSON.parse(entry);
-                    this.committed.push({
-                        ts: e.ts,
-                        kind: e.kind,
-                        source: e.content_source,
-                        flags: e.flags ?? 0,
-                        blob: JSON.stringify({ key: e.key, payload: e.payload, parent_id: e.parent_id }),
-                    });
-                }
-                catch { /* skip malformed */ }
-            }
-            // Remove core/log/ and meta/log_entry_seq from KV (they go to columnar section)
-            for (const k of [...this.kvIndex.keys()]) {
-                if (k.startsWith("core/log/") || k === "meta/log_entry_seq")
-                    this.kvIndex.delete(k);
-            }
-            this.evtBaseId = 0;
-            // force commit to write v2 format (pending is non-empty from migration)
-        }
-        else {
-            // v2: load event section
-            if (hdr.evtLength > 0) {
-                const evtBuf = file.slice(hdr.evtOffset, hdr.evtOffset + hdr.evtLength);
-                this.committed = deserializeEventSection(evtBuf);
-            }
-            else {
-                this.committed = [];
-            }
-            this.evtBaseId = hdr.evtBaseId;
-        }
+        const loaded = loadCommittedStateFromBytes(file);
+        this.kvIndex = loaded.kvIndex;
+        this.kvChunkEnd = loaded.kvChunkEnd;
+        this.committed = loaded.committed;
+        this.evtBaseId = loaded.evtBaseId;
         this.pending = [];
-    }
-    /** Read a KV blob directly from a loaded file buffer (used during migration). */
-    async _readKvBlobDirect(file, key) {
-        const entry = this.kvIndex.get(key);
-        if (!entry)
-            return undefined;
-        const start = entry.offset + 4;
-        const end = start + entry.length;
-        if (end > file.length)
-            return undefined;
-        return DECODE.decode(file.slice(start, end));
+        this.pendingKv.clear();
+        this.pendingDeletes.clear();
+        this.dirty = false;
     }
     async commit() {
-        if (this.readOnly || !this.fh)
+        if (this.readOnly || !this.fh || !this.storePath || !this.dirty)
             return;
-        // Merge pending into committed
-        this.committed.push(...this.pending);
-        this.pending = [];
-        // Serialize event section
-        const evtBytes = serializeEventSection(this.committed);
-        // Write KV index after event section
-        const idxJson = JSON.stringify(Object.fromEntries(this.kvIndex));
+        const currentFile = readFileSync(this.storePath);
+        const latest = loadCommittedStateFromBytes(new Uint8Array(currentFile.buffer, currentFile.byteOffset, currentFile.byteLength));
+        const nextCommitted = [...latest.committed, ...this.pending];
+        const evtBytes = serializeEventSection(nextCommitted);
+        const nextKvIndex = new Map();
+        const liveChunks = [];
+        let writeOff = HEADER_SIZE;
+        for (const [key] of latest.kvIndex) {
+            if (this.pendingDeletes.has(key) || this.pendingKv.has(key))
+                continue;
+            const value = readKvBlobFromBytes(currentFile, latest.kvIndex, key);
+            if (!value)
+                continue;
+            liveChunks.push({ value });
+            nextKvIndex.set(key, { offset: writeOff, length: value.length });
+            writeOff += 4 + value.length;
+        }
+        for (const [key, value] of this.pendingKv) {
+            const blob = value.slice();
+            liveChunks.push({ value: blob });
+            nextKvIndex.set(key, { offset: writeOff, length: blob.length });
+            writeOff += 4 + blob.length;
+        }
+        const idxJson = JSON.stringify(Object.fromEntries(nextKvIndex));
         const idxBytes = TEXT.encode(idxJson);
-        const evtOff = this.kvChunkEnd;
+        const evtOff = writeOff;
         const kvIdxOff = evtOff + evtBytes.length;
-        await writeExact(this.fh, evtBytes, evtOff);
-        await writeExact(this.fh, idxBytes, kvIdxOff);
-        await this.fh.truncate(kvIdxOff + idxBytes.length);
-        // Update header
+        const totalSize = kvIdxOff + idxBytes.length;
         const header = new Uint8Array(HEADER_SIZE);
         writeHeaderV2(header, {
             kvIndexOffset: kvIdxOff,
             kvIndexLength: idxBytes.length,
-            kvChunkEnd: this.kvChunkEnd,
+            kvChunkEnd: writeOff,
             evtOffset: evtOff,
             evtLength: evtBytes.length,
-            evtCount: this.committed.length,
-            evtBaseId: this.evtBaseId,
+            evtCount: nextCommitted.length,
+            evtBaseId: latest.evtBaseId,
         });
-        await writeExact(this.fh, header, 0);
         await this.fh.datasync();
+        const out = new Uint8Array(totalSize);
+        out.set(header, 0);
+        let cursor = HEADER_SIZE;
+        for (const chunk of liveChunks) {
+            out.set(u32be(chunk.value.length), cursor);
+            out.set(chunk.value, cursor + 4);
+            cursor += 4 + chunk.value.length;
+        }
+        out.set(evtBytes, evtOff);
+        out.set(idxBytes, kvIdxOff);
+        const tmpPath = `${this.storePath}.${process.pid}.${Date.now()}.commit.tmp`;
+        writeFileSync(tmpPath, out);
+        readHeaderV2(readFileSync(tmpPath).slice(0, HEADER_SIZE));
+        await this.fh.close();
+        this.fh = null;
+        renameSync(tmpPath, this.storePath);
+        invalidateStoreSnapshotCache(this.storePath);
+        this.fh = await fsOpen(this.storePath, "r+");
+        this.kvIndex = nextKvIndex;
+        this.kvChunkEnd = writeOff;
+        this.committed = nextCommitted;
+        this.pending = [];
+        this.pendingKv.clear();
+        this.pendingDeletes.clear();
+        this.evtBaseId = latest.evtBaseId;
+        this.dirty = false;
     }
     /**
      * Compacts the KV chunk region — removes dead space left by overwritten keys.
@@ -381,23 +428,29 @@ export class AcePackedStore {
     async compact() {
         if (!this.storePath || this.readOnly)
             return;
-        // Flush pending events into committed so they survive the rewrite
-        this.committed.push(...this.pending);
-        this.pending = [];
+        if (this.dirty) {
+            await this.commit();
+        }
         // Rebuild KV chunk region with only live keys (removes dead space)
         const srcFile = readFileSync(this.storePath);
+        const latest = loadCommittedStateFromBytes(new Uint8Array(srcFile.buffer, srcFile.byteOffset, srcFile.byteLength));
         const liveKv = new Map();
         const chunks = [];
         let writeOff = HEADER_SIZE;
-        for (const [key, { offset, length }] of this.kvIndex) {
-            chunks.push(srcFile.slice(offset + 4, offset + 4 + length));
-            liveKv.set(key, { offset: writeOff, length });
-            writeOff += 4 + length;
+        for (const [key] of latest.kvIndex) {
+            const chunk = readKvBlobFromBytes(srcFile, latest.kvIndex, key);
+            if (!chunk)
+                continue;
+            chunks.push(chunk);
+            liveKv.set(key, { offset: writeOff, length: chunk.length });
+            writeOff += 4 + chunk.length;
         }
         this.kvIndex = liveKv;
         this.kvChunkEnd = writeOff;
+        this.committed = latest.committed;
+        this.evtBaseId = latest.evtBaseId;
         // Serialize events (preserved in full) + new KV index
-        const evtBytes = serializeEventSection(this.committed);
+        const evtBytes = serializeEventSection(latest.committed);
         const idxBytes = TEXT.encode(JSON.stringify(Object.fromEntries(liveKv)));
         const evtOff = writeOff;
         const kvIdxOff = evtOff + evtBytes.length;
@@ -410,8 +463,8 @@ export class AcePackedStore {
             kvChunkEnd: writeOff,
             evtOffset: evtOff,
             evtLength: evtBytes.length,
-            evtCount: this.committed.length,
-            evtBaseId: this.evtBaseId,
+            evtCount: latest.committed.length,
+            evtBaseId: latest.evtBaseId,
         });
         out.set(header, 0);
         let pos = HEADER_SIZE;
@@ -431,10 +484,17 @@ export class AcePackedStore {
             this.fh = null;
         }
         renameSync(tmpPath, this.storePath);
+        invalidateStoreSnapshotCache(this.storePath);
         this.fh = await fsOpen(this.storePath, "r+");
+        this.pending = [];
+        this.pendingKv.clear();
+        this.pendingDeletes.clear();
+        this.dirty = false;
     }
     async close() {
-        await this.commit();
+        if (this.dirty) {
+            await this.commit();
+        }
         if (this.fh) {
             await this.fh.close();
             this.fh = null;
@@ -442,6 +502,12 @@ export class AcePackedStore {
     }
     // ── Core KV ─────────────────────────────────────────────────────────────────
     async get(key) {
+        if (this.pendingKv.has(key)) {
+            return this.pendingKv.get(key)?.slice();
+        }
+        if (this.pendingDeletes.has(key)) {
+            return undefined;
+        }
         const entry = this.kvIndex.get(key);
         if (!entry || !this.fh)
             return undefined;
@@ -454,19 +520,26 @@ export class AcePackedStore {
             throw new Error("AcePackedStore: read-only");
         if (!this.fh)
             throw new Error("AcePackedStore: not open");
-        // Append chunk to KV chunk region (at kvChunkEnd)
-        await writeExact(this.fh, u32be(value.length), this.kvChunkEnd);
-        await writeExact(this.fh, value, this.kvChunkEnd + 4);
-        this.kvIndex.set(key, { offset: this.kvChunkEnd, length: value.length });
-        this.kvChunkEnd += 4 + value.length;
+        this.pendingDeletes.delete(key);
+        this.pendingKv.set(key, value.slice());
+        this.dirty = true;
     }
     async delete(key) {
-        const existed = this.kvIndex.has(key);
-        this.kvIndex.delete(key);
+        const existed = this.pendingKv.has(key) || this.kvIndex.has(key);
+        this.pendingKv.delete(key);
+        if (this.kvIndex.has(key)) {
+            this.pendingDeletes.add(key);
+        }
+        this.dirty = this.dirty || existed;
         return existed;
     }
     async *list() {
-        for (const key of this.kvIndex.keys())
+        const keys = new Set(this.kvIndex.keys());
+        for (const key of this.pendingDeletes)
+            keys.delete(key);
+        for (const key of this.pendingKv.keys())
+            keys.add(key);
+        for (const key of keys)
             yield key;
     }
     // ── JSON / Blob convenience ──────────────────────────────────────────────────
@@ -503,6 +576,7 @@ export class AcePackedStore {
             blob: JSON.stringify({ key: entry.key, payload: entry.payload, parent_id: entry.parent_id }),
         };
         this.pending.push(rec);
+        this.dirty = true;
         return { id, ts, kind: entry.kind, content_source: entry.content_source, key: entry.key, payload: entry.payload, flags: entry.flags };
     }
     async getEntries(filter) {
@@ -569,7 +643,7 @@ export class AcePackedStore {
     }
     async listAgents() {
         const agents = new Set();
-        for (const k of this.kvIndex.keys()) {
+        for await (const k of this.list()) {
             if (k.startsWith("knowledge/agents/")) {
                 const p = k.split("/");
                 if (p[2])
@@ -589,7 +663,7 @@ export class AcePackedStore {
     }
     async listSkills() {
         const skills = new Set();
-        for (const k of this.kvIndex.keys()) {
+        for await (const k of this.list()) {
             if (k.startsWith("knowledge/skills/")) {
                 const p = k.split("/");
                 if (p[2])
@@ -601,10 +675,14 @@ export class AcePackedStore {
     // ── Introspection ─────────────────────────────────────────────────────────────
     /** Dead space ratio in the KV chunk region. Used to decide if compaction is needed. */
     get deadSpaceRatio() {
-        const totalKv = this.kvChunkEnd - HEADER_SIZE;
+        const pendingBytes = [...this.pendingKv.values()].reduce((sum, value) => sum + 4 + value.length, 0);
+        const totalKv = this.kvChunkEnd - HEADER_SIZE + pendingBytes;
         if (totalKv <= 0)
             return 0;
-        const liveKv = [...this.kvIndex.values()].reduce((s, e) => s + 4 + e.length, 0);
+        const liveKv = [...this.kvIndex.entries()]
+            .filter(([key]) => !this.pendingDeletes.has(key) && !this.pendingKv.has(key))
+            .reduce((sum, [, entry]) => sum + 4 + entry.length, 0) +
+            pendingBytes;
         return Math.max(0, 1 - liveKv / totalKv);
     }
     /** Total events in log (committed + pending). */

package/dist/store/bootstrap-store.d.ts

@@ -5,7 +5,7 @@
  *
  * Replaces the old copyTree()-based bootstrap with:
  *   1. Create minimal directories
- *   2. Initialize AcePackedStore at .agents/ACE/ace-state.ace
+ *   2. Initialize AcePackedStore at agent-state/ace-state.ace
  *   3. Bake core knowledge (agents, modules, kernel)
  *   4. Write topology records
  *   5. Write initial runtime state seeds