@voybio/ace-swarm 0.1.0 → 0.2.1

package/dist/store/repositories/local-model-runtime-repository.d.ts

@@ -0,0 +1,98 @@
+import { type AcePackedStore } from "../ace-packed-store.js";
+export interface AceSessionActivationLedger {
+    session_id: string;
+    created_at: number;
+    updated_at: number;
+    prompt_count: number;
+    shown_nudges: string[];
+    accepted_nudges: string[];
+    activated_tools: string[];
+    activated_roles: string[];
+    last_recommended_action?: string;
+}
+export interface AceSessionContinuityRecord {
+    session_id: string;
+    created_at: number;
+    updated_at: number;
+    workspace_root: string;
+    state_resolution_mode: "top_level" | "nested_projection" | "store_projection" | "missing";
+    last_role?: string;
+    last_preflight_state?: "ready" | "attention_required" | "blocked";
+    last_bridge_status?: "running" | "needs_input" | "approval_pending" | "retrying" | "blocked" | "failed" | "done";
+    active_tool?: string;
+    blockers: string[];
+    recent_decisions: string[];
+    recommended_next_action?: string;
+    evidence_refs: string[];
+}
+export interface AceRuntimeStatusPacket {
+    session_id: string;
+    process_id: number;
+    turn_count: number;
+    role?: string;
+    bridge_status: "running" | "needs_input" | "approval_pending" | "retrying" | "blocked" | "failed" | "done";
+    preflight_state: "ready" | "attention_required" | "blocked";
+    approval_state?: "not_required" | "pending" | "approved" | "rejected";
+    retry_state?: {
+        attempt: number;
+        max_attempts?: number;
+        backoff_ms?: number;
+        reason?: string;
+    };
+    poll_state?: {
+        active: boolean;
+        interval_ms?: number;
+        waiting_on?: string;
+    };
+    current_task?: string;
+    active_tool?: string;
+    active_tool_role?: string;
+    recommended_next_action?: string;
+    blocked_reason?: string;
+    tokens_in?: number;
+    tokens_out?: number;
+    updated_at: number;
+}
+export interface AceArchivedChatRecord {
+    session_id: string;
+    tab_id: string;
+    label: string;
+    provider: string;
+    model: string;
+    created_at: number;
+    archived_at: number;
+    last_active_at: number;
+    transcript_excerpt?: string;
+    transcript_summary?: string;
+    ace_context: {
+        resolved_layout_mode: string;
+        role?: string;
+        bridge_status: string;
+        active_tool?: string;
+        blocked_reason?: string;
+        approval_state?: string;
+        retry_state?: Record<string, unknown>;
+        recommended_next_action?: string;
+    };
+}
+export declare class LocalModelRuntimeRepository {
+    private store;
+    constructor(store: AcePackedStore);
+    private activationKey;
+    private continuityKey;
+    private statusKey;
+    private archiveKey;
+    getActivationLedger(sessionId: string): Promise<AceSessionActivationLedger | undefined>;
+    upsertActivationLedger(input: Partial<AceSessionActivationLedger> & Pick<AceSessionActivationLedger, "session_id">): Promise<AceSessionActivationLedger>;
+    getContinuityRecord(sessionId: string): Promise<AceSessionContinuityRecord | undefined>;
+    upsertContinuityRecord(input: Omit<AceSessionContinuityRecord, "updated_at" | "created_at"> & Partial<Pick<AceSessionContinuityRecord, "created_at">>): Promise<AceSessionContinuityRecord>;
+    getRuntimeStatus(sessionId: string): Promise<AceRuntimeStatusPacket | undefined>;
+    upsertRuntimeStatus(input: Omit<AceRuntimeStatusPacket, "updated_at">): Promise<AceRuntimeStatusPacket>;
+    listRuntimeStatuses(): Promise<AceRuntimeStatusPacket[]>;
+    archiveChat(input: Omit<AceArchivedChatRecord, "archived_at"> & Partial<Pick<AceArchivedChatRecord, "archived_at">>): Promise<AceArchivedChatRecord>;
+    listArchivedChats(): Promise<AceArchivedChatRecord[]>;
+    private addToIndex;
+    private appendLifecycleEntry;
+}
+export declare function withLocalModelRuntimeRepository<T>(workspaceRoot: string, fn: (repo: LocalModelRuntimeRepository) => Promise<T>): Promise<T | undefined>;
+//# sourceMappingURL=local-model-runtime-repository.d.ts.map

