@voybio/ace-swarm 0.1.0

package/dist/store/materializers/vericify-projector.js

@@ -0,0 +1,239 @@
+/**
+ * VericifyProjector
+ *
+ * Writes 5 Vericify-facing files from store state on every relevant mutation.
+ * These are MIRRORS only — the store is source of truth.
+ *
+ * All files live under .agents/ACE/ (the canonical ACE namespace as defined
+ * by ACE_ROOT_REL in helpers.ts and remapped via ACE_MANAGED_PREFIXES).
+ *
+ * Files projected:
+ *   .agents/ACE/agent-state/handoff-registry.json
+ *   .agents/ACE/agent-state/todo-state.json       ← schema: { version, updated_at, order[], nodes{} }
+ *   .agents/ACE/agent-state/run-ledger.json        ← schema: { version, updated_at, entries[] }
+ *   .agents/ACE/agent-state/STATUS_EVENTS.ndjson   ← schema: StatusEventRecord per line
+ *   .agents/ACE/agent-state/vericify/process-posts.json
+ */
+import { createHash, randomUUID } from "crypto";
+import { HandoffRepository } from "../repositories/handoff-repository.js";
+import { TodoRepository } from "../repositories/todo-repository.js";
+import { LedgerRepository } from "../repositories/ledger-repository.js";
+import { TrackerRepository } from "../repositories/tracker-repository.js";
+import { VericifyRepository } from "../repositories/vericify-repository.js";
+import { operationalArtifactKey } from "../store-artifacts.js";
+// Canonical ACE state root — mirrors helpers.ts ACE_ROOT_REL + ACE_MANAGED_PREFIXES remapping
+const ACE_ROOT = ".agents/ACE";
+const ACE_STATE_ROOT = `${ACE_ROOT}/agent-state`;
+const CHECKSUMS_KEY = "host/materializations/checksums";
+function sha256(content) {
+    return createHash("sha256").update(content, "utf8").digest("hex");
+}
+export class VericifyProjector {
+    store;
+    workspaceRoot;
+    handoffs;
+    todos;
+    ledger;
+    tracker;
+    vericify;
+    constructor(store, workspaceRoot) {
+        this.store = store;
+        this.workspaceRoot = workspaceRoot;
+        this.handoffs = new HandoffRepository(store);
+        this.todos = new TodoRepository(store);
+        this.ledger = new LedgerRepository(store);
+        this.tracker = new TrackerRepository(store);
+        this.vericify = new VericifyRepository(store);
+    }
+    operationalRel(relPath) {
+        return `agent-state/${relPath}`;
+    }
+    async projectAll() {
+        await this.projectHandoffs();
+        await this.projectTodos();
+        await this.projectLedger();
+        await this.projectStatusEvents();
+        await this.projectVericifyPosts();
+    }
+    async projectHandoffs() {
+        const records = await this.handoffs.list();
+        // Schema expected by vericify-bridge: { handoffs: Record<string, HandoffRecord>, updated_at }
+        const handoffMap = {};
+        for (const r of records) {
+            const metadata = r.metadata && typeof r.metadata === "object" && !Array.isArray(r.metadata)
+                ? r.metadata
+                : {};
+            const legacyStatus = mapHandoffStatus(r.status, metadata);
+            handoffMap[r.id] = {
+                handoff_id: r.id,
+                created_at: new Date(r.created_at).toISOString(),
+                updated_at: new Date(r.updated_at).toISOString(),
+                from: r.from_agent,
+                to: r.to_agent,
+                title: typeof metadata.title === "string" ? metadata.title : r.summary,
+                task_type: typeof metadata.task_type === "string" ? metadata.task_type : r.task,
+                priority: typeof metadata.priority === "string" ? metadata.priority : undefined,
+                source_file: typeof metadata.source_file === "string" ? metadata.source_file : undefined,
+                status: legacyStatus,
+                history: Array.isArray(metadata.history) ? metadata.history : [],
+            };
+        }
+        const content = JSON.stringify({ version: 1, updated_at: new Date().toISOString(), handoffs: handoffMap }, null, 2);
+        await this._write("handoff-registry.json", content);
+    }
+    async projectTodos() {
+        const todos = await this.todos.getAll();
+        // Schema expected by consumers (todo-state.ts TodoStateFile):
+        //   { version: 1, updated_at, source_todo_path, order: string[], nodes: Record<string, TodoNode> }
+        const order = [];
+        const nodes = {};
+        for (const t of todos) {
+            order.push(t.id);
+            nodes[t.id] = {
+                id: t.id,
+                title: t.title,
+                section: "",
+                source_line: 0,
+                depends_on: t.depends_on ?? [],
+                status: mapStatus(t.status),
+            };
+        }
+        const content = JSON.stringify({
+            version: 1,
+            updated_at: new Date().toISOString(),
+            source_todo_path: `${ACE_ROOT}/tasks/todo.md`,
+            order,
+            nodes,
+        }, null, 2);
+        await this._write("todo-state.json", content);
+    }
+    async projectLedger() {
+        const events = await this.ledger.list();
+        // Schema expected by consumers (run-ledger.ts RunLedgerFile):
+        //   { version: 1, updated_at, entries: RunLedgerEntry[] }
+        const entries = events.map((e) => ({
+            id: e.id,
+            timestamp_utc: new Date(e.ts).toISOString(),
+            tool: "store",
+            category: mapLedgerCategory(e.kind),
+            message: e.summary,
+            artifacts: e.artifact ? [e.artifact] : [],
+            metadata: e.metadata ?? {},
+        }));
+        const content = JSON.stringify({ version: 1, updated_at: new Date().toISOString(), entries }, null, 2);
+        await this._write("run-ledger.json", content);
+    }
+    async projectStatusEvents() {
+        const events = await this.tracker.list();
+        // Canonical schema (status-events.ts StatusEventRecord):
+        //   { schema_version, event_id, trace_id, timestamp, source_module,
+        //     event_type, status, objective_id?, decision_id?, payload }
+        const lines = events.map((e) => JSON.stringify({
+            schema_version: "1.0.0",
+            event_id: e.id ?? randomUUID(),
+            trace_id: e.metadata?.trace_id ?? randomUUID(),
+            timestamp: new Date(e.ts).toISOString(),
+            source_module: e.agent ?? "store/tracker",
+            event_type: e.kind,
+            status: e.metadata?.status ?? "done",
+            objective_id: e.metadata?.objective_id,
+            decision_id: e.metadata?.decision_id,
+            payload: {
+                summary: e.summary,
+                ...(e.metadata ?? {}),
+            },
+        }));
+        const ndjson = lines.join("\n") + (lines.length ? "\n" : "");
+        await this._write("STATUS_EVENTS.ndjson", ndjson);
+    }
+    async projectVericifyPosts() {
+        const posts = await this.vericify.list();
+        const content = JSON.stringify({
+            version: 1,
+            updated_at: new Date().toISOString(),
+            posts: posts.map((post) => ({
+                process_post_id: post.id,
+                run_id: post.run_id,
+                agent_id: post.agent_id,
+                kind: post.kind,
+                summary: post.summary,
+                timestamp: new Date(post.ts).toISOString(),
+                branch_id: typeof post.metadata?.branch_id === "string" ? post.metadata.branch_id : undefined,
+                lane_id: typeof post.metadata?.lane_id === "string" ? post.metadata.lane_id : undefined,
+                checkpoint_ref: typeof post.metadata?.checkpoint_ref === "string"
+                    ? post.metadata.checkpoint_ref
+                    : undefined,
+                tool_refs: Array.isArray(post.metadata?.tool_refs)
+                    ? post.metadata.tool_refs.filter((value) => typeof value === "string")
+                    : [],
+                evidence_refs: Array.isArray(post.metadata?.evidence_refs)
+                    ? post.metadata.evidence_refs.filter((value) => typeof value === "string")
+                    : [],
+            })),
+        }, null, 2);
+        await this._write("vericify/process-posts.json", content);
+    }
+    async _write(relPath, content) {
+        await this.store.setBlob(operationalArtifactKey(this.operationalRel(relPath)), content);
+        await this._trackChecksum(relPath, content);
+    }
+    async _trackChecksum(relPath, content) {
+        const checksums = (await this.store.getJSON(CHECKSUMS_KEY)) ?? {};
+        checksums[relPath] = { path: relPath, hash: sha256(content), written_at: Date.now() };
+        await this.store.setJSON(CHECKSUMS_KEY, checksums);
+    }
+    async checkExternalModification(relPath, currentContent) {
+        const checksums = (await this.store.getJSON(CHECKSUMS_KEY)) ?? {};
+        const stored = checksums[relPath];
+        if (!stored)
+            return false;
+        return stored.hash !== sha256(currentContent);
+    }
+}
+function mapStatus(storeStatus) {
+    switch (storeStatus) {
+        case "pending":
+            return "backlog";
+        case "in_progress":
+            return "in_progress";
+        case "blocked":
+            return "blocked";
+        case "done":
+            return "done";
+        case "cancelled":
+            return "done"; // closest legacy equivalent
+        default:
+            return "backlog";
+    }
+}
+function mapLedgerCategory(kind) {
+    switch (kind) {
+        case "regression":
+            return "regression";
+        case "milestone":
+        case "update":
+            return "major_update";
+        default:
+            return "info";
+    }
+}
+function mapHandoffStatus(status, metadata) {
+    if (metadata.legacy_status === "open" ||
+        metadata.legacy_status === "accepted" ||
+        metadata.legacy_status === "blocked" ||
+        metadata.legacy_status === "completed") {
+        return metadata.legacy_status;
+    }
+    switch (status) {
+        case "acked":
+        case "active":
+            return "accepted";
+        case "blocked":
+            return "blocked";
+        case "closed":
+            return "completed";
+        default:
+            return "open";
+    }
+}
+//# sourceMappingURL=vericify-projector.js.map

package/dist/store/repositories/discovery-repository.d.ts

@@ -0,0 +1,24 @@
+/**
+ * DiscoveryRepository — state/discovery/
+ * Stores provider discovery results (ollama, llama.cpp, codex, claude, etc.)
+ */
+import { AcePackedStore } from "../ace-packed-store.js";
+export interface DiscoveryResult {
+    provider: string;
+    available: boolean;
+    endpoint?: string;
+    models?: string[];
+    detected_at: number;
+    metadata?: Record<string, unknown>;
+}
+export declare class DiscoveryRepository {
+    private store;
+    constructor(store: AcePackedStore);
+    private key;
+    record(result: Omit<DiscoveryResult, "detected_at">): Promise<DiscoveryResult>;
+    get(provider: string): Promise<DiscoveryResult | undefined>;
+    listAvailable(): Promise<DiscoveryResult[]>;
+    listAll(): Promise<DiscoveryResult[]>;
+    private _addToIndex;
+}
+//# sourceMappingURL=discovery-repository.d.ts.map

package/dist/store/repositories/discovery-repository.js

@@ -0,0 +1,58 @@
+/**
+ * DiscoveryRepository — state/discovery/
+ * Stores provider discovery results (ollama, llama.cpp, codex, claude, etc.)
+ */
+import { ContentSource, EntityKind } from "../types.js";
+const INDEX_KEY = "state/discovery/index";
+export class DiscoveryRepository {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    key(provider) {
+        return `state/discovery/${provider}`;
+    }
+    async record(result) {
+        const record = { ...result, detected_at: Date.now() };
+        await this.store.setJSON(this.key(result.provider), record);
+        await this.store.appendEntry({
+            kind: EntityKind.DiscoveryResult,
+            content_source: ContentSource.Runtime,
+            key: this.key(result.provider),
+            payload: record,
+        });
+        await this._addToIndex(result.provider);
+        return record;
+    }
+    async get(provider) {
+        return this.store.getJSON(this.key(provider));
+    }
+    async listAvailable() {
+        const index = await this.store.getJSON(INDEX_KEY) ?? [];
+        const results = [];
+        for (const p of index) {
+            const r = await this.get(p);
+            if (r?.available)
+                results.push(r);
+        }
+        return results;
+    }
+    async listAll() {
+        const index = await this.store.getJSON(INDEX_KEY) ?? [];
+        const results = [];
+        for (const p of index) {
+            const r = await this.get(p);
+            if (r)
+                results.push(r);
+        }
+        return results;
+    }
+    async _addToIndex(provider) {
+        const index = await this.store.getJSON(INDEX_KEY) ?? [];
+        if (!index.includes(provider)) {
+            index.push(provider);
+            await this.store.setJSON(INDEX_KEY, index);
+        }
+    }
+}
+//# sourceMappingURL=discovery-repository.js.map

