@voybio/ace-swarm 0.2.3 → 0.2.5

package/dist/tools-agent.js

@@ -2,7 +2,7 @@
  * Agent, skill, kernel, and task-pack tool registrations.
  */
 import { z } from "zod";
-import { ALL_AGENTS, COMPOSABLE_AGENTS, SWARM_AGENTS, SWARM_SUBAGENT_MAP, classifyPathSource, getAgentInstructionPath, getAgentManifestPath, getKernelArtifactPath, isSwarmRole, listAvailableSkills, readAgentInstructions, readAgentManifest, readKernelArtifact, readSkillInstructions, readTaskArtifact, resolveWritableTaskPath, safeWrite, } from "./helpers.js";
+import { ALL_AGENTS, COMPOSABLE_AGENTS, SWARM_AGENTS, SWARM_SUBAGENT_MAP, classifyPathSource, getAgentInstructionPath, getAgentManifestPath, getKernelArtifactPath, isSwarmRole, listAvailableSkills, readAgentInstructions, readAgentManifest, readKernelArtifact, readSkillInstructions, readTaskArtifact, resolveWorkspaceRoot, resolveWritableTaskPath, safeWrite, } from "./helpers.js";
 import { loadRuntimeProfile, readRuntimePromptTemplate, readRuntimeProfileState, validateRuntimeProfileContent, } from "./runtime-profile.js";
 import { getUnattendedSession, listUnattendedSessions, startUnattendedSession, stopUnattendedSession, validateRuntimeExecutorSessionRegistryContent, waitForUnattendedSession, } from "./runtime-executor.js";
 import { executeRuntimeTool, listRuntimeToolSpecs, loadRuntimeToolRegistry, validateRuntimeToolRegistryContent, } from "./runtime-tool-specs.js";
@@ -52,25 +52,6 @@ function extractToolTextContent(result) {
         .filter(Boolean)
         .join("\n");
 }
-function normalizeRoleCandidate(input) {
-    if (!input)
-        return undefined;
-    const normalized = input.trim().toLowerCase().replace(/^ace-/, "").replace(/[^a-z0-9]+/g, "");
-    const candidate = normalized === "coder" ? "coders" : normalized;
-    return ROLE_ENUM.options.includes(candidate)
-        ? candidate
-        : undefined;
-}
-function parseRoleFromRoutingSummary(summary) {
-    const match = summary.match(/\*\*Primary Swarm Agent\(s\):\*\*\s*([^\n]+)/i);
-    if (!match?.[1])
-        return undefined;
-    const firstAgent = match[1]
-        .split(",")
-        .map((entry) => entry.trim())
-        .find(Boolean);
-    return normalizeRoleCandidate(firstAgent);
-}
 function mapRoleToTaskType(role) {
     switch (role) {
         case "vos":
@@ -91,15 +72,25 @@ function extractHandoffId(text) {
     return lineMatch?.[1];
 }
 async function buildOrchestratorSteps(task, sessionId) {
-    const routing = await executeAceInternalTool("route_task", { description: task, domain: "unknown" }, sessionId);
-    const routedRole = parseRoleFromRoutingSummary(extractToolTextContent(routing)) ?? "orchestrator";
-    return [{ role: routedRole, task }];
+    void sessionId;
+    return [{ role: "orchestrator", task }];
 }
 function appendUniqueNote(target, note) {
     if (!target.includes(note)) {
         target.push(note);
     }
 }
+function createToolOnlyBridgeResult(step, reason) {
+    return {
+        bridge_id: `tool-only-${step.step_id}-${Date.now()}`,
+        role: step.role,
+        status: "completed",
+        summary: `Tool-only orchestrator completion for ${step.step_id} (${step.role}): ${step.task}. ${reason}`,
+        turns: 0,
+        tool_calls: [],
+        child_results: [],
+    };
+}
 function buildDefaultOrchestratorAmendment(input) {
     if (input.result.status !== "completed" || input.step.role !== "coders") {
         return undefined;
@@ -566,9 +557,9 @@ export function registerAgentTools(server) {
             ],
         };
     });
-    server.tool("run_local_model", "Offload a governed ACE subtask to a local model bridge and return the result", {
-        task: z.string().describe("Task to execute with the local ACE model bridge"),
-        role: ROLE_ENUM.optional().describe("Optional ACE role; defaults to route_task"),
+    server.tool("run_local_model", "Offload a governed ACE subtask to the provider-backed ACE bridge and return the result", {
+        task: z.string().describe("Task to execute with the ACE model bridge"),
+        role: ROLE_ENUM.optional().describe("Optional ACE role; defaults to orchestrator"),
         max_turns: z
             .number()
             .int()
@@ -582,15 +573,15 @@ export function registerAgentTools(server) {
         provider: z
             .string()
             .optional()
-            .describe("Optional provider override; otherwise discovered from local runtime context"),
+            .describe("Optional provider override; otherwise discovered from workspace/runtime context"),
         model: z
             .string()
             .optional()
-            .describe("Optional model override; otherwise discovered from local runtime context"),
+            .describe("Optional model override; otherwise discovered from workspace/runtime context"),
         base_url: z
             .string()
             .optional()
-            .describe("Optional local runtime base URL override"),
+            .describe("Optional provider base URL override"),
         ollama_url: z
             .string()
             .optional()
@@ -621,7 +612,7 @@ export function registerAgentTools(server) {
                 {
                     type: "text",
                     text: [
-                        "## Local Model Run",
+                        "## Delegated Run",
                         `- role: ${delegated.role}`,
                         `- provider: ${delegated.runtime.provider}`,
                         `- model: ${delegated.runtime.model}`,
@@ -655,7 +646,7 @@ export function registerAgentTools(server) {
             ],
         };
     });
-    server.tool("run_orchestrator", "Execute a supervised plan via model bridge child runs; when steps are omitted, auto-planning falls back to a single route_task-derived step", {
+    server.tool("run_orchestrator", "Execute a supervised plan via model bridge child runs; when steps are omitted, the plan starts with ACE-Orchestrator", {
         task: z.string().describe("The task to decompose and execute"),
         steps: z
             .array(z.object({
@@ -675,7 +666,7 @@ export function registerAgentTools(server) {
                 .describe("Optional ACE tool allowlist for the step"),
         }))
             .optional()
-            .describe("Pre-defined steps; if omitted, the orchestrator derives a single routed step"),
+            .describe("Pre-defined steps; if omitted, the orchestrator starts with a single ACE-Orchestrator step"),
         execution_mode: z
             .enum(["sequential", "scheduled"])
             .optional()
@@ -689,15 +680,15 @@ export function registerAgentTools(server) {
         provider: z
             .string()
             .optional()
-            .describe("Optional provider override; otherwise discovered from local runtime context"),
+            .describe("Optional provider override; otherwise discovered from workspace/runtime context"),
         model: z
             .string()
             .optional()
-            .describe("Optional model override; otherwise discovered from local runtime context"),
+            .describe("Optional model override; otherwise discovered from workspace/runtime context"),
         base_url: z
             .string()
             .optional()
-            .describe("Optional local runtime base URL override"),
+            .describe("Optional provider base URL override"),
         ollama_url: z
             .string()
             .optional()
@@ -707,15 +698,25 @@ export function registerAgentTools(server) {
             .optional()
             .describe("Optional workspace root override; defaults to the active workspace"),
     }, async ({ task, steps, execution_mode, max_turns_per_step, provider, model, base_url, ollama_url, workspace_root }, extra) => {
-        const runtime = resolveLocalModelRuntime({
-            workspaceRoot: workspace_root,
-            provider,
-            model,
-            baseUrl: base_url,
-            ollamaUrl: ollama_url,
-        });
+        let runtime;
+        const runtimeWarnings = [];
+        try {
+            runtime = resolveLocalModelRuntime({
+                workspaceRoot: workspace_root,
+                provider,
+                model,
+                baseUrl: base_url,
+                ollamaUrl: ollama_url,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            appendUniqueNote(runtimeWarnings, `Model bridge runtime unavailable; continuing in tool-only mode. ${message}`);
+        }
+        const effectiveWorkspaceRoot = runtime?.workspaceRoot ??
+            (workspace_root ? resolveRuntimeWorkspaceRoot(workspace_root) : resolveWorkspaceRoot());
         const sessionId = typeof extra?.sessionId === "string" ? extra.sessionId : undefined;
-        const planSource = Array.isArray(steps) && steps.length > 0 ? "explicit_steps" : "route_task_single_step";
+        const planSource = Array.isArray(steps) && steps.length > 0 ? "explicit_steps" : "orchestrator_default_step";
         const planSteps = Array.isArray(steps) && steps.length > 0
             ? steps
             : await buildOrchestratorSteps(task, sessionId);
@@ -724,20 +725,27 @@ export function registerAgentTools(server) {
             steps: planSteps,
             execution_mode: execution_mode ?? "sequential",
         });
-        const bridge = new ModelBridge(createDefaultModelBridgeClients(runtime));
+        const bridge = runtime
+            ? new ModelBridge(createDefaultModelBridgeClients(runtime))
+            : undefined;
         const fallbackHandoffPrefix = `LOCAL-${plan.plan_id}-`;
         const vericifyWarnings = [];
         const supervised = await superviseTaskPlan(plan, {
             async spawnStep(step) {
-                return bridge.spawn({
-                    task: step.task,
-                    role: step.role,
-                    workspace: runtime.workspaceRoot,
-                    maxTurns: max_turns_per_step ?? 6,
-                    provider: runtime.provider,
-                    model: runtime.model,
-                    toolScope: step.tool_scope,
-                });
+                if (bridge && runtime) {
+                    return bridge.spawn({
+                        task: step.task,
+                        role: step.role,
+                        workspace: runtime.workspaceRoot,
+                        maxTurns: max_turns_per_step ?? 6,
+                        provider: runtime.provider,
+                        model: runtime.model,
+                        toolScope: step.tool_scope,
+                    });
+                }
+                const reason = runtimeWarnings[0] ??
+                    "No local model provider/runtime was resolved for model bridge execution.";
+                return createToolOnlyBridgeResult(step, reason);
             },
             async createHandoff({ step, plan: activePlan }) {
                 const created = await executeAceInternalTool("create_handoff", {
@@ -776,13 +784,13 @@ export function registerAgentTools(server) {
             },
             async getVericifyContext() {
                 return tryVericifyPacket(() => getVericifyContextPacket({
-                    workspaceRoot: runtime.workspaceRoot,
+                    workspaceRoot: effectiveWorkspaceRoot,
                 }), (message) => appendUniqueNote(vericifyWarnings, `Vericify context unavailable for ${plan.plan_id}: ${message}`));
             },
             async getVericifyDelta(since) {
                 return tryVericifyPacket(() => getVericifyDelta({
                     since,
-                    workspaceRoot: runtime.workspaceRoot,
+                    workspaceRoot: effectiveWorkspaceRoot,
                 }), (message) => appendUniqueNote(vericifyWarnings, `Vericify delta unavailable for ${plan.plan_id}: ${message}`));
             },
             async openCircuitBreaker(reason) {
@@ -838,10 +846,13 @@ export function registerAgentTools(server) {
                 {
                     type: "text",
                     text: JSON.stringify({
-                        runtime,
+                        runtime: runtime ?? null,
+                        execution_backend: runtime ? "model_bridge" : "tool_only",
+                        runtime_warnings: runtimeWarnings,
+                        workspace_root: effectiveWorkspaceRoot,
                         plan_source: planSource,
-                        planning_note: planSource === "route_task_single_step"
-                            ? "Auto-planning currently falls back to a single route_task-derived step. Pass explicit steps for multi-step orchestration."
+                        planning_note: planSource === "orchestrator_default_step"
+                            ? "Auto-planning currently starts with ACE-Orchestrator. Pass explicit steps for multi-step orchestration."
                             : null,
                         plan: supervised.plan,
                         step_summaries,

package/dist/tools-framework.js

@@ -4,9 +4,9 @@
  */
 import { z } from "zod";
 import { bootstrapStoreWorkspace } from "./store/bootstrap-store.js";
-import { ACE_ROOT_REL, ACE_TASKS_ROOT_REL, ALL_MCP_CLIENTS, ALL_AGENTS, COMPOSABLE_AGENTS, SWARM_AGENTS, SWARM_SUBAGENT_MAP, WORKSPACE_ROOT, classifyPathSource, detectAssetDrift, getAllMcpServerConfigSnippets, getAgentInstructionPath, getAgentManifestPath, getKernelArtifactPath, getMcpClientInstallHint, getMcpServerConfigSnippet, getTaskArtifactPath, isSwarmRole, listAvailableSkills, normalizePathForValidation, safeRead, safeWrite, withFileLock, wsPath, } from "./helpers.js";
+import { ACE_ROOT_REL, ACE_TASKS_ROOT_REL, ALL_MCP_CLIENTS, ALL_LLM_PROVIDERS, ALL_AGENTS, COMPOSABLE_AGENTS, SWARM_AGENTS, SWARM_SUBAGENT_MAP, WORKSPACE_ROOT, classifyPathSource, detectAssetDrift, getAllMcpServerConfigSnippets, getAgentInstructionPath, getAgentManifestPath, getKernelArtifactPath, getMcpClientInstallHint, getMcpServerConfigSnippet, getTaskArtifactPath, isSwarmRole, listAvailableSkills, normalizePathForValidation, resolveWorkspaceRoot, safeRead, safeWrite, withFileLock, wsPath, } from "./helpers.js";
 import { getRoleTitle, MCP_CLIENT_ENUM, scoreDomains, } from "./shared.js";
-import { DEFAULT_LLAMA_CPP_MODEL, DEFAULT_OLLAMA_MODEL, } from "./tui/provider-discovery.js";
+import { defaultModelForProvider, } from "./tui/provider-discovery.js";
 import { refreshAstgrepIndex } from "./astgrep-index.js";
 import { scanWorkspaceDelta } from "./index-store.js";
 import { getOrRefreshKanbanSnapshot } from "./kanban.js";
@@ -20,6 +20,7 @@ import { auditPublicSurface } from "./public-surface.js";
 import { auditStoreAuthority, writeStoreAuthorityAuditReport, } from "./store/store-authority-audit.js";
 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";
 function getArtifactManifestEntries(payload) {
     if (!payload || typeof payload !== "object" || Array.isArray(payload))
         return [];
@@ -38,15 +39,37 @@ function getArtifactManifestEntries(payload) {
     }
     return [];
 }
+function parseGateManifest(raw, sourceRef) {
+    try {
+        const gate = JSON.parse(raw);
+        const id = typeof gate.id === "string" ? gate.id.trim() : "";
+        if (!id)
+            return undefined;
+        const type = gate.type === "executable" || gate.type === "artifact_scan" || gate.type === "manual_review"
+            ? gate.type
+            : "manual_review";
+        return {
+            id,
+            type,
+            invariant: typeof gate.invariant === "string" ? gate.invariant : "",
+            command: typeof gate.command === "string" ? gate.command : "",
+            evidence_requirement: typeof gate.evidence_requirement === "string" ? gate.evidence_requirement : "",
+            source_ref: sourceRef,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 function readGateManifests(gatesDir) {
     const files = readdirSync(gatesDir).filter((f) => f.endsWith(".json"));
     const allGates = [];
     for (const file of files) {
         try {
             const raw = readFileSync(resolve(gatesDir, file), "utf-8");
-            const gate = JSON.parse(raw);
-            if (gate.id)
-                allGates.push(gate);
+            const parsed = parseGateManifest(raw, `agent-state/MODULES/gates/${file}`);
+            if (parsed)
+                allGates.push(parsed);
         }
         catch {
             /* skip corrupt manifests */
@@ -54,6 +77,44 @@ function readGateManifests(gatesDir) {
     }
     return allGates;
 }
+function readStoreGateManifests(workspaceRoot) {
+    const gateKeys = listStoreKeysSync(workspaceRoot, "knowledge/gates/").filter((key) => key.endsWith(".json"));
+    const allGates = [];
+    for (const key of gateKeys) {
+        const raw = readStoreBlobSync(workspaceRoot, key);
+        if (typeof raw !== "string")
+            continue;
+        const parsed = parseGateManifest(raw, key);
+        if (parsed)
+            allGates.push(parsed);
+    }
+    return allGates;
+}
+function resolveGateManifests(gatesDir) {
+    if (existsSync(gatesDir)) {
+        const workspaceGates = readGateManifests(gatesDir);
+        if (workspaceGates.length > 0) {
+            return { gates: workspaceGates, source: "workspace" };
+        }
+    }
+    const storeGates = readStoreGateManifests(resolveWorkspaceRoot());
+    if (storeGates.length > 0) {
+        return { gates: storeGates, source: "store" };
+    }
+    return { gates: [], source: "none" };
+}
+function hasArtifactEvidence(reference) {
+    const normalized = reference.trim();
+    if (!normalized)
+        return false;
+    const candidates = [wsPath("agent-state", normalized), wsPath(normalized)];
+    if (candidates.some((candidate) => existsSync(candidate)))
+        return true;
+    return candidates.some((candidate) => {
+        const content = safeRead(candidate);
+        return !content.startsWith("[FILE NOT FOUND]") && !content.startsWith("[ACCESS DENIED]");
+    });
+}
 function evaluateGateTargets(targets) {
     const results = [];
     for (const gate of targets) {
@@ -97,7 +158,7 @@ function evaluateGateTargets(targets) {
                 }
                 else {
                     for (const artifact of relevantArtifacts) {
-                        if (!existsSync(wsPath("agent-state", artifact))) {
+                        if (!hasArtifactEvidence(artifact)) {
                             missing.push(artifact);
                         }
                     }
@@ -109,11 +170,9 @@ function evaluateGateTargets(targets) {
                     .map((s) => s.trim())
                     .filter(Boolean);
                 for (const ref of evidenceFiles) {
-                    const candidates = [wsPath("agent-state", ref), wsPath(ref)];
-                    const found = candidates.some((candidate) => existsSync(candidate));
-                    if (!found) {
+                    if (!hasArtifactEvidence(ref)) {
                         const asFile = ref.replace(/\s+/g, "_").replace(/[^a-zA-Z0-9_./-]/g, "");
-                        const fileFound = existsSync(wsPath("agent-state", asFile));
+                        const fileFound = hasArtifactEvidence(asFile);
                         if (!fileFound)
                             missing.push(ref);
                     }
@@ -289,7 +348,7 @@ export function registerFrameworkTools(server) {
         }
         const routingMap = {
             venture: {
-                swarm_agents: ["vos"],
+                swarm_agents: ["orchestrator"],
                 subagents: [
                     "astgrep",
                     "research",
@@ -298,11 +357,11 @@ export function registerFrameworkTools(server) {
                     "skeptic",
                     "ops",
                 ],
-                pipeline: "VOS -> UI -> Coders (as needed) with composable Research/Spec/Skeptic/Ops support",
-                prompt: "ace-vos",
+                pipeline: "Orchestrator -> VOS/UI/Coders as needed with composable Research/Spec/Skeptic/Ops support",
+                prompt: "ace-orchestrator",
             },
             ux: {
-                swarm_agents: ["ui"],
+                swarm_agents: ["orchestrator"],
                 subagents: [
                     "astgrep",
                     "research",
@@ -313,11 +372,11 @@ export function registerFrameworkTools(server) {
                     "skeptic",
                     "ops",
                 ],
-                pipeline: "UI -> Coders with composable Spec/Builder/QA and Skeptic/Ops sidecars",
-                prompt: "ace-ui",
+                pipeline: "Orchestrator -> UI/Coders with composable Spec/Builder/QA and Skeptic/Ops sidecars",
+                prompt: "ace-orchestrator",
             },
             engineering: {
-                swarm_agents: ["coders"],
+                swarm_agents: ["orchestrator"],
                 subagents: [
                     "astgrep",
                     "spec",
@@ -331,8 +390,8 @@ export function registerFrameworkTools(server) {
                     "skeptic",
                     "ops",
                 ],
-                pipeline: "Coders with composable Spec -> Builder -> QA -> Docs and Skeptic/Ops guards",
-                prompt: "ace-coders",
+                pipeline: "Orchestrator -> Coders with composable Spec -> Builder -> QA -> Docs and Skeptic/Ops guards",
+                prompt: "ace-orchestrator",
             },
             mixed: {
                 swarm_agents: ["orchestrator"],
@@ -486,7 +545,8 @@ export function registerFrameworkTools(server) {
                         `**Primary Swarm Agent(s):** ${activeRoute.swarm_agents
                             .map((agent) => `ACE-${getRoleTitle(agent)}`)
                             .join(", ")}`,
-                        "**Hierarchy Rule:** Top-level routing stays locked to ACE-Orchestrator, ACE-VOS, ACE-UI, or ACE-Coders. Composable agents are delegated specialists, not peer replacements.",
+                        "**Default Entry Agent:** ACE-Orchestrator",
+                        "**Hierarchy Rule:** Top-level work starts with ACE-Orchestrator. VOS, UI, and Coders are delegated specialists, not peer replacements.",
                         `**Preflight Owner:** ACE-Orchestrator`,
                         `**Task Contract:** ${taskContract.ok ? "aligned" : "attention required"}`,
                         `**Composable Subagents (Universal):** ${[...COMPOSABLE_AGENTS].join(", ")}`,
@@ -523,7 +583,7 @@ export function registerFrameworkTools(server) {
         };
     });
     // ── Bootstrap ─────────────────────────────────────────────────────
-    server.tool("bootstrap_state", "Bootstrap ACE framework files (state, tasks, instructions, skills, scripts, MCP configs, optional local LLM profile)", {
+    server.tool("bootstrap_state", "Bootstrap ACE framework files (state, tasks, instructions, skills, scripts, MCP configs, optional runtime profile)", {
         project_name: z
             .string()
             .optional()
@@ -541,18 +601,28 @@ export function registerFrameworkTools(server) {
             .optional()
             .describe("Write minimal workspace host stubs (AGENTS.md, CLAUDE.md, .cursorrules, .github/copilot-instructions.md)"),
         llm_provider: z
-            .enum(["ollama", "llama.cpp"])
+            .enum(ALL_LLM_PROVIDERS)
+            .optional()
+            .describe("Optional LLM runtime provider to scaffold"),
+        llm_model: z
+            .string()
+            .optional()
+            .describe("Model name for generated runtime profile"),
+        llm_base_url: z
+            .string()
             .optional()
-            .describe("Optional local LLM profile provider to scaffold"),
+            .describe("Runtime base URL for generated provider profile"),
         ollama_model: z
             .string()
             .optional()
-            .describe("Model name for generated local profile (legacy field name kept for compatibility)"),
+            .describe("Legacy alias for llm_model"),
         ollama_base_url: z
             .string()
             .optional()
-            .describe("Local runtime base URL for generated profile (legacy field name kept for compatibility)"),
-    }, async ({ project_name, force, include_mcp_config, include_client_config_bundle, llm_provider, ollama_model, ollama_base_url, }) => {
+            .describe("Legacy alias for llm_base_url"),
+    }, async ({ project_name, force, include_mcp_config, include_client_config_bundle, llm_provider, llm_model, llm_base_url, ollama_model, ollama_base_url, }) => {
+        const resolvedLlmModel = llm_model ?? ollama_model;
+        const resolvedLlmBaseUrl = llm_base_url ?? ollama_base_url;
         // Store-first bootstrap — initializes ace-state.ace, bakes host bundles into store,
         // and optionally materializes minimal workspace stubs.
         const storeResult = await bootstrapStoreWorkspace({
@@ -562,8 +632,8 @@ export function registerFrameworkTools(server) {
             includeMcpConfig: include_mcp_config,
             includeClientConfigBundle: include_client_config_bundle,
             llm: llm_provider ?? undefined,
-            model: ollama_model ?? undefined,
-            ollamaUrl: ollama_base_url ?? undefined,
+            model: resolvedLlmModel ?? undefined,
+            baseUrl: resolvedLlmBaseUrl ?? undefined,
         });
         const astIndex = refreshAstgrepIndex({
             scope: ".",
@@ -601,8 +671,8 @@ export function registerFrameworkTools(server) {
                 materialized: storeResult.materialized.length,
                 force: Boolean(force),
                 llm_provider: llm_provider ?? null,
-                llm_model: ollama_model ?? null,
-                llm_base_url: ollama_base_url ?? null,
+                llm_model: resolvedLlmModel ?? null,
+                llm_base_url: resolvedLlmBaseUrl ?? null,
                 indexed_files: delta.snapshot.file_count,
                 index_truncated: delta.truncated,
                 ast_index_scope: astIndex.scope,
@@ -645,10 +715,13 @@ export function registerFrameworkTools(server) {
                         ...(llm_provider
                             ? [
                                 "",
-                                "## Local LLM Profile",
+                                "## LLM Runtime Profile",
                                 `- provider: ${llm_provider}`,
-                                `- model: ${ollama_model ?? (llm_provider === "llama.cpp" ? DEFAULT_LLAMA_CPP_MODEL : DEFAULT_OLLAMA_MODEL)}`,
-                                `- base_url: ${ollama_base_url ?? "discover via ace doctor --scan or set explicitly"}`,
+                                `- model: ${resolvedLlmModel ?? defaultModelForProvider(llm_provider)}`,
+                                `- base_url: ${resolvedLlmBaseUrl ??
+                                    (llm_provider === "ollama" || llm_provider === "llama.cpp"
+                                        ? "discover via ace doctor --scan or set explicitly"
+                                        : "optional; use provider defaults or set explicitly")}`,
                                 `- profile_path: ${storeResult.storePath}#state/runtime/llm_profile`,
                                 `- doctor_path: ${storeResult.storePath}#state/runtime/doctor_checks.md`,
                             ]
@@ -1335,31 +1408,27 @@ export function registerFrameworkTools(server) {
             .describe("Optional short focus string persisted with skeptic adversarial review evidence."),
     }, async ({ gate_ids, review_mode, review_focus }) => {
         const gatesDir = wsPath("agent-state", "MODULES", "gates");
-        if (!existsSync(gatesDir)) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "❌ Gates directory not found: agent-state/MODULES/gates/",
-                    },
-                ],
-            };
-        }
-        const allGates = readGateManifests(gatesDir);
+        const resolved = resolveGateManifests(gatesDir);
+        const allGates = resolved.gates;
+        const gateEvidenceRef = resolved.source === "store" ? "knowledge/gates/*" : "agent-state/MODULES/gates/";
         // Filter to requested gates (or run all)
         const targets = gate_ids
             ? allGates.filter((g) => gate_ids.includes(g.id))
             : allGates;
         if (targets.length === 0) {
+            const noGateMessage = allGates.length === 0
+                ? "❌ No gate manifests found in agent-state/MODULES/gates/ or ace-state.ace knowledge/gates/*."
+                : `❌ No matching gates found. Available: ${allGates.map((g) => g.id).join(", ")}`;
             return {
                 content: [
                     {
                         type: "text",
-                        text: `❌ No matching gates found. Available: ${allGates.map((g) => g.id).join(", ")}`,
+                        text: noGateMessage,
                     },
                 ],
             };
         }
+        const gateArtifactRefs = targets.map((gate) => gate.source_ref ?? gateEvidenceRef);
         const results = evaluateGateTargets(targets);
         const passed = results.filter((r) => r.ok).length;
         const failed = results.filter((r) => !r.ok).length;
@@ -1387,7 +1456,8 @@ export function registerFrameworkTools(server) {
                 })),
                 passed,
                 failed,
-                evidence_ref: evidence?.evidenceRef ?? "agent-state/MODULES/gates/",
+                evidence_ref: evidence?.evidenceRef ?? gateEvidenceRef,
+                gate_manifest_source: resolved.source,
                 ...(review
                     ? {
                         review: {
@@ -1414,13 +1484,14 @@ export function registerFrameworkTools(server) {
                 ? `Gate execution with skeptic review: ${review.summary.confirmed_count} confirmed findings`
                 : `Gate execution: ${passed}/${results.length} passed`,
             artifacts: [
-                ...results.map((r) => `agent-state/MODULES/gates/${r.id}.json`),
+                ...gateArtifactRefs,
                 ...(evidence ? ["agent-state/EVIDENCE_LOG.md"] : []),
             ],
             metadata: {
                 passed,
                 failed,
                 gate_ids: results.map((r) => r.id),
+                gate_manifest_source: resolved.source,
                 ...(review
                     ? {
                         review_mode: review.mode,
@@ -1446,6 +1517,9 @@ export function registerFrameworkTools(server) {
                             : allOk
                                 ? `✅ All gates passed: ${passed}/${results.length}`
                                 : `❌ Gate failures: ${failed}/${results.length} failed`,
+                        `Gate manifest source: ${resolved.source === "store"
+                            ? "ace-state.ace (knowledge/gates/*)"
+                            : "agent-state/MODULES/gates/"}`,
                         `Run ledger: ${ledger.path} (${ledger.entry.id})`,
                         ...(evidence ? [`Evidence: ${evidence.path} (${evidence.evidenceRef})`] : []),
                         "",

package/dist/tui/index.js

@@ -17,7 +17,7 @@ import { OpenAICompatibleClient, diagnoseChatRuntimeConfig, } from "./openai-com
 import { detectColorLevel, write, cursor, screen, fg, style } from "./renderer.js";
 import { ALL_AGENTS, WORKSPACE_ROOT } from "../helpers.js";
 import { backfillHandoffsIntoScheduler } from "../tools-handoff.js";
-import { DEFAULT_OLLAMA_MODEL, inferProviderFromModel, normalizeLocalBaseUrl, } from "./provider-discovery.js";
+import { DEFAULT_OLLAMA_MODEL, defaultModelForProvider, inferProviderFromModel, normalizeLocalBaseUrl, } 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"];
@@ -56,7 +56,7 @@ export class AceTui {
         const workspaceRoot = options.workspaceRoot ?? WORKSPACE_ROOT;
         this.workspaceRoot = workspaceRoot;
         this.provider = this.normalizeProvider(options.provider ?? inferProviderFromModel(options.model) ?? "ollama") ?? "ollama";
-        this.model = (options.model ?? DEFAULT_OLLAMA_MODEL).trim();
+        this.model = (options.model ?? defaultModelForProvider(this.provider)).trim();
         // Initialize modules
         const colorLevel = detectColorLevel();
         for (const [provider, baseUrl] of Object.entries(options.providerBaseUrls ?? {})) {
@@ -758,7 +758,7 @@ export class AceTui {
             this.model = DEFAULT_OLLAMA_MODEL;
         }
         else {
-            this.model = `${this.provider}/default`;
+            this.model = defaultModelForProvider(this.provider);
         }
         this.config.set("model", this.model);
         this.telemetry.setModel(this.model);