@voybio/ace-swarm 0.1.0

package/dist/store/knowledge-bake.js

@@ -0,0 +1,339 @@
+/**
+ * knowledge-bake.ts
+ *
+ * Reads core assets from the npm package (assets/) and writes them into an
+ * open AcePackedStore. Called once at `ace init` time.
+ *
+ * Baked categories:
+ *   - Agent instructions (17 agents: 4 swarm + 13 composable)
+ *   - Module definitions (gates, roles, schemas)
+ *   - Kernel artifacts (DIRECTIVE_KERNEL, AGENT_REGISTRY)
+ *   - Static ACE state artifacts (TASK, STATUS, TEAL_CONFIG, runtime registries, etc.)
+ *   - Task artifacts (role packs, handoff templates, lessons seed, todo seed)
+ *   - Runtime profile seed (ACE_WORKFLOW.md)
+ *   - Skills (baked at init so the store is authoritative)
+ *   - Hook/bootstrap scripts used by turnkey materialization
+ */
+import { readdirSync, readFileSync, statSync, existsSync } from "fs";
+import { join, relative, extname } from "path";
+import { ContentSource, EntityKind } from "./types.js";
+const TEXT = new TextDecoder();
+// Map asset directory names → canonical store agent names
+const AGENT_DIR_MAP = {
+    orchestrator: "ace-orchestrator",
+    VOS: "ace-vos",
+    UI: "ace-ui",
+    ACE_coders: "ace-coders",
+    "ACE-Init": "ace-init",
+    "agent-astgrep": "astgrep",
+    "agent-builder": "builder",
+    "agent-docs": "docs",
+    "agent-eval": "eval",
+    "agent-memory": "memory",
+    "agent-observability": "observability",
+    "agent-ops": "ops",
+    "agent-qa": "qa",
+    "agent-release": "release",
+    "agent-research": "research",
+    "agent-security": "security",
+    "agent-skeptic": "skeptic",
+    "agent-spec": "spec",
+};
+const MARKDOWN_EXTS = new Set([".md", ".mdc", ".txt", ".json", ".yaml", ".yml"]);
+const STATIC_AGENT_STATE_FILES = [
+    "ACE_WORKFLOW.md",
+    "ARTIFACT_MANIFEST.json",
+    "AST_GREP_COMMANDS.md",
+    "AST_GREP_INDEX.json",
+    "AST_GREP_INDEX.md",
+    "DECISIONS.md",
+    "EVIDENCE_LOG.md",
+    "HANDOFF.json",
+    "INTERFACE_REGISTRY.md",
+    "PROVENANCE_LOG.md",
+    "QUALITY_GATES.md",
+    "RISKS.md",
+    "SCOPE.md",
+    "SKILL_CATALOG.md",
+    "STATUS.md",
+    "STATUS_EVENTS.ndjson",
+    "TASK.md",
+    "TEAL_CONFIG.md",
+    "handoff-registry.json",
+    "index-fingerprints.json",
+    "index.json",
+    "run-ledger.json",
+    "runtime-executor-sessions.json",
+    "runtime-tool-specs.json",
+    "runtime-workspaces.json",
+    "todo-state.json",
+    "tracker-snapshot.json",
+    "MODULES/registry.json",
+    "vericify/ace-bridge.json",
+    "vericify/process-posts.json",
+];
+function readText(filePath) {
+    return readFileSync(filePath, "utf8");
+}
+function walkDir(dir) {
+    const results = [];
+    if (!existsSync(dir))
+        return results;
+    for (const entry of readdirSync(dir)) {
+        const full = join(dir, entry);
+        if (statSync(full).isDirectory()) {
+            results.push(...walkDir(full));
+        }
+        else {
+            results.push(full);
+        }
+    }
+    return results;
+}
+// ── Agent Instructions ────────────────────────────────────────────────────────
+export async function bakeAgentInstructions(store, assetsRoot) {
+    const aceDir = join(assetsRoot, ".agents", "ACE");
+    if (!existsSync(aceDir)) {
+        console.warn(`[knowledge-bake] .agents/ACE not found at ${aceDir}`);
+        return { agents: [], files: 0 };
+    }
+    const agents = [];
+    let fileCount = 0;
+    for (const dirEntry of readdirSync(aceDir)) {
+        const dirPath = join(aceDir, dirEntry);
+        if (!statSync(dirPath).isDirectory())
+            continue;
+        const agentName = AGENT_DIR_MAP[dirEntry] ?? dirEntry.toLowerCase().replace(/^ace[-_]?/, "");
+        agents.push(agentName);
+        for (const filePath of walkDir(dirPath)) {
+            const ext = extname(filePath);
+            if (!MARKDOWN_EXTS.has(ext))
+                continue;
+            const relPath = relative(dirPath, filePath);
+            const content = readText(filePath);
+            await store.setAgentInstruction(agentName, relPath, content, ContentSource.Package);
+            fileCount++;
+        }
+    }
+    // Kernel artifacts live directly in aceDir (not in agent subdirs)
+    const kernelFiles = ["DIRECTIVE_KERNEL.md", "AGENT_REGISTRY.md", "AGENT_REGISTRY_7.md"];
+    for (const kf of kernelFiles) {
+        const kfPath = join(aceDir, kf);
+        if (!existsSync(kfPath))
+            continue;
+        const content = readText(kfPath);
+        const key = `knowledge/kernel/${kf}`;
+        await store.setBlob(key, content);
+        await store.appendEntry({
+            kind: EntityKind.KernelArtifact,
+            content_source: ContentSource.Package,
+            key,
+            payload: { file: kf, length: content.length },
+        });
+        fileCount++;
+    }
+    console.log(`[knowledge-bake] agents: baked ${agents.length} agents, ${fileCount} files`);
+    return { agents, files: fileCount };
+}
+// ── Module Definitions (Gates, Roles, Schemas) ────────────────────────────────
+export async function bakeModules(store, assetsRoot) {
+    const modulesDir = join(assetsRoot, "agent-state", "MODULES");
+    if (!existsSync(modulesDir)) {
+        console.warn(`[knowledge-bake] MODULES not found at ${modulesDir}`);
+        return { gates: 0, roles: 0, schemas: 0 };
+    }
+    let gates = 0, roles = 0, schemas = 0;
+    // Gates
+    const gatesDir = join(modulesDir, "gates");
+    if (existsSync(gatesDir)) {
+        for (const file of readdirSync(gatesDir)) {
+            const filePath = join(gatesDir, file);
+            if (!statSync(filePath).isFile())
+                continue;
+            const content = readText(filePath);
+            const key = `knowledge/gates/${file}`;
+            await store.setBlob(key, content);
+            await store.appendEntry({
+                kind: EntityKind.GateDefinition,
+                content_source: ContentSource.Package,
+                key,
+                payload: { file },
+            });
+            gates++;
+        }
+    }
+    // Roles
+    const rolesDir = join(modulesDir, "roles");
+    if (existsSync(rolesDir)) {
+        for (const file of readdirSync(rolesDir)) {
+            const filePath = join(rolesDir, file);
+            if (!statSync(filePath).isFile())
+                continue;
+            const content = readText(filePath);
+            const key = `knowledge/roles/${file}`;
+            await store.setBlob(key, content);
+            await store.appendEntry({
+                kind: EntityKind.RoleCapability,
+                content_source: ContentSource.Package,
+                key,
+                payload: { file },
+            });
+            roles++;
+        }
+    }
+    // Schemas
+    const schemasDir = join(modulesDir, "schemas");
+    if (existsSync(schemasDir)) {
+        for (const file of readdirSync(schemasDir)) {
+            const filePath = join(schemasDir, file);
+            if (!statSync(filePath).isFile())
+                continue;
+            const content = readText(filePath);
+            const key = `knowledge/schemas/${file}`;
+            await store.setBlob(key, content);
+            await store.appendEntry({
+                kind: EntityKind.SchemaDefinition,
+                content_source: ContentSource.Package,
+                key,
+                payload: { file },
+            });
+            schemas++;
+        }
+    }
+    console.log(`[knowledge-bake] modules: ${gates} gates, ${roles} roles, ${schemas} schemas`);
+    return { gates, roles, schemas };
+}
+// ── Static state artifacts + runtime profile ─────────────────────────────────
+export async function bakeStaticStateArtifacts(store, assetsRoot) {
+    const agentStateDir = join(assetsRoot, "agent-state");
+    if (!existsSync(agentStateDir)) {
+        return 0;
+    }
+    let count = 0;
+    for (const relPath of STATIC_AGENT_STATE_FILES) {
+        const filePath = join(agentStateDir, relPath);
+        if (!existsSync(filePath) || !statSync(filePath).isFile())
+            continue;
+        const content = readText(filePath);
+        const key = `knowledge/agent-state/${relPath.replace(/\\/g, "/")}`;
+        await store.setBlob(key, content);
+        await store.appendEntry({
+            kind: EntityKind.DomainDocument,
+            content_source: ContentSource.Package,
+            key,
+            payload: { file: relPath, length: content.length },
+        });
+        count++;
+    }
+    return count;
+}
+// ── Scripts ──────────────────────────────────────────────────────────────────
+export async function bakeScripts(store, assetsRoot) {
+    const scriptsDir = join(assetsRoot, "scripts");
+    if (!existsSync(scriptsDir))
+        return 0;
+    let count = 0;
+    for (const filePath of walkDir(scriptsDir)) {
+        if (!statSync(filePath).isFile())
+            continue;
+        const relPath = relative(scriptsDir, filePath).replace(/\\/g, "/");
+        const content = readText(filePath);
+        const key = `knowledge/scripts/${relPath}`;
+        await store.setBlob(key, content);
+        await store.appendEntry({
+            kind: EntityKind.DomainDocument,
+            content_source: ContentSource.Package,
+            key,
+            payload: { file: relPath, length: content.length },
+        });
+        count++;
+    }
+    console.log(`[knowledge-bake] scripts: ${count} files baked`);
+    return count;
+}
+// ── Task artifacts + runtime profile ─────────────────────────────────────────
+export async function bakeTaskArtifacts(store, assetsRoot) {
+    const tasksDir = join(assetsRoot, "tasks");
+    let tasks = 0;
+    const state = await bakeStaticStateArtifacts(store, assetsRoot);
+    if (existsSync(tasksDir)) {
+        for (const file of readdirSync(tasksDir)) {
+            const filePath = join(tasksDir, file);
+            if (!statSync(filePath).isFile())
+                continue;
+            const content = readText(filePath);
+            const key = `knowledge/tasks/${file}`;
+            await store.setBlob(key, content);
+            await store.appendEntry({
+                kind: EntityKind.DomainDocument,
+                content_source: ContentSource.Package,
+                key,
+                payload: { file, length: content.length },
+            });
+            tasks++;
+        }
+    }
+    let runtime = 0;
+    const runtimeProfilePath = join(assetsRoot, "agent-state", "ACE_WORKFLOW.md");
+    if (existsSync(runtimeProfilePath)) {
+        const content = readText(runtimeProfilePath);
+        const key = "knowledge/runtime/ACE_WORKFLOW.md";
+        await store.setBlob(key, content);
+        await store.appendEntry({
+            kind: EntityKind.DomainDocument,
+            content_source: ContentSource.Package,
+            key,
+            payload: { file: "ACE_WORKFLOW.md", length: content.length },
+        });
+        runtime = 1;
+    }
+    console.log(`[knowledge-bake] tasks: ${tasks} task artifacts, ${runtime} runtime profile`);
+    console.log(`[knowledge-bake] static state artifacts: ${state}`);
+    return { state, tasks, runtime };
+}
+// ── Skills ───────────────────────────────────────────────────────────────────
+export async function bakeSkillPack(store, assetsRoot, skillName) {
+    const skillDir = join(assetsRoot, ".agents", "skills", skillName);
+    if (!existsSync(skillDir)) {
+        throw new Error(`[knowledge-bake] skill pack not found: ${skillName} at ${skillDir}`);
+    }
+    let fileCount = 0;
+    for (const filePath of walkDir(skillDir)) {
+        const ext = extname(filePath);
+        if (!MARKDOWN_EXTS.has(ext))
+            continue;
+        const relPath = relative(skillDir, filePath);
+        const content = readText(filePath);
+        await store.setSkillContent(skillName, relPath, content, ContentSource.Package);
+        fileCount++;
+    }
+    console.log(`[knowledge-bake] skill ${skillName}: ${fileCount} files baked`);
+    return fileCount;
+}
+export async function listAvailableSkills(assetsRoot) {
+    const skillsDir = join(assetsRoot, ".agents", "skills");
+    if (!existsSync(skillsDir))
+        return [];
+    return readdirSync(skillsDir).filter((d) => statSync(join(skillsDir, d)).isDirectory());
+}
+// ── Full bake (called from bootstrapAceWorkspace) ─────────────────────────────
+export async function bakeAllCoreKnowledge(store, assetsRoot) {
+    const agents = await bakeAgentInstructions(store, assetsRoot);
+    const modules = await bakeModules(store, assetsRoot);
+    const taskArtifacts = await bakeTaskArtifacts(store, assetsRoot);
+    let skillsCount = 0;
+    let skillFiles = 0;
+    const scripts = await bakeScripts(store, assetsRoot);
+    for (const skillName of await listAvailableSkills(assetsRoot)) {
+        skillFiles += await bakeSkillPack(store, assetsRoot, skillName);
+        skillsCount++;
+    }
+    return {
+        agents,
+        modules,
+        taskArtifacts,
+        skills: { count: skillsCount, files: skillFiles },
+        scripts: { count: scripts },
+    };
+}
+//# sourceMappingURL=knowledge-bake.js.map