package/dist/store/repositories/handoff-repository.d.ts

@@ -0,0 +1,31 @@
+/**
+ * HandoffRepository — state/handoffs/
+ * Replaces: agent-state/handoff-registry.json
+ */
+import { AcePackedStore } from "../ace-packed-store.js";
+export interface HandoffRecord {
+    id: string;
+    from_agent: string;
+    to_agent: string;
+    status: "pending" | "active" | "acked" | "closed" | "blocked";
+    summary: string;
+    task?: string;
+    created_at: number;
+    updated_at: number;
+    metadata?: Record<string, unknown>;
+}
+export declare class HandoffRepository {
+    private store;
+    constructor(store: AcePackedStore);
+    private key;
+    create(handoff: Omit<HandoffRecord, "created_at" | "updated_at">): Promise<HandoffRecord>;
+    get(id: string): Promise<HandoffRecord | undefined>;
+    update(id: string, patch: Partial<HandoffRecord>): Promise<HandoffRecord>;
+    list(filter?: {
+        status?: HandoffRecord["status"];
+        to_agent?: string;
+    }): Promise<HandoffRecord[]>;
+    ack(id: string): Promise<HandoffRecord>;
+    close(id: string): Promise<HandoffRecord>;
+}
+//# sourceMappingURL=handoff-repository.d.ts.map

