@voybio/ace-swarm 0.1.0

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

@@ -0,0 +1,123 @@
+/**
+ * SchedulerRepository — state/scheduler/
+ * Replaces: job-queue.json, job-locks.json, scheduler-lease.json
+ */
+import { ContentSource, EntityKind } from "../types.js";
+const QUEUE_KEY = "state/scheduler/queue";
+const LOCKS_KEY = "state/scheduler/locks";
+const LEASE_KEY = "state/scheduler/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);
+        await this.store.appendEntry({
+            kind: EntityKind.SchedulerTick,
+            content_source: ContentSource.Runtime,
+            key: QUEUE_KEY,
+            payload: { op: "enqueue", job_id: job.id },
+        });
+        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 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 completeJob(id, result) {
+        return this.updateJob(id, { status: "done", completed_at: Date.now(), result });
+    }
+    async failJob(id, reason) {
+        return this.updateJob(id, {
+            status: "failed",
+            completed_at: Date.now(),
+            metadata: { failure_reason: reason },
+        });
+    }
+    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));
+        });
+    }
+    // ── 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/session-repository.d.ts

@@ -0,0 +1,33 @@
+/**
+ * SessionRepository — state/runtime/sessions
+ * Replaces: agent-state/index.json session tracking
+ */
+import { AcePackedStore } from "../ace-packed-store.js";
+export interface SessionRecord {
+    id: string;
+    agent: string;
+    role: string;
+    workspace_root: string;
+    status: "active" | "idle" | "stopped" | "error";
+    started_at: number;
+    last_active_at: number;
+    stopped_at?: number;
+    metadata?: Record<string, unknown>;
+}
+export declare class SessionRepository {
+    private store;
+    constructor(store: AcePackedStore);
+    private key;
+    create(session: Omit<SessionRecord, "started_at" | "last_active_at" | "status">): Promise<SessionRecord>;
+    get(id: string): Promise<SessionRecord | undefined>;
+    touch(id: string): Promise<void>;
+    stop(id: string): Promise<SessionRecord | undefined>;
+    list(filter?: {
+        agent?: string;
+        status?: SessionRecord["status"];
+    }): Promise<SessionRecord[]>;
+    remove(id: string): Promise<boolean>;
+    private _addToIndex;
+    private _removeFromIndex;
+}
+//# sourceMappingURL=session-repository.d.ts.map

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

@@ -0,0 +1,82 @@
+/**
+ * SessionRepository — state/runtime/sessions
+ * Replaces: agent-state/index.json session tracking
+ */
+import { ContentSource, EntityKind } from "../types.js";
+const INDEX_KEY = "state/runtime/sessions/index";
+export class SessionRepository {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    key(id) {
+        return `state/runtime/sessions/${id}`;
+    }
+    async create(session) {
+        const now = Date.now();
+        const record = {
+            ...session,
+            status: "active",
+            started_at: now,
+            last_active_at: now,
+        };
+        await this.store.setJSON(this.key(session.id), record);
+        await this.store.appendEntry({
+            kind: EntityKind.SessionEvent,
+            content_source: ContentSource.Runtime,
+            key: this.key(session.id),
+            payload: { op: "create", session_id: session.id },
+        });
+        await this._addToIndex(session.id);
+        return record;
+    }
+    async get(id) {
+        return this.store.getJSON(this.key(id));
+    }
+    async touch(id) {
+        const s = await this.get(id);
+        if (!s)
+            return;
+        await this.store.setJSON(this.key(id), { ...s, last_active_at: Date.now() });
+    }
+    async stop(id) {
+        const s = await this.get(id);
+        if (!s)
+            return undefined;
+        const updated = { ...s, status: "stopped", stopped_at: Date.now() };
+        await this.store.setJSON(this.key(id), updated);
+        return updated;
+    }
+    async list(filter) {
+        const index = await this.store.getJSON(INDEX_KEY) ?? [];
+        const sessions = [];
+        for (const id of index) {
+            const s = await this.get(id);
+            if (!s)
+                continue;
+            if (filter?.agent && s.agent !== filter.agent)
+                continue;
+            if (filter?.status && s.status !== filter.status)
+                continue;
+            sessions.push(s);
+        }
+        return sessions.sort((a, b) => b.started_at - a.started_at);
+    }
+    async remove(id) {
+        await this.store.delete(this.key(id));
+        await this._removeFromIndex(id);
+        return true;
+    }
+    async _addToIndex(id) {
+        const index = await this.store.getJSON(INDEX_KEY) ?? [];
+        if (!index.includes(id)) {
+            index.push(id);
+            await this.store.setJSON(INDEX_KEY, index);
+        }
+    }
+    async _removeFromIndex(id) {
+        const index = await this.store.getJSON(INDEX_KEY) ?? [];
+        await this.store.setJSON(INDEX_KEY, index.filter((i) => i !== id));
+    }
+}
+//# sourceMappingURL=session-repository.js.map

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

