@voybio/ace-swarm 0.1.0

package/dist/store/state-reader.js

@@ -0,0 +1,111 @@
+/**
+ * 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 { openStore } from "./ace-packed-store.js";
+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 class StoreStateReader {
+    store = null;
+    get repos() {
+        if (!this.store)
+            throw new Error("StoreStateReader: not open");
+        return {
+            handoffs: new HandoffRepository(this.store),
+            todos: new TodoRepository(this.store),
+            ledger: new LedgerRepository(this.store),
+            scheduler: new SchedulerRepository(this.store),
+            sessions: new SessionRepository(this.store),
+            tracker: new TrackerRepository(this.store),
+            discovery: new DiscoveryRepository(this.store),
+            vericify: new VericifyRepository(this.store),
+        };
+    }
+    async open(storePath) {
+        // Read-only: no write lock acquired — safe for concurrent TUI reads
+        this.store = await openStore(storePath, { readOnly: true });
+    }
+    async close() {
+        if (this.store) {
+            await this.store.close();
+            this.store = null;
+        }
+    }
+    async snapshot() {
+        const r = this.repos;
+        const [handoffs, todos, ledger, jobs, sessions, events, providers, posts] = await Promise.all([
+            r.handoffs.list(),
+            r.todos.getAll(),
+            r.ledger.recent(20),
+            r.scheduler.listJobs(),
+            r.sessions.list(),
+            r.tracker.list({ limit: 50 }),
+            r.discovery.listAll(),
+            r.vericify.list(),
+        ]);
+        return {
+            handoffs,
+            todos,
+            ledger,
+            jobs,
+            sessions,
+            events,
+            providers,
+            posts,
+            snapped_at: Date.now(),
+        };
+    }
+    async handoffs() { return this.repos.handoffs.list(); }
+    async todos() { return this.repos.todos.getAll(); }
+    async ledger() { return this.repos.ledger.list(); }
+    async schedulerState() { return this.repos.scheduler.listJobs(); }
+    async sessions() { return this.repos.sessions.list(); }
+    async statusEvents() { return this.repos.tracker.list(); }
+    async providerDiscovery() { return this.repos.discovery.listAll(); }
+    async vericifyPosts() { return this.repos.vericify.list(); }
+    async domainDocs(_domain) { return []; } // Phase 6 wiring
+}
+/**
+ * Poll the store on an interval and call the callback with snapshots.
+ * TUI dashboard ingestion pattern.
+ */
+export function pollStore(storePath, intervalMs, onSnapshot, onError) {
+    let stopped = false;
+    let reader = null;
+    async function poll() {
+        while (!stopped) {
+            try {
+                if (!reader) {
+                    reader = new StoreStateReader();
+                    await reader.open(storePath);
+                }
+                const snap = await reader.snapshot();
+                onSnapshot(snap);
+            }
+            catch (err) {
+                onError?.(err);
+                // Close and reopen on next poll
+                if (reader) {
+                    await reader.close().catch(() => { });
+                    reader = null;
+                }
+            }
+            await new Promise((r) => setTimeout(r, intervalMs));
+        }
+        if (reader)
+            await reader.close().catch(() => { });
+    }
+    poll();
+    return () => { stopped = true; };
+}
+//# sourceMappingURL=state-reader.js.map

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

@@ -0,0 +1,12 @@
+export declare const OPERATIONAL_ARTIFACT_REL_PATHS: Set<string>;
+export declare function operationalArtifactKey(relPath: string): string;
+export declare function isOperationalArtifactPath(relPath: string): boolean;
+export declare function readOperationalArtifactSync(workspaceRoot: string, relPath: string): string | undefined;
+export declare function operationalArtifactVirtualPath(workspaceRoot: string, relPath: string): string;
+export declare function writeStoreBlobsSync(workspaceRoot: string, blobs: ReadonlyArray<{
+    key: string;
+    content: string;
+}>): string[];
+export declare function writeStoreBlobSync(workspaceRoot: string, key: string, content: string): string;
+export declare function writeOperationalArtifactSync(workspaceRoot: string, relPath: string, content: string): string;
+//# sourceMappingURL=store-artifacts.d.ts.map

package/dist/store/store-artifacts.js

@@ -0,0 +1,138 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
+import { dirname } from "node:path";
+import { getWorkspaceStorePath, readStoreBlobSync, toVirtualStorePath } from "./store-snapshot.js";
+import { HEADER_SIZE, MAGIC } from "./types.js";
+const TEXT = new TextEncoder();
+const DECODE = new TextDecoder();
+export const OPERATIONAL_ARTIFACT_REL_PATHS = new Set([
+    "agent-state/AST_GREP_INDEX.json",
+    "agent-state/AST_GREP_INDEX.md",
+    "agent-state/EVIDENCE_LOG.md",
+    "agent-state/STATUS_EVENTS.ndjson",
+    "agent-state/STATUS_EVENTS-archive.ndjson",
+    "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/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",
+    "agent-state/vericify/ace-bridge.json",
+    "agent-state/vericify/process-posts.json",
+]);
+const OPERATIONAL_ARTIFACT_PREFIX = "state/artifacts/";
+function uint32ToBytes(value) {
+    const bytes = new Uint8Array(4);
+    new DataView(bytes.buffer).setUint32(0, value, false);
+    return bytes;
+}
+function uint64ToBytes(value) {
+    const bytes = new Uint8Array(8);
+    const view = new DataView(bytes.buffer);
+    view.setUint32(0, Math.floor(value / 2 ** 32), false);
+    view.setUint32(4, value >>> 0, false);
+    return bytes;
+}
+function bytesToUint64(bytes, offset = 0) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset);
+    return view.getUint32(offset, false) * 2 ** 32 + view.getUint32(offset + 4, false);
+}
+function writeHeader(header, indexOffset, indexLength) {
+    for (let idx = 0; idx < 8; idx += 1)
+        header[idx] = MAGIC.charCodeAt(idx);
+    header.set(uint32ToBytes(1), 8);
+    header.set(uint32ToBytes(0), 12);
+    header.set(uint64ToBytes(indexOffset), 16);
+    header.set(uint64ToBytes(indexLength), 24);
+}
+function readHeader(header) {
+    const magic = DECODE.decode(header.slice(0, 8));
+    if (magic !== MAGIC) {
+        throw new Error("AcePackedStore artifact write failed: invalid store header");
+    }
+    return {
+        indexOffset: bytesToUint64(header, 16),
+        indexLength: bytesToUint64(header, 24),
+    };
+}
+function defaultStoreBuffer() {
+    const header = new Uint8Array(HEADER_SIZE);
+    const indexBytes = TEXT.encode("{}");
+    writeHeader(header, HEADER_SIZE, indexBytes.length);
+    const buffer = Buffer.alloc(HEADER_SIZE + indexBytes.length);
+    buffer.set(header, 0);
+    buffer.set(indexBytes, HEADER_SIZE);
+    return buffer;
+}
+function readStoreBuffer(storePath) {
+    const file = existsSync(storePath) ? readFileSync(storePath) : defaultStoreBuffer();
+    if (file.length < HEADER_SIZE) {
+        return {
+            file: defaultStoreBuffer(),
+            chunkEnd: HEADER_SIZE,
+            index: {},
+        };
+    }
+    const { indexOffset, indexLength } = readHeader(file.subarray(0, HEADER_SIZE));
+    const indexRaw = file.subarray(indexOffset, indexOffset + indexLength);
+    const index = JSON.parse(DECODE.decode(indexRaw));
+    return { file, chunkEnd: indexOffset, index };
+}
+export function operationalArtifactKey(relPath) {
+    return `${OPERATIONAL_ARTIFACT_PREFIX}${relPath}`;
+}
+export function isOperationalArtifactPath(relPath) {
+    return OPERATIONAL_ARTIFACT_REL_PATHS.has(relPath);
+}
+export function readOperationalArtifactSync(workspaceRoot, relPath) {
+    return readStoreBlobSync(workspaceRoot, operationalArtifactKey(relPath));
+}
+export function operationalArtifactVirtualPath(workspaceRoot, relPath) {
+    return toVirtualStorePath(getWorkspaceStorePath(workspaceRoot), operationalArtifactKey(relPath));
+}
+export function writeStoreBlobsSync(workspaceRoot, blobs) {
+    const storePath = getWorkspaceStorePath(workspaceRoot);
+    const { file, chunkEnd, index } = readStoreBuffer(storePath);
+    const encoded = blobs.map(({ key, content }) => ({
+        key,
+        contentBytes: TEXT.encode(content),
+    }));
+    const appendedSize = encoded.reduce((sum, entry) => sum + 4 + entry.contentBytes.length, 0);
+    const nextIndexOffset = chunkEnd + appendedSize;
+    const nextIndex = { ...index };
+    let cursor = chunkEnd;
+    for (const entry of encoded) {
+        nextIndex[entry.key] = { offset: cursor, length: entry.contentBytes.length };
+        cursor += 4 + entry.contentBytes.length;
+    }
+    const indexBytes = TEXT.encode(JSON.stringify(nextIndex));
+    const output = Buffer.alloc(nextIndexOffset + indexBytes.length);
+    const header = new Uint8Array(HEADER_SIZE);
+    writeHeader(header, nextIndexOffset, indexBytes.length);
+    output.set(header, 0);
+    if (chunkEnd > HEADER_SIZE) {
+        output.set(file.subarray(HEADER_SIZE, chunkEnd), HEADER_SIZE);
+    }
+    cursor = chunkEnd;
+    for (const entry of encoded) {
+        output.set(uint32ToBytes(entry.contentBytes.length), cursor);
+        output.set(entry.contentBytes, cursor + 4);
+        cursor += 4 + entry.contentBytes.length;
+    }
+    output.set(indexBytes, nextIndexOffset);
+    mkdirSync(dirname(storePath), { recursive: true });
+    const tmpPath = `${storePath}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmpPath, output);
+    renameSync(tmpPath, storePath);
+    return blobs.map(({ key }) => toVirtualStorePath(storePath, key));
+}
+export function writeStoreBlobSync(workspaceRoot, key, content) {
+    return writeStoreBlobsSync(workspaceRoot, [{ key, content }])[0];
+}
+export function writeOperationalArtifactSync(workspaceRoot, relPath, content) {
+    return writeStoreBlobSync(workspaceRoot, operationalArtifactKey(relPath), content);
+}
+//# sourceMappingURL=store-artifacts.js.map

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

@@ -0,0 +1,19 @@
+export declare function getWorkspaceStorePath(workspaceRoot: string): string;
+export declare function storeExistsSync(workspaceRoot: string): boolean;
+export declare function readStoreBlobSync(workspaceRoot: string, key: string): string | undefined;
+export declare function readStoreBlobByPathSync(storePath: string, key: string): string | undefined;
+export declare function readStoreJsonSync<T>(workspaceRoot: string, key: string): T | undefined;
+export declare function readStoreJsonByPathSync<T>(storePath: string, key: string): T | undefined;
+export declare function listStoreKeysSync(workspaceRoot: string, prefix?: string): string[];
+export declare function listStoreKeysByPathSync(storePath: string, prefix?: string): string[];
+export declare function getStoreStatSync(storePath: string): {
+    mtimeMs: number;
+    size: number;
+} | undefined;
+export declare function toVirtualStorePath(storePath: string, key: string): string;
+export declare function parseVirtualStorePath(path: string): {
+    storePath: string;
+    key: string;
+} | undefined;
+export declare function readVirtualStorePathSync(path: string): string | undefined;
+//# sourceMappingURL=store-snapshot.d.ts.map

package/dist/store/store-snapshot.js

@@ -0,0 +1,140 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { HEADER_SIZE, MAGIC } from "./types.js";
+const DECODE = new TextDecoder();
+let cached;
+function bytesToUint32(bytes, offset = 0) {
+    return new DataView(bytes.buffer, bytes.byteOffset).getUint32(offset, false);
+}
+function bytesToUint64(bytes, offset = 0) {
+    const dv = new DataView(bytes.buffer, bytes.byteOffset);
+    return dv.getUint32(offset, false) * 2 ** 32 + dv.getUint32(offset + 4, false);
+}
+function readHeader(bytes) {
+    const magic = DECODE.decode(bytes.slice(0, 8));
+    if (magic !== MAGIC) {
+        throw new Error("AcePackedStore snapshot: invalid magic bytes");
+    }
+    return {
+        indexOffset: bytesToUint64(bytes, 16),
+        indexLength: bytesToUint64(bytes, 24),
+    };
+}
+function loadSnapshot(storePath) {
+    if (!existsSync(storePath))
+        return undefined;
+    const stats = statSync(storePath);
+    if (cached &&
+        cached.path === storePath &&
+        cached.mtimeMs === stats.mtimeMs &&
+        cached.size === stats.size) {
+        return cached;
+    }
+    try {
+        const file = readFileSync(storePath);
+        if (file.length < HEADER_SIZE)
+            return cached?.path === storePath ? cached : undefined;
+        const { indexOffset, indexLength } = readHeader(file);
+        const indexBytes = file.slice(indexOffset, indexOffset + indexLength);
+        const parsed = JSON.parse(DECODE.decode(indexBytes));
+        cached = {
+            path: storePath,
+            mtimeMs: stats.mtimeMs,
+            size: stats.size,
+            file,
+            index: new Map(Object.entries(parsed)),
+        };
+        return cached;
+    }
+    catch {
+        return cached?.path === storePath ? cached : undefined;
+    }
+}
+export function getWorkspaceStorePath(workspaceRoot) {
+    return resolve(workspaceRoot, ".agents", "ACE", "ace-state.zarr");
+}
+export function storeExistsSync(workspaceRoot) {
+    return existsSync(getWorkspaceStorePath(workspaceRoot));
+}
+export function readStoreBlobSync(workspaceRoot, key) {
+    const snapshot = loadSnapshot(getWorkspaceStorePath(workspaceRoot));
+    const entry = snapshot?.index.get(key);
+    if (!snapshot || !entry)
+        return undefined;
+    const start = entry.offset + 4;
+    const end = start + entry.length;
+    return DECODE.decode(snapshot.file.slice(start, end));
+}
+export function readStoreBlobByPathSync(storePath, key) {
+    const snapshot = loadSnapshot(storePath);
+    const entry = snapshot?.index.get(key);
+    if (!snapshot || !entry)
+        return undefined;
+    const start = entry.offset + 4;
+    const end = start + entry.length;
+    return DECODE.decode(snapshot.file.slice(start, end));
+}
+export function readStoreJsonSync(workspaceRoot, key) {
+    const raw = readStoreBlobSync(workspaceRoot, key);
+    if (typeof raw !== "string")
+        return undefined;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readStoreJsonByPathSync(storePath, key) {
+    const raw = readStoreBlobByPathSync(storePath, key);
+    if (typeof raw !== "string")
+        return undefined;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function listStoreKeysSync(workspaceRoot, prefix = "") {
+    const snapshot = loadSnapshot(getWorkspaceStorePath(workspaceRoot));
+    if (!snapshot)
+        return [];
+    return [...snapshot.index.keys()]
+        .filter((key) => key.startsWith(prefix))
+        .sort((a, b) => a.localeCompare(b));
+}
+export function listStoreKeysByPathSync(storePath, prefix = "") {
+    const snapshot = loadSnapshot(storePath);
+    if (!snapshot)
+        return [];
+    return [...snapshot.index.keys()]
+        .filter((key) => key.startsWith(prefix))
+        .sort((a, b) => a.localeCompare(b));
+}
+export function getStoreStatSync(storePath) {
+    const snapshot = loadSnapshot(storePath);
+    if (!snapshot)
+        return undefined;
+    return { mtimeMs: snapshot.mtimeMs, size: snapshot.size };
+}
+export function toVirtualStorePath(storePath, key) {
+    return `${storePath}#${key}`;
+}
+export function parseVirtualStorePath(path) {
+    const marker = ".zarr#";
+    const index = path.indexOf(marker);
+    if (index === -1)
+        return undefined;
+    return {
+        storePath: path.slice(0, index + ".zarr".length),
+        key: path.slice(index + marker.length),
+    };
+}
+export function readVirtualStorePathSync(path) {
+    const parsed = parseVirtualStorePath(path);
+    if (!parsed)
+        return undefined;
+    return readStoreBlobByPathSync(parsed.storePath, parsed.key);
+}
+//# sourceMappingURL=store-snapshot.js.map

package/dist/store/topology-bake.d.ts

@@ -0,0 +1,15 @@
+/**
+ * topology-bake.ts
+ *
+ * Writes swarm topology into the store:
+ *   - swarm_registry: agent graph, group, capabilities
+ *   - agent_enablement: per-agent enable/disable flags and tool policies
+ *   - skill_bindings: which skills each agent can activate
+ *   - role_routing: role → agent dispatch table
+ */
+import { AcePackedStore } from "./ace-packed-store.js";
+export declare function bakeTopology(store: AcePackedStore, _assetsRoot: string): Promise<void>;
+export declare function resolveRole(store: AcePackedStore, role: string): Promise<string | undefined>;
+export declare function getEnabledAgents(store: AcePackedStore): Promise<string[]>;
+export declare function getAgentSkills(store: AcePackedStore, agentName: string): Promise<string[]>;
+//# sourceMappingURL=topology-bake.d.ts.map

package/dist/store/topology-bake.js

@@ -0,0 +1,215 @@
+/**
+ * topology-bake.ts
+ *
+ * Writes swarm topology into the store:
+ *   - swarm_registry: agent graph, group, capabilities
+ *   - agent_enablement: per-agent enable/disable flags and tool policies
+ *   - skill_bindings: which skills each agent can activate
+ *   - role_routing: role → agent dispatch table
+ */
+import { ContentSource } from "./types.js";
+// Derived from AGENT_REGISTRY.md table
+const AGENT_DEFINITIONS = [
+    {
+        name: "ace-orchestrator",
+        group: "swarm",
+        objective: "Global routing and lifecycle control",
+        defaultSkills: ["handoff-lint", "state-auditor"],
+        enabled: true,
+    },
+    {
+        name: "ace-vos",
+        group: "swarm",
+        objective: "Venture thesis and strategy hardening",
+        defaultSkills: ["risk-quant"],
+        enabled: true,
+    },
+    {
+        name: "ace-ui",
+        group: "swarm",
+        objective: "UX/copy strategy and conversion surfaces",
+        defaultSkills: ["memory-curator"],
+        enabled: true,
+    },
+    {
+        name: "ace-coders",
+        group: "swarm",
+        objective: "Engineering execution and TDD delivery",
+        defaultSkills: ["handoff-lint"],
+        enabled: true,
+    },
+    {
+        name: "astgrep",
+        group: "composable",
+        objective: "Structural discovery indexing",
+        defaultSkills: ["astgrep-index", "codemunch"],
+        enabled: true,
+    },
+    {
+        name: "skeptic",
+        group: "composable",
+        objective: "Falsifiable quality gates and risk challenge",
+        defaultSkills: ["state-auditor", "risk-quant"],
+        enabled: true,
+    },
+    {
+        name: "ops",
+        group: "composable",
+        objective: "Dependency orchestration and unblock routing",
+        defaultSkills: ["handoff-lint", "incident-commander", "state-auditor"],
+        enabled: true,
+    },
+    {
+        name: "research",
+        group: "composable",
+        objective: "Source-backed evidence and assumptions",
+        defaultSkills: ["codemunch", "codesnipe", "memory-curator"],
+        enabled: true,
+    },
+    {
+        name: "spec",
+        group: "composable",
+        objective: "Machine-readable requirement contracts",
+        defaultSkills: ["schema-forge", "handoff-lint"],
+        enabled: true,
+    },
+    {
+        name: "builder",
+        group: "composable",
+        objective: "Build artifacts that satisfy spec",
+        defaultSkills: ["handoff-lint"],
+        enabled: true,
+    },
+    {
+        name: "qa",
+        group: "composable",
+        objective: "Verification and failure classification",
+        defaultSkills: ["eval-harness", "state-auditor"],
+        enabled: true,
+    },
+    {
+        name: "docs",
+        group: "composable",
+        objective: "Documentation consistency vs verified reality",
+        defaultSkills: ["memory-curator", "state-auditor"],
+        enabled: true,
+    },
+    {
+        name: "memory",
+        group: "composable",
+        objective: "Durable memory reconciliation",
+        defaultSkills: ["memory-curator"],
+        enabled: true,
+    },
+    {
+        name: "security",
+        group: "composable",
+        objective: "Security and policy gate review",
+        defaultSkills: ["risk-quant"],
+        enabled: true,
+    },
+    {
+        name: "observability",
+        group: "composable",
+        objective: "Operability and incident-readiness verification",
+        defaultSkills: ["incident-commander", "state-auditor"],
+        enabled: true,
+    },
+    {
+        name: "eval",
+        group: "composable",
+        objective: "Autonomy/regression benchmark execution",
+        defaultSkills: ["eval-harness"],
+        enabled: true,
+    },
+    {
+        name: "release",
+        group: "composable",
+        objective: "Promotion/hold/rollback decisions",
+        defaultSkills: ["release-sentry"],
+        enabled: true,
+    },
+];
+// Role routing: maps user-facing role names → agent names
+const ROLE_ROUTING = {
+    orchestrator: "ace-orchestrator",
+    vos: "ace-vos",
+    ui: "ace-ui",
+    coders: "ace-coders",
+    astgrep: "astgrep",
+    skeptic: "skeptic",
+    ops: "ops",
+    research: "research",
+    spec: "spec",
+    builder: "builder",
+    qa: "qa",
+    docs: "docs",
+    memory: "memory",
+    security: "security",
+    observability: "observability",
+    eval: "eval",
+    release: "release",
+    // Aliases
+    coder: "ace-coders",
+    engineer: "ace-coders",
+    architect: "spec",
+    reviewer: "skeptic",
+    tester: "qa",
+};
+export async function bakeTopology(store, _assetsRoot) {
+    // 1. Swarm registry
+    const swarmEntries = AGENT_DEFINITIONS.map((a) => ({
+        kind: "swarm_registry",
+        key: a.name,
+        value: {
+            name: a.name,
+            group: a.group,
+            objective: a.objective,
+        },
+        source: ContentSource.Package,
+    }));
+    await store.setTopology("swarm_registry", swarmEntries);
+    // 2. Agent enablement
+    const enablementEntries = AGENT_DEFINITIONS.map((a) => ({
+        kind: "agent_enablement",
+        key: a.name,
+        value: { enabled: a.enabled },
+        source: ContentSource.Package,
+    }));
+    await store.setTopology("agent_enablement", enablementEntries);
+    // 3. Skill bindings
+    const skillEntries = AGENT_DEFINITIONS.map((a) => ({
+        kind: "skill_bindings",
+        key: a.name,
+        value: { skills: a.defaultSkills },
+        source: ContentSource.Package,
+    }));
+    await store.setTopology("skill_bindings", skillEntries);
+    // 4. Role routing
+    const roleEntries = Object.entries(ROLE_ROUTING).map(([role, agent]) => ({
+        kind: "role_routing",
+        key: role,
+        value: { agent },
+        source: ContentSource.Package,
+    }));
+    await store.setTopology("role_routing", roleEntries);
+    console.log(`[topology-bake] ${AGENT_DEFINITIONS.length} agents, ${Object.keys(ROLE_ROUTING).length} role routes`);
+}
+// ── Query helpers ─────────────────────────────────────────────────────────────
+export async function resolveRole(store, role) {
+    const entries = await store.getTopology("role_routing");
+    const match = entries.find((e) => e.key === role);
+    return match ? match.value.agent : undefined;
+}
+export async function getEnabledAgents(store) {
+    const entries = await store.getTopology("agent_enablement");
+    return entries
+        .filter((e) => e.value.enabled)
+        .map((e) => e.key);
+}
+export async function getAgentSkills(store, agentName) {
+    const entries = await store.getTopology("skill_bindings");
+    const match = entries.find((e) => e.key === agentName);
+    return match ? match.value.skills : [];
+}
+//# sourceMappingURL=topology-bake.js.map