@voybio/ace-swarm 0.2.5 → 2.4.1

package/dist/workspace-manager.js

@@ -3,19 +3,30 @@ import { randomUUID } from "node:crypto";
 import { existsSync, mkdtempSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, relative, resolve } from "node:path";
-import { resolveWorkspaceArtifactPath as resolveWorkspaceArtifactPathHelper, safeRead, safeWrite, resolveWorkspaceRoot, } from "./helpers.js";
+import { resolveWorkspaceArtifactPath as resolveWorkspaceArtifactPathHelper, safeRead, safeWrite, safeWriteAsync, resolveWorkspaceRoot, } from "./helpers.js";
 import { storeExistsSync } from "./store/store-snapshot.js";
-import { operationalArtifactVirtualPath, writeStoreBlobsSync, } from "./store/store-artifacts.js";
-import { getRuntimeProfilePath, readRuntimeProfile } from "./runtime-profile.js";
+import { operationalArtifactVirtualPath, writeStoreBlobsQueued, } from "./store/store-artifacts.js";
+import { getRuntimeProfilePath, loadRuntimeProfile } from "./runtime-profile.js";
 import { validateWorkspaceSessionRegistryPayload } from "./schemas.js";
 import { isInside, isReadError, slugify } from "./shared.js";
-import { appendStatusEvent } from "./status-events.js";
+import { appendStatusEventSafe } from "./status-events.js";
 import { buildAutonomyHookEnv, normalizeAutonomyPolicy, normalizeContinuityPolicy, } from "./ace-autonomy.js";
 export const WORKSPACE_SESSION_REGISTRY_REL_PATH = "agent-state/runtime-workspaces.json";
 const DEFAULT_MANAGED_WORKSPACE_ROOT = ".agents/ACE/.ace/workspaces";
 const DEFAULT_HOOK_TIMEOUT_MS = 15_000;
 const MAX_HOOK_TIMEOUT_MS = 60_000;
 const MIN_HOOK_TIMEOUT_MS = 1_000;
+export function requiresManagedWorkspace(ctx) {
+    if (ctx.surface_kind === "unattended_runtime")
+        return true;
+    if (ctx.surface_kind === "scheduled_job" && ctx.produces_artifacts_for_downstream)
+        return true;
+    if (ctx.surface_kind === "supervised_step" && ctx.performs_file_mutations)
+        return true;
+    if (ctx.multi_turn_bridge)
+        return true;
+    return false;
+}
 function defaultHookState() {
     return { status: "not_run" };
 }
@@ -27,6 +38,41 @@ function defaultHookSummary() {
         before_remove: defaultHookState(),
     };
 }