@@ -0,0 +1,31 @@
+/**
+ * TodoRepository — state/todo/
+ * Replaces: agent-state/todo-state.json
+ */
+import { AcePackedStore } from "../ace-packed-store.js";
+export interface TodoNode {
+    id: string;
+    title: string;
+    status: "pending" | "in_progress" | "done" | "blocked" | "cancelled";
+    priority?: "high" | "medium" | "low";
+    assigned_to?: string;
+    depends_on?: string[];
+    created_at: number;
+    updated_at: number;
+    notes?: string;
+}
+export declare class TodoRepository {
+    private store;
+    constructor(store: AcePackedStore);
+    private key;
+    create(todo: Omit<TodoNode, "created_at" | "updated_at">): Promise<TodoNode>;
+    get(id: string): Promise<TodoNode | undefined>;
+    update(id: string, patch: Partial<TodoNode>): Promise<TodoNode>;
+    list(filter?: {
+        status?: TodoNode["status"];
+        assigned_to?: string;
+    }): Promise<TodoNode[]>;
+    getAll(): Promise<TodoNode[]>;
+    private _updateIndex;
+}
+//# sourceMappingURL=todo-repository.d.ts.map

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

@@ -0,0 +1,77 @@
+/**
+ * TodoRepository — state/todo/
+ * Replaces: agent-state/todo-state.json
+ */
+import { ContentSource, EntityKind } from "../types.js";
+const TODO_INDEX_KEY = "state/todo/index";
+export class TodoRepository {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    key(id) {
+        return `state/todo/${id}`;
+    }
+    async create(todo) {
+        const now = Date.now();
+        const record = { ...todo, 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,
+        });
+        await this._updateIndex(record, "add");
+        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(`TodoRepository: todo 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.Todo,
+            content_source: ContentSource.Runtime,
+            key: this.key(id),
+            payload: updated,
+        });
+        await this._updateIndex(updated, "update");
+        return updated;
+    }
+    async list(filter) {
+        const index = await this.store.getJSON(TODO_INDEX_KEY) ?? [];
+        const todos = [];
+        for (const id of index) {
+            const todo = await this.get(id);
+            if (!todo)
+                continue;
+            if (filter?.status && todo.status !== filter.status)
+                continue;
+            if (filter?.assigned_to && todo.assigned_to !== filter.assigned_to)
+                continue;
+            todos.push(todo);
+        }
+        return todos;
+    }
+    async getAll() {
+        return this.list();
+    }
+    async _updateIndex(todo, op) {
+        const index = await this.store.getJSON(TODO_INDEX_KEY) ?? [];
+        if (op === "add" && !index.includes(todo.id)) {
+            index.push(todo.id);
+            await this.store.setJSON(TODO_INDEX_KEY, index);
+        }
+        else if (op === "remove") {
+            const next = index.filter((id) => id !== todo.id);
+            await this.store.setJSON(TODO_INDEX_KEY, next);
+        }
+        // update: no index change needed
+    }
+}
+//# sourceMappingURL=todo-repository.js.map

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

@@ -0,0 +1,25 @@
+/**
+ * TrackerRepository — state/tracker/
+ * Replaces: agent-state/STATUS_EVENTS.ndjson
+ */
+import { AcePackedStore } from "../ace-packed-store.js";
+export interface StatusEvent {
+    id: string;
+    ts: number;
+    kind: string;
+    agent?: string;
+    summary: string;
+    metadata?: Record<string, unknown>;
+}
+export declare class TrackerRepository {
+    private store;
+    constructor(store: AcePackedStore);
+    emit(event: Omit<StatusEvent, "id" | "ts">): Promise<StatusEvent>;
+    list(filter?: {
+        kind?: string;
+        agent?: string;
+        since?: number;
+        limit?: number;
+    }): Promise<StatusEvent[]>;
+}
+//# sourceMappingURL=tracker-repository.d.ts.map

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

@@ -0,0 +1,43 @@
+/**
+ * TrackerRepository — state/tracker/
+ * Replaces: agent-state/STATUS_EVENTS.ndjson
+ */
+import { ContentSource, EntityKind } from "../types.js";
+const TRACKER_SEQ_KEY = "state/tracker/__seq";
+export class TrackerRepository {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    async emit(event) {
+        const current = (await this.store.getJSON(TRACKER_SEQ_KEY)) ?? 0;
+        const next = current + 1;
+        await this.store.setJSON(TRACKER_SEQ_KEY, next);
+        const id = `se-${String(next).padStart(10, "0")}`;
+        const record = { ...event, id, ts: Date.now() };
+        const key = `state/tracker/${id}`;
+        await this.store.setJSON(key, record);
+        await this.store.appendEntry({
+            kind: EntityKind.SessionEvent,
+            content_source: ContentSource.Runtime,
+            key,
+            payload: record,
+        });
+        return record;
+    }
+    async list(filter) {
+        const entries = await this.store.getEntries({
+            kind: EntityKind.SessionEvent,
+            since: filter?.since,
+            keyPrefix: "state/tracker/",
+        });
+        let events = entries.map((e) => e.payload).filter(Boolean);
+        if (filter?.kind)
+            events = events.filter((e) => e.kind === filter.kind);
+        if (filter?.agent)
+            events = events.filter((e) => e.agent === filter.agent);
+        events.sort((a, b) => a.ts - b.ts);
+        return filter?.limit ? events.slice(-filter.limit) : events;
+    }
+}
+//# sourceMappingURL=tracker-repository.js.map

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

@@ -0,0 +1,32 @@
+/**
+ * VericifyRepository — state/vericify/
+ * Replaces: agent-state/vericify/process-posts.json
+ *
+ * Also triggers Vericify projection file writes on mutation.
+ */
+import { AcePackedStore } from "../ace-packed-store.js";
+export interface VericifyPost {
+    id: string;
+    run_id: string;
+    agent_id: string;
+    kind: "intent" | "progress" | "completion" | "blocker" | "handoff_note" | "stale_ack";
+    summary: string;
+    ts: number;
+    metadata?: Record<string, unknown>;
+}
+export declare class VericifyRepository {
+    private store;
+    private onMutation?;
+    constructor(store: AcePackedStore, opts?: {
+        onMutation?: () => Promise<void>;
+    });
+    private key;
+    appendPost(post: Omit<VericifyPost, "id" | "ts">): Promise<VericifyPost>;
+    list(filter?: {
+        run_id?: string;
+        agent_id?: string;
+        kind?: VericifyPost["kind"];
+    }): Promise<VericifyPost[]>;
+    private _addToIndex;
+}
+//# sourceMappingURL=vericify-repository.d.ts.map

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

@@ -0,0 +1,58 @@
+/**
+ * VericifyRepository — state/vericify/
+ * Replaces: agent-state/vericify/process-posts.json
+ *
+ * Also triggers Vericify projection file writes on mutation.
+ */
+import { ContentSource, EntityKind } from "../types.js";
+const INDEX_KEY = "state/vericify/posts/index";
+export class VericifyRepository {
+    store;
+    onMutation;
+    constructor(store, opts) {
+        this.store = store;
+        this.onMutation = opts?.onMutation;
+    }
+    key(id) {
+        return `state/vericify/posts/${id}`;
+    }
+    async appendPost(post) {
+        const id = `vp-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const record = { ...post, id, ts: Date.now() };
+        await this.store.setJSON(this.key(id), record);
+        await this.store.appendEntry({
+            kind: EntityKind.VericifyPost,
+            content_source: ContentSource.Runtime,
+            key: this.key(id),
+            payload: record,
+        });
+        await this._addToIndex(id);
+        await this.onMutation?.();
+        return record;
+    }
+    async list(filter) {
+        const index = await this.store.getJSON(INDEX_KEY) ?? [];
+        const posts = [];
+        for (const id of index) {
+            const post = await this.store.getJSON(this.key(id));
+            if (!post)
+                continue;
+            if (filter?.run_id && post.run_id !== filter.run_id)
+                continue;
+            if (filter?.agent_id && post.agent_id !== filter.agent_id)
+                continue;
+            if (filter?.kind && post.kind !== filter.kind)
+                continue;
+            posts.push(post);
+        }
+        return posts.sort((a, b) => a.ts - b.ts);
+    }
+    async _addToIndex(id) {
+        const index = await this.store.getJSON(INDEX_KEY) ?? [];
+        if (!index.includes(id)) {
+            index.push(id);
+            await this.store.setJSON(INDEX_KEY, index);
+        }
+    }
+}
+//# sourceMappingURL=vericify-repository.js.map

