@voybio/ace-swarm 0.1.0

package/dist/resources.js

@@ -0,0 +1,545 @@
+/**
+ * MCP Resources – expose ACE instruction files, task artifacts, skills,
+ * and handoff examples as readable resources.
+ */
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ALL_AGENTS, getKernelArtifactPath, listAvailableSkills, readAgentInstructions, readAgentManifest, readKernelArtifact, readSkillInstructions, readTaskArtifact, safeRead, } from "./helpers.js";
+import { readHandoffRegistry } from "./handoff-registry.js";
+import { getOrRefreshKanbanSnapshot, renderKanbanHtml } from "./kanban.js";
+import { loadRuntimeProfile, readRuntimePromptTemplate, readRuntimeProfileState, } from "./runtime-profile.js";
+import { buildAceContinuityPacket, formatAceContinuityPacketMarkdown, normalizeContinuityPolicy, } from "./ace-autonomy.js";
+import { listUnattendedSessions } from "./runtime-executor.js";
+import { readRunLedger } from "./run-ledger.js";
+import { loadRuntimeToolRegistry } from "./runtime-tool-specs.js";
+import { loadTrackerSnapshot } from "./tracker-adapters.js";
+import { loadVericifyBridgeSnapshot, loadVericifyProcessPostLog, refreshVericifyBridgeSnapshot, } from "./vericify-bridge.js";
+import { readStatusEvents } from "./status-events.js";
+import { listWorkspaceSessions } from "./workspace-manager.js";
+import { readJobLockTable, readJobQueue, readSchedulerLease, } from "./job-scheduler.js";
+export function registerResources(server) {
+    // ── 1. Agent instruction + manifest resources ────────────────────────
+    for (const role of ALL_AGENTS) {
+        server.resource(`ace-${role}-instructions`, `ace://agents/${role}/instructions`, {
+            description: `Full instruction file for ACE-${role.toUpperCase()} agent`,
+            mimeType: "text/markdown",
+        }, () => ({
+            contents: [
+                {
+                    uri: `ace://agents/${role}/instructions`,
+                    text: readAgentInstructions(role),
+                    mimeType: "text/markdown",
+                },
+            ],
+        }));
+        server.resource(`ace-${role}-manifest`, `ace://agents/${role}/manifest`, {
+            description: `Agent manifest for ACE-${role.toUpperCase()}`,
+            mimeType: "text/markdown",
+        }, () => ({
+            contents: [
+                {
+                    uri: `ace://agents/${role}/manifest`,
+                    text: readAgentManifest(role),
+                    mimeType: "text/markdown",
+                },
+            ],
+        }));
+    }
+    // ── 2. Kernel artifacts ──────────────────────────────────────────────
+    const kernelResourceMap = {
+        directive_kernel: {
+            desc: "Global ACE machine directives shared by swarm + composable agents",
+        },
+        agent_registry: {
+            desc: "ACE composable registry, dependency matrix, and skill catalog mapping",
+        },
+    };
+    for (const [key, meta] of Object.entries(kernelResourceMap)) {
+        server.resource(`ace-kernel-${key}`, `ace://kernel/${key}`, {
+            description: meta.desc,
+            mimeType: "text/markdown",
+        }, () => ({
+            contents: [
+                {
+                    uri: `ace://kernel/${key}`,
+                    text: [
+                        `Source: ${getKernelArtifactPath(key) ?? "missing"}`,
+                        "",
+                        readKernelArtifact(key),
+                    ].join("\n"),
+                    mimeType: "text/markdown",
+                },
+            ],
+        }));
+    }
+    // ── 3. Task artifacts ────────────────────────────────────────────────
+    const taskResourceMap = {
+        todo: { desc: "Live checkable execution board" },
+        role_tasks: {
+            desc: "Explicit task boundaries per agent role",
+        },
+        cli_work_split: {
+            desc: "Codex CLI vs Gemini CLI routing contract",
+        },
+        lessons: {
+            desc: "Persistent guardrails captured after corrections",
+        },
+        readme: {
+            desc: "Control-plane overview for task artifacts",
+        },
+    };
+    for (const [key, meta] of Object.entries(taskResourceMap)) {
+        server.resource(`ace-task-${key}`, `ace://tasks/${key}`, { description: meta.desc, mimeType: "text/markdown" }, () => ({
+            contents: [
+                {
+                    uri: `ace://tasks/${key}`,
+                    text: readTaskArtifact(key),
+                    mimeType: "text/markdown",
+                },
+            ],
+        }));
+    }
+    // ── 4. Handoff templates & examples ─────────────────────────────────
+    const handoffResources = {
+        handoff_template: {
+            desc: "Canonical SWARM_HANDOFF.json shape",
+        },
+        handoff_example: {
+            desc: "Filled handoff payload example",
+        },
+        handoff_example_vos_ui: {
+            desc: "VOS to UI concrete handoff example",
+        },
+        handoff_example_ui_coders: {
+            desc: "UI to Coders concrete handoff example",
+        },
+    };
+    for (const [key, meta] of Object.entries(handoffResources)) {
+        server.resource(`ace-${key}`, `ace://handoffs/${key}`, { description: meta.desc, mimeType: "application/json" }, () => ({
+            contents: [
+                {
+                    uri: `ace://handoffs/${key}`,
+                    text: readTaskArtifact(key),
+                    mimeType: "application/json",
+                },
+            ],
+        }));
+    }
+    // ── 5. Skills index + dynamic skill template ────────────────────────
+    server.resource("ace-skills-index", "ace://skills", {
+        description: "List all discoverable ACE skills",
+        mimeType: "text/markdown",
+    }, () => {
+        const skills = listAvailableSkills();
+        const lines = [
+            "# ACE Skills",
+            "",
+            ...skills.map((skill) => `- ${skill.name} (${skill.source}) -> ace://skills/${skill.name}/instructions`),
+        ];
+        return {
+            contents: [
+                {
+                    uri: "ace://skills",
+                    text: lines.join("\n"),
+                    mimeType: "text/markdown",
+                },
+            ],
+        };
+    });
+    server.resource("ace-skill-instructions", new ResourceTemplate("ace://skills/{name}/instructions", { list: undefined }), {
+        description: "Read a skill's SKILL.md by skill name",
+        mimeType: "text/markdown",
+    }, (uri, params) => {
+        const name = params.name || "";
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text: readSkillInstructions(name),
+                    mimeType: "text/markdown",
+                },
+            ],
+        };
+    });
+    // ── 6. Dynamic workspace file resource ──────────────────────────────
+    server.resource("ace-workspace-file", new ResourceTemplate("ace://workspace/{path+}", { list: undefined }), { description: "Read any file from the ACE workspace by relative path" }, (uri, params) => {
+        const relPath = params["path+"] ||
+            params.path ||
+            "";
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text: safeRead(relPath),
+                    mimeType: "text/plain",
+                },
+            ],
+        };
+    });
+    // ── 7. Kanban resources ─────────────────────────────────────────────
+    server.resource("ace-kanban-json", "ace://kanban", {
+        description: "Generated ACE Kanban snapshot JSON",
+        mimeType: "application/json",
+    }, () => {
+        const snapshot = getOrRefreshKanbanSnapshot("resource:ace://kanban");
+        return {
+            contents: [
+                {
+                    uri: "ace://kanban",
+                    text: JSON.stringify(snapshot, null, 2),
+                    mimeType: "application/json",
+                },
+            ],
+        };
+    });
+    server.resource("ace-kanban-html", "ace://kanban/html", {
+        description: "Generated ACE Kanban HTML board",
+        mimeType: "text/html",
+    }, () => {
+        const snapshot = getOrRefreshKanbanSnapshot("resource:ace://kanban/html");
+        const html = safeRead("agent-state/kanban.html");
+        const text = html.startsWith("[FILE NOT FOUND]") ? renderKanbanHtml(snapshot) : html;
+        return {
+            contents: [
+                {
+                    uri: "ace://kanban/html",
+                    text,
+                    mimeType: "text/html",
+                },
+            ],
+        };
+    });
+    // ── 8. Runtime stores ───────────────────────────────────────────────
+    server.resource("ace-runtime-profile", "ace://runtime/profile", {
+        description: "Validated ACE runtime profile with active and current load state",
+        mimeType: "application/json",
+    }, () => {
+        const current = loadRuntimeProfile();
+        const active = readRuntimeProfileState();
+        return {
+            contents: [
+                {
+                    uri: "ace://runtime/profile",
+                    text: JSON.stringify({
+                        current,
+                        active,
+                    }, null, 2),
+                    mimeType: "application/json",
+                },
+            ],
+        };
+    });
+    server.resource("ace-runtime-prompt-template", "ace://runtime/prompt-template", {
+        description: "Active ACE runtime prompt template body from ACE_WORKFLOW.md",
+        mimeType: "text/markdown",
+    }, () => ({
+        contents: [
+            {
+                uri: "ace://runtime/prompt-template",
+                text: readRuntimePromptTemplate(),
+                mimeType: "text/markdown",
+            },
+        ],
+    }));
+    server.resource("ace-runtime-continuity-packet", "ace://runtime/continuity-packet", {
+        description: "Derived ACE continuity packet built from the active runtime policy and current ACE truth",
+        mimeType: "application/json",
+    }, () => {
+        const active = readRuntimeProfileState();
+        const continuity = normalizeContinuityPolicy(active.profile.continuity);
+        const packet = buildAceContinuityPacket({
+            policy: continuity,
+        });
+        return {
+            contents: [
+                {
+                    uri: "ace://runtime/continuity-packet",
+                    text: JSON.stringify({
+                        runtime_profile: {
+                            path: active.path,
+                            source: active.source,
+                            profile_name: active.profile.runtime.profile_name,
+                        },
+                        continuity_policy: continuity,
+                        packet,
+                        markdown: formatAceContinuityPacketMarkdown(packet),
+                    }, null, 2),
+                    mimeType: "application/json",
+                },
+            ],
+        };
+    });
+    server.resource("ace-runtime-workspaces", "ace://runtime/workspaces", {
+        description: "Managed ACE workspace/session registry",
+        mimeType: "application/json",
+    }, () => ({
+        contents: [
+            {
+                uri: "ace://runtime/workspaces",
+                text: JSON.stringify(listWorkspaceSessions(), null, 2),
+                mimeType: "application/json",
+            },
+        ],
+    }));
+    server.resource("ace-runtime-tool-specs", "ace://runtime/tool-specs", {
+        description: "Runtime-configured external tool spec registry",
+        mimeType: "application/json",
+    }, () => {
+        const result = loadRuntimeToolRegistry();
+        return {
+            contents: [
+                {
+                    uri: "ace://runtime/tool-specs",
+                    text: result.ok
+                        ? JSON.stringify(result.registry, null, 2)
+                        : JSON.stringify({
+                            schema: result.schema,
+                            path: result.path,
+                            source: result.source,
+                            errors: result.errors,
+                        }, null, 2),
+                    mimeType: "application/json",
+                },
+            ],
+        };
+    });
+    server.resource("ace-runtime-tracker-snapshot", "ace://runtime/tracker-snapshot", {
+        description: "Normalized ACE tracker snapshot for the active tracker adapter",
+        mimeType: "application/json",
+    }, () => {
+        const result = loadTrackerSnapshot();
+        return {
+            contents: [
+                {
+                    uri: "ace://runtime/tracker-snapshot",
+                    text: result.ok
+                        ? JSON.stringify(result.snapshot, null, 2)
+                        : JSON.stringify({
+                            schema: result.schema,
+                            path: result.path,
+                            source: result.source,
+                            errors: result.errors,
+                        }, null, 2),
+                    mimeType: "application/json",
+                },
+            ],
+        };
+    });
+    server.resource("ace-runtime-executor-sessions", "ace://runtime/executor-sessions", {
+        description: "Unattended ACE runtime executor session registry",
+        mimeType: "application/json",
+    }, () => ({
+        contents: [
+            {
+                uri: "ace://runtime/executor-sessions",
+                text: JSON.stringify(listUnattendedSessions(), null, 2),
+                mimeType: "application/json",
+            },
+        ],
+    }));
+    server.resource("ace-runtime-vericify-bridge", "ace://runtime/vericify-bridge", {
+        description: "Optional Vericify sidecar bridge snapshot derived from ACE runtime artifacts",
+        mimeType: "application/json",
+    }, () => {
+        const current = loadVericifyBridgeSnapshot();
+        const snapshot = current.ok ? current.snapshot : refreshVericifyBridgeSnapshot().snapshot;
+        return {
+            contents: [
+                {
+                    uri: "ace://runtime/vericify-bridge",
+                    text: JSON.stringify(current.ok
+                        ? current.snapshot
+                        : snapshot ?? {
+                            schema: current.schema,
+                            path: current.path,
+                            errors: current.errors,
+                        }, null, 2),
+                    mimeType: "application/json",
+                },
+            ],
+        };
+    });
+    server.resource("ace-runtime-vericify-process-posts", "ace://runtime/vericify-process-posts", {
+        description: "Optional Vericify sidecar process-post log maintained by ACE",
+        mimeType: "application/json",
+    }, () => {
+        const result = loadVericifyProcessPostLog();
+        return {
+            contents: [
+                {
+                    uri: "ace://runtime/vericify-process-posts",
+                    text: result.ok
+                        ? JSON.stringify(result.log, null, 2)
+                        : JSON.stringify({
+                            schema: result.schema,
+                            path: result.path,
+                            errors: result.errors,
+                        }, null, 2),
+                    mimeType: "application/json",
+                },
+            ],
+        };
+    });
+    server.resource("ace-run-ledger", "ace://run-ledger", {
+        description: "Milestone/regression history appended by major ACE tools",
+        mimeType: "application/json",
+    }, () => ({
+        contents: [
+            {
+                uri: "ace://run-ledger",
+                text: JSON.stringify(readRunLedger(), null, 2),
+                mimeType: "application/json",
+            },
+        ],
+    }));
+    server.resource("ace-handoff-status", "ace://handoffs/status", {
+        description: "Persisted handoff lifecycle registry (open/accepted/blocked/completed)",
+        mimeType: "application/json",
+    }, () => ({
+        contents: [
+            {
+                uri: "ace://handoffs/status",
+                text: JSON.stringify(readHandoffRegistry(), null, 2),
+                mimeType: "application/json",
+            },
+        ],
+    }));
+    server.resource("ace-scheduler-queue", "ace://scheduler/queue", {
+        description: "Scheduler job queue state",
+        mimeType: "application/json",
+    }, () => ({
+        contents: [
+            {
+                uri: "ace://scheduler/queue",
+                text: JSON.stringify(readJobQueue(), null, 2),
+                mimeType: "application/json",
+            },
+        ],
+    }));
+    server.resource("ace-scheduler-locks", "ace://scheduler/locks", {
+        description: "Scheduler resource lock table for running jobs",
+        mimeType: "application/json",
+    }, () => ({
+        contents: [
+            {
+                uri: "ace://scheduler/locks",
+                text: JSON.stringify(readJobLockTable(), null, 2),
+                mimeType: "application/json",
+            },
+        ],
+    }));
+    server.resource("ace-scheduler-lease", "ace://scheduler/lease", {
+        description: "Scheduler lease ownership and heartbeat state",
+        mimeType: "application/json",
+    }, () => ({
+        contents: [
+            {
+                uri: "ace://scheduler/lease",
+                text: JSON.stringify(readSchedulerLease() ?? null, null, 2),
+                mimeType: "application/json",
+            },
+        ],
+    }));
+    server.resource("ace-status-events", "ace://status/events", {
+        description: "Lifecycle status events (NDJSON)",
+        mimeType: "application/x-ndjson",
+    }, () => ({
+        contents: [
+            {
+                uri: "ace://status/events",
+                text: readStatusEvents(1000).map((event) => JSON.stringify(event)).join("\n"),
+                mimeType: "application/x-ndjson",
+            },
+        ],
+    }));
+    server.resource("ace-astgrep-commands", "ace://state/astgrep-commands", {
+        description: "AST-grep command pack for deep code discovery without large index payloads",
+        mimeType: "text/markdown",
+    }, () => ({
+        contents: [
+            {
+                uri: "ace://state/astgrep-commands",
+                text: safeRead("agent-state/AST_GREP_COMMANDS.md"),
+                mimeType: "text/markdown",
+            },
+        ],
+    }));
+    server.resource("ace-astgrep-index-md", "ace://state/astgrep-index/md", {
+        description: "Human-readable structural discovery summary generated by agent-astgrep",
+        mimeType: "text/markdown",
+    }, () => ({
+        contents: [
+            {
+                uri: "ace://state/astgrep-index/md",
+                text: safeRead("agent-state/AST_GREP_INDEX.md"),
+                mimeType: "text/markdown",
+            },
+        ],
+    }));
+    server.resource("ace-astgrep-index-json", "ace://state/astgrep-index/json", {
+        description: "Machine-readable structural discovery payload generated by agent-astgrep",
+        mimeType: "application/json",
+    }, () => ({
+        contents: [
+            {
+                uri: "ace://state/astgrep-index/json",
+                text: safeRead("agent-state/AST_GREP_INDEX.json"),
+                mimeType: "application/json",
+            },
+        ],
+    }));
+    server.resource("ace-index", "ace://index", {
+        description: "Latest workspace delta index snapshot",
+        mimeType: "application/json",
+    }, () => {
+        const raw = safeRead("agent-state/index.json");
+        const fallback = JSON.stringify({
+            version: 1,
+            root: ".",
+            generated_at: "",
+            discovery: {
+                mode: "ast_grep_commands",
+                command_pack: "agent-state/AST_GREP_COMMANDS.md",
+                subagent: "astgrep",
+                skill: "astgrep-index",
+                fingerprint_store: "agent-state/index-fingerprints.json",
+            },
+            options: {
+                depth: 6,
+                max_files: 10000,
+                include_hidden: false,
+                exclude: [".git", "node_modules", "dist", "target", ".venv", "__pycache__", ".DS_Store"],
+                file_entry_cap: 0,
+            },
+            file_count: 0,
+            stored_file_count: 0,
+            directories: {},
+            extensions: {},
+            files: {},
+        }, null, 2);
+        const text = raw.startsWith("[FILE NOT FOUND]") || raw.startsWith("[ACCESS DENIED]")
+            ? fallback
+            : raw;
+        return {
+            contents: [
+                {
+                    uri: "ace://index",
+                    text,
+                    mimeType: "application/json",
+                },
+            ],
+        };
+    });
+    server.resource("ace-index-fingerprints", "ace://index/fingerprints", {
+        description: "Compact full-file fingerprint map used for accurate delta detection",
+        mimeType: "application/json",
+    }, () => ({
+        contents: [
+            {
+                uri: "ace://index/fingerprints",
+                text: safeRead("agent-state/index-fingerprints.json"),
+                mimeType: "application/json",
+            },
+        ],
+    }));
+}
+//# sourceMappingURL=resources.js.map

