@voybio/ace-swarm 0.2.0 → 0.2.1

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

@@ -3,48 +3,30 @@
  * 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;
-}
+import type { JobLockRecord, JobLockTableFile, JobQueueFile, JobRecord, SchedulerLeaseFile } from "../../job-scheduler.js";
 export declare class SchedulerRepository {
     private store;
     constructor(store: AcePackedStore);
-    enqueue(job: Omit<Job, "created_at" | "status">): Promise<Job>;
+    readQueue(): Promise<JobQueueFile>;
+    readLockTable(): Promise<JobLockTableFile>;
+    readLease(): Promise<SchedulerLeaseFile | undefined>;
+    writeQueue(queue: JobQueueFile): Promise<JobQueueFile>;
+    writeLockTable(table: JobLockTableFile): Promise<JobLockTableFile>;
+    writeLease(lease: SchedulerLeaseFile | undefined): Promise<SchedulerLeaseFile | undefined>;
+    replaceState(input: {
+        queue: JobQueueFile;
+        locks: JobLockTableFile;
+        lease?: SchedulerLeaseFile;
+    }): Promise<{
+        queue: JobQueueFile;
+        locks: JobLockTableFile;
+        lease?: SchedulerLeaseFile;
+    }>;
     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>;
+        status?: JobRecord["status"];
+    }): Promise<JobRecord[]>;
+    listLocks(filter?: {
+        status?: JobLockRecord["status"];
+    }): Promise<JobLockRecord[]>;
 }
 //# sourceMappingURL=scheduler-repository.d.ts.map

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

@@ -6,118 +6,148 @@ import { ContentSource, EntityKind } from "../types.js";
 const QUEUE_KEY = "state/scheduler/queue";
 const LOCKS_KEY = "state/scheduler/locks";
 const LEASE_KEY = "state/scheduler/lease";