package/dist/store/repositories/handoff-repository.js

@@ -0,0 +1,67 @@
+/**
+ * HandoffRepository — state/handoffs/
+ * Replaces: agent-state/handoff-registry.json
+ */
+import { ContentSource, EntityKind } from "../types.js";
+export class HandoffRepository {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    key(id) {
+        return `state/handoffs/${id}`;
+    }
+    async create(handoff) {
+        const now = Date.now();
+        const record = { ...handoff, created_at: now, updated_at: now };
+        await this.store.setJSON(this.key(handoff.id), record);
+        await this.store.appendEntry({
+            kind: EntityKind.Handoff,
+            content_source: ContentSource.Runtime,
+            key: this.key(handoff.id),
+            payload: record,
+        });
+        return record;
+    }
+    async get(id) {
+        return this.store.getJSON(this.key(id));
+    }
+    async update(id, patch) {
+        const existing = await this.get(id);
+        if (!existing)
+            throw new Error(`HandoffRepository: handoff not found: ${id}`);
+        const updated = { ...existing, ...patch, updated_at: Date.now() };
+        await this.store.setJSON(this.key(id), updated);
+        await this.store.appendEntry({
+            kind: EntityKind.Handoff,
+            content_source: ContentSource.Runtime,
+            key: this.key(id),
+            payload: updated,
+        });
+        return updated;
+    }
+    async list(filter) {
+        const all = await this.store.getEntries({ kind: EntityKind.Handoff });
+        // Deduplicate — only keep latest entry per handoff id
+        const latest = new Map();
+        for (const entry of all) {
+            const record = entry.payload;
+            if (!record?.id)
+                continue;
+            latest.set(record.id, record);
+        }
+        let results = [...latest.values()];
+        if (filter?.status)
+            results = results.filter((r) => r.status === filter.status);
+        if (filter?.to_agent)
+            results = results.filter((r) => r.to_agent === filter.to_agent);
+        return results.sort((a, b) => b.created_at - a.created_at);
+    }
+    async ack(id) {
+        return this.update(id, { status: "acked" });
+    }
+    async close(id) {
+        return this.update(id, { status: "closed" });
+    }
+}
+//# sourceMappingURL=handoff-repository.js.map

package/dist/store/repositories/ledger-repository.d.ts

@@ -0,0 +1,26 @@
+/**
+ * LedgerRepository — state/ledger/
+ * Replaces: agent-state/run-ledger.json
+ */
+import { AcePackedStore } from "../ace-packed-store.js";
+export interface LedgerEvent {
+    id: string;
+    ts: number;
+    kind: "update" | "regression" | "milestone" | "note" | "gate_passed" | "gate_failed";
+    summary: string;
+    agent?: string;
+    artifact?: string;
+    metadata?: Record<string, unknown>;
+}
+export declare class LedgerRepository {
+    private store;
+    private seq;
+    constructor(store: AcePackedStore);
+    init(): Promise<void>;
+    private nextSeq;
+    private key;
+    append(event: Omit<LedgerEvent, "id" | "ts">): Promise<LedgerEvent>;
+    list(limit?: number): Promise<LedgerEvent[]>;
+    recent(n?: number): Promise<LedgerEvent[]>;
+}
+//# sourceMappingURL=ledger-repository.d.ts.map

package/dist/store/repositories/ledger-repository.js

@@ -0,0 +1,49 @@
+/**
+ * LedgerRepository — state/ledger/
+ * Replaces: agent-state/run-ledger.json
+ */
+import { ContentSource, EntityKind } from "../types.js";
+const LEDGER_SEQ_KEY = "state/ledger/seq";
+export class LedgerRepository {
+    store;
+    seq = 0;
+    constructor(store) {
+        this.store = store;
+    }
+    async init() {
+        this.seq = (await this.store.getJSON(LEDGER_SEQ_KEY)) ?? 0;
+    }
+    nextSeq() {
+        this.seq++;
+        return String(this.seq).padStart(10, "0");
+    }
+    key(id) {
+        return `state/ledger/${id}`;
+    }
+    async append(event) {
+        const id = `le-${this.nextSeq()}`;
+        const record = { ...event, id, ts: Date.now() };
+        await this.store.setJSON(this.key(id), record);
+        await this.store.setJSON(LEDGER_SEQ_KEY, this.seq);
+        await this.store.appendEntry({
+            kind: EntityKind.LedgerEvent,
+            content_source: ContentSource.Runtime,
+            key: this.key(id),
+            payload: record,
+        });
+        return record;
+    }
+    async list(limit) {
+        const entries = await this.store.getEntries({ kind: EntityKind.LedgerEvent });
+        const events = entries
+            .map((e) => e.payload)
+            .filter(Boolean)
+            .sort((a, b) => a.ts - b.ts);
+        return limit ? events.slice(-limit) : events;
+    }
+    async recent(n = 10) {
+        const all = await this.list();
+        return all.slice(-n);
+    }
+}
+//# sourceMappingURL=ledger-repository.js.map