package/dist/store/skills-install.d.ts

@@ -0,0 +1,28 @@
+/**
+ * skills-install.ts — Phase 9
+ *
+ * `npx @voybio/ace-swarm add skills [bundle]`
+ *
+ * Installs skill packs into ace-state.zarr on demand.
+ * Skills are also baked at ace init; this command is retained for repair/reinstall.
+ *
+ * What install does:
+ *   1. Resolve the requested skill from assets/
+ *   2. Write skill_definition entries into knowledge/skills/{skill}/
+ *   3. Update topology skill_bindings if requested agents are specified
+ *   4. Compact if the install materially expands the store (>50% dead space)
+ */
+export interface InstallResult {
+    skill: string;
+    files: number;
+    compacted: boolean;
+}
+export declare function installSkillPack(workspaceRoot: string, skillName: string): Promise<InstallResult>;
+export declare function installAllSkills(workspaceRoot: string): Promise<InstallResult[]>;
+export declare function listInstalledSkills(workspaceRoot: string): Promise<string[]>;
+export declare function listAvailableSkillPacks(workspaceRoot: string): Promise<{
+    installed: string[];
+    available: string[];
+    notInstalled: string[];
+}>;
+//# sourceMappingURL=skills-install.d.ts.map

package/dist/store/skills-install.js