package/dist/run-ledger.d.ts

@@ -0,0 +1,36 @@
+export type RunLedgerCategory = "major_update" | "regression" | "info";
+export interface RunLedgerEntry {
+    id: string;
+    timestamp_utc: string;
+    tool: string;
+    category: RunLedgerCategory;
+    message: string;
+    artifacts: string[];
+    metadata: Record<string, unknown>;
+}
+export interface RunLedgerFile {
+    version: 1;
+    updated_at: string;
+    entries: RunLedgerEntry[];
+}
+export interface AppendRunLedgerEntryInput {
+    tool: string;
+    category: RunLedgerCategory;
+    message: string;
+    artifacts?: string[];
+    metadata?: Record<string, unknown>;
+}
+export declare function readRunLedger(): RunLedgerFile;
+export declare function appendRunLedgerEntry(input: AppendRunLedgerEntryInput): {
+    entry: RunLedgerEntry;
+    path: string;
+};
+/**
+ * Concurrency-safe variant of appendRunLedgerEntry.
+ */
+export declare function appendRunLedgerEntrySafe(input: AppendRunLedgerEntryInput): Promise<{
+    entry: RunLedgerEntry;
+    path: string;
+}>;
+export declare function getRunLedgerPath(): string;
+//# sourceMappingURL=run-ledger.d.ts.map