package/dist/store/repositories/local-model-runtime-repository.js

@@ -0,0 +1,165 @@
+import { randomUUID } from "node:crypto";
+import { openStore } from "../ace-packed-store.js";
+import { ContentSource, EntityKind } from "../types.js";
+import { getWorkspaceStorePath } from "../store-snapshot.js";
+import { withStoreWriteQueue } from "../write-queue.js";
+const ACTIVATION_INDEX_KEY = "state/ui/session_activation/index";
+const CONTINUITY_INDEX_KEY = "state/runtime/session_continuity/index";
+const STATUS_INDEX_KEY = "state/runtime/ui_status/index";
+const ARCHIVE_INDEX_KEY = "state/ui/chat_archives/index";
+function uniqueStrings(values) {
+    return Array.from(new Set((values ?? []).filter((value) => typeof value === "string" && value.length > 0)));
+}
+export class LocalModelRuntimeRepository {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    activationKey(sessionId) {
+        return `state/ui/session_activation/${sessionId}`;
+    }
+    continuityKey(sessionId) {
+        return `state/runtime/session_continuity/${sessionId}`;
+    }
+    statusKey(sessionId) {
+        return `state/runtime/ui_status/${sessionId}`;
+    }
+    archiveKey(sessionId) {
+        return `state/ui/chat_archives/${sessionId}`;
+    }
+    async getActivationLedger(sessionId) {
+        return this.store.getJSON(this.activationKey(sessionId));
+    }
+    async upsertActivationLedger(input) {
+        const current = await this.getActivationLedger(input.session_id);
+        const now = Date.now();
+        const record = {
+            session_id: input.session_id,
+            created_at: current?.created_at ?? now,
+            updated_at: now,
+            prompt_count: input.prompt_count ?? current?.prompt_count ?? 0,
+            shown_nudges: uniqueStrings(input.shown_nudges ?? current?.shown_nudges ?? []),
+            accepted_nudges: uniqueStrings(input.accepted_nudges ?? current?.accepted_nudges ?? []),
+            activated_tools: uniqueStrings(input.activated_tools ?? current?.activated_tools ?? []),
+            activated_roles: uniqueStrings(input.activated_roles ?? current?.activated_roles ?? []),
+            last_recommended_action: input.last_recommended_action ?? current?.last_recommended_action,
+        };
+        await this.store.setJSON(this.activationKey(record.session_id), record);
+        await this.appendLifecycleEntry(this.activationKey(record.session_id), {
+            op: current ? "activation_update" : "activation_create",
+            session_id: record.session_id,
+        });
+        await this.addToIndex(ACTIVATION_INDEX_KEY, record.session_id);
+        return record;
+    }
+    async getContinuityRecord(sessionId) {
+        return this.store.getJSON(this.continuityKey(sessionId));
+    }
+    async upsertContinuityRecord(input) {
+        const current = await this.getContinuityRecord(input.session_id);
+        const now = Date.now();
+        const record = {
+            ...input,
+            created_at: current?.created_at ?? input.created_at ?? now,
+            updated_at: now,
+            blockers: uniqueStrings(input.blockers ?? current?.blockers ?? []),
+            recent_decisions: uniqueStrings(input.recent_decisions ?? current?.recent_decisions ?? []),
+            evidence_refs: uniqueStrings(input.evidence_refs ?? current?.evidence_refs ?? []),
+        };
+        await this.store.setJSON(this.continuityKey(record.session_id), record);
+        await this.appendLifecycleEntry(this.continuityKey(record.session_id), {
+            op: current ? "continuity_update" : "continuity_create",
+            session_id: record.session_id,
+            bridge_status: record.last_bridge_status,
+        });
+        await this.addToIndex(CONTINUITY_INDEX_KEY, record.session_id);
+        return record;
+    }
+    async getRuntimeStatus(sessionId) {
+        return this.store.getJSON(this.statusKey(sessionId));
+    }
+    async upsertRuntimeStatus(input) {
+        const record = {
+            ...input,
+            updated_at: Date.now(),
+        };
+        await this.store.setJSON(this.statusKey(record.session_id), record);
+        await this.appendLifecycleEntry(this.statusKey(record.session_id), {
+            op: "runtime_status",
+            session_id: record.session_id,
+            bridge_status: record.bridge_status,
+            preflight_state: record.preflight_state,
+        });
+        await this.addToIndex(STATUS_INDEX_KEY, record.session_id);
+        return record;
+    }
+    async listRuntimeStatuses() {
+        const index = await this.store.getJSON(STATUS_INDEX_KEY) ?? [];
+        const statuses = [];
+        for (const sessionId of index) {
+            const record = await this.getRuntimeStatus(sessionId);
+            if (record)
+                statuses.push(record);
+        }
+        return statuses.sort((left, right) => right.updated_at - left.updated_at);
+    }
+    async archiveChat(input) {
+        const record = {
+            ...input,
+            archived_at: input.archived_at ?? Date.now(),
+        };
+        await this.store.setJSON(this.archiveKey(record.session_id), record);
+        await this.appendLifecycleEntry(this.archiveKey(record.session_id), {
+            op: "chat_archive",
+            session_id: record.session_id,
+            tab_id: record.tab_id,
+            label: record.label,
+        });
+        await this.addToIndex(ARCHIVE_INDEX_KEY, record.session_id);
+        return record;
+    }
+    async listArchivedChats() {
+        const index = await this.store.getJSON(ARCHIVE_INDEX_KEY) ?? [];
+        const archives = [];
+        for (const sessionId of index) {
+            const record = await this.store.getJSON(this.archiveKey(sessionId));
+            if (record)
+                archives.push(record);
+        }
+        return archives.sort((left, right) => right.archived_at - left.archived_at);
+    }
+    async addToIndex(indexKey, id) {
+        const index = await this.store.getJSON(indexKey) ?? [];
+        if (!index.includes(id)) {
+            index.push(id);
+            await this.store.setJSON(indexKey, index);
+        }
+    }
+    async appendLifecycleEntry(key, payload) {
+        await this.store.appendEntry({
+            kind: EntityKind.SessionEvent,
+            content_source: ContentSource.Runtime,
+            key,
+            payload: {
+                ...payload,
+                id: randomUUID(),
+            },
+        });
+    }
+}
+export async function withLocalModelRuntimeRepository(workspaceRoot, fn) {
+    const storePath = getWorkspaceStorePath(workspaceRoot);
+    return withStoreWriteQueue(storePath, async () => {
+        const store = await openStore(storePath);
+        try {
+            const repo = new LocalModelRuntimeRepository(store);
+            const result = await fn(repo);
+            await store.commit();
+            return result;
+        }
+        finally {
+            await store.close();
+        }
+    });
+}
+//# sourceMappingURL=local-model-runtime-repository.js.map

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/skills-install.d.ts

@@ -3,7 +3,7 @@
  *
  * `npx @voybio/ace-swarm add skills [bundle]`
  *
- * Installs skill packs into ace-state.zarr on demand.
+ * Installs skill packs into ace-state.ace on demand.
  * Skills are also baked at ace init; this command is retained for repair/reinstall.
  *
  * What install does: