@voybio/ace-swarm 2.4.1 → 2.4.2

package/dist/hermes/session-manager.js

@@ -0,0 +1,187 @@
+import { randomUUID } from "node:crypto";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { HERMES_BRIDGE_PROTOCOL_VERSION, HermesBridgeFrameDecoder, } from "./bridge-protocol.js";
+import { resolveHermesLaunchProfile, } from "./launch-profile.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const DIST_ROOT = resolve(__dirname, "..");
+const PACKAGE_ROOT = resolve(DIST_ROOT, "..");
+const MIN_HERMES_LOCAL_CONTEXT_LENGTH = 65536;
+function summarizeToolResult(value) {
+    if (typeof value === "string")
+        return value.slice(0, 500);
+    try {
+        return JSON.stringify(value).slice(0, 500);
+    }
+    catch {
+        return String(value).slice(0, 500);
+    }
+}
+function eventText(event) {
+    const value = event.text ?? event.message;
+    return typeof value === "string" ? value : "";
+}
+function hermesBaseUrl(provider, baseUrl) {
+    const normalized = String(baseUrl ?? "").replace(/\/+$/, "");
+    if (provider === "ollama" && normalized && !normalized.endsWith("/v1")) {
+        return `${normalized}/v1`;
+    }
+    return normalized;
+}
+export class HermesSubprocessExecutor {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async runTurn(options) {
+        const sessionId = `hermes-${randomUUID()}`;
+        const shadowId = `shadow-${randomUUID()}`;
+        const hermesHome = mkdtempSync(resolve(tmpdir(), "ace-hermes-home-"));
+        mkdirSync(hermesHome, { recursive: true });
+        const toolScope = options.toolScope ?? [];
+        const cliPath = resolve(DIST_ROOT, "cli.js");
+        const baseUrl = hermesBaseUrl(options.runtime.provider, options.runtime.baseUrl ?? options.runtime.ollamaUrl);
+        writeFileSync(resolve(hermesHome, "config.yaml"), [
+            "model:",
+            `  default: ${JSON.stringify(options.runtime.model)}`,
+            "  provider: custom",
+            `  base_url: ${JSON.stringify(baseUrl)}`,
+            "  api_key: no-key-required",
+            `  context_length: ${MIN_HERMES_LOCAL_CONTEXT_LENGTH}`,
+            "",
+            "auxiliary:",
+            "  compression:",
+            `    model: ${JSON.stringify(options.runtime.model)}`,
+            "    provider: custom",
+            `    base_url: ${JSON.stringify(baseUrl)}`,
+            "    api_key: no-key-required",
+            `    context_length: ${MIN_HERMES_LOCAL_CONTEXT_LENGTH}`,
+            "",
+            "mcp_servers:",
+            "  ace_shadow:",
+            `    command: ${JSON.stringify(process.execPath)}`,
+            "    args:",
+            `      - ${JSON.stringify(cliPath)}`,
+            "      - mcp-shadow",
+            `      - ${JSON.stringify("--tools")}`,
+            `      - ${JSON.stringify(toolScope.join(","))}`,
+            "    timeout: 30",
+            "",
+        ].join("\n"), "utf-8");
+        const launchProfile = this.options.launchProfile ??
+            resolveHermesLaunchProfile({
+                workspaceRoot: options.runtime.workspaceRoot,
+                cliHermesRoot: this.options.hermesRoot,
+                cliHermesPython: this.options.pythonCommand,
+            });
+        const workerPath = this.options.workerPath ?? launchProfile.worker_path;
+        const hermesRoot = this.options.hermesRoot ?? launchProfile.hermes_root;
+        const command = this.options.command ?? launchProfile.command;
+        const [bin, ...args] = command;
+        if (!bin) {
+            throw new Error("Hermes launch command must contain at least one executable argument.");
+        }
+        const child = spawn(bin, [...args, workerPath], {
+            cwd: PACKAGE_ROOT,
+            env: {
+                ...process.env,
+                HERMES_HOME: hermesHome,
+                ACE_WORKSPACE_ROOT: options.runtime.workspaceRoot,
+            },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const decoder = new HermesBridgeFrameDecoder();
+        const events = [];
+        const malformed = [];
+        const stderr = [];
+        let finalText = "";
+        let turns = 0;
+        let sawError = "";
+        child.stdout.on("data", (chunk) => {
+            for (const frame of decoder.push(chunk)) {
+                if (frame.ok) {
+                    events.push(frame.event);
+                    if (frame.event.type === "final") {
+                        finalText = eventText(frame.event);
+                        const rawTurns = frame.event.turns;
+                        turns = typeof rawTurns === "number" ? rawTurns : turns;
+                    }
+                    if (frame.event.type === "error") {
+                        sawError = eventText(frame.event) || "Hermes bridge error";
+                    }
+                }
+                else {
+                    malformed.push(frame.reason);
+                }
+            }
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr.push(chunk.toString("utf8"));
+        });
+        const request = {
+            session_id: sessionId,
+            turn_id: randomUUID(),
+            hermes_root: hermesRoot ?? "",
+            task: options.task,
+            role: options.role,
+            provider: options.runtime.provider,
+            model: options.runtime.model,
+            base_url: options.runtime.baseUrl ?? options.runtime.ollamaUrl,
+            max_turns: options.maxTurns,
+            system_prompt: "You are running inside ACE Hermes-local mode. Use only the imported ACE MCP toolset for tool calls. Do not use plain text as executable authority.",
+        };
+        child.stdin.end(`${JSON.stringify(request)}\n`);
+        const exitCode = await new Promise((resolvePromise, reject) => {
+            child.on("error", reject);
+            child.on("close", resolvePromise);
+        });
+        for (const frame of decoder.push(new Uint8Array(), true)) {
+            if (frame.ok)
+                events.push(frame.event);
+            else
+                malformed.push(frame.reason);
+        }
+        if (!this.options.keepTemp) {
+            rmSync(hermesHome, { recursive: true, force: true });
+        }
+        const toolCalls = events
+            .filter((event) => event.type === "tool_complete")
+            .map((event) => ({
+            tool: String(event.tool ?? "unknown"),
+            ok: !event.is_error,
+            summary: summarizeToolResult(event.result ?? eventText(event)),
+            isError: Boolean(event.is_error),
+        }));
+        const status = sawError || malformed.length > 0 || exitCode !== 0 ? "failed" : "completed";
+        const summary = status === "failed"
+            ? sawError ||
+                `Hermes bridge failed${malformed.length ? `; malformed_frames=${malformed.join(",")}` : ""}${stderr.length ? `; stderr=${stderr.join("").slice(0, 500)}` : ""}`
+            : finalText || "Hermes-local turn completed.";
+        return {
+            result: {
+                bridge_id: sessionId,
+                role: options.role,
+                status,
+                summary,
+                turns,
+                tool_calls: toolCalls,
+                child_results: [],
+                evidence_refs: toolCalls.map((tool) => `tool:${tool.tool}`),
+            },
+            metadata: {
+                bridge_protocol_version: HERMES_BRIDGE_PROTOCOL_VERSION,
+                hermes_session_id: sessionId,
+                shadow_mcp_session_id: shadowId,
+                execution_engine: "hermes_local",
+                provider: options.runtime.provider,
+                model: options.runtime.model,
+                events,
+            },
+        };
+    }
+}
+//# sourceMappingURL=session-manager.js.map

package/dist/local-model-runtime.d.ts

@@ -1,9 +1,13 @@
+import { type ExecutionEngine } from "./helpers/constants.js";
 import { type BridgeResult, type ModelBridgeClients } from "./model-bridge.js";
 import type { AceContextTier } from "./ace-context.js";
 import { type LocalModelExecutionPolicy } from "./local-model-policy.js";
 import type { RuntimeModelClass } from "./runtime-profile.js";
+import { type HermesLocalExecutor, type HermesLocalTurnResult } from "./hermes/session-manager.js";
+import { type HermesLaunchProfile } from "./hermes/launch-profile.js";
 export interface LocalModelRuntimeConfig {
     workspaceRoot: string;
+    executionEngine: ExecutionEngine;
     provider: string;
     model: string;
     baseUrl?: string;
@@ -16,6 +20,7 @@ export interface RunLocalModelTaskOptions {
     role?: string;
     workspaceRoot?: string;
     provider?: string;
+    engine?: string;
     model?: string;
     baseUrl?: string;
     ollamaUrl?: string;
@@ -24,6 +29,8 @@ export interface RunLocalModelTaskOptions {
     modelClass?: RuntimeModelClass;
     toolScope?: string[];
     clients?: ModelBridgeClients;
+    hermesExecutor?: HermesLocalExecutor;
+    hermesLaunchProfile?: HermesLaunchProfile;
 }
 export interface RunLocalModelTaskResult {
     runtime: LocalModelRuntimeConfig;
@@ -31,15 +38,19 @@ export interface RunLocalModelTaskResult {
     routingSummary?: string;
     policy: LocalModelExecutionPolicy;
     result: BridgeResult;
+    hermes?: HermesLocalTurnResult["metadata"];
 }
+export declare function parseExecutionEngine(input?: string): ExecutionEngine | undefined;
 export declare function resolveTier(requested: RunLocalModelTaskOptions["tier"], provider: string, model: string, role: string): AceContextTier;
 export declare function createDefaultModelBridgeClients(runtime: Pick<LocalModelRuntimeConfig, "providerBaseUrls">): ModelBridgeClients;
 export declare function resolveLocalModelRuntime(input: {
     workspaceRoot?: string;
     provider?: string;
+    engine?: string;
     model?: string;
     baseUrl?: string;
     ollamaUrl?: string;
+    hermesReady?: boolean;
 }): LocalModelRuntimeConfig;
 export declare function runLocalModelTask(options: RunLocalModelTaskOptions): Promise<RunLocalModelTaskResult>;
 export { resolveLocalModelExecutionPolicy, resolveLocalModelClass } from "./local-model-policy.js";

package/dist/local-model-runtime.js

@@ -1,12 +1,36 @@
 import { resolve } from "node:path";
 import { ROLE_ENUM } from "./shared.js";
 import { resolveWorkspaceRoot } from "./helpers.js";
+import { ALL_EXECUTION_ENGINES } from "./helpers/constants.js";
 import { executeAceInternalTool } from "./ace-internal-tools.js";
 import { ModelBridge } from "./model-bridge.js";
 import { OllamaClient } from "./tui/ollama.js";
 import { OpenAICompatibleClient, diagnoseChatRuntimeConfig, } from "./tui/openai-compatible.js";
 import { discoverProviderContext } from "./tui/provider-discovery.js";
 import { defaultToolScopeForPolicy, defaultTurnsForPolicy, resolveLocalModelExecutionPolicy, } from "./local-model-policy.js";
+import { HermesSubprocessExecutor, } from "./hermes/session-manager.js";
+import { resolveHermesLaunchProfile, } from "./hermes/launch-profile.js";
+export function parseExecutionEngine(input) {
+    if (!input)
+        return undefined;
+    const normalized = input.trim().toLowerCase().replace(/-/g, "_");
+    return ALL_EXECUTION_ENGINES.includes(normalized)
+        ? normalized
+        : undefined;
+}
+function isLocalProvider(provider) {
+    return provider === "ollama" || provider === "llama.cpp";
+}
+function resolveExecutionEngine(input) {
+    const parsed = parseExecutionEngine(input.requested);
+    if (parsed) {
+        if (parsed === "hermes_local" && !isLocalProvider(input.provider)) {
+            throw new Error("engine=hermes_local is only valid for local providers.");
+        }
+        return parsed;
+    }
+    return isLocalProvider(input.provider) && input.hermesReady ? "hermes_local" : "direct";
+}
 function extractTextContent(result) {
     if (!result || typeof result !== "object")
         return "";
@@ -80,6 +104,11 @@ export function resolveLocalModelRuntime(input) {
         cliBaseUrl: input.baseUrl,
         cliOllamaUrl: input.ollamaUrl,
     });
+    const executionEngine = resolveExecutionEngine({
+        requested: input.engine,
+        provider: discovered.provider,
+        hermesReady: input.hermesReady,
+    });
     if (discovered.provider === "ollama" && !discovered.ollamaUrl) {
         throw new Error("Ollama base URL is not configured. Provide `--base-url`/`ollama_url`, set OLLAMA_HOST, or run `ace doctor --llm ollama --scan`.");
     }
@@ -93,6 +122,7 @@ export function resolveLocalModelRuntime(input) {
     }
     return {
         workspaceRoot,
+        executionEngine,
         provider: discovered.provider,
         model: discovered.model,
         baseUrl: discovered.baseUrl,
@@ -105,6 +135,7 @@ export async function runLocalModelTask(options) {
     const runtime = resolveLocalModelRuntime({
         workspaceRoot: options.workspaceRoot,
         provider: options.provider,
+        engine: options.engine,
         model: options.model,
         baseUrl: options.baseUrl,
         ollamaUrl: options.ollamaUrl,
@@ -119,15 +150,40 @@ export async function runLocalModelTask(options) {
         requested_tier: options.tier,
         requested_model_class: options.modelClass,
     });
+    const maxTurns = options.maxTurns ?? defaultTurnsForPolicy(role, policy);
+    const toolScope = options.toolScope ?? defaultToolScopeForPolicy(role, policy);
+    if (runtime.executionEngine === "hermes_local") {
+        const launchProfile = options.hermesLaunchProfile ?? resolveHermesLaunchProfile({ workspaceRoot: runtime.workspaceRoot });
+        const hermesExecutor = options.hermesExecutor ??
+            new HermesSubprocessExecutor({
+                launchProfile,
+            });
+        const hermes = await hermesExecutor.runTurn({
+            task: options.task,
+            role,
+            runtime,
+            policy,
+            toolScope,
+            maxTurns,
+        });
+        return {
+            runtime,
+            role,
+            routingSummary,
+            policy,
+            result: hermes.result,
+            hermes: hermes.metadata,
+        };
+    }
     const result = await bridge.run({
         task: options.task,
         role,
         workspace: runtime.workspaceRoot,
         tier: policy.tier,
-        maxTurns: options.maxTurns ?? defaultTurnsForPolicy(role, policy),
+        maxTurns,
         provider: runtime.provider,
         model: runtime.model,
-        toolScope: options.toolScope ?? defaultToolScopeForPolicy(role, policy),
+        toolScope,
     });
     return {
         runtime,

package/dist/schemas.js

@@ -436,6 +436,7 @@ const vericifyProcessPostSchema = z
     agent_id: NON_EMPTY,
     kind: z.enum(["intent", "progress", "blocker", "handoff_note", "stale_ack", "completion", "plan_proposal", "plan_quality_assessment"]),
     summary: NON_EMPTY,
+    blocker_category: z.string().optional(),
     tool_refs: z.array(z.string()),
     evidence_refs: z.array(z.string()),
     checkpoint_ref: z.string().optional(),

package/dist/server.d.ts

@@ -4,7 +4,10 @@ export declare const ACE_MCP_SERVER_VERSION = "0.2.1";
 export interface CreateAceServerOptions {
     toolGovernance?: boolean;
     instructions?: string;
+    toolAllowlist?: readonly string[];
+    mode?: "public" | "hermes_shadow";
 }
 export declare function createAceServer(options?: CreateAceServerOptions): McpServer;
 export declare function startStdioServer(logStartup?: boolean): Promise<void>;
+export declare function startHermesShadowStdioServer(toolAllowlist: readonly string[], logStartup?: boolean): Promise<void>;
 //# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -12,20 +12,26 @@ 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";
+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();
     const server = new McpServer({
         name: ACE_MCP_SERVER_NAME,
         version: ACE_MCP_SERVER_VERSION,
     }, {
-        instructions: options.instructions ?? buildServerInstructions(workspaceRoot),
+        instructions: options.instructions ??
+            (options.mode === "hermes_shadow"
+                ? HERMES_SHADOW_INSTRUCTIONS
+                : buildServerInstructions(workspaceRoot)),
     });
     if (options.toolGovernance !== false) {
         installAceToolGovernance(server, workspaceRoot);
     }
-    registerResources(server);
-    registerPrompts(server);
-    registerTools(server);
+    if (options.mode !== "hermes_shadow") {
+        registerResources(server);
+        registerPrompts(server);
+    }
+    registerTools(server, { toolAllowlist: options.toolAllowlist });
     return server;
 }
 function appendEmergencyMcpStatusEvent(workspaceRoot, message) {
@@ -94,4 +100,16 @@ export async function startStdioServer(logStartup = true) {
         console.error(`ACE MCP Server (${ACE_MCP_SERVER_NAME}) running on stdio`);
     }
 }
+export async function startHermesShadowStdioServer(toolAllowlist, logStartup = false) {
+    const server = createAceServer({
+        mode: "hermes_shadow",
+        toolAllowlist,
+        instructions: HERMES_SHADOW_INSTRUCTIONS,
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    if (logStartup) {
+        console.error(`ACE Hermes shadow MCP Server (${ACE_MCP_SERVER_NAME}) running on stdio with ${toolAllowlist.length} tools`);
+    }
+}
 //# sourceMappingURL=server.js.map

package/dist/store/materializers/vericify-projector.js

@@ -160,6 +160,9 @@ export class VericifyProjector {
                 timestamp: new Date(post.ts).toISOString(),
                 branch_id: typeof post.metadata?.branch_id === "string" ? post.metadata.branch_id : undefined,
                 lane_id: typeof post.metadata?.lane_id === "string" ? post.metadata.lane_id : undefined,
+                blocker_category: typeof post.metadata?.blocker_category === "string"
+                    ? post.metadata.blocker_category
+                    : undefined,
                 checkpoint_ref: typeof post.metadata?.checkpoint_ref === "string"
                     ? post.metadata.checkpoint_ref
                     : undefined,

package/dist/store/repositories/local-model-runtime-repository.d.ts

@@ -27,6 +27,12 @@ export interface AceSessionContinuityRecord {
     recent_decisions: string[];
     recommended_next_action?: string;
     evidence_refs: string[];
+    execution_engine?: "direct" | "hermes_local";
+    underlying_provider?: string;
+    underlying_model?: string;
+    hermes_bridge_protocol_version?: string;
+    hermes_session_id?: string;
+    shadow_mcp_session_id?: string;
     last_transition_id?: string;
 }
 export interface AceRuntimeStatusPacket {
@@ -56,6 +62,12 @@ export interface AceRuntimeStatusPacket {
     tokens_in?: number;
     tokens_out?: number;
     updated_at: number;
+    execution_engine?: "direct" | "hermes_local";
+    underlying_provider?: string;
+    underlying_model?: string;
+    hermes_bridge_protocol_version?: string;
+    hermes_session_id?: string;
+    shadow_mcp_session_id?: string;
     surface_kind?: "tui_interactive" | "unattended_runtime" | "scheduled_job" | "bridge_resumed" | "supervised_step";
     model_class?: "frontier" | "mid" | "small_local";
     waiting_on?: string;

package/dist/store/repositories/local-model-runtime-repository.js

@@ -196,6 +196,9 @@ export class LocalModelRuntimeRepository {
             session_id: record.session_id,
             bridge_status: record.bridge_status,
             preflight_state: record.preflight_state,
+            execution_engine: record.execution_engine,
+            underlying_provider: record.underlying_provider,
+            underlying_model: record.underlying_model,
         });
         await this.addToIndex(STATUS_INDEX_KEY, record.session_id);
         return record;

package/dist/tools-agent.js

@@ -1806,6 +1806,10 @@ export function registerAgentTools(server) {
             .enum(["intent", "progress", "blocker", "handoff_note", "stale_ack", "completion"])
             .describe("Structured process post kind"),
         summary: z.string().describe("Short operator-facing summary"),
+        blocker_category: z
+            .string()
+            .optional()
+            .describe("Optional blocker category for blocker posts"),
         tool_refs: z
             .array(z.string())
             .optional()
@@ -1815,7 +1819,7 @@ export function registerAgentTools(server) {
             .optional()
             .describe("Optional evidence references attached to the process post"),
         checkpoint_ref: z.string().optional().describe("Optional checkpoint id"),
-    }, async ({ run_id, branch_id, lane_id, agent_id, kind, summary, tool_refs, evidence_refs, checkpoint_ref }) => {
+    }, async ({ run_id, branch_id, lane_id, agent_id, kind, summary, blocker_category, tool_refs, evidence_refs, checkpoint_ref, }) => {
         const result = await appendVericifyProcessPost({
             run_id,
             branch_id,
@@ -1823,6 +1827,7 @@ export function registerAgentTools(server) {
             agent_id,
             kind,
             summary,
+            blocker_category,
             tool_refs,
             evidence_refs,
             checkpoint_ref,

package/dist/tools.d.ts

@@ -5,5 +5,8 @@
  * This keeps the registration entry-point small and each domain testable.
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-export declare function registerTools(server: McpServer): void;
+export interface RegisterToolsOptions {
+    toolAllowlist?: readonly string[];
+}
+export declare function registerTools(server: McpServer, options?: RegisterToolsOptions): void;
 //# sourceMappingURL=tools.d.ts.map

package/dist/tools.js

@@ -16,18 +16,40 @@ import { registerMemoryTools } from "./tools-memory.js";
 import { registerDriftTools } from "./tools-drift.js";
 import { registerSchedulerTools } from "./tools-scheduler.js";
 import { registerSkillTools } from "./tools-skills.js";
-export function registerTools(server) {
-    registerAgentTools(server);
-    registerHandoffTools(server);
-    registerTodoTools(server);
-    registerDiscoveryTools(server);
-    registerLifecycleTools(server);
-    registerFileTools(server);
-    registerFrameworkTools(server);
-    registerGitTools(server);
-    registerMemoryTools(server);
-    registerDriftTools(server);
-    registerSchedulerTools(server);
-    registerSkillTools(server);
+const TOOL_REGISTRARS = [
+    registerAgentTools,
+    registerHandoffTools,
+    registerTodoTools,
+    registerDiscoveryTools,
+    registerLifecycleTools,
+    registerFileTools,
+    registerFrameworkTools,
+    registerGitTools,
+    registerMemoryTools,
+    registerDriftTools,
+    registerSchedulerTools,
+    registerSkillTools,
+];
+function createAllowlistedServer(server, allowed) {
+    return new Proxy(server, {
+        get(target, property, receiver) {
+            if (property !== "tool")
+                return Reflect.get(target, property, receiver);
+            const registerTool = Reflect.get(target, property, receiver);
+            return (name, ...args) => {
+                if (!allowed.has(name))
+                    return undefined;
+                return Reflect.apply(registerTool, target, [name, ...args]);
+            };
+        },
+    });
+}
+export function registerTools(server, options = {}) {
+    const target = options.toolAllowlist === undefined
+        ? server
+        : createAllowlistedServer(server, new Set(options.toolAllowlist));
+    for (const register of TOOL_REGISTRARS) {
+        register(target);
+    }
 }
 //# sourceMappingURL=tools.js.map

package/dist/tui/chat.d.ts

@@ -12,6 +12,8 @@ import type { ChatMessage } from "./layout.js";
 import { ModelBridge } from "../model-bridge.js";
 import type { AceContextTier } from "../ace-context.js";
 import { type AceRuntimeStatusPacket } from "../store/repositories/local-model-runtime-repository.js";
+import type { HermesLocalExecutor } from "../hermes/session-manager.js";
+import type { HermesLaunchProfile } from "../hermes/launch-profile.js";
 export interface ChatSessionOptions {
     provider: string;
     model: string;
@@ -25,7 +27,10 @@ export interface ChatSessionOptions {
     aceRole?: string;
     aceTier?: AceContextTier;
     maxTurns?: number;
+    engine?: string;
     bridge?: Pick<ModelBridge, "run" | "interrupt">;
+    hermesExecutor?: HermesLocalExecutor;
+    hermesLaunchProfile?: HermesLaunchProfile;
 }
 export interface ChatSessionClients {
     ollama: Pick<OllamaClient, "chat" | "abort">;
@@ -51,7 +56,10 @@ export declare class ChatSession extends EventEmitter {
     private aceRole;
     private aceTier?;
     private maxTurns;
+    private executionEngine;
     private aceBridge;
+    private hermesExecutor?;
+    private hermesLaunchProfile?;
     private activeAceBridge;
     private providerBaseUrls;
     private sessionId;