@voybio/ace-swarm 2.4.0 → 2.4.2

package/dist/tools-framework.js

@@ -21,6 +21,7 @@ import { auditStoreAuthority, writeStoreAuthorityAuditReport, } from "./store/st
 import { PROVENANCE_CRITICAL_EVENT_TYPES, validateArtifactManifestPayload, validateProvenanceLogContent, validateTealConfigContent, } from "./schemas.js";
 import { readAceTaskContractAssessment } from "./ace-autonomy.js";
 import { listStoreKeysSync, readStoreBlobSync } from "./store/store-snapshot.js";
+import { parseJsonLikeText } from "./json-sanitizer.js";
 function executionRoleForDomain(domain) {
     switch (domain) {
         case "venture":
@@ -75,6 +76,14 @@ function parseGateManifest(raw, sourceRef) {
         return undefined;
     }
 }
+function parseJsonForValidation(raw) {
+    return parseJsonLikeText(raw);
+}
+function jsonValidationDetail(parsed, validDetail = "valid JSON") {
+    return parsed.sanitized.removed_control_bytes > 0
+        ? `control bytes removed before parse (${parsed.sanitized.removed_control_bytes}); source requires repair`
+        : validDetail;
+}
 function readGateManifests(gatesDir) {
     const files = readdirSync(gatesDir).filter((f) => f.endsWith(".json"));
     const allGates = [];
@@ -737,7 +746,10 @@ export function registerFrameworkTools(server) {
                                 "",
                                 "## LLM Runtime Profile",
                                 `- provider: ${llm_provider}`,
-                                `- model: ${resolvedLlmModel ?? defaultModelForProvider(llm_provider)}`,
+                                `- model: ${resolvedLlmModel ??
+                                    (llm_provider === "llama.cpp"
+                                        ? "(set via ace connect or ace doctor --scan)"
+                                        : defaultModelForProvider(llm_provider))}`,
                                 `- base_url: ${resolvedLlmBaseUrl ??
                                     (llm_provider === "ollama" || llm_provider === "llama.cpp"
                                         ? "discover via ace doctor --scan or set explicitly"
@@ -1010,58 +1022,60 @@ export function registerFrameworkTools(server) {
         // Check: handoff registry parseable
         const hrRaw = safeRead("agent-state/handoff-registry.json");
         const hrOk = !hrRaw.startsWith("[FILE NOT FOUND]");
+        let hrParsed;
         if (hrOk) {
-            try {
-                JSON.parse(hrRaw);
+            const parsed = parseJsonForValidation(hrRaw);
+            if (parsed.ok) {
+                hrParsed = parsed.value;
                 checks.push({
                     name: "handoff-registry:parse",
-                    ok: true,
-                    detail: "valid JSON",
+                    ok: parsed.sanitized.removed_control_bytes === 0,
+                    detail: jsonValidationDetail(parsed),
                 });
             }
-            catch {
+            else {
                 checks.push({
                     name: "handoff-registry:parse",
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `agent-state/handoff-registry.json: ${parsed.error}`,
                 });
             }
         }
         // Check: run-ledger parseable
         const rlRaw = safeRead("agent-state/run-ledger.json");
         if (!rlRaw.startsWith("[FILE NOT FOUND]")) {
-            try {
-                JSON.parse(rlRaw);
+            const parsed = parseJsonForValidation(rlRaw);
+            if (parsed.ok) {
                 checks.push({
                     name: "run-ledger:parse",
-                    ok: true,
-                    detail: "valid JSON",
+                    ok: parsed.sanitized.removed_control_bytes === 0,
+                    detail: jsonValidationDetail(parsed),
                 });
             }
-            catch {
+            else {
                 checks.push({
                     name: "run-ledger:parse",
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `agent-state/run-ledger.json: ${parsed.error}`,
                 });
             }
         }
         // Check: todo-state parseable
         const tsRaw = safeRead("agent-state/todo-state.json");
         if (!tsRaw.startsWith("[FILE NOT FOUND]")) {
-            try {
-                JSON.parse(tsRaw);
+            const parsed = parseJsonForValidation(tsRaw);
+            if (parsed.ok) {
                 checks.push({
                     name: "todo-state:parse",
-                    ok: true,
-                    detail: "valid JSON",
+                    ok: parsed.sanitized.removed_control_bytes === 0,
+                    detail: jsonValidationDetail(parsed),
                 });
             }
-            catch {
+            else {
                 checks.push({
                     name: "todo-state:parse",
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `agent-state/todo-state.json: ${parsed.error}`,
                 });
             }
         }
@@ -1081,19 +1095,19 @@ export function registerFrameworkTools(server) {
                 });
                 continue;
             }
-            try {
-                JSON.parse(raw);
+            const parsed = parseJsonForValidation(raw);
+            if (parsed.ok) {
                 checks.push({
                     name: check.name,
-                    ok: true,
-                    detail: "valid JSON",
+                    ok: parsed.sanitized.removed_control_bytes === 0,
+                    detail: jsonValidationDetail(parsed),
                 });
             }
-            catch {
+            else {
                 checks.push({
                     name: check.name,
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `${check.rel}: ${parsed.error}`,
                 });
             }
         }
@@ -1147,25 +1161,28 @@ export function registerFrameworkTools(server) {
         const artifactManifestRaw = safeRead("agent-state/ARTIFACT_MANIFEST.json");
         let artifactManifestEntries = [];
         if (!artifactManifestRaw.startsWith("[FILE NOT FOUND]")) {
-            try {
-                const parsed = JSON.parse(artifactManifestRaw);
-                const validation = validateArtifactManifestPayload(parsed);
+            const parsed = parseJsonForValidation(artifactManifestRaw);
+            if (parsed.ok) {
+                const validation = validateArtifactManifestPayload(parsed.value);
+                const controlBytesOk = parsed.sanitized.removed_control_bytes === 0;
                 checks.push({
                     name: "artifact-manifest:schema",
-                    ok: validation.ok,
-                    detail: validation.ok
-                        ? `valid (${validation.schema})`
-                        : validation.errors.join("; "),
+                    ok: validation.ok && controlBytesOk,
+                    detail: !controlBytesOk
+                        ? jsonValidationDetail(parsed)
+                        : validation.ok
+                            ? `valid (${validation.schema})`
+                            : validation.errors.join("; "),
                 });
                 if (validation.ok) {
-                    artifactManifestEntries = getArtifactManifestEntries(parsed);
+                    artifactManifestEntries = getArtifactManifestEntries(parsed.value);
                 }
             }
-            catch {
+            else {
                 checks.push({
                     name: "artifact-manifest:parse",
                     ok: false,
-                    detail: "CORRUPT JSON",
+                    detail: `agent-state/ARTIFACT_MANIFEST.json: ${parsed.error}`,
                 });
             }
         }
@@ -1203,8 +1220,16 @@ export function registerFrameworkTools(server) {
         // Check: module registry role coverage vs event emitters
         const registryRaw = safeRead("agent-state/MODULES/registry.json");
         if (!registryRaw.startsWith("[FILE NOT FOUND]")) {
-            try {
-                const registry = JSON.parse(registryRaw);
+            const parsed = parseJsonForValidation(registryRaw);
+            if (parsed.ok) {
+                if (parsed.sanitized.removed_control_bytes > 0) {
+                    checks.push({
+                        name: "registry:parse",
+                        ok: false,
+                        detail: jsonValidationDetail(parsed),
+                    });
+                }
+                const registry = parsed.value;
                 const registeredRoles = new Set(registry.roles ?? []);
                 const expectedEmitters = [
                     "capability-safety",
@@ -1223,11 +1248,11 @@ export function registerFrameworkTools(server) {
                     });
                 }
             }
-            catch {
+            else {
                 checks.push({
                     name: "registry:parse",
                     ok: false,
-                    detail: "registry.json is corrupt",
+                    detail: `agent-state/MODULES/registry.json: ${parsed.error}`,
                 });
             }
         }
@@ -1248,30 +1273,24 @@ export function registerFrameworkTools(server) {
             });
         }
         // Check: handoff consistency (open handoffs have source files)
-        if (hrOk) {
-            try {
-                const registry = JSON.parse(hrRaw);
-                const handoffs = Object.values(registry.handoffs ?? {});
-                let openWithoutFile = 0;
-                for (const h of handoffs) {
-                    if ((h.status === "open" || h.status === "accepted") &&
-                        h.source_file) {
-                        const fileContent = safeRead(h.source_file);
-                        if (fileContent.startsWith("[FILE NOT FOUND]"))
-                            openWithoutFile++;
-                    }
+        if (hrOk && hrParsed) {
+            const handoffs = Object.values(hrParsed.handoffs ?? {});
+            let openWithoutFile = 0;
+            for (const h of handoffs) {
+                if ((h.status === "open" || h.status === "accepted") &&
+                    h.source_file) {
+                    const fileContent = safeRead(h.source_file);
+                    if (fileContent.startsWith("[FILE NOT FOUND]"))
+                        openWithoutFile++;
                 }
-                checks.push({
-                    name: "handoff:source-file-integrity",
-                    ok: openWithoutFile === 0,
-                    detail: openWithoutFile === 0
-                        ? "all open handoffs have source files"
-                        : `${openWithoutFile} open handoffs reference missing source files`,
-                });
-            }
-            catch {
-                /* already caught above */
             }
+            checks.push({
+                name: "handoff:source-file-integrity",
+                ok: openWithoutFile === 0,
+                detail: openWithoutFile === 0
+                    ? "all open handoffs have source files"
+                    : `${openWithoutFile} open handoffs reference missing source files`,
+            });
         }
         // Check: event provenance gaps in recent events.
         // Scans for provenance-critical event types that are missing

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;

package/dist/tui/chat.js

@@ -13,6 +13,7 @@ import { ModelBridge } from "../model-bridge.js";
 import { resolveAceStateLayout } from "../ace-state-resolver.js";
 import { applyEvidenceGuardrail, buildAcePreflightPacket, buildBridgeTaskInput, buildContinuityRecord, buildStartupNudge, mapBridgeResultToRuntimeStatus, nextActivationLedger, } from "./local-model-contract.js";
 import { withLocalModelRuntimeRepository, } from "../store/repositories/local-model-runtime-repository.js";
+import { parseExecutionEngine, runLocalModelTask } from "../local-model-runtime.js";
 export class ChatSession extends EventEmitter {
     clients;
     telemetry;
@@ -32,7 +33,10 @@ export class ChatSession extends EventEmitter {
     aceRole;
     aceTier;
     maxTurns;
+    executionEngine;
     aceBridge;
+    hermesExecutor;
+    hermesLaunchProfile;
     activeAceBridge = false;
     providerBaseUrls;
     sessionId = randomUUID();
@@ -56,7 +60,10 @@ export class ChatSession extends EventEmitter {
         this.aceRole = options.aceRole?.trim() || "orchestrator";
         this.aceTier = options.aceTier;
         this.maxTurns = options.maxTurns ?? 6;
+        this.executionEngine = parseExecutionEngine(options.engine) ?? "direct";
         this.aceBridge = options.bridge ?? new ModelBridge(clients);
+        this.hermesExecutor = options.hermesExecutor;
+        this.hermesLaunchProfile = options.hermesLaunchProfile;
         // Add system prompt if provided
         if (this.systemPrompt) {
             this.messages.push({ role: "system", content: this.systemPrompt });
@@ -349,6 +356,9 @@ export class ChatSession extends EventEmitter {
             recommended_next_action: input.recommendedNextAction,
             blocked_reason: input.blockedReason,
             updated_at: Date.now(),
+            execution_engine: this.executionEngine,
+            underlying_provider: this.provider,
+            underlying_model: this.model,
         };
     }
     setRuntimeStatus(status) {
@@ -536,6 +546,70 @@ export class ChatSession extends EventEmitter {
             this.activationLedger = activationLedger;
             return;
         }
+        if (this.executionEngine === "hermes_local") {
+            const delegated = await runLocalModelTask({
+                task: buildBridgeTaskInput(recentConversation, preflight),
+                role: executionRole,
+                workspaceRoot: this.workspaceRoot,
+                provider: streamProvider,
+                model: streamModel,
+                baseUrl: this.providerBaseUrls[streamProvider],
+                ollamaUrl: this.providerBaseUrls.ollama,
+                engine: "hermes_local",
+                maxTurns: this.maxTurns,
+                tier: this.aceTier ?? (executionRole === "orchestrator" ? "compressed" : "brief"),
+                hermesExecutor: this.hermesExecutor,
+                hermesLaunchProfile: this.hermesLaunchProfile,
+            });
+            const assistantText = delegated.result.summary.trim() || "Hermes-local turn completed.";
+            this.messages.push({ role: "assistant", content: assistantText });
+            this.displayMessages.push({
+                role: "assistant",
+                content: assistantText,
+                timestamp: Date.now(),
+                tokens: estimateTokenCount(assistantText),
+            });
+            runtimeStatus = {
+                ...runtimeStatus,
+                bridge_status: delegated.result.status === "completed"
+                    ? "done"
+                    : delegated.result.status === "failed"
+                        ? "failed"
+                        : delegated.result.status === "max_turns"
+                            ? "needs_input"
+                            : delegated.result.status,
+                blocked_reason: delegated.result.status === "failed" ? assistantText : undefined,
+                hermes_bridge_protocol_version: delegated.hermes?.bridge_protocol_version,
+                hermes_session_id: delegated.hermes?.hermes_session_id,
+                shadow_mcp_session_id: delegated.hermes?.shadow_mcp_session_id,
+                updated_at: Date.now(),
+            };
+            this.setRuntimeStatus(runtimeStatus);
+            const continuity = {
+                ...buildContinuityRecord({
+                    preflight,
+                    role: executionRole,
+                    bridgeStatus: runtimeStatus.bridge_status,
+                    evidenceRefs: delegated.result.evidence_refs ?? [],
+                }),
+                execution_engine: "hermes_local",
+                underlying_provider: streamProvider,
+                underlying_model: streamModel,
+                hermes_bridge_protocol_version: delegated.hermes?.bridge_protocol_version,
+                hermes_session_id: delegated.hermes?.hermes_session_id,
+                shadow_mcp_session_id: delegated.hermes?.shadow_mcp_session_id,
+            };
+            this.persistRuntimeSessionArtifacts({ activationLedger, runtimeStatus, continuity });
+            this.activationLedger = activationLedger;
+            this.telemetry.recordRequest({
+                startTime,
+                endTime: Date.now(),
+                promptTokens: estimateTokenCount(text),
+                completionTokens: estimateTokenCount(assistantText),
+                model: streamModel,
+            });
+            return;
+        }
         let bridgeOutput = "";
         const toolNames = [];
         let retryAttempt = 0;

package/dist/tui/index.d.ts

@@ -5,6 +5,7 @@
  * This is the process entry when `ace tui` is invoked.
  */
 import { type TuiController } from "./commands.js";
+import type { HermesLaunchProfile } from "../hermes/launch-profile.js";
 export declare class AceTui implements TuiController {
     private input;
     private layout;
@@ -18,6 +19,7 @@ export declare class AceTui implements TuiController {
     private chatSessions;
     private activeChatSession;
     private provider;
+    private executionEngine;
     private model;
     private ollamaAvailable;
     private providers;
@@ -32,6 +34,7 @@ export declare class AceTui implements TuiController {
     private providerBaseUrls;
     private latestRuntimeStatus;
     private pendingCloseTabId;
+    private hermesLaunchProfile?;
     constructor(options?: {
         provider?: string;
         model?: string;
@@ -40,6 +43,8 @@ export declare class AceTui implements TuiController {
         baseUrl?: string;
         ollamaUrl?: string;
         providerBaseUrls?: Record<string, string>;
+        engine?: string;
+        hermesLaunchProfile?: HermesLaunchProfile;
         workspaceRoot?: string;
         systemPrompt?: string;
     });
@@ -114,6 +119,8 @@ export declare function runTui(options?: {
     baseUrl?: string;
     ollamaUrl?: string;
     providerBaseUrls?: Record<string, string>;
+    engine?: string;
+    hermesLaunchProfile?: HermesLaunchProfile;
     workspaceRoot?: string;
 }): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

package/dist/tui/index.js

@@ -16,8 +16,9 @@ import { ChatSession } from "./chat.js";
 import { OpenAICompatibleClient, diagnoseChatRuntimeConfig, } from "./openai-compatible.js";
 import { detectColorLevel, write, cursor, screen, fg, style } from "./renderer.js";
 import { ALL_AGENTS, WORKSPACE_ROOT } from "../helpers.js";
+import { parseExecutionEngine } from "../local-model-runtime.js";
 import { backfillHandoffsIntoScheduler } from "../tools-handoff.js";
-import { DEFAULT_OLLAMA_MODEL, defaultModelForProvider, inferProviderFromModel, normalizeLocalBaseUrl, } from "./provider-discovery.js";
+import { DEFAULT_OLLAMA_MODEL, defaultModelForProvider, inferProviderFromModel, normalizeLocalBaseUrl, scanLocalModelRuntimes, } from "./provider-discovery.js";
 import { resolveAceStateLayout } from "../ace-state-resolver.js";
 import { withLocalModelRuntimeRepository, } from "../store/repositories/local-model-runtime-repository.js";
 const DASHBOARD_CONTROLS = ["provider", "model", "chat", "logs", "refresh"];
@@ -38,6 +39,7 @@ export class AceTui {
     activeChatSession = null;
     // State
     provider;
+    executionEngine;
     model;
     ollamaAvailable = false;
     providers = [];
@@ -52,11 +54,20 @@ export class AceTui {
     providerBaseUrls = new Map();
     latestRuntimeStatus = null;
     pendingCloseTabId = null;
+    hermesLaunchProfile;
     constructor(options = {}) {
         const workspaceRoot = options.workspaceRoot ?? WORKSPACE_ROOT;
         this.workspaceRoot = workspaceRoot;
+        this.hermesLaunchProfile = options.hermesLaunchProfile;
         this.provider = this.normalizeProvider(options.provider ?? inferProviderFromModel(options.model) ?? "ollama") ?? "ollama";
-        this.model = (options.model ?? defaultModelForProvider(this.provider)).trim();
+        this.executionEngine = parseExecutionEngine(options.engine) ?? "direct";
+        const initialModel = options.model ??
+            (this.provider === "ollama"
+                ? defaultModelForProvider(this.provider)
+                : this.provider === "llama.cpp"
+                    ? ""
+                    : defaultModelForProvider(this.provider));
+        this.model = initialModel.trim();
         // Initialize modules
         const colorLevel = detectColorLevel();
         for (const [provider, baseUrl] of Object.entries(options.providerBaseUrls ?? {})) {
@@ -86,6 +97,7 @@ export class AceTui {
             this.config.set("ollama_url", this.providerBaseUrls.get("ollama"));
         }
         this.config.set("provider", this.provider);
+        this.config.set("engine", this.executionEngine);
         this.config.set("model", this.model);
         this.config.set("temperature", "0.7");
         this.config.set("top_p", "0.9");
@@ -142,6 +154,31 @@ export class AceTui {
             this.showMessage(`Provider '${this.provider}' loaded from session/config. Switch with /provider or dashboard controls.`, "info");
             this.checkProviderRuntimeConfig(this.provider, this.model, "startup");
         }
+        // Additionally probe local runtimes (llama.cpp / Ollama) and merge discoveries into TUI so users can explicitly pick either.
+        try {
+            const scan = await scanLocalModelRuntimes({ workspaceRoot: this.workspaceRoot, timeoutMs: 800 });
+            for (const c of scan.candidates) {
+                this.ensureProvider(c.provider);
+                this.setProviderBaseUrl(c.provider, c.baseUrl);
+                if (c.models && c.models.length > 0)
+                    this.setProviderModels(c.provider, c.models, false);
+            }
+            // If the current model appears served by a discovered runtime and the provider wasn't explicitly forced, prefer the local runtime.
+            if (!process.env.ACE_TUI_PROVIDER) {
+                for (const c of scan.candidates) {
+                    if (c.models.includes(this.model) && this.provider !== c.provider) {
+                        this.provider = c.provider;
+                        this.config.set("provider", this.provider);
+                        this.telemetry.setModel(this.model);
+                        this.showMessage(`Discovered local runtime '${c.provider}' serving model '${this.model}'. Provider set to '${this.provider}'.`, "info");
+                        break;
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore scan failures — discovery is best-effort.
+        }
         // Initial render
         this.fullRender();
         // Start 1-second tick for status bar updates
@@ -492,6 +529,7 @@ export class AceTui {
         const state = {
             taskState: this.getTaskState(),
             provider: this.provider,
+            engine: this.executionEngine,
             model: this.model,
             tokensIn: snap.tokensIn + agentTokens.input,
             tokensOut: snap.tokensOut + agentTokens.output,
@@ -757,6 +795,9 @@ export class AceTui {
         else if (this.provider === "ollama") {
             this.model = DEFAULT_OLLAMA_MODEL;
         }
+        else if (this.provider === "llama.cpp") {
+            this.model = "";
+        }
         else {
             this.model = defaultModelForProvider(this.provider);
         }
@@ -919,6 +960,7 @@ export class AceTui {
         // Create a chat session for this tab
         const session = new ChatSession({ ollama: this.ollama, openai: this.openai }, this.telemetry, {
             provider: this.provider,
+            engine: this.executionEngine,
             model: this.model,
             providerBaseUrls: Object.fromEntries(this.providerBaseUrls.entries()),
             systemPrompt: this.config.get("system_prompt"),
@@ -926,6 +968,7 @@ export class AceTui {
             topP: parseFloat(this.config.get("top_p") ?? "0.9"),
             numCtx: parseInt(this.config.get("num_ctx") ?? "8192", 10),
             workspaceRoot: this.workspaceRoot,
+            hermesLaunchProfile: this.hermesLaunchProfile,
         });
         // Wire chat session events
         session.on("updated", () => {

package/dist/tui/layout.d.ts

@@ -20,6 +20,7 @@ export interface LayoutZones {
 export interface StatusBarState {
     taskState: "idle" | "running" | "blocked" | "overdue";
     provider: string;
+    engine?: string;
     model: string;
     tokensIn: number;
     tokensOut: number;

package/dist/tui/layout.js

@@ -160,6 +160,9 @@ export class LayoutManager {
             ? `${fg.gray}tab: ${fg.white}${state.activeTabLabel}${style.reset}`
             : undefined;
         const providerSeg = `${fg.cyan}provider: ${fg.brightCyan}${state.provider}${style.reset}`;
+        const engineSeg = state.engine
+            ? `${fg.cyan}engine: ${fg.brightCyan}${state.engine}${style.reset}`
+            : undefined;
         const modelSeg = `${fg.cyan}model: ${fg.brightCyan}${state.model}${style.reset}`;
         const runtimeSummary = formatRuntimeStatusSummary(state);
         const runtimeSeg = runtimeSummary
@@ -175,7 +178,7 @@ export class LayoutManager {
                 : state.bridgeStatus
                     ? `${fg.gray}${state.bridgeStatus}${style.reset}`
                     : undefined;
-        const segments = [stateIndicator, tabSeg, providerSeg, modelSeg, runtimeSeg, contextSeg, tokenSeg, timeSeg, clockSeg]
+        const segments = [stateIndicator, tabSeg, providerSeg, engineSeg, modelSeg, runtimeSeg, contextSeg, tokenSeg, timeSeg, clockSeg]
             .filter((segment) => Boolean(segment));
         const sep = ` ${fg.gray}│${style.reset} `;
         const line = ` ${segments.join(sep)} `;

package/dist/tui/ollama.d.ts

@@ -111,6 +111,13 @@ export declare class OllamaClient {
 export declare class OllamaError extends Error {
     statusCode: number;
     responseBody: string;
-    constructor(message: string, statusCode: number, responseBody: string);
+    kind?: string;
+    meta?: Record<string, unknown>;
+    suggested_remediation?: string;
+    constructor(message: string, statusCode: number, responseBody: string, options?: {
+        kind?: string;
+        model?: string;
+        suggested_remediation?: string;
+    });
 }
 //# sourceMappingURL=ollama.d.ts.map