@voybio/ace-swarm 0.2.5 → 2.4.1

package/dist/astgrep-index.js

@@ -1,8 +1,144 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { isAbsolute, relative, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
-import { appendStatusEvent } from "./status-events.js";
+import { appendStatusEventSafe } from "./status-events.js";
 import { safeRead, safeWrite, WORKSPACE_ROOT, wsPath } from "./helpers.js";
+export function runAstgrepQuery(pattern, lang, roots, _contextLines) {
+    const cmd = detectAstgrepCommand();
+    const raw = runAstgrep(cmd, pattern, lang, roots);
+    return raw.slice(0, 200).map((m) => ({
+        file: m.file ?? "",
+        line: m.range?.start?.line ?? 0,
+        column: m.range?.start?.column ?? 0,
+        text: m.text ?? "",
+        context_lines: [],
+    }));
+}
+function hashTextContent(content) {
+    return `sha256:${createHash("sha256").update(content, "utf8").digest("hex")}`;
+}
+function textPreview(text, maxChars = 160) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxChars)
+        return normalized;
+    return `${normalized.slice(0, Math.max(0, maxChars - 1)).trimEnd()}…`;
+}
+function nodeKindForMatch(match) {
+    if (typeof match.nodeKind === "string" && match.nodeKind.length > 0)
+        return match.nodeKind;
+    if (typeof match.kind === "string" && match.kind.length > 0)
+        return match.kind;
+    return undefined;
+}
+function captureMapForMatch(match) {
+    if (!match.metaVariables)
+        return undefined;
+    const captures = Object.entries(match.metaVariables).reduce((acc, [key]) => {
+        const text = extractMetaVarText(match, key);
+        if (typeof text === "string" && text.length > 0)
+            acc[key] = text;
+        return acc;
+    }, {});
+    return Object.keys(captures).length > 0 ? captures : undefined;
+}
+function computeMatchId(input) {
+    const encoded = [
+        input.file,
+        input.range.start?.line ?? 0,
+        input.range.start?.column ?? 0,
+        input.range.end?.line ?? 0,
+        input.range.end?.column ?? 0,
+        input.file_hash,
+        input.pattern,
+        input.lang,
+        input.matched_text,
+    ].join("|");
+    return `match_${createHash("sha256").update(encoded, "utf8").digest("hex").slice(0, 16)}`;
+}
+function matchUsesSymbolHint(match, symbolHint) {
+    if ((match.text ?? "").includes(symbolHint))
+        return true;
+    if (!match.metaVariables)
+        return false;
+    return Object.keys(match.metaVariables).some((key) => {
+        const text = extractMetaVarText(match, key);
+        return typeof text === "string" && text.includes(symbolHint);
+    });
+}
+export function locateAstgrepMatches(input) {
+    const scope = resolveScope(input.scope ?? "src");
+    const astgrepCmd = detectAstgrepCommand();
+    if (!astgrepCmd) {
+        return {
+            ok: false,
+            pattern: input.pattern,
+            lang: input.lang,
+            scope: scope.rel,
+            symbol_hint: input.symbol_hint,
+            astgrep_command: null,
+            total_matches: 0,
+            matches: [],
+            error: "ast-grep command not available",
+        };
+    }
+    const rawMatches = runAstgrep(astgrepCmd, input.pattern, input.lang, [scope.abs]);
+    const effectiveMatches = input.symbol_hint && input.symbol_hint.trim().length > 0
+        ? (() => {
+            const hinted = rawMatches.filter((match) => matchUsesSymbolHint(match, input.symbol_hint));
+            return hinted.length > 0 ? hinted : rawMatches;
+        })()
+        : rawMatches;
+    const limit = input.max_results ?? 50;
+    const matches = effectiveMatches.slice(0, limit).flatMap((match) => {
+        const absFile = typeof match.file === "string" && match.file.length > 0
+            ? (isAbsolute(match.file) ? match.file : resolve(WORKSPACE_ROOT, match.file))
+            : undefined;
+        if (!absFile || !isInside(WORKSPACE_ROOT, absFile) || !match.range)
+            return [];
+        const matchedText = match.text ?? "";
+        const fileContent = safeReadText(absFile);
+        const fileHash = hashTextContent(fileContent);
+        const file = normalizeHitPath(relative(WORKSPACE_ROOT, absFile));
+        const range = {
+            start: {
+                line: match.range.start?.line ?? 0,
+                column: match.range.start?.column ?? 0,
+            },
+            end: {
+                line: match.range.end?.line ?? 0,
+                column: match.range.end?.column ?? 0,
+            },
+        };
+        return [{
+                match_id: computeMatchId({
+                    file,
+                    range,
+                    matched_text: matchedText,
+                    file_hash: fileHash,
+                    pattern: input.pattern,
+                    lang: input.lang,
+                }),
+                file,
+                range,
+                text_preview: textPreview(matchedText),
+                matched_text: matchedText,
+                captures: captureMapForMatch(match),
+                node_kind: nodeKindForMatch(match),
+                file_hash: fileHash,
+            }];
+    });
+    return {
+        ok: true,
+        pattern: input.pattern,
+        lang: input.lang,
+        scope: scope.rel,
+        symbol_hint: input.symbol_hint,
+        astgrep_command: astgrepCmd,
+        total_matches: effectiveMatches.length,
+        matches,
+    };
+}
 const CODE_EXTENSIONS = new Set(["ts", "tsx", "js", "mjs", "cjs", "py", "rs", "go"]);
 const EXCLUDE_DIRS = new Set([
     ".git",
@@ -28,7 +164,7 @@ function resolveScope(scope) {
     }
     return { abs, rel: rel || "." };
 }
-function detectAstgrepCommand() {
+export function detectAstgrepCommand() {
     for (const cmd of ["ast-grep", "sg"]) {
         const probe = spawnSync(cmd, ["--version"], { encoding: "utf8" });
         if (probe.status === 0)
@@ -180,7 +316,7 @@ function appendEvidenceLine(timestamp, astgrepCmd, stats) {
     ].join("\n");
     safeWrite("agent-state/EVIDENCE_LOG.md", `${seed}${entry}\n`);
 }
-export function refreshAstgrepIndex(input = {}) {
+export async function refreshAstgrepIndex(input = {}) {
     const generatedAt = new Date().toISOString();
     const scope = resolveScope(input.scope);
     const appendEvidence = input.append_evidence ?? true;
@@ -440,7 +576,7 @@ export function refreshAstgrepIndex(input = {}) {
     if (emitEvent) {
         const status = astgrepCmd ? "pass" : "blocked";
         const eventType = astgrepCmd ? "DISCOVERY_INDEX_READY" : "DISCOVERY_SCOPE_BLOCKED";
-        const event = appendStatusEvent({
+        const event = await appendStatusEventSafe({
             source_module: "capability-astgrep",
             event_type: eventType,
             status,

package/dist/cli.js

@@ -1,20 +1,22 @@
 #!/usr/bin/env node
-import { ACE_ROOT_REL, ACE_TASKS_ROOT_REL, ALL_MCP_CLIENTS, ALL_LLM_PROVIDERS, DEFAULTS_ROOT, PACKAGE_ROOT, WORKSPACE_ROOT, fileExists, getAllMcpServerConfigSnippets, getMcpClientInstallHint, getMcpServerConfigSnippet, wsPath, } from "./helpers.js";
+import { ACE_TASKS_ROOT_REL, ALL_MCP_CLIENTS, ALL_LLM_PROVIDERS, DEFAULTS_ROOT, PACKAGE_ROOT, WORKSPACE_ROOT, fileExists, getAllMcpServerConfigSnippets, getMcpClientInstallHint, getMcpServerConfigSnippet, wsPath, } from "./helpers.js";
 import { refreshAstgrepIndex } from "./astgrep-index.js";
 import { scanWorkspaceDelta } from "./index-store.js";
 import { startStdioServer } from "./server.js";
 import { appendRunLedgerEntrySafe } from "./run-ledger.js";
-import { waitForPendingStatusEventMirrors } from "./status-events.js";
+import { appendStatusEventSafe, waitForPendingStatusEventMirrors } from "./status-events.js";
 import { bootstrapStoreWorkspace } from "./store/bootstrap-store.js";
 import { HostFileMaterializer } from "./store/materializers/host-file-materializer.js";
 import { openStore } from "./store/ace-packed-store.js";
-import { withStoreWriteQueue } from "./store/write-queue.js";
 import { DiscoveryRepository } from "./store/repositories/discovery-repository.js";
+import { withStoreWriteCoordinator } from "./store/write-coordinator.js";
 import { getWorkspaceStorePath, readStoreBlobSync, readStoreJsonSync, } from "./store/store-snapshot.js";
+import { ensureCanonicalWorkspaceStore } from "./store/workspace-store-paths.js";
 import { readFileSync } from "node:fs";
 import { runTui } from "./tui/index.js";
-import { buildOpenAiCompatibleBaseUrl, buildProviderDoctorCommands, defaultModelForProvider, discoverProviderContext, isLocalLlmProvider, normalizeLocalBaseUrl, normalizeProvider, scanLocalModelRuntimes, } from "./tui/provider-discovery.js";
+import { buildOpenAiCompatibleBaseUrl, buildProviderDoctorCommands, defaultModelForProvider, discoverProviderContext, isLocalLlmProvider, normalizeLocalBaseUrl, normalizeLlamaCppHfModelName, normalizeProvider, scanLocalModelRuntimes, } from "./tui/provider-discovery.js";
 import { diagnoseChatRuntimeConfig, OpenAICompatibleClient, } from "./tui/openai-compatible.js";
+import { runShellCommand } from "./runtime-command.js";
 function printHelp() {
     console.log(`ACE Swarm CLI
 
@@ -23,6 +25,7 @@ Usage:
   ace serve                    Alias for mcp
   ace tui [options]            Launch interactive TUI dashboard
   ace init [options]           Bootstrap the ACE store into current workspace
+  ace connect [provider]       Register a live local runtime or hosted provider in the store
   ace turnkey [options]        Project minimal workspace bootstrap stubs from the ACE store
   ace doctor [options]         Validate ACE runtime + MCP readiness
   ace cache [options]          Cache ACE artifacts into ace-state.ace and optionally clean projections
@@ -38,7 +41,7 @@ Options for tui:
   --ollama-url <url>           Legacy alias for --base-url
 
 Options for init:
-  --project <name>             Project name stored in ${ACE_ROOT_REL}/ace-state.ace metadata
+  --project <name>             Project name stored in agent-state/ace-state.ace metadata
   --force                      Overwrite scaffolded files if they already exist
   --mcp-config                 Also write .vscode/mcp.json workspace bridge
   --client-config-bundle       Also write minimal workspace host stubs (AGENTS.md, CLAUDE.md, .cursorrules, .github/copilot-instructions.md)
@@ -47,23 +50,32 @@ Options for init:
   --base-url <url>             Runtime base URL override (local or OpenAI-compatible)
   --ollama-url <url>           Legacy alias for --base-url
 
+Options for connect:
+  llama-server|llama-cli       Optional launcher name for llama.cpp HF runtimes
+  --hf <repo>                  Hugging Face model repo or local model identifier
+  --model <name>               Alias for --hf when you already know the model name
+  --base-url <url>             OpenAI-compatible endpoint for the live runtime
+  --provider <name>            Explicit provider override when not using a launcher alias
+
 Options for doctor:
-  --llm <provider>             ollama|llama.cpp|codex|claude|gemini|copilot|... (default: auto from ${ACE_ROOT_REL}/ace-state.ace)
+  --llm <provider>             ollama|llama.cpp|codex|claude|gemini|copilot|... (default: auto from agent-state/ace-state.ace)
   --model <name>               Model name override
   --base-url <url>             Runtime base URL override
   --ollama-url <url>           Legacy alias for --base-url
   --scan                       Probe common local Ollama + llama.cpp endpoints when URL is unset
+  --repair-ollama              Opt-in: run ollama pull <model> when doctor finds a missing Ollama model
 
 Options for cache:
   --dry-run                    Preview what would be cached and cleaned (no writes/deletes)
   --no-clean                   Keep workspace ACE artifacts after caching them into ace-state.ace
 
 Options for mcp-config:
-  --client <name>              codex|vscode|claude|cursor|antigravity
+  --client <name>              codex|vscode|copilot|claude|cursor|antigravity
   --all                        Print all client snippets for optional global install
 
 preconfig writes .mcp-config/ at the workspace root with ready-to-use config files for every
-supported MCP client. Run once after ace init. Each file includes the install hint for its client.
+supported MCP client plus a root .mcp.json for GitHub Copilot CLI. Run once after ace init.
+Each file includes the install hint for its client.
 `);
 }
 function readFlagValue(args, flag) {
@@ -96,6 +108,29 @@ function readLlmProfile() {
 function readBaseUrlFlag(args) {
     return normalizeLocalBaseUrl(readFlagValue(args, "--base-url") ?? readFlagValue(args, "--ollama-url"));
 }
+function readConnectModelFlag(args) {
+    return (readFlagValue(args, "--hf") ??
+        readFlagValue(args, "-hf") ??
+        readFlagValue(args, "--model"))?.trim();
+}
+function parseConnectArgs(args) {
+    const firstToken = args[0];
+    const hasLauncher = Boolean(firstToken && !firstToken.startsWith("-"));
+    const launcher = hasLauncher ? firstToken?.trim().toLowerCase() : undefined;
+    const providerOverride = normalizeProvider(readFlagValue(args, "--provider")?.trim());
+    const provider = providerOverride ??
+        (launcher === "llama-server" || launcher === "llama-cli" ? "llama.cpp" : providerOverride);
+    const rawModel = readConnectModelFlag(args);
+    const model = provider === "llama.cpp" ? normalizeLlamaCppHfModelName(rawModel) ?? rawModel : rawModel;
+    const baseUrl = readBaseUrlFlag(args);
+    const launcherCommand = hasLauncher ? args.join(" ").trim() : undefined;
+    return {
+        provider: provider,
+        model,
+        baseUrl,
+        launcherCommand,
+    };
+}
 function parseLlmOptions(args) {
     const profile = readLlmProfile();
     const selected = normalizeProvider(readFlagValue(args, "--llm")?.trim() ?? profile?.provider?.trim());
@@ -105,8 +140,11 @@ function parseLlmOptions(args) {
         throw new Error(`Unsupported LLM provider: ${selected}`);
     }
     const provider = selected;
-    const defaultModel = defaultModelForProvider(provider);
-    const llmModel = readFlagValue(args, "--model")?.trim() || profile?.model || defaultModel;
+    const explicitModel = readFlagValue(args, "--model")?.trim();
+    const profileModel = profile?.model?.trim();
+    const llmModel = explicitModel ||
+        profileModel ||
+        (provider === "ollama" ? defaultModelForProvider(provider) : undefined);
     const llmBaseUrl = readBaseUrlFlag(args) ?? normalizeLocalBaseUrl(profile?.base_url);
     return {
         llmProvider: provider,
@@ -116,12 +154,14 @@ function parseLlmOptions(args) {
 }
 async function writeLlmProfile(profile) {
     const storePath = getWorkspaceStorePath(WORKSPACE_ROOT);
-    await withStoreWriteQueue(storePath, async () => {
+    await withStoreWriteCoordinator(storePath, async () => {
         const payload = {
             provider: profile.provider,
-            model: profile.model,
             generated_at: new Date().toISOString(),
         };
+        if (profile.model) {
+            payload.model = profile.model;
+        }
         if (profile.baseUrl) {
             payload.base_url = profile.baseUrl;
             if (profile.provider === "ollama") {
@@ -129,6 +169,9 @@ async function writeLlmProfile(profile) {
                 payload.default_api_key = "ollama";
             }
         }
+        if (profile.launcherCommand) {
+            payload.launch_command = profile.launcherCommand;
+        }
         const doctorCommands = buildProviderDoctorCommands(profile.provider, profile.model, profile.baseUrl);
         const store = await openStore(storePath);
         try {
@@ -148,12 +191,46 @@ async function writeLlmProfile(profile) {
         finally {
             await store.close();
         }
-    });
+    }, { operation_label: "writeLlmProfile" });
     return `${storePath}#state/runtime/llm_profile`;
 }
+async function runConnect(args) {
+    const parsed = parseConnectArgs(args);
+    if (!parsed.provider) {
+        throw new Error("ace connect expects a provider or launcher command. Try `ace connect llama-server -hf <model> --base-url http://127.0.0.1:8080`.");
+    }
+    if (!ALL_LLM_PROVIDERS.includes(parsed.provider)) {
+        throw new Error(`Unsupported LLM provider: ${parsed.provider}`);
+    }
+    if (isLocalLlmProvider(parsed.provider) && !parsed.model) {
+        throw new Error("ace connect for local runtimes requires an explicit model. Pass `--hf <repo>` or `--model <name>`.");
+    }
+    const storeResult = await bootstrapStoreWorkspace({
+        workspaceRoot: WORKSPACE_ROOT,
+        llm: parsed.provider,
+        model: parsed.model,
+        baseUrl: parsed.baseUrl,
+        includeMcpConfig: false,
+        includeClientConfigBundle: false,
+        launcherCommand: parsed.launcherCommand,
+    });
+    console.log("ACE connect complete");
+    console.log(`Workspace: ${WORKSPACE_ROOT}`);
+    console.log(`Store: ${storeResult.storePath}`);
+    console.log(`Provider: ${parsed.provider}`);
+    console.log(`Model: ${parsed.model ?? "(not set)"}`);
+    console.log(`Base URL: ${parsed.baseUrl ?? "(not set)"}`);
+    if (parsed.launcherCommand) {
+        console.log(`Launcher: ${parsed.launcherCommand}`);
+    }
+    console.log(`Profile path: ${storeResult.storePath}#state/runtime/llm_profile`);
+    for (const warning of storeResult.warnings) {
+        console.warn(`  [store] ${warning}`);
+    }
+}
 async function recordDiscoveryProfile(input) {
     const storePath = getWorkspaceStorePath(WORKSPACE_ROOT);
-    await withStoreWriteQueue(storePath, async () => {
+    await withStoreWriteCoordinator(storePath, async () => {
         const store = await openStore(storePath);
         try {
             const discovery = new DiscoveryRepository(store);
@@ -176,7 +253,7 @@ async function recordDiscoveryProfile(input) {
         finally {
             await store.close();
         }
-    });
+    }, { operation_label: "recordDiscoveryProfile" });
 }
 async function runInit(args, mode = "init") {
     const projectName = readFlagValue(args, "--project");
@@ -197,7 +274,7 @@ async function runInit(args, mode = "init") {
         model: llm.llmModel ?? undefined,
         baseUrl: llm.llmBaseUrl ?? undefined,
     });
-    const astIndex = refreshAstgrepIndex({
+    const astIndex = await refreshAstgrepIndex({
         scope: ".",
         append_evidence: true,
         emit_event: true,
@@ -253,7 +330,7 @@ async function runInit(args, mode = "init") {
             message: `ace ${mode} completed: ${storeResult.materialized.length} bootstrap files materialized`,
             artifacts: [
                 `${ACE_TASKS_ROOT_REL}/`,
-                `${ACE_ROOT_REL}/ace-state.ace`,
+                storeResult.storePath,
                 delta.index_path,
                 astIndex.output_json_path,
             ],
@@ -294,6 +371,13 @@ async function listLocalRuntimeModels(provider, baseUrl) {
             headers: { Accept: "application/json" },
         });
         if (!response.ok) {
+            const text = await response.text().catch(() => "");
+            if (response.status >= 500 && /unable to load model/i.test(text)) {
+                const error = new Error(`${response.status} ${response.statusText}: ollama_model_load_error. ` +
+                    `Suggested remediation: run ollama pull <model> or ace doctor --repair-ollama.`);
+                error.reason_code = "ollama_model_load_error";
+                throw error;
+            }
             throw new Error(`${response.status} ${response.statusText}`);
         }
         const payload = (await response.json().catch(() => ({})));
@@ -319,6 +403,7 @@ async function listLocalRuntimeModels(provider, baseUrl) {
 }
 async function runDoctor(args) {
     const llm = parseLlmOptions(args);
+    const repairOllama = args.includes("--repair-ollama");
     const checks = [];
     const mcpConfigPaths = [wsPath(".vscode", "mcp.json")];
     const hasWorkspaceMcpConfig = mcpConfigPaths.some((path) => fileExists(path));
@@ -340,12 +425,14 @@ async function runDoctor(args) {
         ok: hasProfile,
         detail: hasProfile
             ? profilePath
-            : `Missing ${ACE_ROOT_REL}/ace-state.ace#state/runtime/llm_profile. Run \`ace init --llm <provider>\` or \`ace doctor --scan\` for a local runtime.`,
+            : `Missing agent-state/ace-state.ace#state/runtime/llm_profile. Run \`ace init --llm <provider>\` or \`ace doctor --scan\` for a local runtime.`,
     });
     let provider = llm.llmProvider;
     let model = llm.llmModel;
     let baseUrl = llm.llmBaseUrl;
-    const shouldScan = args.includes("--scan") || (!provider && !baseUrl) || (isLocalLlmProvider(provider) && !baseUrl);
+    const shouldScan = args.includes("--scan") ||
+        (!provider && !baseUrl) ||
+        (isLocalLlmProvider(provider) && (!baseUrl || !model));
     if (shouldScan) {
         const scanned = await scanLocalModelRuntimes({
             workspaceRoot: WORKSPACE_ROOT,
@@ -357,7 +444,7 @@ async function runDoctor(args) {
         if (chosen) {
             provider = chosen.provider ?? provider;
             baseUrl = baseUrl ?? chosen.baseUrl;
-            model = model || chosen.models[0] || defaultModelForProvider(provider);
+            model = model || chosen.models[0];
             checks.push({
                 name: "Runtime endpoint discovered",
                 ok: true,
@@ -365,7 +452,7 @@ async function runDoctor(args) {
             });
             const writtenProfilePath = await writeLlmProfile({
                 provider: provider ?? chosen.provider,
-                model: model ?? defaultModelForProvider(provider ?? chosen.provider),
+                model,
                 baseUrl,
             });
             checks.push({
@@ -383,9 +470,33 @@ async function runDoctor(args) {
         }
     }
     if (!provider) {
-        throw new Error(`No runtime provider configured. Use --llm <provider>, bootstrap one into ${ACE_ROOT_REL}/ace-state.ace#state/runtime/llm_profile, or run \`ace doctor --scan\` for a local runtime.`);
+        throw new Error(`No runtime provider configured. Use --llm <provider>, bootstrap one into agent-state/ace-state.ace#state/runtime/llm_profile, or run \`ace doctor --scan\` for a local runtime.`);
     }
     if (!model) {
+        if (isLocalLlmProvider(provider)) {
+            checks.push({
+                name: "Runtime model configured",
+                ok: false,
+                detail: "No local runtime model is configured yet. Run `ace connect` with a user-supplied HF model or run `ace doctor --scan` after the runtime is up.",
+            });
+            const failed = checks.filter((check) => !check.ok);
+            console.log("ACE Doctor Report");
+            console.log(`Workspace: ${WORKSPACE_ROOT}`);
+            console.log(`Provider: ${provider}`);
+            console.log("Model: (not set)");
+            if (baseUrl) {
+                console.log(`Base URL: ${baseUrl}`);
+            }
+            console.log("");
+            for (const check of checks) {
+                const status = check.ok ? "PASS" : "FAIL";
+                console.log(`- [${status}] ${check.name}: ${check.detail}`);
+            }
+            if (failed.length > 0) {
+                process.exitCode = 1;
+            }
+            return;
+        }
         model = defaultModelForProvider(provider);
     }
     if (isLocalLlmProvider(provider) && !baseUrl) {
@@ -423,6 +534,23 @@ async function runDoctor(args) {
             });
         }
         catch (error) {
+            const reasonCode = typeof error === "object" && error !== null && "reason_code" in error
+                ? String(error.reason_code)
+                : undefined;
+            if (reasonCode === "ollama_model_load_error") {
+                await appendStatusEventSafe({
+                    source_module: "capability-ops",
+                    event_type: "OLLAMA_MODEL_LOAD_ERROR",
+                    status: "blocked",
+                    summary: `Ollama model-load error for ${model}: ${error instanceof Error ? error.message : String(error)}`,
+                    objective_id: "ollama-doctor",
+                    payload: {
+                        reason_code: "ollama_model_load_error",
+                        model,
+                        base_url: baseUrl,
+                    },
+                }).catch(() => undefined);
+            }
             checks.push({
                 name: "Runtime endpoint reachable",
                 ok: false,
@@ -448,6 +576,44 @@ async function runDoctor(args) {
                     ? `${model} found`
                     : `${model} not reported by llama.cpp (available: ${modelNames.join(", ") || "none"})`,
         });
+        if (provider === "ollama" && !hasModel && repairOllama) {
+            const repair = await runShellCommand(`ollama pull ${model}`, {
+                cwd: WORKSPACE_ROOT,
+                timeout_ms: 10 * 60_000,
+            });
+            await appendRunLedgerEntrySafe({
+                tool: "doctor",
+                category: repair.exit_code === 0 ? "info" : "regression",
+                message: `Opt-in Ollama repair attempted for ${model}`,
+                artifacts: [],
+                metadata: {
+                    reason_code: "ollama_model_load_error",
+                    model,
+                    exit_code: repair.exit_code,
+                    timed_out: repair.timed_out,
+                },
+            }).catch(() => undefined);
+            await appendStatusEventSafe({
+                source_module: "capability-ops",
+                event_type: "OLLAMA_REPAIR_ATTEMPTED",
+                status: repair.exit_code === 0 ? "done" : "fail",
+                summary: `Opt-in Ollama repair attempted for ${model}`,
+                objective_id: "ollama-doctor",
+                payload: {
+                    reason_code: "ollama_model_load_error",
+                    model,
+                    exit_code: repair.exit_code,
+                    timed_out: repair.timed_out,
+                },
+            }).catch(() => undefined);
+            checks.push({
+                name: "Ollama model repair attempted",
+                ok: repair.exit_code === 0,
+                detail: repair.exit_code === 0
+                    ? `ollama pull ${model} completed`
+                    : `ollama pull ${model} failed with exit ${repair.exit_code}: ${repair.stderr || repair.stdout || "no output"}`,
+            });
+        }
     }
     else {
         const diagnosis = diagnoseChatRuntimeConfig(provider, model, baseUrl ? { baseUrl } : undefined);
@@ -520,16 +686,21 @@ function parseClientFlag(args) {
     return match;
 }
 async function runPreconfig() {
-    const storePath = wsPath(".agents", "ACE", "ace-state.ace");
-    if (!fileExists(storePath)) {
-        console.error(`No ACE store found at ${storePath}. Run 'ace init' first.`);
+    const resolved = await ensureCanonicalWorkspaceStore(WORKSPACE_ROOT, {
+        operationLabel: "runPreconfig",
+    });
+    if (resolved.mode === "missing") {
+        console.error(`No ACE store found. Expected canonical ${resolved.canonicalPath}; legacy fallback ${resolved.legacyPath} was also not found. Run 'ace init' first.`);
         process.exit(1);
     }
-    const store = await openStore(storePath);
+    for (const w of resolved.warnings) {
+        console.warn(`[preconfig] ${w}`);
+    }
+    const store = await openStore(resolved.storePath);
     try {
         const mat = new HostFileMaterializer(store, WORKSPACE_ROOT);
         const written = await mat.materializeMcpBundle();
-        console.log(`ACE preconfig complete — wrote ${written.length} files to .mcp-config/\n`);
+        console.log(`ACE preconfig complete — wrote ${written.length} files to .mcp-config/ and root .mcp.json\n`);
         for (const p of written) {
             console.log(`  ${p}`);
         }
@@ -581,14 +752,36 @@ async function main() {
             cliModel,
             cliBaseUrl,
         });
+        const needsLocalScan = isLocalLlmProvider(discovered.provider) &&
+            (!discovered.baseUrl || !discovered.model || discovered.model === defaultModelForProvider(discovered.provider));
+        const runtime = needsLocalScan
+            ? await scanLocalModelRuntimes({
+                workspaceRoot: WORKSPACE_ROOT,
+                preferredProvider: discovered.provider,
+                explicitBaseUrl: discovered.baseUrl,
+            })
+            : undefined;
+        const scanned = runtime?.candidates.find((candidate) => candidate.provider === discovered.provider) ??
+            runtime?.candidates[0];
+        const resolvedTui = scanned?.models[0]
+            ? {
+                ...discovered,
+                model: scanned.models[0],
+                baseUrl: discovered.baseUrl ?? scanned.baseUrl,
+                providerBaseUrls: {
+                    ...discovered.providerBaseUrls,
+                    [scanned.provider]: discovered.baseUrl ?? scanned.baseUrl,
+                },
+            }
+            : discovered;
         await runTui({
-            provider: discovered.provider,
-            model: discovered.model,
-            providers: discovered.providers,
-            modelsByProvider: discovered.modelsByProvider,
-            baseUrl: discovered.baseUrl,
-            ollamaUrl: discovered.ollamaUrl,
-            providerBaseUrls: discovered.providerBaseUrls,
+            provider: resolvedTui.provider,
+            model: resolvedTui.model,
+            providers: resolvedTui.providers,
+            modelsByProvider: resolvedTui.modelsByProvider,
+            baseUrl: resolvedTui.baseUrl,
+            ollamaUrl: resolvedTui.ollamaUrl,
+            providerBaseUrls: resolvedTui.providerBaseUrls,
             workspaceRoot: WORKSPACE_ROOT,
         });
         return;
@@ -597,6 +790,10 @@ async function main() {
         await runInit(args.slice(1), "init");
         return;
     }
+    if (command === "connect") {
+        await runConnect(args.slice(1));
+        return;
+    }
     if (command === "turnkey") {
         await runInit(args.slice(1), "turnkey");
         return;
@@ -649,7 +846,7 @@ async function main() {
     }
     if (command === "migrate") {
         const { importFromFileWorkspace } = await import("./store/importer.js");
-        const storePath = args[1] ?? `${WORKSPACE_ROOT}/.agents/ACE/ace-state.ace`;
+        const storePath = args[1] ?? getWorkspaceStorePath(WORKSPACE_ROOT);
         console.log(`Migrating file workspace at ${WORKSPACE_ROOT} to store at ${storePath}...`);
         const result = await importFromFileWorkspace(WORKSPACE_ROOT, storePath);
         console.log(`Migration complete:`);