@voybio/ace-swarm 0.2.5 → 2.4.1

package/dist/safe-edit.js

@@ -2,10 +2,11 @@
  * Safe-edit module: copy → modify → validate → swap pattern.
  * Prevents bricking by never leaving core files in a broken state.
  */
-import { copyFileSync, existsSync, mkdirSync, unlinkSync, writeFileSync, } from "node:fs";
+import { copyFileSync, cpSync, existsSync, mkdtempSync, mkdirSync, readFileSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync, } from "node:fs";
 import { createHash } from "node:crypto";
-import { dirname, resolve } from "node:path";
+import { basename, dirname, relative, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
+import { tmpdir } from "node:os";
 import { WORKSPACE_ROOT, safeRead, wsPath } from "./helpers.js";
 import { isInside, isReadError, normalizeRelPath } from "./shared.js";
 const STAGING_DIR = ".ace-staging";
@@ -19,14 +20,56 @@ function ensureDir(dirPath) {
     if (!existsSync(dirPath))
         mkdirSync(dirPath, { recursive: true });
 }
-function runValidation(validationCmd, testCmd) {
+function resolveWorkspaceTarget(inputPath) {
+    const absPath = resolve(WORKSPACE_ROOT, inputPath);
+    if (!isInside(WORKSPACE_ROOT, absPath)) {
+        return { error: `Path escapes workspace root: ${inputPath}`, absPath };
+    }
+    return {
+        absPath,
+        relPath: normalizeRelPath(relative(WORKSPACE_ROOT, absPath)),
+    };
+}
+function shouldCopyIntoStaging(src) {
+    const rel = normalizeRelPath(relative(WORKSPACE_ROOT, src));
+    if (!rel || rel === ".")
+        return true;
+    const first = rel.split("/")[0];
+    return !new Set([".ace-staging", ".git", "node_modules", ".npm-cache"]).has(first);
+}
+function prepareStagedWorkspace(stagingDir) {
+    const stagedWorkspace = mkdtempSync(resolve(tmpdir(), "ace-staged-workspace-"));
+    rmSync(stagedWorkspace, { recursive: true, force: true });
+    mkdirSync(stagedWorkspace, { recursive: true });
+    cpSync(WORKSPACE_ROOT, stagedWorkspace, {
+        recursive: true,
+        dereference: false,
+        filter: (src) => shouldCopyIntoStaging(src),
+    });
+    const rootNodeModules = resolve(WORKSPACE_ROOT, "node_modules");
+    if (existsSync(rootNodeModules)) {
+        symlinkSync(rootNodeModules, resolve(stagedWorkspace, "node_modules"), "dir");
+    }
+    writeFileSync(resolve(stagingDir, "workspace-path.txt"), stagedWorkspace, "utf-8");
+    return stagedWorkspace;
+}
+function workspacePathIn(root, relPath) {
+    return resolve(root, relPath);
+}
+function swapTargetContent(absPath, content) {
+    ensureDir(dirname(absPath));
+    const swapPath = `${absPath}.ace-swap.${process.pid}.${Date.now()}`;
+    writeFileSync(swapPath, content, "utf-8");
+    renameSync(swapPath, absPath);
+}
+function runValidation(validationCmd, testCmd, cwd = WORKSPACE_ROOT) {
     let validation_passed;
     let validation_output;
     let test_passed;
     let test_output;
     if (validationCmd) {
         const res = spawnSync("sh", ["-c", validationCmd], {
-            cwd: WORKSPACE_ROOT,
+            cwd,
             encoding: "utf-8",
             timeout: 60_000,
             maxBuffer: 4 * 1024 * 1024,
@@ -36,7 +79,7 @@ function runValidation(validationCmd, testCmd) {
     }
     if (testCmd && (validation_passed === undefined || validation_passed)) {
         const res = spawnSync("sh", ["-c", testCmd], {
-            cwd: WORKSPACE_ROOT,
+            cwd,
             encoding: "utf-8",
             timeout: 120_000,
             maxBuffer: 4 * 1024 * 1024,
@@ -51,84 +94,80 @@ function runValidation(validationCmd, testCmd) {
 // Safe edit (copy → modify → validate → swap)
 // ────────────────────────────────────────────────────────────────────
 export function safeEditFile(input) {
-    const absPath = resolve(WORKSPACE_ROOT, input.path);
-    // ── Workspace boundary guard ──────────────────────────────────────
-    if (!isInside(WORKSPACE_ROOT, absPath)) {
+    const target = resolveWorkspaceTarget(input.path);
+    if ("error" in target) {
         return {
             ok: false,
-            original_path: absPath,
+            original_path: target.absPath,
             staging_path: "",
             original_hash: "none",
             new_hash: "none",
-            error: `Path escapes workspace root: ${input.path}`,
+            error: target.error,
             restored: false,
         };
     }
-    const relPath = normalizeRelPath(input.path);
+    const { absPath, relPath } = target;
     const timestamp = Date.now();
     const originalContent = safeRead(input.path);
     const isNew = isReadError(originalContent);
     const originalHash = isNew ? "none" : fileHash(originalContent);
-    const newHash = fileHash(input.content);
+    const stagedNewHash = fileHash(input.content);
     // Step 1: Create staging directory
     const stagingDir = wsPath(STAGING_DIR, `${timestamp}-${isNew ? "new" : originalHash.slice(0, 8)}`);
     ensureDir(stagingDir);
     const flatName = relPath.replace(/\//g, "__");
     const stagingNew = resolve(stagingDir, `new__${flatName}`);
     writeFileSync(stagingNew, input.content, "utf-8");
+    const stagedWorkspace = prepareStagedWorkspace(stagingDir);
+    const stagedTarget = workspacePathIn(stagedWorkspace, relPath);
+    ensureDir(dirname(stagedTarget));
+    writeFileSync(stagedTarget, input.content, "utf-8");
     // Step 2: If file exists, copy original to staging + backup
     let backupPath;
     if (!isNew) {
         const stagingOriginal = resolve(stagingDir, `original__${flatName}`);
         writeFileSync(stagingOriginal, originalContent, "utf-8");
-        if (input.backup !== false) {
-            backupPath = `${absPath}.ace-backup.${originalHash.slice(0, 8)}`;
-            copyFileSync(absPath, backupPath);
-        }
     }
-    // Step 3: Write new content
-    ensureDir(dirname(absPath));
-    writeFileSync(absPath, input.content, "utf-8");
-    // Step 4: Run validation/tests
+    // Step 3: Run validation/tests against the staged workspace.
+    let check;
     if (input.validation_command || input.test_command) {
-        const check = runValidation(input.validation_command, input.test_command);
+        check = runValidation(input.validation_command, input.test_command, stagedWorkspace);
         if (!check.passed) {
-            // ROLLBACK: restore original content
-            if (!isNew) {
-                writeFileSync(absPath, originalContent, "utf-8");
-            }
-            else {
-                // Remove newly created file
-                try {
-                    unlinkSync(absPath);
-                }
-                catch {
-                    /* best effort */
-                }
-            }
             return {
                 ok: false,
                 original_path: absPath,
                 staging_path: stagingDir,
                 backup_path: backupPath,
                 original_hash: originalHash,
-                new_hash: newHash,
+                new_hash: stagedNewHash,
                 validation_passed: check.validation_passed,
                 validation_output: check.validation_output,
                 test_passed: check.test_passed,
                 test_output: check.test_output,
-                error: "Validation/test failed — original restored",
+                error: "Validation/test failed — staged change not promoted",
                 restored: true,
             };
         }
     }
+    // Step 4: Promote staged content to the real target only after checks pass.
+    if (!isNew && input.backup !== false) {
+        backupPath = `${absPath}.ace-backup.${originalHash.slice(0, 8)}`;
+        copyFileSync(absPath, backupPath);
+    }
+    const promotedContent = readFileSync(stagedTarget, "utf-8");
+    const promotedHash = fileHash(promotedContent);
+    swapTargetContent(absPath, promotedContent);
     return {
         ok: true,
         original_path: absPath,
         staging_path: stagingDir,
         backup_path: backupPath,
         original_hash: originalHash,
-        new_hash: newHash,
+        new_hash: promotedHash,
+        validation_passed: check?.validation_passed,
+        validation_output: check?.validation_output,
+        test_passed: check?.test_passed,
+        test_output: check?.test_output,
     };
 }
 // ────────────────────────────────────────────────────────────────────
@@ -252,4 +291,91 @@ export function diffFiles(pathA, pathB) {
     }
     return diffContents(contentA, contentB);
 }
+export function applyPatch(input) {
+    const target = resolveWorkspaceTarget(input.path);
+    if ("error" in target) {
+        return {
+            ok: false,
+            original_path: target.absPath,
+            staging_path: "",
+            original_hash: "none",
+            new_hash: "none",
+            error: target.error,
+            restored: false,
+        };
+    }
+    const { absPath, relPath } = target;
+    const originalContent = safeRead(input.path);
+    const isNew = isReadError(originalContent);
+    const originalHash = isNew ? "none" : fileHash(originalContent);
+    const timestamp = Date.now();
+    const stagingDir = wsPath(STAGING_DIR, `${timestamp}-patch-${isNew ? "new" : originalHash.slice(0, 8)}`);
+    ensureDir(stagingDir);
+    const stagedWorkspace = prepareStagedWorkspace(stagingDir);
+    const stagedTarget = workspacePathIn(stagedWorkspace, relPath);
+    ensureDir(dirname(stagedTarget));
+    if (isNew && !existsSync(stagedTarget))
+        writeFileSync(stagedTarget, "", "utf-8");
+    const tmpPatch = resolve(stagingDir, `${basename(relPath)}.${timestamp}.patch`);
+    try {
+        writeFileSync(tmpPatch, input.patch, "utf8");
+        const patchResult = spawnSync("patch", [stagedTarget, tmpPatch], {
+            encoding: "utf8",
+            cwd: stagedWorkspace,
+        });
+        if (patchResult.status !== 0) {
+            return {
+                ok: false,
+                original_path: absPath,
+                staging_path: stagingDir,
+                original_hash: originalHash,
+                new_hash: "none",
+                error: `patch command failed: ${patchResult.stderr || patchResult.stdout}`,
+                restored: true,
+            };
+        }
+        const patchedContent = readFileSync(stagedTarget, "utf-8");
+        const newHash = fileHash(patchedContent);
+        const check = runValidation(input.validation_command, input.test_command, stagedWorkspace);
+        if (!check.passed) {
+            return {
+                ok: false,
+                original_path: absPath,
+                staging_path: stagingDir,
+                original_hash: originalHash,
+                new_hash: newHash,
+                validation_passed: check.validation_passed,
+                validation_output: check.validation_output,
+                test_passed: check.test_passed,
+                test_output: check.test_output,
+                error: "Validation/test failed — staged patch not promoted",
+                restored: true,
+            };
+        }
+        let backupPath;
+        if (!isNew) {
+            backupPath = `${absPath}.ace-backup.${originalHash.slice(0, 8)}`;
+            copyFileSync(absPath, backupPath);
+        }
+        swapTargetContent(absPath, patchedContent);
+        return {
+            ok: true,
+            original_path: absPath,
+            staging_path: stagingDir,
+            backup_path: backupPath,
+            original_hash: originalHash,
+            new_hash: newHash,
+            validation_passed: check.validation_passed,
+            validation_output: check.validation_output,
+            test_passed: check.test_passed,
+            test_output: check.test_output,
+        };
+    }
+    finally {
+        try {
+            unlinkSync(tmpPatch);
+        }
+        catch { /* ignore */ }
+    }
+}
 //# sourceMappingURL=safe-edit.js.map

package/dist/schemas.js

@@ -186,6 +186,8 @@ const workspaceSessionRecordSchema = z
     last_error: z.string().optional(),
     created_at: z.string().datetime({ offset: true }),
     updated_at: z.string().datetime({ offset: true }),
+    hook_health: z.enum(["ok", "degraded", "failed"]).optional(),
+    hook_summary: z.string().optional(),
     hooks: z
         .object({
         after_create: workspaceHookStateSchema,
@@ -292,6 +294,32 @@ const runtimeToolExecutorSchema = z
     env: z.record(z.string(), z.string()).optional(),
 })
     .strict();
+const runtimeToolMcpServerSchema = z
+    .object({
+    transport: z.enum(["stdio", "http"]),
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    url: z.string().url().optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    tool_allowlist: z.array(z.string()).optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.transport === "stdio" && !value.command?.trim()) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["command"],
+            message: "stdio MCP servers require command",
+        });
+    }
+    if (value.transport === "http" && !value.url?.trim()) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["url"],
+            message: "http MCP servers require url",
+        });
+    }
+});
 const runtimeToolSpecSchema = z
     .object({
     name: NON_EMPTY,
@@ -300,6 +328,7 @@ const runtimeToolSpecSchema = z
     success_schema: runtimeToolSchemaNodeSchema.optional(),
     failure_schema: runtimeToolSchemaNodeSchema.optional(),
     executor: runtimeToolExecutorSchema,
+    mcp_server: runtimeToolMcpServerSchema.optional(),
 })
     .strict();
 const runtimeToolSpecRegistrySchema = z
@@ -352,6 +381,15 @@ const unattendedTurnRecordSchema = z
     stdout: z.string(),
     stderr: z.string(),
     tool_calls: z.array(unattendedToolCallRecordSchema),
+    turn_outcome: z.enum(["no_op_success", "meaningful_completion", "escalation_blocker"]).optional(),
+    outcome_reason: z.string().optional(),
+})
+    .strict();
+const runtimeOutputPolicySchema = z
+    .object({
+    emit_to: z.array(z.enum(["tui", "tracker", "handoff", "vericify"])),
+    silent_unless_blocked: z.boolean(),
+    require_approval_before_emit: z.boolean(),
 })
     .strict();
 const runtimeExecutorSessionRecordSchema = z
@@ -377,6 +415,8 @@ const runtimeExecutorSessionRecordSchema = z
     last_error: z.string().optional(),
     cleanup_error: z.string().optional(),
     workspace_cleanup_status: z.enum(["pending", "removed", "archived", "failed"]),
+    validated_plan_id: z.string().optional(),
+    output_policy: runtimeOutputPolicySchema.optional(),
     turns: z.array(unattendedTurnRecordSchema),
 })
     .strict();