@@ -0,0 +1,86 @@
+/**
+ * skills-install.ts — Phase 9
+ *
+ * `npx @voybio/ace-swarm add skills [bundle]`
+ *
+ * Installs skill packs into ace-state.zarr on demand.
+ * Skills are also baked at ace init; this command is retained for repair/reinstall.
+ *
+ * What install does:
+ *   1. Resolve the requested skill from assets/
+ *   2. Write skill_definition entries into knowledge/skills/{skill}/
+ *   3. Update topology skill_bindings if requested agents are specified
+ *   4. Compact if the install materially expands the store (>50% dead space)
+ */
+import { existsSync } from "fs";
+import { join, dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { openStore } from "./ace-packed-store.js";
+import { bakeSkillPack, listAvailableSkills } from "./knowledge-bake.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function getAssetsRoot() {
+    const candidate = resolve(__dirname, "..", "..", "assets");
+    if (existsSync(candidate))
+        return candidate;
+    return resolve(__dirname, "..", "..", "..", "assets");
+}
+export async function installSkillPack(workspaceRoot, skillName) {
+    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.zarr");
+    if (!existsSync(storePath)) {
+        throw new Error(`No store found at ${storePath}. Run 'ace init' first.`);
+    }
+    const assetsRoot = getAssetsRoot();
+    const available = await listAvailableSkills(assetsRoot);
+    if (!available.includes(skillName)) {
+        throw new Error(`Skill pack '${skillName}' not found. Available: ${available.join(", ")}`);
+    }
+    const store = await openStore(storePath);
+    let compacted = false;
+    try {
+        // Check if already installed
+        const existing = await store.listSkills();
+        if (existing.includes(skillName)) {
+            console.log(`[skills-install] '${skillName}' already installed — reinstalling`);
+        }
+        const files = await bakeSkillPack(store, assetsRoot, skillName);
+        await store.commit();
+        // Compact if dead space > 50%
+        if (store.deadSpaceRatio > 0.5) {
+            await store.compact();
+            compacted = true;
+        }
+        return { skill: skillName, files, compacted };
+    }
+    finally {
+        await store.close();
+    }
+}
+export async function installAllSkills(workspaceRoot) {
+    const assetsRoot = getAssetsRoot();
+    const available = await listAvailableSkills(assetsRoot);
+    const results = [];
+    for (const skill of available) {
+        results.push(await installSkillPack(workspaceRoot, skill));
+    }
+    return results;
+}
+export async function listInstalledSkills(workspaceRoot) {
+    const storePath = join(workspaceRoot, ".agents", "ACE", "ace-state.zarr");
+    if (!existsSync(storePath))
+        return [];
+    const store = await openStore(storePath);
+    try {
+        return await store.listSkills();
+    }
+    finally {
+        await store.close();
+    }
+}
+export async function listAvailableSkillPacks(workspaceRoot) {
+    const assetsRoot = getAssetsRoot();
+    const available = await listAvailableSkills(assetsRoot);
+    const installed = await listInstalledSkills(workspaceRoot);
+    const notInstalled = available.filter((s) => !installed.includes(s));
+    return { installed, available, notInstalled };
+}
+//# sourceMappingURL=skills-install.js.map

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

