@voybio/ace-swarm 2.4.4 → 2.4.7

package/dist/safe-edit.js

@@ -2,13 +2,14 @@
  * Safe-edit module: copy → modify → validate → swap pattern.
  * Prevents bricking by never leaving core files in a broken state.
  */
-import { copyFileSync, cpSync, existsSync, mkdtempSync, mkdirSync, readFileSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync, } from "node:fs";
+import { copyFileSync, cpSync, existsSync, mkdtempSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync, } from "node:fs";
 import { createHash } from "node:crypto";
 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";
+import { appendSourceEditEvent, SourceEditLeaseBusyError, withSourceMutationCoordinatorSync, } from "./source-mutation-coordinator.js";
 const STAGING_DIR = ".ace-staging";
 // ────────────────────────────────────────────────────────────────────
 // Helpers
@@ -16,6 +17,52 @@ const STAGING_DIR = ".ace-staging";
 function fileHash(content) {
     return createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
+function fullFileHash(content) {
+    return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+function hashMatchesExpected(expected, content) {
+    return expected === fullFileHash(content) || expected === fileHash(content);
+}
+function sourceConflictResult(input) {
+    return {
+        ok: false,
+        original_path: input.absPath,
+        staging_path: input.stagingDir,
+        backup_path: input.backupPath,
+        original_hash: input.originalHash,
+        new_hash: input.newHash,
+        validation_passed: input.validationCheck?.validation_passed,
+        validation_output: input.validationCheck?.validation_output,
+        test_passed: input.validationCheck?.test_passed,
+        test_output: input.validationCheck?.test_output,
+        error: "Source edit conflict — target changed after base hash was captured",
+        reason_code: "source_edit_conflict",
+        expected_hash: input.expectedHash,
+        observed_hash: input.observedHash,
+        lease_lock_path: input.leaseLockPath,
+        lease_waited_ms: input.leaseWaitedMs,
+        restored: true,
+    };
+}
+function leaseBusyResult(input) {
+    return {
+        ok: false,
+        original_path: input.absPath,
+        staging_path: input.stagingDir,
+        backup_path: input.backupPath,
+        original_hash: input.originalHash,
+        new_hash: input.newHash,
+        validation_passed: input.validationCheck?.validation_passed,
+        validation_output: input.validationCheck?.validation_output,
+        test_passed: input.validationCheck?.test_passed,
+        test_output: input.validationCheck?.test_output,
+        error: input.error.message,
+        reason_code: input.error.reason_code,
+        lease_lock_path: input.error.lockPath,
+        lease_waited_ms: input.error.waitedMs,
+        restored: true,
+    };
+}
 function ensureDir(dirPath) {
     if (!existsSync(dirPath))
         mkdirSync(dirPath, { recursive: true });
@@ -30,12 +77,14 @@ function resolveWorkspaceTarget(inputPath) {
         relPath: normalizeRelPath(relative(WORKSPACE_ROOT, absPath)),
     };
 }
+const STAGING_PRUNE_DIR_NAMES = new Set([".ace-staging", ".git", "node_modules", ".npm-cache"]);
 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);
+    // Prune heavy/ignored directories at ANY depth (e.g. monorepo packages/*/node_modules),
+    // not just top-level — a first-segment-only check copied nested node_modules per edit.
+    return !rel.split("/").some((segment) => STAGING_PRUNE_DIR_NAMES.has(segment));
 }
 function prepareStagedWorkspace(stagingDir) {
     const stagedWorkspace = mkdtempSync(resolve(tmpdir(), "ace-staged-workspace-"));
@@ -56,12 +105,77 @@ function prepareStagedWorkspace(stagingDir) {
 function workspacePathIn(root, relPath) {
     return resolve(root, relPath);
 }
+function backupPathForTarget(relPath, originalHash) {
+    const flatName = relPath.replace(/\//g, "__");
+    const backupDir = wsPath(STAGING_DIR, "backups");
+    ensureDir(backupDir);
+    return resolve(backupDir, `${flatName}.${originalHash.slice(0, 8)}.backup`);
+}
 function swapTargetContent(absPath, content) {
     ensureDir(dirname(absPath));
     const swapPath = `${absPath}.ace-swap.${process.pid}.${Date.now()}`;
     writeFileSync(swapPath, content, "utf-8");
     renameSync(swapPath, absPath);
 }
+export function gcStaging(input = {}) {
+    const maxAgeHours = input.max_age_hours ?? 72;
+    const maxEntries = input.max_entries ?? 200;
+    const stagingPath = wsPath(STAGING_DIR);
+    if (!existsSync(stagingPath)) {
+        return {
+            ok: true,
+            staging_path: stagingPath,
+            removed_entries: 0,
+            kept_entries: 0,
+            errors: [],
+        };
+    }
+    const protectedEntries = new Set(["backups", "locks"]);
+    const now = Date.now();
+    const maxAgeMs = Math.max(0, maxAgeHours) * 60 * 60 * 1000;
+    const entries = readdirSync(stagingPath, { withFileTypes: true })
+        .filter((entry) => !protectedEntries.has(entry.name))
+        .map((entry) => {
+        const absPath = resolve(stagingPath, entry.name);
+        const stats = statSync(absPath);
+        return {
+            absPath,
+            name: entry.name,
+            mtimeMs: stats.mtimeMs,
+            ageMs: now - stats.mtimeMs,
+        };
+    })
+        .sort((a, b) => b.mtimeMs - a.mtimeMs);
+    const toRemove = new Set();
+    for (const entry of entries) {
+        if (maxAgeMs === 0 || entry.ageMs > maxAgeMs) {
+            toRemove.add(entry.absPath);
+        }
+    }
+    if (Number.isFinite(maxEntries) && maxEntries >= 0) {
+        for (const entry of entries.slice(maxEntries)) {
+            toRemove.add(entry.absPath);
+        }
+    }
+    const errors = [];
+    let removed = 0;
+    for (const absPath of toRemove) {
+        try {
+            rmSync(absPath, { recursive: true, force: true });
+            removed += 1;
+        }
+        catch (error) {
+            errors.push(`${absPath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return {
+        ok: errors.length === 0,
+        staging_path: stagingPath,
+        removed_entries: removed,
+        kept_entries: entries.length - removed,
+        errors,
+    };
+}
 function runValidation(validationCmd, testCmd, cwd = WORKSPACE_ROOT) {
     let validation_passed;
     let validation_output;
@@ -115,13 +229,16 @@ export function safeEditFile(input) {
     // Step 1: Create staging directory
     const stagingDir = wsPath(STAGING_DIR, `${timestamp}-${isNew ? "new" : originalHash.slice(0, 8)}`);
     ensureDir(stagingDir);
+    const needsValidationWorkspace = Boolean(input.validation_command || input.test_command);
     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");
+    const stagedWorkspace = needsValidationWorkspace ? prepareStagedWorkspace(stagingDir) : undefined;
+    const stagedTarget = stagedWorkspace ? workspacePathIn(stagedWorkspace, relPath) : stagingNew;
+    if (stagedWorkspace) {
+        ensureDir(dirname(stagedTarget));
+        writeFileSync(stagedTarget, input.content, "utf-8");
+    }
     // Step 2: If file exists, copy original to staging + backup
     let backupPath;
     if (!isNew) {
@@ -130,7 +247,19 @@ export function safeEditFile(input) {
     }
     // Step 3: Run validation/tests against the staged workspace.
     let check;
-    if (input.validation_command || input.test_command) {
+    if (needsValidationWorkspace) {
+        if (!stagedWorkspace) {
+            return {
+                ok: false,
+                original_path: absPath,
+                staging_path: stagingDir,
+                backup_path: backupPath,
+                original_hash: originalHash,
+                new_hash: stagedNewHash,
+                error: "Validation workspace was not prepared",
+                restored: true,
+            };
+        }
         check = runValidation(input.validation_command, input.test_command, stagedWorkspace);
         if (!check.passed) {
             return {
@@ -149,26 +278,83 @@ export function safeEditFile(input) {
             };
         }
     }
-    // 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);
+    try {
+        return withSourceMutationCoordinatorSync(relPath, (lease) => {
+            // Step 4: Promote staged content to the real target only after checks pass.
+            if (input.expected_base_hash) {
+                const currentContent = safeRead(input.path);
+                const observedHash = isReadError(currentContent) ? "none" : fullFileHash(currentContent);
+                if (isReadError(currentContent) || !hashMatchesExpected(input.expected_base_hash, currentContent)) {
+                    appendSourceEditEvent({
+                        event: "SOURCE_EDIT_CONFLICT",
+                        target_path: relPath,
+                        lock_path: lease.lockPath,
+                        waited_ms: lease.waitedMs,
+                        base_hash: originalHash,
+                        expected_hash: input.expected_base_hash,
+                        observed_hash: observedHash,
+                        reason_code: "source_edit_conflict",
+                    });
+                    return sourceConflictResult({
+                        absPath,
+                        stagingDir,
+                        backupPath,
+                        originalHash,
+                        newHash: stagedNewHash,
+                        expectedHash: input.expected_base_hash,
+                        observedHash,
+                        validationCheck: check,
+                        leaseLockPath: lease.lockPath,
+                        leaseWaitedMs: lease.waitedMs,
+                    });
+                }
+            }
+            let promotedBackupPath;
+            if (!isNew && input.backup !== false) {
+                promotedBackupPath = backupPathForTarget(relPath, originalHash);
+                copyFileSync(absPath, promotedBackupPath);
+            }
+            const promotedContent = needsValidationWorkspace ? readFileSync(stagedTarget, "utf-8") : input.content;
+            const promotedHash = fileHash(promotedContent);
+            swapTargetContent(absPath, promotedContent);
+            appendSourceEditEvent({
+                event: "SOURCE_EDIT_COMMITTED",
+                target_path: relPath,
+                lock_path: lease.lockPath,
+                waited_ms: lease.waitedMs,
+                base_hash: originalHash,
+                committed_hash: promotedHash,
+            });
+            return {
+                ok: true,
+                original_path: absPath,
+                staging_path: stagingDir,
+                backup_path: promotedBackupPath,
+                original_hash: originalHash,
+                new_hash: promotedHash,
+                validation_passed: check?.validation_passed,
+                validation_output: check?.validation_output,
+                test_passed: check?.test_passed,
+                test_output: check?.test_output,
+                lease_lock_path: lease.lockPath,
+                lease_waited_ms: lease.waitedMs,
+            };
+        });
+    }
+    catch (error) {
+        if (error instanceof SourceEditLeaseBusyError) {
+            return leaseBusyResult({
+                absPath,
+                stagingDir,
+                backupPath,
+                originalHash,
+                newHash: stagedNewHash,
+                error,
+                validationCheck: check,
+            });
+        }
+        throw error;
     }
-    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: promotedHash,
-        validation_passed: check?.validation_passed,
-        validation_output: check?.validation_output,
-        test_passed: check?.test_passed,
-        test_output: check?.test_output,
-    };
 }
 // ────────────────────────────────────────────────────────────────────
 // Test runner
@@ -221,42 +407,72 @@ export function runTestSuite(command) {
 export function diffContents(original, updated) {
     const origLines = original.split(/\r?\n/);
     const newLines = updated.split(/\r?\n/);
-    // Simple line-based diff summary
-    const origSet = new Set(origLines);
-    const newSet = new Set(newLines);
+    let prefix = 0;
+    while (prefix < origLines.length &&
+        prefix < newLines.length &&
+        origLines[prefix] === newLines[prefix])
+        prefix++;
+    let suffix = 0;
+    while (suffix < origLines.length - prefix &&
+        suffix < newLines.length - prefix &&
+        origLines[origLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix])
+        suffix++;
+    const origChanged = origLines.slice(prefix, origLines.length - suffix);
+    const newChanged = newLines.slice(prefix, newLines.length - suffix);
+    // Exact LCS is useful for normal source files but its matrix is quadratic.
+    // Above this fixed budget, emit a valid deterministic whole-file replacement
+    // hunk instead. That fallback is linear, preserves every line, and never
+    // turns a real change into a false negative.
+    const exactComparisonBudget = 1_000_000;
+    const useExactLcs = origChanged.length * newChanged.length <= exactComparisonBudget;
+    const changes = [];
     let added = 0;
     let removed = 0;
-    for (const line of newLines) {
-        if (!origSet.has(line))
-            added++;
+    if (!useExactLcs) {
+        for (const line of origChanged)
+            changes.push(`-${line}`);
+        for (const line of newChanged)
+            changes.push(`+${line}`);
+        removed = origChanged.length;
+        added = newChanged.length;
     }
-    for (const line of origLines) {
-        if (!newSet.has(line))
-            removed++;
-    }
-    const summaryLines = [];
-    summaryLines.push(`Lines: ${origLines.length} → ${newLines.length} (${added > 0 ? `+${added}` : "+0"}, ${removed > 0 ? `-${removed}` : "-0"})`);
-    // Show first 30 changed lines for context
-    const changes = [];
-    const maxContext = 30;
-    let shown = 0;
-    for (const line of origLines) {
-        if (!newSet.has(line) && shown < maxContext) {
-            changes.push(`- ${line}`);
-            shown++;
+    else {
+        const lengths = Array.from({ length: origChanged.length + 1 }, () => new Uint32Array(newChanged.length + 1));
+        for (let i = origChanged.length - 1; i >= 0; i--) {
+            for (let j = newChanged.length - 1; j >= 0; j--) {
+                lengths[i][j] = origChanged[i] === newChanged[j]
+                    ? lengths[i + 1][j + 1] + 1
+                    : Math.max(lengths[i + 1][j], lengths[i][j + 1]);
+            }
         }
-    }
-    for (const line of newLines) {
-        if (!origSet.has(line) && shown < maxContext) {
-            changes.push(`+ ${line}`);
-            shown++;
+        let i = 0;
+        let j = 0;
+        while (i < origChanged.length || j < newChanged.length) {
+            if (i < origChanged.length && j < newChanged.length && origChanged[i] === newChanged[j]) {
+                changes.push(` ${origChanged[i]}`);
+                i++;
+                j++;
+            }
+            else if (j < newChanged.length && (i === origChanged.length || lengths[i][j + 1] >= lengths[i + 1][j])) {
+                changes.push(`+${newChanged[j]}`);
+                added++;
+                j++;
+            }
+            else {
+                changes.push(`-${origChanged[i]}`);
+                removed++;
+                i++;
+            }
         }
     }
-    if (changes.length > 0) {
-        summaryLines.push("", "Changes (sample):", ...changes);
-    }
+    const summaryLines = [
+        "--- original",
+        "+++ modified",
+        `@@ -${prefix + 1},${origChanged.length} +${prefix + 1},${newChanged.length} @@`,
+        ...changes,
+    ];
     return {
-        has_diff: added > 0 || removed > 0,
+        has_diff: original !== updated,
         original_lines: origLines.length,
         new_lines: newLines.length,
         added,
@@ -311,17 +527,24 @@ export function applyPatch(input) {
     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);
+    const needsValidationWorkspace = Boolean(input.validation_command || input.test_command);
+    const stagedWorkspace = needsValidationWorkspace ? prepareStagedWorkspace(stagingDir) : undefined;
+    const stagedTarget = stagedWorkspace
+        ? workspacePathIn(stagedWorkspace, relPath)
+        : resolve(stagingDir, `patch-target__${relPath.replace(/\//g, "__")}`);
     ensureDir(dirname(stagedTarget));
-    if (isNew && !existsSync(stagedTarget))
+    if (!stagedWorkspace && !isNew) {
+        writeFileSync(stagedTarget, originalContent, "utf-8");
+    }
+    else 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,
+            cwd: stagedWorkspace ?? WORKSPACE_ROOT,
         });
         if (patchResult.status !== 0) {
             return {
@@ -336,7 +559,7 @@ export function applyPatch(input) {
         }
         const patchedContent = readFileSync(stagedTarget, "utf-8");
         const newHash = fileHash(patchedContent);
-        const check = runValidation(input.validation_command, input.test_command, stagedWorkspace);
+        const check = runValidation(input.validation_command, input.test_command, stagedWorkspace ?? stagingDir);
         if (!check.passed) {
             return {
                 ok: false,
@@ -352,24 +575,78 @@ export function applyPatch(input) {
                 restored: true,
             };
         }
-        let backupPath;
-        if (!isNew) {
-            backupPath = `${absPath}.ace-backup.${originalHash.slice(0, 8)}`;
-            copyFileSync(absPath, backupPath);
+        try {
+            return withSourceMutationCoordinatorSync(relPath, (lease) => {
+                let backupPath;
+                if (input.expected_base_hash) {
+                    const currentContent = safeRead(input.path);
+                    const observedHash = isReadError(currentContent) ? "none" : fullFileHash(currentContent);
+                    if (isReadError(currentContent) || !hashMatchesExpected(input.expected_base_hash, currentContent)) {
+                        appendSourceEditEvent({
+                            event: "SOURCE_EDIT_CONFLICT",
+                            target_path: relPath,
+                            lock_path: lease.lockPath,
+                            waited_ms: lease.waitedMs,
+                            base_hash: originalHash,
+                            expected_hash: input.expected_base_hash,
+                            observed_hash: observedHash,
+                            reason_code: "source_edit_conflict",
+                        });
+                        return sourceConflictResult({
+                            absPath,
+                            stagingDir,
+                            originalHash,
+                            newHash,
+                            expectedHash: input.expected_base_hash,
+                            observedHash,
+                            validationCheck: check,
+                            leaseLockPath: lease.lockPath,
+                            leaseWaitedMs: lease.waitedMs,
+                        });
+                    }
+                }
+                if (!isNew) {
+                    backupPath = backupPathForTarget(relPath, originalHash);
+                    copyFileSync(absPath, backupPath);
+                }
+                swapTargetContent(absPath, patchedContent);
+                appendSourceEditEvent({
+                    event: "SOURCE_EDIT_COMMITTED",
+                    target_path: relPath,
+                    lock_path: lease.lockPath,
+                    waited_ms: lease.waitedMs,
+                    base_hash: originalHash,
+                    committed_hash: newHash,
+                });
+                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,
+                    lease_lock_path: lease.lockPath,
+                    lease_waited_ms: lease.waitedMs,
+                };
+            });
+        }
+        catch (error) {
+            if (error instanceof SourceEditLeaseBusyError) {
+                return leaseBusyResult({
+                    absPath,
+                    stagingDir,
+                    originalHash,
+                    newHash,
+                    error,
+                    validationCheck: check,
+                });
+            }
+            throw error;
         }
-        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 {

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 export declare const ACE_MCP_SERVER_NAME = "ace-swarm";
-export declare const ACE_MCP_SERVER_VERSION = "0.2.1";
+export declare const ACE_MCP_SERVER_VERSION: string;
 export interface CreateAceServerOptions {
     toolGovernance?: boolean;
     instructions?: string;
@@ -8,6 +8,15 @@ export interface CreateAceServerOptions {
     mode?: "public" | "hermes_shadow";
 }
 export declare function createAceServer(options?: CreateAceServerOptions): McpServer;
-export declare function startStdioServer(logStartup?: boolean): Promise<void>;
+export type AceHostProfile = "host-min" | "full";
+/**
+ * Curated premium-host surface (report WS-G). ~15–25 high-value tools instead of the
+ * full tool surface, cutting the per-session schema tax. Everything omitted here remains reachable
+ * via `run_orchestrator` delegation or by starting with `--profile full`. Goal-engine
+ * tools (start_goal/…) are intentionally absent until WS-F ships.
+ */
+export declare const HOST_MIN_TOOL_PROFILE: readonly string[];
+export declare function resolveHostProfileAllowlist(profile: AceHostProfile): readonly string[] | undefined;
+export declare function startStdioServer(logStartup?: boolean, profile?: AceHostProfile): Promise<void>;
 export declare function startHermesShadowStdioServer(toolAllowlist: readonly string[], logStartup?: boolean): Promise<void>;
 //# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -1,7 +1,8 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { buildServerInstructions, installAceToolGovernance, } from "./ace-server-instructions.js";
 import { resolveWorkspaceRoot } from "./helpers.js";
 import { openStore } from "./store/ace-packed-store.js";
@@ -11,7 +12,21 @@ import { registerResources } from "./resources.js";
 import { registerTools } from "./tools.js";
 import { backfillHandoffsIntoScheduler } from "./tools-handoff.js";
 export const ACE_MCP_SERVER_NAME = "ace-swarm";
-export const ACE_MCP_SERVER_VERSION = "0.2.1";
+// Report the true package version to MCP clients instead of a stale hard-coded string.
+function resolvePackageVersion() {
+    try {
+        // dist/server.js → package root is one level up from dist/.
+        const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+        const parsed = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (typeof parsed.version === "string" && parsed.version.length > 0)
+            return parsed.version;
+    }
+    catch {
+        // fall through to the compiled fallback
+    }
+    return "0.0.0";
+}
+export const ACE_MCP_SERVER_VERSION = resolvePackageVersion();
 const HERMES_SHADOW_INSTRUCTIONS = "ACE filtered shadow MCP tool transport for Hermes-local execution. Only tools allowed by the active ACE capability snapshot are registered; public ACE prompts and resources are not exposed.";
 export function createAceServer(options = {}) {
     const workspaceRoot = resolveWorkspaceRoot();
@@ -77,7 +92,40 @@ async function verifyMcpStoreStartup(workspaceRoot, logStartup) {
         console.error(message);
     return false;
 }
-export async function startStdioServer(logStartup = true) {
+/**
+ * Curated premium-host surface (report WS-G). ~15–25 high-value tools instead of the
+ * full tool surface, cutting the per-session schema tax. Everything omitted here remains reachable
+ * via `run_orchestrator` delegation or by starting with `--profile full`. Goal-engine
+ * tools (start_goal/…) are intentionally absent until WS-F ships.
+ */
+export const HOST_MIN_TOOL_PROFILE = [
+    "recall_context",
+    "route_task",
+    "run_orchestrator",
+    "propose_plan",
+    "validate_plan",
+    "create_handoff",
+    "ack_handoff",
+    "get_handoff_status",
+    "execute_gates",
+    "emit_status_event",
+    "append_vericify_process_post",
+    "get_vericify_context",
+    "get_vericify_delta",
+    "astgrep_locate",
+    "compile_structural_edit",
+    "preview_structural_edit",
+    "astgrep_rewrite",
+    "safe_edit_file",
+    "run_tests",
+    "run_local_model",
+    "context_snapshot",
+    "build_continuity_packet",
+];
+export function resolveHostProfileAllowlist(profile) {
+    return profile === "host-min" ? HOST_MIN_TOOL_PROFILE : undefined;
+}
+export async function startStdioServer(logStartup = true, profile = "full") {
     const workspaceRoot = resolveWorkspaceRoot();
     if (!(await verifyMcpStoreStartup(workspaceRoot, logStartup))) {
         return;
@@ -93,11 +141,13 @@ export async function startStdioServer(logStartup = true) {
             console.error(`Scheduler backfill warning: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    const server = createAceServer();
+    const toolAllowlist = resolveHostProfileAllowlist(profile);
+    const server = createAceServer({ toolAllowlist });
     const transport = new StdioServerTransport();
     await server.connect(transport);
     if (logStartup) {
-        console.error(`ACE MCP Server (${ACE_MCP_SERVER_NAME}) running on stdio`);
+        console.error(`ACE MCP Server (${ACE_MCP_SERVER_NAME}) running on stdio` +
+            (toolAllowlist ? ` (profile=${profile}, ${toolAllowlist.length} tools)` : ` (profile=${profile})`));
     }
 }
 export async function startHermesShadowStdioServer(toolAllowlist, logStartup = false) {