@@ -394,7 +434,7 @@ const vericifyProcessPostSchema = z
     branch_id: z.string().optional(),
     lane_id: z.string().optional(),
     agent_id: NON_EMPTY,
-    kind: z.enum(["intent", "progress", "blocker", "handoff_note", "stale_ack", "completion"]),
+    kind: z.enum(["intent", "progress", "blocker", "handoff_note", "stale_ack", "completion", "plan_proposal", "plan_quality_assessment"]),
     summary: NON_EMPTY,
     tool_refs: z.array(z.string()),
     evidence_refs: z.array(z.string()),
@@ -453,6 +493,13 @@ const vericifyBridgeSnapshotSchema = z
     })
         .strict(),
     active_run_refs: z.array(vericifyBridgeActiveRunRefSchema),
+    ace_runtime_enrichment: z
+        .object({
+        live_session_id: z.string().optional(),
+        last_turn_outcome: z.string().optional(),
+        last_turn_outcome_reason: z.string().optional(),
+    })
+        .optional(),
 })
     .strict();
 /**

package/dist/server.js

@@ -1,7 +1,11 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { buildServerInstructions, installAceToolGovernance, } from "./ace-server-instructions.js";
 import { resolveWorkspaceRoot } from "./helpers.js";
+import { openStore } from "./store/ace-packed-store.js";
+import { getWorkspaceStorePath } from "./store/store-snapshot.js";
 import { registerPrompts } from "./prompts.js";
 import { registerResources } from "./resources.js";
 import { registerTools } from "./tools.js";
@@ -24,7 +28,54 @@ export function createAceServer(options = {}) {
     registerTools(server);
     return server;
 }
+function appendEmergencyMcpStatusEvent(workspaceRoot, message) {
+    const event = {
+        schema_version: "1.0.0",
+        event_id: `evt-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+        trace_id: `trace-${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        source_module: "capability-ops",
+        event_type: "MCP_BINARY_PARSE_ERROR",
+        status: "blocked",
+        objective_id: "mcp-stdio-startup",
+        payload: {
+            reason_code: "mcp_binary_parse_error",
+            summary: message,
+        },
+    };
+    const target = join(workspaceRoot, "agent-state", "STATUS_EVENTS.ndjson");
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, `${JSON.stringify(event)}\n`, { flag: "a" });
+}
+async function verifyMcpStoreStartup(workspaceRoot, logStartup) {
+    const canonicalStore = getWorkspaceStorePath(workspaceRoot);
+    const legacyStore = join(workspaceRoot, ".agents", "ACE", "ace-state.ace");
+    const candidates = [canonicalStore, legacyStore].filter((storePath, index, all) => existsSync(storePath) && all.indexOf(storePath) === index);
+    if (candidates.length === 0)
+        return true;
+    const errors = [];
+    for (const storePath of candidates) {
+        try {
+            const store = await openStore(storePath, { readOnly: true });
+            await store.close();
+            return true;
+        }
+        catch (error) {
+            errors.push(`${storePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const message = `ACE MCP startup could not open ace-state.ace as ACEPACK; refusing stdio startup without crashing. ` +
+        `reason_code=mcp_binary_parse_error. ${errors.join(" | ")}`;
+    appendEmergencyMcpStatusEvent(workspaceRoot, message);
+    if (logStartup)
+        console.error(message);
+    return false;
+}
 export async function startStdioServer(logStartup = true) {
+    const workspaceRoot = resolveWorkspaceRoot();
+    if (!(await verifyMcpStoreStartup(workspaceRoot, logStartup))) {
+        return;
+    }
     try {
         const backfill = await backfillHandoffsIntoScheduler();
         if (logStartup && backfill.scanned > 0) {

package/dist/shared.d.ts

@@ -19,10 +19,10 @@ export declare function looksLikeSwarmHandoffPath(path: string): boolean;
 export declare const ROLE_TITLES: Record<string, string>;
 export declare function getRoleTitle(role: string): string;
 export declare const MCP_CLIENT_ENUM: z.ZodEnum<{
-    claude: "claude";
-    cursor: "cursor";
     codex: "codex";
     vscode: "vscode";
+    claude: "claude";
+    cursor: "cursor";
     antigravity: "antigravity";
 }>;
 export declare const ROLE_ENUM: z.ZodEnum<{
@@ -43,6 +43,7 @@ export declare const ROLE_ENUM: z.ZodEnum<{
     observability: "observability";
     eval: "eval";
     release: "release";
+    planner: "planner";
 }>;
 export declare const HANDOFF_VALIDATION_MODE: z.ZodOptional<z.ZodEnum<{
     "agent-state": "agent-state";

package/dist/shared.js

@@ -57,6 +57,7 @@ export const ROLE_TITLES = {
     observability: "Observability",
     eval: "Eval",
     release: "Release",
+    planner: "Planner",
 };
 export function getRoleTitle(role) {
     return ROLE_TITLES[role] ?? role.toUpperCase();
@@ -89,6 +90,7 @@ export const ROLE_ENUM = z.enum([
     "observability",
     "eval",
     "release",
+    "planner",
 ]);
 export const HANDOFF_VALIDATION_MODE = z
     .enum(["auto", "swarm", "agent-state"])

package/dist/status-events.js

@@ -8,7 +8,7 @@ import { ProjectionManager } from "./store/materializers/projection-manager.js";
 import { TrackerRepository } from "./store/repositories/tracker-repository.js";
 import { getWorkspaceStorePath, listStoreKeysSync, readStoreJsonSync, storeExistsSync, } from "./store/store-snapshot.js";
 import { operationalArtifactVirtualPath } from "./store/store-artifacts.js";
-import { withStoreWriteQueue } from "./store/write-queue.js";
+import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
 export const STATUS_EVENTS_REL_PATH = "agent-state/STATUS_EVENTS.ndjson";
 const STATUS_EVENTS_ARCHIVE_REL = "agent-state/STATUS_EVENTS-archive.ndjson";
 const MAX_EVENT_LINES = 2000;
@@ -94,7 +94,7 @@ async function mirrorStatusEventToStore(root, event) {
     const storePath = getWorkspaceStorePath(root);
     if (!existsSync(storePath))
         return;
-    await withStoreWriteQueue(storePath, async () => {
+    await withStoreWriteCoordinator(storePath, async () => {
         const store = await openStore(storePath);
         try {
             const tracker = new TrackerRepository(store);
@@ -120,7 +120,7 @@ async function mirrorStatusEventToStore(root, event) {
         finally {
             await store.close();
         }
-    });
+    }, { operation_label: "mirrorStatusEventToStore" });
 }
 function scheduleStatusEventMirror(event) {
     const root = workspaceRoot();
@@ -135,7 +135,7 @@ export async function waitForPendingStatusEventMirrors() {
 }
 async function appendStatusEventStoreBacked(root, event) {
     const storePath = getWorkspaceStorePath(root);
-    return withStoreWriteQueue(storePath, async () => {
+    return withStoreWriteCoordinator(storePath, async () => {
         const store = await openStore(storePath);
         try {
             const tracker = new TrackerRepository(store);
@@ -165,9 +165,10 @@ async function appendStatusEventStoreBacked(root, event) {
         finally {
             await store.close();
         }
-    });
+    }, { operation_label: "appendStatusEventStoreBacked" });
 }
 export function appendStatusEvent(input) {
+    const root = workspaceRoot();
     const event = buildStatusEvent(input);
     validateStatusEvent(event);
     // Atomic append under file lock to prevent lost writes under parallelism
@@ -176,7 +177,9 @@ export function appendStatusEvent(input) {
     const combined = existing.length > 0 ? `${existing}\n${line}\n` : `${line}\n`;
     const next = rotateIfNeeded(combined);
     const path = safeWriteWorkspaceFile(STATUS_EVENTS_REL_PATH, next);
-    scheduleStatusEventMirror(event);
+    if (storeExistsSync(root)) {
+        scheduleStatusEventMirror(event);
+    }
     return { path, event };
 }
 /**

package/dist/store/ace-packed-store.d.ts

@@ -59,6 +59,9 @@ export declare class AcePackedStore implements IAcePackedStore {
     private fh;
     private kvIndex;
     private kvChunkEnd;
+    private pendingKv;
+    private pendingDeletes;
+    private dirty;
     private committed;
     private pending;
     private evtBaseId;
@@ -67,8 +70,6 @@ export declare class AcePackedStore implements IAcePackedStore {
     }): Promise<void>;
     private _initNew;
     private _loadExisting;
-    /** Read a KV blob directly from a loaded file buffer (used during migration). */
-    private _readKvBlobDirect;
     commit(): Promise<void>;
     /**
      * Compacts the KV chunk region — removes dead space left by overwritten keys.