@@ -0,0 +1,49 @@
+/**
+ * StateReader — read-only projection over AcePackedStore
+ *
+ * The TUI uses StateReader for dashboard ingestion.
+ * The TUI never opens the store for writing.
+ *
+ * Opens the store in a read-compatible mode (no write lock needed for reads).
+ */
+import { HandoffRepository } from "./repositories/handoff-repository.js";
+import { TodoRepository } from "./repositories/todo-repository.js";
+import { LedgerRepository } from "./repositories/ledger-repository.js";
+import { SchedulerRepository } from "./repositories/scheduler-repository.js";
+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";
+export interface DashboardSnapshot {
+    handoffs: Awaited<ReturnType<HandoffRepository["list"]>>;
+    todos: Awaited<ReturnType<TodoRepository["getAll"]>>;
+    ledger: Awaited<ReturnType<LedgerRepository["recent"]>>;
+    jobs: Awaited<ReturnType<SchedulerRepository["listJobs"]>>;
+    sessions: Awaited<ReturnType<SessionRepository["list"]>>;
+    events: Awaited<ReturnType<TrackerRepository["list"]>>;
+    providers: Awaited<ReturnType<DiscoveryRepository["listAll"]>>;
+    posts: Awaited<ReturnType<VericifyRepository["list"]>>;
+    snapped_at: number;
+}
+export declare class StoreStateReader {
+    private store;
+    private get repos();
+    open(storePath: string): Promise<void>;
+    close(): Promise<void>;
+    snapshot(): Promise<DashboardSnapshot>;
+    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[]>;
+    sessions(): Promise<import("./repositories/session-repository.js").SessionRecord[]>;
+    statusEvents(): Promise<import("./repositories/tracker-repository.js").StatusEvent[]>;
+    providerDiscovery(): Promise<import("./repositories/discovery-repository.js").DiscoveryResult[]>;
+    vericifyPosts(): Promise<import("./repositories/vericify-repository.js").VericifyPost[]>;
+    domainDocs(_domain: string): Promise<never[]>;
+}
+/**
+ * Poll the store on an interval and call the callback with snapshots.
+ * TUI dashboard ingestion pattern.
+ */
+export declare function pollStore(storePath: string, intervalMs: number, onSnapshot: (snapshot: DashboardSnapshot) => void, onError?: (err: Error) => void): () => void;
+//# sourceMappingURL=state-reader.d.ts.map