+function nowIso() {
+    return new Date().toISOString();
+}
+function defaultQueueFile() {
+    return {
+        version: 1,
+        updated_at: nowIso(),
+        jobs: [],
+    };
+}
+function defaultLockTableFile() {
+    return {
+        version: 1,
+        updated_at: nowIso(),
+        locks: [],
+    };
+}
+function normalizeQueue(queue) {
+    if (!queue || queue.version !== 1 || !Array.isArray(queue.jobs)) {
+        return defaultQueueFile();
+    }
+    return {
+        version: 1,
+        updated_at: typeof queue.updated_at === "string" ? queue.updated_at : nowIso(),
+        jobs: Array.isArray(queue.jobs) ? queue.jobs : [],
+    };
+}
+function normalizeLockTable(table) {
+    if (!table || table.version !== 1 || !Array.isArray(table.locks)) {
+        return defaultLockTableFile();
+    }
+    return {
+        version: 1,
+        updated_at: typeof table.updated_at === "string" ? table.updated_at : nowIso(),
+        locks: Array.isArray(table.locks) ? table.locks : [],
+    };
+}
+function normalizeLease(lease) {
+    if (!lease || lease.version !== 1)
+        return undefined;
+    return lease;
+}
 export class SchedulerRepository {
     store;
     constructor(store) {
         this.store = store;
     }
-    // ── Jobs ──────────────────────────────────────────────────────────────────
-    async enqueue(job) {
-        const record = { ...job, status: "queued", created_at: Date.now() };
-        const queue = await this.store.getJSON(QUEUE_KEY) ?? [];
-        queue.push(record);
-        await this.store.setJSON(QUEUE_KEY, queue);
+    async readQueue() {
+        return normalizeQueue(await this.store.getJSON(QUEUE_KEY));
+    }
+    async readLockTable() {
+        return normalizeLockTable(await this.store.getJSON(LOCKS_KEY));
+    }
+    async readLease() {
+        const stored = await this.store.getJSON(LEASE_KEY);
+        return normalizeLease(stored);
+    }
+    async writeQueue(queue) {
+        const record = {
+            ...normalizeQueue(queue),
+            updated_at: nowIso(),
+        };
+        await this.store.setJSON(QUEUE_KEY, record);
         await this.store.appendEntry({
             kind: EntityKind.SchedulerTick,
             content_source: ContentSource.Runtime,
             key: QUEUE_KEY,
-            payload: { op: "enqueue", job_id: job.id },
+            payload: {
+                op: "queue_write",
+                job_count: record.jobs.length,
+            },
         });
         return record;
     }
-    async listJobs(filter) {
-        const queue = await this.store.getJSON(QUEUE_KEY) ?? [];
-        return queue.filter((j) => {
-            if (filter?.status && j.status !== filter.status)
-                return false;
-            if (filter?.role && j.role !== filter.role)
-                return false;
-            return true;
+    async writeLockTable(table) {
+        const record = {
+            ...normalizeLockTable(table),
+            updated_at: nowIso(),
+        };
+        await this.store.setJSON(LOCKS_KEY, record);
+        await this.store.appendEntry({
+            kind: EntityKind.SchedulerTick,
+            content_source: ContentSource.Runtime,
+            key: LOCKS_KEY,
+            payload: {
+                op: "lock_table_write",
+                lock_count: record.locks.length,
+            },
         });
+        return record;
     }
-    async updateJob(id, patch) {
-        const queue = await this.store.getJSON(QUEUE_KEY) ?? [];
-        const idx = queue.findIndex((j) => j.id === id);
-        if (idx === -1)
-            throw new Error(`SchedulerRepository: job not found: ${id}`);
-        queue[idx] = { ...queue[idx], ...patch };
-        await this.store.setJSON(QUEUE_KEY, queue);
-        return queue[idx];
+    async writeLease(lease) {
+        if (!lease) {
+            await this.store.setJSON(LEASE_KEY, null);
+            await this.store.appendEntry({
+                kind: EntityKind.SchedulerTick,
+                content_source: ContentSource.Runtime,
+                key: LEASE_KEY,
+                payload: {
+                    op: "lease_clear",
+                },
+            });
+            return undefined;
+        }
+        const record = {
+            ...lease,
+            version: 1,
+        };
+        await this.store.setJSON(LEASE_KEY, record);
+        await this.store.appendEntry({
+            kind: EntityKind.SchedulerTick,
+            content_source: ContentSource.Runtime,
+            key: LEASE_KEY,
+            payload: {
+                op: "lease_write",
+                owner: record.owner,
+                lease_id: record.lease_id,
+            },
+        });
+        return record;
     }
-    async completeJob(id, result) {
-        return this.updateJob(id, { status: "done", completed_at: Date.now(), result });
+    async replaceState(input) {
+        const queue = await this.writeQueue(input.queue);
+        const locks = await this.writeLockTable(input.locks);
+        const lease = await this.writeLease(input.lease);
+        return { queue, locks, lease };
     }
-    async failJob(id, reason) {
-        return this.updateJob(id, {
-            status: "failed",
-            completed_at: Date.now(),
-            metadata: { failure_reason: reason },
+    async listJobs(filter) {
+        const queue = await this.readQueue();
+        return queue.jobs.filter((job) => {
+            if (filter?.status && job.status !== filter.status)
+                return false;
+            return true;
         });
     }
-    async dispatchReady() {
-        const queue = await this.listJobs({ status: "queued" });
-        const done = new Set((await this.listJobs({ status: "done" })).map((j) => j.id));
-        return queue.filter((j) => {
-            if (!j.depends_on?.length)
-                return true;
-            return j.depends_on.every((dep) => done.has(dep));
+    async listLocks(filter) {
+        const table = await this.readLockTable();
+        return table.locks.filter((lock) => {
+            if (filter?.status && lock.status !== filter.status)
+                return false;
+            return true;
         });
     }
-    // ── Resource locks ────────────────────────────────────────────────────────
-    async acquireLock(resource, holder, ttlMs) {
-        const locks = await this.store.getJSON(LOCKS_KEY) ?? [];
-        const existing = locks.find((l) => l.resource === resource);
-        const now = Date.now();
-        if (existing) {
-            if (!existing.expires_at || existing.expires_at > now) {
-                throw new Error(`SchedulerRepository: resource locked by ${existing.holder}: ${resource}`);
-            }
-            // Expired lock — remove it
-            const next = locks.filter((l) => l.resource !== resource);
-            next.push({ resource, holder, acquired_at: now, expires_at: ttlMs ? now + ttlMs : undefined });
-            await this.store.setJSON(LOCKS_KEY, next);
-            return next.find((l) => l.resource === resource);
-        }
-        locks.push({ resource, holder, acquired_at: now, expires_at: ttlMs ? now + ttlMs : undefined });
-        await this.store.setJSON(LOCKS_KEY, locks);
-        return locks.find((l) => l.resource === resource);
-    }
-    async releaseLock(resource, holder) {
-        const locks = await this.store.getJSON(LOCKS_KEY) ?? [];
-        const next = locks.filter((l) => !(l.resource === resource && l.holder === holder));
-        if (next.length === locks.length)
-            return false;
-        await this.store.setJSON(LOCKS_KEY, next);
-        return true;
-    }
-    async getLocks() {
-        return (await this.store.getJSON(LOCKS_KEY)) ?? [];
-    }
-    // ── Scheduler lease ───────────────────────────────────────────────────────
-    async acquireLease(holder, ttlMs = 60_000, runId) {
-        const existing = await this.getLease();
-        const now = Date.now();
-        if (existing && existing.expires_at > now) {
-            throw new Error(`SchedulerRepository: lease held by ${existing.holder}`);
-        }
-        const lease = {
-            holder,
-            acquired_at: now,
-            expires_at: now + ttlMs,
-            run_id: runId,
-        };
-        await this.store.setJSON(LEASE_KEY, lease);
-        return lease;
-    }
-    async releaseLease(holder) {
-        const lease = await this.getLease();
-        if (!lease || lease.holder !== holder)
-            return false;
-        await this.store.delete(LEASE_KEY);
-        return true;
-    }
-    async getLease() {
-        return this.store.getJSON(LEASE_KEY);
-    }
 }
 //# sourceMappingURL=scheduler-repository.js.map

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

@@ -14,6 +14,7 @@ export interface TodoNode {
     updated_at: number;
     notes?: string;
 }
+type TodoUpsertInput = Omit<TodoNode, "created_at" | "updated_at"> & Partial<Pick<TodoNode, "created_at">>;
 export declare class TodoRepository {
     private store;
     constructor(store: AcePackedStore);
@@ -26,6 +27,9 @@ export declare class TodoRepository {
         assigned_to?: string;
     }): Promise<TodoNode[]>;
     getAll(): Promise<TodoNode[]>;
+    remove(id: string): Promise<boolean>;
+    replaceAll(todos: TodoUpsertInput[]): Promise<TodoNode[]>;
     private _updateIndex;
 }
+export {};
 //# sourceMappingURL=todo-repository.d.ts.map

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

@@ -61,6 +61,56 @@ export class TodoRepository {
     async getAll() {
         return this.list();
     }
+    async remove(id) {
+        const existing = await this.get(id);
+        if (!existing)
+            return false;
+        await this.store.delete(this.key(id));
+        await this.store.appendEntry({
+            kind: EntityKind.Todo,
+            content_source: ContentSource.Runtime,
+            key: this.key(id),
+            payload: { op: "remove", id },
+        });
+        await this._updateIndex(existing, "remove");
+        return true;
+    }
+    async replaceAll(todos) {
+        const existing = new Map((await this.getAll()).map((todo) => [todo.id, todo]));
+        const nextRecords = [];
+        const nextIds = [];
+        for (const todo of todos) {
+            const now = Date.now();
+            const prior = existing.get(todo.id);
+            const record = {
+                ...prior,
+                ...todo,
+                created_at: todo.created_at ?? prior?.created_at ?? now,
+                updated_at: now,
+            };
+            await this.store.setJSON(this.key(todo.id), record);
+            await this.store.appendEntry({
+                kind: EntityKind.Todo,
+                content_source: ContentSource.Runtime,
+                key: this.key(todo.id),
+                payload: record,
+            });
+            nextIds.push(todo.id);
+            nextRecords.push(record);
+            existing.delete(todo.id);
+        }
+        for (const staleId of existing.keys()) {
+            await this.store.delete(this.key(staleId));
+            await this.store.appendEntry({
+                kind: EntityKind.Todo,
+                content_source: ContentSource.Runtime,
+                key: this.key(staleId),
+                payload: { op: "remove", id: staleId },
+            });
+        }
+        await this.store.setJSON(TODO_INDEX_KEY, nextIds);
+        return nextRecords;
+    }
     async _updateIndex(todo, op) {
         const index = await this.store.getJSON(TODO_INDEX_KEY) ?? [];
         if (op === "add" && !index.includes(todo.id)) {

package/dist/store/state-reader.d.ts

@@ -14,14 +14,18 @@ import { SessionRepository } from "./repositories/session-repository.js";
 import { TrackerRepository } from "./repositories/tracker-repository.js";
 import { DiscoveryRepository } from "./repositories/discovery-repository.js";
 import { VericifyRepository } from "./repositories/vericify-repository.js";
+import { LocalModelRuntimeRepository } from "./repositories/local-model-runtime-repository.js";
 export interface DashboardSnapshot {
     handoffs: Awaited<ReturnType<HandoffRepository["list"]>>;
     todos: Awaited<ReturnType<TodoRepository["getAll"]>>;
     ledger: Awaited<ReturnType<LedgerRepository["recent"]>>;
     jobs: Awaited<ReturnType<SchedulerRepository["listJobs"]>>;
+    schedulerLocks: Awaited<ReturnType<SchedulerRepository["listLocks"]>>;
+    schedulerLease: Awaited<ReturnType<SchedulerRepository["readLease"]>>;
     sessions: Awaited<ReturnType<SessionRepository["list"]>>;
     events: Awaited<ReturnType<TrackerRepository["list"]>>;
     providers: Awaited<ReturnType<DiscoveryRepository["listAll"]>>;
+    runtimeStatuses: Awaited<ReturnType<LocalModelRuntimeRepository["listRuntimeStatuses"]>>;
     posts: Awaited<ReturnType<VericifyRepository["list"]>>;
     snapped_at: number;
 }
@@ -34,10 +38,13 @@ export declare class StoreStateReader {
     handoffs(): Promise<import("./repositories/handoff-repository.js").HandoffRecord[]>;
     todos(): Promise<import("./repositories/todo-repository.js").TodoNode[]>;
     ledger(): Promise<import("./repositories/ledger-repository.js").LedgerEvent[]>;
-    schedulerState(): Promise<import("./repositories/scheduler-repository.js").Job[]>;
+    schedulerState(): Promise<import("../job-scheduler.js").JobRecord[]>;
+    schedulerLocks(): Promise<import("../job-scheduler.js").JobLockRecord[]>;
+    schedulerLease(): Promise<import("../job-scheduler.js").SchedulerLeaseFile | undefined>;
     sessions(): Promise<import("./repositories/session-repository.js").SessionRecord[]>;
     statusEvents(): Promise<import("./repositories/tracker-repository.js").StatusEvent[]>;
     providerDiscovery(): Promise<import("./repositories/discovery-repository.js").DiscoveryResult[]>;
+    runtimeStatuses(): Promise<import("./repositories/local-model-runtime-repository.js").AceRuntimeStatusPacket[]>;
     vericifyPosts(): Promise<import("./repositories/vericify-repository.js").VericifyPost[]>;
     domainDocs(_domain: string): Promise<never[]>;
 }

package/dist/store/state-reader.js

@@ -15,6 +15,7 @@ import { SessionRepository } from "./repositories/session-repository.js";
 import { TrackerRepository } from "./repositories/tracker-repository.js";
 import { DiscoveryRepository } from "./repositories/discovery-repository.js";
 import { VericifyRepository } from "./repositories/vericify-repository.js";
+import { LocalModelRuntimeRepository } from "./repositories/local-model-runtime-repository.js";
 export class StoreStateReader {
     store = null;
     get repos() {
@@ -28,6 +29,7 @@ export class StoreStateReader {
             sessions: new SessionRepository(this.store),
             tracker: new TrackerRepository(this.store),
             discovery: new DiscoveryRepository(this.store),
+            localModelRuntime: new LocalModelRuntimeRepository(this.store),
             vericify: new VericifyRepository(this.store),
         };
     }
@@ -43,14 +45,17 @@ export class StoreStateReader {
     }
     async snapshot() {
         const r = this.repos;
-        const [handoffs, todos, ledger, jobs, sessions, events, providers, posts] = await Promise.all([
+        const [handoffs, todos, ledger, jobs, schedulerLocks, schedulerLease, sessions, events, providers, runtimeStatuses, posts] = await Promise.all([
             r.handoffs.list(),
             r.todos.getAll(),
             r.ledger.recent(20),
             r.scheduler.listJobs(),
+            r.scheduler.listLocks(),
+            r.scheduler.readLease(),
             r.sessions.list(),
             r.tracker.list({ limit: 50 }),
             r.discovery.listAll(),
+            r.localModelRuntime.listRuntimeStatuses(),
             r.vericify.list(),
         ]);
         return {
@@ -58,9 +63,12 @@ export class StoreStateReader {
             todos,
             ledger,
             jobs,
+            schedulerLocks,
+            schedulerLease,
             sessions,
             events,
             providers,
+            runtimeStatuses,
             posts,
             snapped_at: Date.now(),
         };
@@ -69,9 +77,12 @@ export class StoreStateReader {
     async todos() { return this.repos.todos.getAll(); }
     async ledger() { return this.repos.ledger.list(); }
     async schedulerState() { return this.repos.scheduler.listJobs(); }
+    async schedulerLocks() { return this.repos.scheduler.listLocks(); }
+    async schedulerLease() { return this.repos.scheduler.readLease(); }
     async sessions() { return this.repos.sessions.list(); }
     async statusEvents() { return this.repos.tracker.list(); }
     async providerDiscovery() { return this.repos.discovery.listAll(); }
+    async runtimeStatuses() { return this.repos.localModelRuntime.listRuntimeStatuses(); }
     async vericifyPosts() { return this.repos.vericify.list(); }
     async domainDocs(_domain) { return []; } // Phase 6 wiring
 }

package/dist/store/store-artifacts.js

@@ -13,21 +13,47 @@ const H_EVT_BASE = 60;
 const TEXT = new TextEncoder();
 const DECODE = new TextDecoder();
 export const OPERATIONAL_ARTIFACT_REL_PATHS = new Set([
+    // ── Core mutable state — agent-written, must stay inside ace-state.ace ──────
+    "agent-state/TASK.md",
+    "agent-state/STATUS.md",
+    "agent-state/SCOPE.md",
+    "agent-state/DECISIONS.md",
+    "agent-state/RISKS.md",
+    "agent-state/QUALITY_GATES.md",
+    "agent-state/HANDOFF.json",
+    "agent-state/EVIDENCE_LOG.md",
+    "agent-state/PROVENANCE_LOG.md",
+    "agent-state/TEAL_CONFIG.md",
+    "agent-state/INTERFACE_REGISTRY.md",
+    // ── Tool-generated state — written by internal tools, not agents directly ───
+    "agent-state/ARTIFACT_MANIFEST.json",
+    "agent-state/AST_GREP_COMMANDS.md",
     "agent-state/AST_GREP_INDEX.json",
     "agent-state/AST_GREP_INDEX.md",
-    "agent-state/EVIDENCE_LOG.md",
+    "agent-state/SKILL_CATALOG.md",
+    "agent-state/PUBLIC_SURFACE_REPORT.md",
+    // ── Append-only event logs ────────────────────────────────────────────────
     "agent-state/STATUS_EVENTS.ndjson",
     "agent-state/STATUS_EVENTS-archive.ndjson",
+    "agent-state/run-ledger.json",
+    "agent-state/run-ledger-archive.ndjson",
+    // ── Registries and indexes ────────────────────────────────────────────────
     "agent-state/handoff-registry.json",
     "agent-state/index-fingerprints.json",
     "agent-state/index.json",
-    "agent-state/run-ledger.json",
-    "agent-state/run-ledger-archive.ndjson",
+    "agent-state/kanban.html",
+    "agent-state/kanban.json",
+    "agent-state/tracker-snapshot.json",
+    "agent-state/todo-state.json",
+    // ── Runtime config and sessions ───────────────────────────────────────────
     "agent-state/runtime-executor-sessions.json",
     "agent-state/runtime-tool-specs.json",
     "agent-state/runtime-workspaces.json",
-    "agent-state/todo-state.json",
-    "agent-state/tracker-snapshot.json",
+    // ── Scheduler hot-path — also projected to disk for fast reads ────────────
+    "agent-state/job-locks.json",
+    "agent-state/job-queue.json",
+    "agent-state/scheduler-lease.json",
+    // ── Vericify sidecar ─────────────────────────────────────────────────────
     "agent-state/vericify/ace-bridge.json",
     "agent-state/vericify/process-posts.json",
 ]);

package/dist/store/store-authority-audit.d.ts

@@ -0,0 +1,30 @@
+export declare const STORE_AUTHORITY_AUDIT_REPORT_REL_PATH = "agent-state/STORE_AUTHORITY_AUDIT.md";
+export type StoreAuthorityClassification = "canonical knowledge artifact" | "canonical runtime state" | "projection only";
+export interface StoreAuthoritySafeWriteSite {
+    call: "safeWrite" | "safeWriteWorkspaceFile" | "safeWriteReport";
+    classification: StoreAuthorityClassification;
+    file: string;
+    line: number;
+    column: number;
+    target_expression: string;
+    target_path?: string;
+    fallback_keys: string[];
+    bypasses_acepack: boolean;
+    regenerable_from_store: boolean;
+    note: string;
+}
+export interface StoreAuthorityAuditResult {
+    bypassing_sites: StoreAuthoritySafeWriteSite[];
+    classifications: Record<StoreAuthorityClassification, StoreAuthoritySafeWriteSite[]>;
+    generated_at: string;
+    non_regenerable_projections: StoreAuthoritySafeWriteSite[];
+    report_path: string;
+    runtime_files_without_store_fallback_keys: StoreAuthoritySafeWriteSite[];
+    safe_write_sites: StoreAuthoritySafeWriteSite[];
+    source_root: string;
+    total_safe_write_sites: number;
+}
+export declare function auditStoreAuthority(): StoreAuthorityAuditResult;
+export declare function renderStoreAuthorityAuditReport(result: StoreAuthorityAuditResult): string;
+export declare function writeStoreAuthorityAuditReport(result: StoreAuthorityAuditResult, targetPath?: string): string;
+//# sourceMappingURL=store-authority-audit.d.ts.map