+function deriveManagedWorkspaceTrigger(ctx) {
+    if (!ctx)
+        return {};
+    const reasons = [];
+    if (ctx.surface_kind === "unattended_runtime") {
+        reasons.push({
+            trigger: "unattended_runtime",
+            summary: "required for unattended runtime execution",
+        });
+    }
+    if (ctx.surface_kind === "supervised_step" && ctx.performs_file_mutations) {
+        reasons.push({
+            trigger: "supervised_step_file_mutation",
+            summary: "required because the supervised step mutates files",
+        });
+    }
+    if (ctx.surface_kind === "scheduled_job" && ctx.produces_artifacts_for_downstream) {
+        reasons.push({
+            trigger: "scheduled_job_downstream_artifacts",
+            summary: "required because the scheduled job produces downstream artifacts",
+        });
+    }
+    if (ctx.multi_turn_bridge) {
+        reasons.push({
+            trigger: "multi_turn_bridge",
+            summary: "required because the bridge spans multiple turns and may write to disk",
+        });
+    }
+    return reasons.length > 0
+        ? {
+            trigger: reasons[0].trigger,
+            trigger_summary: reasons.map((entry) => entry.summary).join("; "),
+        }
+        : {};
+}
 function defaultRegistry() {
     return {
         version: 1,
@@ -41,7 +87,26 @@ function clampHookTimeout(input) {
 }
 function emitWorkspaceEvent(eventType, summary, payload) {
     try {
-        appendStatusEvent({
+        void appendStatusEventSafe({
+            source_module: "capability-framework",
+            event_type: eventType,
+            status: eventType === "WORKSPACE_SESSION_CREATED" ||
+                eventType === "WORKSPACE_SESSION_REMOVED"
+                ? "done"
+                : "fail",
+            summary,
+            payload,
+        }).catch(() => {
+            // Workspace lifecycle must not fail because status logging failed.
+        });
+    }
+    catch {
+        // Workspace lifecycle must not fail because status logging failed.
+    }
+}
+async function emitWorkspaceEventAsync(eventType, summary, payload) {
+    try {
+        await appendStatusEventSafe({
             source_module: "capability-framework",
             event_type: eventType,
             status: eventType === "WORKSPACE_SESSION_CREATED" ||
@@ -57,11 +122,8 @@ function emitWorkspaceEvent(eventType, summary, payload) {
     }
 }
 export function resolveRuntimeWorkspaceRoot(rootOverride) {
-    const workspaceRoot = resolveWorkspaceRoot();
-    const configured = rootOverride?.trim() ||
-        readRuntimeProfile().workspace.root ||
-        DEFAULT_MANAGED_WORKSPACE_ROOT;
-    return resolve(configured.startsWith("/") ? configured : resolve(workspaceRoot, configured));
+    const configured = rootOverride?.trim() || DEFAULT_MANAGED_WORKSPACE_ROOT;
+    return resolve(configured.startsWith("/") ? configured : resolve(resolveWorkspaceRoot(), configured));
 }
 function resolveTargetPath(rootPath, target) {
     return resolve(target.startsWith("/") ? target : resolve(rootPath, target));
@@ -80,7 +142,7 @@ function canonicalizeCandidatePath(targetPath) {
     return resolve(existing, ...remainder);
 }
 function parseWorkspaceRegistry(raw) {
-    if (isReadError(raw))
+    if (isReadError(raw) || raw.trim() === "" || raw.includes("\x00"))
         return defaultRegistry();
     let parsed;
     try {
@@ -111,6 +173,13 @@ function writeWorkspaceRegistry(registry) {
     }
     return safeWriteWorkspaceFile(WORKSPACE_SESSION_REGISTRY_REL_PATH, JSON.stringify(registry, null, 2));
 }
+async function writeWorkspaceRegistryAsync(registry) {
+    const validation = validateWorkspaceSessionRegistryPayload(registry);
+    if (!validation.ok) {
+        throw new Error(`Workspace session registry failed validation (${validation.schema}): ${validation.errors.join("; ")}`);
+    }
+    return safeWriteAsync(WORKSPACE_SESSION_REGISTRY_REL_PATH, JSON.stringify(registry, null, 2));
+}
 function findSessionIndex(registry, input) {
     if (input.session_id) {
         return registry.sessions.findIndex((session) => session.session_id === input.session_id);
@@ -132,6 +201,34 @@ function deriveWorkspacePath(rootPath, input, sessionId) {
 function workspaceHookStateFromResult(result) {
     return result.detail ? { status: result.status, detail: result.detail } : { status: result.status };
 }
+function refreshWorkspaceSessionHookSummary(session) {
+    const orderedKinds = [
+        "before_remove",
+        "after_run",
+        "before_run",
+        "after_create",
+    ];
+    const firstFailure = orderedKinds.find((kind) => session.hooks[kind].status === "failed");
+    const latestExecuted = orderedKinds.find((kind) => session.hooks[kind].status !== "not_run");
+    const summaryKind = firstFailure ?? latestExecuted;
+    session.hook_health = orderedKinds.some((kind) => session.hooks[kind].status === "failed")
+        ? "failed"
+        : "ok";
+    session.hook_summary = summaryKind
+        ? `${summaryKind}: ${session.hooks[summaryKind].detail ?? session.hooks[summaryKind].status}`
+        : undefined;
+}
+export function projectWorkspaceSessionRuntimeSummary(session) {
+    return {
+        active_workspace_path: session.workspace_path,
+        active_workspace_session_id: session.session_id,
+        workspace_session_status: session.status,
+        workspace_hook_health: session.hook_health,
+        workspace_hook_summary: session.hook_summary,
+        managed_workspace_trigger: session.trigger,
+        managed_workspace_trigger_summary: session.trigger_summary,
+    };
+}
 function readWorkspaceRegistry() {
     return parseWorkspaceRegistry(safeReadWorkspaceFile(WORKSPACE_SESSION_REGISTRY_REL_PATH));
 }
@@ -253,7 +350,7 @@ function listWorkspaceFiles(rootPath) {
     walk(rootPath);
     return entries.sort((a, b) => a.localeCompare(b));
 }
-function captureWorkspaceToStore(session) {
+async function captureWorkspaceToStore(session) {
     const workspaceRoot = resolveWorkspaceRoot();
     if (!storeExistsSync(workspaceRoot) || !existsSync(session.workspace_path)) {
         return undefined;
@@ -287,7 +384,9 @@ function captureWorkspaceToStore(session) {
         files: manifestFiles,
     };
     blobs.push({ key: manifestKey, content: JSON.stringify(manifest, null, 2) });
-    const written = writeStoreBlobsSync(workspaceRoot, blobs);
+    const written = await writeStoreBlobsQueued(workspaceRoot, blobs, {
+        operation_label: "captureWorkspaceToStore",
+    });
     const storePath = (written[0] ?? "").split("#")[0];
     return {
         workspace_path: `${storePath}#${baseKey}`,
@@ -297,8 +396,21 @@ function captureWorkspaceToStore(session) {
         file_count: manifestFiles.length,
     };
 }
-export function runWorkspaceHook(kind, session, timeoutMs) {
-    const runtimeProfile = readRuntimeProfile();
+export function runWorkspaceHook(kind, session, timeoutMs, runtimeProfilePath) {
+    const runtimeProfileResult = runtimeProfilePath
+        ? loadRuntimeProfile(runtimeProfilePath)
+        : loadRuntimeProfile();
+    if (!runtimeProfileResult.ok) {
+        const message = runtimeProfileResult.errors.join("; ");
+        return {
+            ok: false,
+            kind,
+            status: "failed",
+            command: null,
+            detail: message,
+        };
+    }
+    const runtimeProfile = runtimeProfileResult.profile;
     const command = runtimeProfile.workspace.hooks[kind];
     if (!command) {
         return {
@@ -366,9 +478,15 @@ export function createWorkspaceSession(input) {
         return { ok: false, registry_path: registryPath, error: message };
     }
     const useEphemeralRoot = shouldUseEphemeralWorkspaceRoot(input);
+    const runtimeProfileResult = input.runtime_profile_path
+        ? loadRuntimeProfile(input.runtime_profile_path)
+        : undefined;
+    const runtimeWorkspaceRoot = runtimeProfileResult?.ok
+        ? runtimeProfileResult.profile.workspace.root
+        : DEFAULT_MANAGED_WORKSPACE_ROOT;
     const rootPath = useEphemeralRoot
         ? mkdtempSync(join(tmpdir(), "ace-runtime-workspaces-"))
-        : resolveRuntimeWorkspaceRoot(input.root);
+        : resolveRuntimeWorkspaceRoot(input.root ?? runtimeWorkspaceRoot);
     const workspacePath = deriveWorkspacePath(rootPath, input, sessionId);
     const validation = validateManagedWorkspacePath(rootPath, workspacePath, {
         allowExternalRoot: useEphemeralRoot,
@@ -405,14 +523,16 @@ export function createWorkspaceSession(input) {
         root_path: validation.root_path,
         status: "active",
         source: input.source,
+        ...deriveManagedWorkspaceTrigger(input.trigger_context),
         objective_id: input.objective_id,
         tracker_item_id: input.tracker_item_id,
         created_at: now,
         updated_at: now,
         hooks: defaultHookSummary(),
     };
-    const hookResult = runWorkspaceHook("after_create", session, input.hooks_timeout_ms);
+    const hookResult = runWorkspaceHook("after_create", session, input.hooks_timeout_ms, input.runtime_profile_path);
     session.hooks.after_create = workspaceHookStateFromResult(hookResult);
+    refreshWorkspaceSessionHookSummary(session);
     if (!hookResult.ok) {
         session.status = "failed";
         session.last_error = hookResult.detail;
@@ -447,7 +567,110 @@ export function createWorkspaceSession(input) {
     });
     return { ok: true, registry_path: registryPath, session, validation };
 }
-export function removeWorkspaceSession(input) {
+export async function createWorkspaceSessionAsync(input) {
+    const registryPath = getWorkspaceSessionRegistryPath();
+    const sessionId = input.session_id?.trim() || randomUUID();
+    const now = new Date().toISOString();
+    let registry;
+    try {
+        registry = readWorkspaceRegistry();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await emitWorkspaceEventAsync("WORKSPACE_SESSION_FAILED", "Workspace session create failed because the registry could not be read.", { error: message });
+        return { ok: false, registry_path: registryPath, error: message };
+    }
+    const useEphemeralRoot = shouldUseEphemeralWorkspaceRoot(input);
+    const runtimeProfileResult = input.runtime_profile_path
+        ? loadRuntimeProfile(input.runtime_profile_path)
+        : undefined;
+    const runtimeWorkspaceRoot = runtimeProfileResult?.ok
+        ? runtimeProfileResult.profile.workspace.root
+        : DEFAULT_MANAGED_WORKSPACE_ROOT;
+    const rootPath = useEphemeralRoot
+        ? mkdtempSync(join(tmpdir(), "ace-runtime-workspaces-"))
+        : resolveRuntimeWorkspaceRoot(input.root ?? runtimeWorkspaceRoot);
+    const workspacePath = deriveWorkspacePath(rootPath, input, sessionId);
+    const validation = validateManagedWorkspacePath(rootPath, workspacePath, {
+        allowExternalRoot: useEphemeralRoot,
+    });
+    if (!validation.ok) {
+        await emitWorkspaceEventAsync("WORKSPACE_SESSION_FAILED", `Workspace session create rejected for ${workspacePath}`, { validation });
+        return {
+            ok: false,
+            registry_path: registryPath,
+            error: validation.reason,
+            validation,
+        };
+    }
+    const duplicate = registry.sessions.find((session) => resolve(session.workspace_path) === validation.target_path &&
+        session.status !== "archived" &&
+        session.status !== "removed");
+    if (duplicate) {
+        const error = `Workspace path is already managed by session ${duplicate.session_id}.`;
+        await emitWorkspaceEventAsync("WORKSPACE_SESSION_FAILED", error, { session_id: duplicate.session_id, workspace_path: duplicate.workspace_path });
+        return { ok: false, registry_path: registryPath, error, validation };
+    }
+    if (existsSync(validation.target_path)) {
+        const error = `Workspace path already exists and cannot be claimed: ${validation.target_path}`;
+        await emitWorkspaceEventAsync("WORKSPACE_SESSION_FAILED", error, {
+            workspace_path: validation.target_path,
+        });
+        return { ok: false, registry_path: registryPath, error, validation };
+    }
+    mkdirSync(validation.root_path, { recursive: true });
+    mkdirSync(validation.target_path, { recursive: true });
+    const session = {
+        session_id: sessionId,
+        workspace_path: validation.target_path,
+        root_path: validation.root_path,
+        status: "active",
+        source: input.source,
+        ...deriveManagedWorkspaceTrigger(input.trigger_context),
+        objective_id: input.objective_id,
+        tracker_item_id: input.tracker_item_id,
+        created_at: now,
+        updated_at: now,
+        hooks: defaultHookSummary(),
+    };
+    const hookResult = runWorkspaceHook("after_create", session, input.hooks_timeout_ms, input.runtime_profile_path);
+    session.hooks.after_create = workspaceHookStateFromResult(hookResult);
+    refreshWorkspaceSessionHookSummary(session);
+    if (!hookResult.ok) {
+        session.status = "failed";
+        session.last_error = hookResult.detail;
+    }
+    registry.sessions.push(session);
+    registry.updated_at = now;
+    await writeWorkspaceRegistryAsync(registry);
+    if (!hookResult.ok) {
+        await emitWorkspaceEventAsync("WORKSPACE_HOOK_FAILED", `Workspace hook after_create failed for ${session.session_id}`, {
+            session_id: session.session_id,
+            workspace_path: session.workspace_path,
+            detail: hookResult.detail,
+        });
+        await emitWorkspaceEventAsync("WORKSPACE_SESSION_FAILED", `Workspace session ${session.session_id} created with failed after_create hook.`, {
+            session_id: session.session_id,
+            workspace_path: session.workspace_path,
+            detail: hookResult.detail,
+        });
+        return {
+            ok: false,
+            registry_path: registryPath,
+            session,
+            error: hookResult.detail ?? "after_create hook failed",
+            validation,
+        };
+    }
+    await emitWorkspaceEventAsync("WORKSPACE_SESSION_CREATED", `Workspace session ${session.session_id} created.`, {
+        session_id: session.session_id,
+        workspace_path: session.workspace_path,
+        root_path: session.root_path,
+        source: session.source,
+    });
+    return { ok: true, registry_path: registryPath, session, validation };
+}
+export async function removeWorkspaceSession(input) {
     const registryPath = getWorkspaceSessionRegistryPath();
     const now = new Date().toISOString();
     let registry;
@@ -483,14 +706,15 @@ export function removeWorkspaceSession(input) {
             validation,
         };
     }
-    const hookResult = runWorkspaceHook("before_remove", session, input.hooks_timeout_ms);
+    const hookResult = runWorkspaceHook("before_remove", session, input.hooks_timeout_ms, input.runtime_profile_path);
     session.hooks.before_remove = workspaceHookStateFromResult(hookResult);
+    refreshWorkspaceSessionHookSummary(session);
     session.updated_at = now;
     if (!hookResult.ok) {
         session.status = "failed";
         session.last_error = hookResult.detail;
         registry.updated_at = now;
-        writeWorkspaceRegistry(registry);
+        await writeWorkspaceRegistryAsync(registry);
         emitWorkspaceEvent("WORKSPACE_HOOK_FAILED", `Workspace hook before_remove failed for ${session.session_id}`, {
             session_id: session.session_id,
             workspace_path: session.workspace_path,
@@ -509,8 +733,13 @@ export function removeWorkspaceSession(input) {
             validation,
         };
     }
-    const retention = readRuntimeProfile().workspace.retention;
-    const captured = captureWorkspaceToStore(session);
+    const runtimeProfileResult = input.runtime_profile_path
+        ? loadRuntimeProfile(input.runtime_profile_path)
+        : undefined;
+    const retention = runtimeProfileResult?.ok
+        ? runtimeProfileResult.profile.workspace.retention
+        : "delete";
+    const captured = await captureWorkspaceToStore(session);
     if (retention === "archive" && !captured) {
         const archivePath = resolve(validation.root_path, ".archive", session.session_id);
         const archiveValidation = validateManagedWorkspacePath(validation.root_path, archivePath, { allowExternalRoot });
@@ -518,7 +747,7 @@ export function removeWorkspaceSession(input) {
             session.status = "failed";
             session.last_error = archiveValidation.reason;
             registry.updated_at = now;
-            writeWorkspaceRegistry(registry);
+            await writeWorkspaceRegistryAsync(registry);
             emitWorkspaceEvent("WORKSPACE_SESSION_FAILED", `Archive target rejected for workspace session ${session.session_id}`, { session_id: session.session_id, validation: archiveValidation });
             return {
                 ok: false,
@@ -556,7 +785,7 @@ export function removeWorkspaceSession(input) {
     session.updated_at = now;
     delete session.last_error;
     registry.updated_at = now;
-    writeWorkspaceRegistry(registry);
+    await writeWorkspaceRegistryAsync(registry);
     emitWorkspaceEvent("WORKSPACE_SESSION_REMOVED", `Workspace session ${session.session_id} ${session.status}.`, {
         session_id: session.session_id,
         workspace_path: session.workspace_path,
@@ -564,7 +793,7 @@ export function removeWorkspaceSession(input) {
     });
     return { ok: true, registry_path: registryPath, session, validation };
 }
-export function runWorkspaceSessionHook(input) {
+export async function runWorkspaceSessionHook(input) {
     const registryPath = getWorkspaceSessionRegistryPath();
     const now = new Date().toISOString();
     let registry;
@@ -601,8 +830,9 @@ export function runWorkspaceSessionHook(input) {
         };
     }
     const session = registry.sessions[sessionIndex];
-    const hookResult = runWorkspaceHook(input.kind, session, input.hooks_timeout_ms);
+    const hookResult = runWorkspaceHook(input.kind, session, input.hooks_timeout_ms, input.runtime_profile_path);
     session.hooks[input.kind] = workspaceHookStateFromResult(hookResult);
+    refreshWorkspaceSessionHookSummary(session);
     session.updated_at = now;
     if (!hookResult.ok) {
         session.status = "failed";
@@ -612,7 +842,7 @@ export function runWorkspaceSessionHook(input) {
         delete session.last_error;
     }
     registry.updated_at = now;
-    writeWorkspaceRegistry(registry);
+    await writeWorkspaceRegistryAsync(registry);
     if (!hookResult.ok) {
         emitWorkspaceEvent("WORKSPACE_HOOK_FAILED", `Workspace hook ${input.kind} failed for ${session.session_id}`, {
             session_id: session.session_id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voybio/ace-swarm",
-  "version": "0.2.5",
+  "version": "2.4.1",
   "description": "ACE Framework MCP server and CLI — single-file ACEPACK state, local-model serving, agent orchestration, and host compliance enforcement.",
   "type": "module",
   "main": "dist/index.js",
@@ -69,7 +69,6 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "typescript": "^5.9.3",
-    "vericify": "*",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/dist/internal-tool-runtime.d.ts

@@ -1,21 +0,0 @@
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-export interface InternalToolDescriptor {
-    name: string;
-    description: string;
-    inputSchema?: unknown;
-    outputSchema?: unknown;
-}
-export interface InternalToolExecutionContext {
-    sessionId?: string;
-}
-export interface InternalToolExecutionResult {
-    ok: boolean;
-    name: string;
-    summary: string;
-    result?: CallToolResult;
-    error?: string;
-}
-export declare function listInternalTools(toolScope?: string[]): InternalToolDescriptor[];
-export declare function executeInternalTool(name: string, args?: Record<string, unknown>, context?: InternalToolExecutionContext): Promise<InternalToolExecutionResult>;
-export declare function resetInternalToolRuntime(): void;
-//# sourceMappingURL=internal-tool-runtime.d.ts.map

package/dist/internal-tool-runtime.js

@@ -1,136 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { z } from "zod";
-import { createAceServer } from "./server.js";
-function isPlainObject(value) {
-    return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function isZodSchema(value) {
-    return Boolean(value) && typeof value === "object" && "safeParseAsync" in value;
-}
-function buildZodObject(shape) {
-    if (!isPlainObject(shape))
-        return undefined;
-    const values = Object.values(shape);
-    if (!values.every((value) => isZodSchema(value)))
-        return undefined;
-    return z.object(shape);
-}
-function describeSchema(schema) {
-    if (isPlainObject(schema)) {
-        const properties = Object.fromEntries(Object.entries(schema).map(([key, value]) => [
-            key,
-            {
-                description: isZodSchema(value)
-                    ? value.description ?? value._def?.typeName ?? "input"
-                    : "input",
-            },
-        ]));
-        return { type: "object", properties };
-    }
-    if (isZodSchema(schema)) {
-        return {
-            type: schema._def?.typeName ?? "schema",
-            description: schema.description ?? "tool input",
-        };
-    }
-    return undefined;
-}
-function summarizeResult(name, result) {
-    const textBlocks = Array.isArray(result.content)
-        ? result.content
-            .filter((entry) => {
-            return isPlainObject(entry) && entry.type === "text" && typeof entry.text === "string";
-        })
-            .map((entry) => entry.text.trim())
-            .filter(Boolean)
-        : [];
-    const summary = textBlocks[0] ?? `${name} completed`;
-    return summary.length <= 240 ? summary : `${summary.slice(0, 239).trimEnd()}…`;
-}
-let cachedTools;
-function getRegisteredTools() {
-    if (cachedTools)
-        return cachedTools;
-    const server = createAceServer({ toolGovernance: false });
-    const registry = server
-        ._registeredTools;
-    cachedTools = new Map(Object.entries(registry ?? {}).filter(([, tool]) => tool.enabled !== false));
-    return cachedTools;
-}
-export function listInternalTools(toolScope) {
-    const allowed = toolScope ? new Set(toolScope) : undefined;
-    return [...getRegisteredTools().entries()]
-        .filter(([name]) => !allowed || allowed.has(name))
-        .map(([name, tool]) => ({
-        name,
-        description: tool.description ?? tool.title ?? "ACE MCP tool",
-        inputSchema: describeSchema(tool.inputSchema),
-        outputSchema: describeSchema(tool.outputSchema),
-    }))
-        .sort((left, right) => left.name.localeCompare(right.name));
-}
-export async function executeInternalTool(name, args = {}, context = {}) {
-    const tool = getRegisteredTools().get(name);
-    if (!tool) {
-        return {
-            ok: false,
-            name,
-            summary: `Unknown tool: ${name}`,
-            error: `Unknown tool: ${name}`,
-        };
-    }
-    let validatedArgs = args;
-    try {
-        if (tool.inputSchema) {
-            const schema = isZodSchema(tool.inputSchema) ? tool.inputSchema : buildZodObject(tool.inputSchema);
-            if (schema) {
-                const parsed = await schema.safeParseAsync(args);
-                if (!parsed.success) {
-                    const message = parsed.error.issues.map((issue) => issue.message).join("; ");
-                    return {
-                        ok: false,
-                        name,
-                        summary: `Input validation failed for ${name}`,
-                        error: message,
-                    };
-                }
-                if (isPlainObject(parsed.data)) {
-                    validatedArgs = parsed.data;
-                }
-            }
-        }
-        const extra = {
-            signal: new AbortController().signal,
-            sessionId: context.sessionId ?? `internal-${randomUUID()}`,
-            requestId: `internal-${randomUUID()}`,
-            sendNotification: async () => undefined,
-            sendRequest: async () => {
-                throw new Error("Internal tool runtime does not support nested MCP requests.");
-            },
-        };
-        const raw = tool.inputSchema
-            ? await tool.handler(validatedArgs, extra)
-            : await tool.handler(extra);
-        const result = raw;
-        return {
-            ok: !Boolean(result?.isError),
-            name,
-            summary: summarizeResult(name, result),
-            result,
-            error: result.isError ? summarizeResult(name, result) : undefined,
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            ok: false,
-            name,
-            summary: `${name} failed`,
-            error: message,
-        };
-    }
-}
-export function resetInternalToolRuntime() {
-    cachedTools = undefined;
-}
-//# sourceMappingURL=internal-tool-runtime.js.map

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

@@ -1,26 +0,0 @@
-export interface WorkspaceSnapshotFileRecord {
-    path: string;
-    size: number;
-    mtime_ms: number;
-    encoding: "utf8" | "base64";
-    key: string;
-    virtual_path: string;
-}
-export interface WorkspaceSnapshotResult {
-    version: 1;
-    captured_at: string;
-    session_id: string;
-    source_workspace_path: string;
-    virtual_root: string;
-    manifest_key: string;
-    manifest_path: string;
-    file_count: number;
-    files: WorkspaceSnapshotFileRecord[];
-    skipped_paths: Array<{
-        path: string;
-        reason: string;
-    }>;
-}
-export declare function workspaceSnapshotVirtualRoot(workspaceRoot: string, sessionId: string): string;
-export declare function persistWorkspaceSnapshot(workspaceRoot: string, sessionId: string, sourceWorkspacePath: string): Promise<WorkspaceSnapshotResult>;
-//# sourceMappingURL=workspace-snapshot.d.ts.map