package/dist/store/repositories/runtime-kv-repository.d.ts

@@ -0,0 +1,16 @@
+/**
+ * RuntimeKVRepository — state/runtime/kv
+ * General-purpose key-value store for runtime metadata.
+ */
+import { AcePackedStore } from "../ace-packed-store.js";
+export declare class RuntimeKVRepository {
+    private store;
+    constructor(store: AcePackedStore);
+    private key;
+    set(k: string, value: unknown): Promise<void>;
+    get<T>(k: string): Promise<T | undefined>;
+    delete(k: string): Promise<boolean>;
+    setString(k: string, value: string): Promise<void>;
+    getString(k: string): Promise<string | undefined>;
+}
+//# sourceMappingURL=runtime-kv-repository.d.ts.map

package/dist/store/repositories/runtime-kv-repository.js

@@ -0,0 +1,36 @@
+/**
+ * RuntimeKVRepository — state/runtime/kv
+ * General-purpose key-value store for runtime metadata.
+ */
+import { ContentSource, EntityKind } from "../types.js";
+export class RuntimeKVRepository {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    key(k) {
+        return `state/runtime/kv/${k}`;
+    }
+    async set(k, value) {
+        await this.store.setJSON(this.key(k), value);
+        await this.store.appendEntry({
+            kind: EntityKind.RuntimeKv,
+            content_source: ContentSource.Runtime,
+            key: this.key(k),
+            payload: { key: k },
+        });
+    }
+    async get(k) {
+        return this.store.getJSON(this.key(k));
+    }
+    async delete(k) {
+        return this.store.delete(this.key(k));
+    }
+    async setString(k, value) {
+        await this.store.setBlob(this.key(k), value);
+    }
+    async getString(k) {
+        return this.store.getBlob(this.key(k));
+    }
+}
+//# sourceMappingURL=runtime-kv-repository.js.map

package/dist/store/repositories/scheduler-repository.d.ts

@@ -0,0 +1,50 @@
+/**
+ * SchedulerRepository — state/scheduler/
+ * Replaces: job-queue.json, job-locks.json, scheduler-lease.json
+ */
+import { AcePackedStore } from "../ace-packed-store.js";
+export interface Job {
+    id: string;
+    role: string;
+    task: string;
+    priority: "high" | "medium" | "low";
+    status: "queued" | "running" | "done" | "failed" | "cancelled";
+    depends_on?: string[];
+    created_at: number;
+    started_at?: number;
+    completed_at?: number;
+    result?: unknown;
+    metadata?: Record<string, unknown>;
+}
+export interface ResourceLock {
+    resource: string;
+    holder: string;
+    acquired_at: number;
+    expires_at?: number;
+}
+export interface SchedulerLease {
+    holder: string;
+    acquired_at: number;
+    expires_at: number;
+    run_id?: string;
+}
+export declare class SchedulerRepository {
+    private store;
+    constructor(store: AcePackedStore);
+    enqueue(job: Omit<Job, "created_at" | "status">): Promise<Job>;
+    listJobs(filter?: {
+        status?: Job["status"];
+        role?: string;
+    }): Promise<Job[]>;
+    updateJob(id: string, patch: Partial<Job>): Promise<Job>;
+    completeJob(id: string, result?: unknown): Promise<Job>;
+    failJob(id: string, reason?: string): Promise<Job>;
+    dispatchReady(): Promise<Job[]>;
+    acquireLock(resource: string, holder: string, ttlMs?: number): Promise<ResourceLock>;
+    releaseLock(resource: string, holder: string): Promise<boolean>;
+    getLocks(): Promise<ResourceLock[]>;
+    acquireLease(holder: string, ttlMs?: number, runId?: string): Promise<SchedulerLease>;
+    releaseLease(holder: string): Promise<boolean>;
+    getLease(): Promise<SchedulerLease | undefined>;
+}
+//# sourceMappingURL=scheduler-repository.d.ts.map