package/dist/store/materializers/hook-context-materializer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * HookContextMaterializer
+ *
+ * Writes .agents/ACE/ace-hook-context.json from store state.
+ * Called at every session start, prompt submit, and tool gating change.
+ *
+ * The hook dispatcher (ace-hook-dispatch.mjs) reads ONLY this file.
+ * It never touches the .zarr store directly.
+ */
+import { AcePackedStore } from "../ace-packed-store.js";
+export declare class HookContextMaterializer {
+    private store;
+    private workspaceRoot;
+    private kv;
+    constructor(store: AcePackedStore, workspaceRoot: string);
+    private contextPath;
+    materialize(): Promise<void>;
+    private _readContent;
+    private _readKernelWorkflow;
+    private _getEnabledAgents;
+    private _buildGateMap;
+    /** Update a runtime content field (task, status, scope, etc.) */
+    setContent(kind: string, content: string): Promise<void>;
+}
+//# sourceMappingURL=hook-context-materializer.d.ts.map

package/dist/store/materializers/hook-context-materializer.js

@@ -0,0 +1,100 @@
+/**
+ * HookContextMaterializer
+ *
+ * Writes .agents/ACE/ace-hook-context.json from store state.
+ * Called at every session start, prompt submit, and tool gating change.
+ *
+ * The hook dispatcher (ace-hook-dispatch.mjs) reads ONLY this file.
+ * It never touches the .zarr store directly.
+ */
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { RuntimeKVRepository } from "../repositories/runtime-kv-repository.js";
+function fnv1a(s) {
+    let h = 2166136261;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619) >>> 0;
+    }
+    return (h >>> 0).toString(16);
+}
+export class HookContextMaterializer {
+    store;
+    workspaceRoot;
+    kv;
+    constructor(store, workspaceRoot) {
+        this.store = store;
+        this.workspaceRoot = workspaceRoot;
+        this.kv = new RuntimeKVRepository(store);
+    }
+    contextPath() {
+        return join(this.workspaceRoot, ".agents", "ACE", "ace-hook-context.json");
+    }
+    async materialize() {
+        const task = await this._readContent("task");
+        const status = await this._readContent("status");
+        const scope = await this._readContent("scope");
+        const evidence = await this._readContent("evidence_log");
+        const workflow = await this._readKernelWorkflow();
+        const enabledAgents = await this._getEnabledAgents();
+        const gatedTools = await this._buildGateMap();
+        const snapshot = {
+            schema_version: 1,
+            generated_at: new Date().toISOString(),
+            task: { content: task, hash: fnv1a(task) },
+            status: { content: status, hash: fnv1a(status) },
+            scope: { content: scope, hash: fnv1a(scope) },
+            evidence_log: { content: evidence, hash: fnv1a(evidence) },
+            workflow: { content: workflow, hash: fnv1a(workflow) },
+            active_agents: enabledAgents,
+            gated_tools: gatedTools,
+        };
+        const contextPath = this.contextPath();
+        const dir = dirname(contextPath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(contextPath, JSON.stringify(snapshot, null, 2), "utf8");
+    }
+    async _readContent(kind) {
+        // Try KV first (runtime overrides), then store blobs, then empty
+        const kv = await this.kv.getString(`context/${kind}`);
+        if (kv)
+            return kv;
+        const blob = await this.store.getBlob(`state/runtime/${kind}`);
+        if (blob)
+            return blob;
+        const fallback = {
+            task: "knowledge/agent-state/TASK.md",
+            status: "knowledge/agent-state/STATUS.md",
+            scope: "knowledge/agent-state/SCOPE.md",
+            evidence_log: "knowledge/agent-state/EVIDENCE_LOG.md",
+        };
+        const fallbackKey = fallback[kind];
+        return fallbackKey ? (await this.store.getBlob(fallbackKey)) ?? "" : "";
+    }
+    async _readKernelWorkflow() {
+        return ((await this.store.getBlob("knowledge/runtime/ACE_WORKFLOW.md")) ??
+            (await this.store.getBlob("knowledge/agent-state/ACE_WORKFLOW.md")) ??
+            (await this.store.getBlob("knowledge/kernel/ACE_WORKFLOW.md")) ??
+            "");
+    }
+    async _getEnabledAgents() {
+        const entries = await this.store.getTopology("agent_enablement");
+        return entries
+            .filter((e) => e.value.enabled)
+            .map((e) => e.key);
+    }
+    async _buildGateMap() {
+        // Read gate definitions from store
+        const gatedTools = {};
+        // All tools are allowed by default; gates can restrict
+        // Specific gate logic would read knowledge/gates/* and apply rules
+        return gatedTools;
+    }
+    /** Update a runtime content field (task, status, scope, etc.) */
+    async setContent(kind, content) {
+        await this.kv.setString(`context/${kind}`, content);
+        await this.materialize();
+    }
+}
+//# sourceMappingURL=hook-context-materializer.js.map

package/dist/store/materializers/host-file-materializer.d.ts

@@ -0,0 +1,37 @@
+/**
+ * HostFileMaterializer
+ *
+ * Writes the minimal host-facing shim files that must remain on disk because
+ * external tools do not read the ACE store directly.
+ *
+ * The store remains authoritative. These files are projections only.
+ */
+import { AcePackedStore } from "../ace-packed-store.js";
+export interface HostMaterializeOptions {
+    mcpServerPath?: string;
+    includeMcpConfig?: boolean;
+    includeClientConfigBundle?: boolean;
+}
+export declare class HostFileMaterializer {
+    private store;
+    private workspaceRoot;
+    private packageName;
+    constructor(store: AcePackedStore, workspaceRoot: string, packageName?: string);
+    private ace;
+    private root;
+    private hostKey;
+    private materializeProjectedText;
+    private seedProjectedText;
+    private materializeEntry;
+    private buildInstructionShimEntries;
+    private buildHookFileEntries;
+    private buildOptionalHookBundleEntries;
+    private buildScriptEntries;
+    private buildWorkspaceScriptEntries;
+    private buildMcpBundleEntries;
+    private buildVsCodeMcpEntry;
+    private buildAllProjectedEntries;
+    seedStorePayload(): Promise<void>;
+    materializeAll(opts?: HostMaterializeOptions): Promise<string[]>;
+}
+//# sourceMappingURL=host-file-materializer.d.ts.map