cc-claw 0.18.5 → 0.19.1

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.18.5" : (() => {
+    VERSION = true ? "0.19.1" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -1690,6 +1690,34 @@ function initSchema(db3) {
   } catch {
   }
   applySalienceDecay(db3);
+  db3.exec(`
+    CREATE TABLE IF NOT EXISTS ollama_servers (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      host TEXT NOT NULL,
+      port INTEGER NOT NULL DEFAULT 11434,
+      api_key TEXT,
+      status TEXT NOT NULL DEFAULT 'offline',
+      last_health_check TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+  db3.exec(`
+    CREATE TABLE IF NOT EXISTS ollama_models (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      server_id INTEGER NOT NULL REFERENCES ollama_servers(id) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      family TEXT,
+      parameter_size TEXT,
+      quantization TEXT,
+      context_window INTEGER DEFAULT 4096,
+      size_bytes INTEGER,
+      digest TEXT,
+      last_seen TEXT NOT NULL DEFAULT (datetime('now')),
+      quality_score REAL,
+      UNIQUE(server_id, name)
+    );
+  `);
   initAgentTables(db3);
   initMcpTables(db3);
   initActivityTable(db3);
@@ -2028,7 +2056,7 @@ var init_embeddings = __esm({
         return results[0];
       }
       async embedBatch(texts) {
-        const url = `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:batchEmbedContents?key=${this.apiKey}`;
+        const url = `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:batchEmbedContents`;
         const requests = texts.map((text) => ({
           model: `models/${this.model}`,
           content: { parts: [{ text }] },
@@ -2036,7 +2064,10 @@ var init_embeddings = __esm({
         }));
         const res = await fetch(url, {
           method: "POST",
-          headers: { "Content-Type": "application/json" },
+          headers: {
+            "Content-Type": "application/json",
+            "x-goog-api-key": this.apiKey
+          },
           body: JSON.stringify({ requests })
         });
         if (!res.ok) {
@@ -2485,6 +2516,7 @@ var chat_settings_exports = {};
 __export(chat_settings_exports, {
   ALL_TOOLS: () => ALL_TOOLS,
   ChatSettingsSnapshot: () => ChatSettingsSnapshot,
+  GLOBAL_SUMMARIZER_SENTINEL: () => GLOBAL_SUMMARIZER_SENTINEL,
   clearAgentMode: () => clearAgentMode,
   clearAllPaidSlots: () => clearAllPaidSlots,
   clearChatPaidSlots: () => clearChatPaidSlots,
@@ -2504,6 +2536,7 @@ __export(chat_settings_exports, {
   getCwd: () => getCwd,
   getEnabledTools: () => getEnabledTools,
   getExecMode: () => getExecMode,
+  getGlobalSummarizer: () => getGlobalSummarizer,
   getMode: () => getMode,
   getModel: () => getModel,
   getPendingEscalation: () => getPendingEscalation,
@@ -2521,6 +2554,7 @@ __export(chat_settings_exports, {
   setBackend: () => setBackend,
   setCwd: () => setCwd,
   setExecMode: () => setExecMode,
+  setGlobalSummarizer: () => setGlobalSummarizer,
   setMode: () => setMode,
   setModel: () => setModel,
   setSessionLogEnabled: () => setSessionLogEnabled,
@@ -2755,11 +2789,29 @@ function clearThinkingLevel(chatId) {
   getDb().prepare("DELETE FROM chat_thinking WHERE chat_id = ?").run(chatId);
 }
 function getSummarizer(chatId) {
-  const row = getDb().prepare(
+  const perChat = getDb().prepare(
     "SELECT backend, model FROM chat_summarizer WHERE chat_id = ?"
   ).get(chatId);
+  if (perChat && (perChat.backend || perChat.model)) return perChat;
+  const global = getDb().prepare(
+    "SELECT backend, model FROM chat_summarizer WHERE chat_id = ?"
+  ).get(GLOBAL_SUMMARIZER_SENTINEL);
+  if (global && (global.backend || global.model)) return global;
+  return { backend: null, model: null };
+}
+function getGlobalSummarizer() {
+  const row = getDb().prepare(
+    "SELECT backend, model FROM chat_summarizer WHERE chat_id = ?"
+  ).get(GLOBAL_SUMMARIZER_SENTINEL);
   return row ?? { backend: null, model: null };
 }
+function setGlobalSummarizer(backend2, model2) {
+  getDb().prepare(`
+    INSERT INTO chat_summarizer (chat_id, backend, model)
+    VALUES (?, ?, ?)
+    ON CONFLICT(chat_id) DO UPDATE SET backend = ?, model = ?
+  `).run(GLOBAL_SUMMARIZER_SENTINEL, backend2, model2, backend2, model2);
+}
 function setSummarizer(chatId, backend2, model2) {
   getDb().prepare(`
     INSERT INTO chat_summarizer (chat_id, backend, model)
@@ -2836,7 +2888,7 @@ function clearChatPaidSlots(chatId) {
 function clearAllPaidSlots() {
   getDb().prepare("DELETE FROM chat_allow_paid_slots").run();
 }
-var pendingEscalations, ESCALATION_TTL_MS, ALL_TOOLS, ChatSettingsSnapshot;
+var pendingEscalations, ESCALATION_TTL_MS, ALL_TOOLS, GLOBAL_SUMMARIZER_SENTINEL, ChatSettingsSnapshot;
 var init_chat_settings = __esm({
   "src/memory/chat-settings.ts"() {
     "use strict";
@@ -2845,6 +2897,7 @@ var init_chat_settings = __esm({
     pendingEscalations = /* @__PURE__ */ new Map();
     ESCALATION_TTL_MS = 5 * 60 * 1e3;
     ALL_TOOLS = ["Read", "Glob", "Grep", "Bash", "Write", "Edit", "WebFetch", "WebSearch", "Agent", "AskUserQuestion"];
+    GLOBAL_SUMMARIZER_SENTINEL = "__global__";
     ChatSettingsSnapshot = class {
       constructor(chatId) {
         this.chatId = chatId;
@@ -3754,6 +3807,7 @@ var store_exports5 = {};
 __export(store_exports5, {
   ALL_TOOLS: () => ALL_TOOLS,
   ChatSettingsSnapshot: () => ChatSettingsSnapshot,
+  GLOBAL_SUMMARIZER_SENTINEL: () => GLOBAL_SUMMARIZER_SENTINEL,
   addBackendSlot: () => addBackendSlot,
   addGeminiSlot: () => addGeminiSlot,
   addHeartbeatWatch: () => addHeartbeatWatch,
@@ -3815,6 +3869,7 @@ __export(store_exports5, {
   getExecMode: () => getExecMode,
   getGeminiRotationMode: () => getGeminiRotationMode,
   getGeminiSlots: () => getGeminiSlots,
+  getGlobalSummarizer: () => getGlobalSummarizer,
   getHeartbeatConfig: () => getHeartbeatConfig,
   getJobById: () => getJobById,
   getJobRuns: () => getJobRuns,
@@ -3892,6 +3947,7 @@ __export(store_exports5, {
   setExecMode: () => setExecMode,
   setGeminiRotationMode: () => setGeminiRotationMode,
   setGeminiSlotEnabled: () => setGeminiSlotEnabled,
+  setGlobalSummarizer: () => setGlobalSummarizer,
   setHeartbeatConfig: () => setHeartbeatConfig,
   setMode: () => setMode,
   setModel: () => setModel,
@@ -5231,19 +5287,1043 @@ var init_cursor = __esm({
             } : void 0
           });
         }
-        return events;
+        return events;
+      }
+      getSubagentInstructions() {
+        return "You have native sub-agent support via the Task tool. Built-in agent types: generalPurpose (multi-step tasks), explore (fast codebase search), shell (command execution), code-reviewer. Use them for parallel work.";
+      }
+      shouldKillOnResult() {
+        return false;
+      }
+      resolveModelWithThinking(model2, level) {
+        if (!model2 || !level || level === "auto") return model2;
+        const variants = THINKING_VARIANTS[model2];
+        if (!variants) return model2;
+        return variants[level] ?? model2;
+      }
+    };
+  }
+});
+
+// src/services/ollama/client.ts
+var client_exports = {};
+__export(client_exports, {
+  chat: () => chat,
+  generate: () => generate,
+  listModels: () => listModels,
+  ping: () => ping,
+  runningModels: () => runningModels,
+  showModel: () => showModel
+});
+function buildHeaders(apiKey) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  return headers;
+}
+async function parseNdjsonStream(reader, onChunk, signal) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) break;
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const parsed = JSON.parse(trimmed);
+          onChunk(parsed);
+        } catch {
+        }
+      }
+    }
+    if (buffer.trim()) {
+      try {
+        const parsed = JSON.parse(buffer.trim());
+        onChunk(parsed);
+      } catch {
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function ping(baseUrl, opts) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(
+      () => controller.abort(),
+      opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS
+    );
+    try {
+      const res = await fetch(baseUrl, {
+        signal: controller.signal,
+        headers: buildHeaders(opts?.apiKey)
+      });
+      return res.ok;
+    } finally {
+      clearTimeout(timeout);
+    }
+  } catch {
+    return false;
+  }
+}
+async function listModels(baseUrl, opts) {
+  const res = await fetch(`${baseUrl}/api/tags`, {
+    signal: opts?.signal,
+    headers: buildHeaders(opts?.apiKey)
+  });
+  if (!res.ok) {
+    throw new Error(`Ollama listModels failed: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+async function showModel(baseUrl, model2, opts) {
+  const res = await fetch(`${baseUrl}/api/show`, {
+    method: "POST",
+    headers: buildHeaders(opts?.apiKey),
+    body: JSON.stringify({ name: model2 }),
+    signal: opts?.signal
+  });
+  if (!res.ok) {
+    throw new Error(`Ollama showModel(${model2}) failed: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+async function runningModels(baseUrl, opts) {
+  const res = await fetch(`${baseUrl}/api/ps`, {
+    signal: opts?.signal,
+    headers: buildHeaders(opts?.apiKey)
+  });
+  if (!res.ok) {
+    throw new Error(`Ollama runningModels failed: ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+async function generate(baseUrl, model2, prompt, opts) {
+  const overallTimeoutMs = opts?.timeoutMs ?? DEFAULT_GENERATE_TIMEOUT_MS;
+  const controller = new AbortController();
+  if (opts?.signal) {
+    if (opts.signal.aborted) {
+      controller.abort(opts.signal.reason);
+    } else {
+      opts.signal.addEventListener("abort", () => controller.abort(opts.signal.reason), { once: true });
+    }
+  }
+  const overallTimer = setTimeout(() => controller.abort("Overall timeout"), overallTimeoutMs);
+  let firstByteReceived = false;
+  const firstByteTimer = setTimeout(() => {
+    if (!firstByteReceived) {
+      controller.abort("First byte timeout \u2014 model may be loading into VRAM");
+    }
+  }, FIRST_BYTE_TIMEOUT_MS);
+  try {
+    const body = {
+      model: model2,
+      prompt,
+      stream: true
+    };
+    if (opts?.systemPrompt) body.system = opts.systemPrompt;
+    if (opts?.temperature != null || opts?.maxTokens != null) {
+      const options = {};
+      if (opts.temperature != null) options.temperature = opts.temperature;
+      if (opts.maxTokens != null) options.num_predict = opts.maxTokens;
+      body.options = options;
+    }
+    const res = await fetch(`${baseUrl}/api/generate`, {
+      method: "POST",
+      headers: buildHeaders(opts?.apiKey),
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      const errorText = await res.text().catch(() => "");
+      throw new Error(`Ollama generate failed: ${res.status} ${res.statusText} \u2014 ${errorText}`);
+    }
+    if (!res.body) {
+      throw new Error("Ollama generate: response body is null (streaming not supported?)");
+    }
+    const reader = res.body.getReader();
+    let fullText = "";
+    let promptTokens = 0;
+    let completionTokens = 0;
+    await parseNdjsonStream(
+      reader,
+      (chunk) => {
+        if (!firstByteReceived) {
+          firstByteReceived = true;
+          clearTimeout(firstByteTimer);
+        }
+        if (chunk.response) {
+          fullText += chunk.response;
+          opts?.onStream?.(chunk.response);
+        }
+        if (chunk.done) {
+          promptTokens = chunk.prompt_eval_count ?? 0;
+          completionTokens = chunk.eval_count ?? 0;
+        }
+      },
+      controller.signal
+    );
+    return {
+      text: fullText,
+      usage: { promptTokens, completionTokens }
+    };
+  } finally {
+    clearTimeout(overallTimer);
+    clearTimeout(firstByteTimer);
+  }
+}
+async function chat(baseUrl, model2, messages, opts) {
+  const overallTimeoutMs = opts?.timeoutMs ?? DEFAULT_GENERATE_TIMEOUT_MS;
+  const controller = new AbortController();
+  if (opts?.signal) {
+    if (opts.signal.aborted) {
+      controller.abort(opts.signal.reason);
+    } else {
+      opts.signal.addEventListener("abort", () => controller.abort(opts.signal.reason), { once: true });
+    }
+  }
+  const overallTimer = setTimeout(() => controller.abort("Overall timeout"), overallTimeoutMs);
+  let firstByteReceived = false;
+  const firstByteTimer = setTimeout(() => {
+    if (!firstByteReceived) {
+      controller.abort("First byte timeout \u2014 model may be loading into VRAM");
+    }
+  }, FIRST_BYTE_TIMEOUT_MS);
+  try {
+    const body = {
+      model: model2,
+      messages,
+      stream: true
+    };
+    if (opts?.temperature != null || opts?.maxTokens != null) {
+      const options = {};
+      if (opts.temperature != null) options.temperature = opts.temperature;
+      if (opts.maxTokens != null) options.num_predict = opts.maxTokens;
+      body.options = options;
+    }
+    const res = await fetch(`${baseUrl}/api/chat`, {
+      method: "POST",
+      headers: buildHeaders(opts?.apiKey),
+      body: JSON.stringify(body),
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      const errorText = await res.text().catch(() => "");
+      throw new Error(`Ollama chat failed: ${res.status} ${res.statusText} \u2014 ${errorText}`);
+    }
+    if (!res.body) {
+      throw new Error("Ollama chat: response body is null (streaming not supported?)");
+    }
+    const reader = res.body.getReader();
+    let fullText = "";
+    let promptTokens = 0;
+    let completionTokens = 0;
+    await parseNdjsonStream(
+      reader,
+      (chunk) => {
+        if (!firstByteReceived) {
+          firstByteReceived = true;
+          clearTimeout(firstByteTimer);
+        }
+        if (chunk.message?.content) {
+          fullText += chunk.message.content;
+          opts?.onStream?.(chunk.message.content);
+        }
+        if (chunk.done) {
+          promptTokens = chunk.prompt_eval_count ?? 0;
+          completionTokens = chunk.eval_count ?? 0;
+        }
+      },
+      controller.signal
+    );
+    return {
+      text: fullText,
+      usage: { promptTokens, completionTokens }
+    };
+  } finally {
+    clearTimeout(overallTimer);
+    clearTimeout(firstByteTimer);
+  }
+}
+var DEFAULT_TIMEOUT_MS, DEFAULT_GENERATE_TIMEOUT_MS, FIRST_BYTE_TIMEOUT_MS;
+var init_client = __esm({
+  "src/services/ollama/client.ts"() {
+    "use strict";
+    DEFAULT_TIMEOUT_MS = 1e4;
+    DEFAULT_GENERATE_TIMEOUT_MS = 12e4;
+    FIRST_BYTE_TIMEOUT_MS = 6e4;
+  }
+});
+
+// src/services/ollama/store.ts
+var store_exports6 = {};
+__export(store_exports6, {
+  addServer: () => addServer,
+  getAvailableModels: () => getAvailableModels,
+  getBaseUrl: () => getBaseUrl,
+  getModelByName: () => getModelByName,
+  getServer: () => getServer,
+  getServerById: () => getServerById,
+  listModels: () => listModels2,
+  listServers: () => listServers,
+  removeServer: () => removeServer,
+  removeStaleModels: () => removeStaleModels,
+  updateModelContextWindow: () => updateModelContextWindow,
+  updateModelQualityScore: () => updateModelQualityScore,
+  updateServerStatus: () => updateServerStatus,
+  upsertModel: () => upsertModel
+});
+function addServer(name, host, port, apiKey) {
+  const db3 = getDb();
+  const result = db3.prepare(`
+    INSERT INTO ollama_servers (name, host, port, api_key, status)
+    VALUES (?, ?, ?, ?, 'offline')
+  `).run(name, host, port, apiKey ?? null);
+  return {
+    id: Number(result.lastInsertRowid),
+    name,
+    host,
+    port,
+    apiKey: apiKey ?? null,
+    status: "offline",
+    lastHealthCheck: null,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function removeServer(name) {
+  const result = getDb().prepare(
+    "DELETE FROM ollama_servers WHERE name = ?"
+  ).run(name);
+  return result.changes > 0;
+}
+function getServer(name) {
+  const row = getDb().prepare(
+    "SELECT id, name, host, port, api_key, status, last_health_check, created_at FROM ollama_servers WHERE name = ?"
+  ).get(name);
+  return row ? mapServerRow(row) : void 0;
+}
+function getServerById(id) {
+  const row = getDb().prepare(
+    "SELECT id, name, host, port, api_key, status, last_health_check, created_at FROM ollama_servers WHERE id = ?"
+  ).get(id);
+  return row ? mapServerRow(row) : void 0;
+}
+function listServers() {
+  const rows = getDb().prepare(
+    "SELECT id, name, host, port, api_key, status, last_health_check, created_at FROM ollama_servers ORDER BY name"
+  ).all();
+  return rows.map(mapServerRow);
+}
+function updateServerStatus(serverId, status) {
+  getDb().prepare(
+    "UPDATE ollama_servers SET status = ?, last_health_check = datetime('now') WHERE id = ?"
+  ).run(status, serverId);
+}
+function getBaseUrl(server) {
+  return `http://${server.host}:${server.port}`;
+}
+function upsertModel(serverId, model2) {
+  getDb().prepare(`
+    INSERT INTO ollama_models (server_id, name, family, parameter_size, quantization, context_window, size_bytes, digest, last_seen)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+    ON CONFLICT(server_id, name) DO UPDATE SET
+      family = excluded.family,
+      parameter_size = excluded.parameter_size,
+      quantization = excluded.quantization,
+      context_window = COALESCE(excluded.context_window, context_window),
+      size_bytes = excluded.size_bytes,
+      digest = excluded.digest,
+      last_seen = datetime('now')
+  `).run(
+    serverId,
+    model2.name,
+    model2.family ?? null,
+    model2.parameterSize ?? null,
+    model2.quantization ?? null,
+    model2.contextWindow ?? 4096,
+    model2.sizeBytes ?? 0,
+    model2.digest ?? ""
+  );
+}
+function listModels2(serverId) {
+  const db3 = getDb();
+  let rows;
+  if (serverId != null) {
+    rows = db3.prepare(
+      "SELECT id, server_id, name, family, parameter_size, quantization, context_window, size_bytes, digest, last_seen, quality_score FROM ollama_models WHERE server_id = ? ORDER BY name"
+    ).all(serverId);
+  } else {
+    rows = db3.prepare(
+      "SELECT id, server_id, name, family, parameter_size, quantization, context_window, size_bytes, digest, last_seen, quality_score FROM ollama_models ORDER BY server_id, name"
+    ).all();
+  }
+  return rows.map(mapModelRow);
+}
+function getModelByName(name, serverId) {
+  const db3 = getDb();
+  let row;
+  if (serverId != null) {
+    row = db3.prepare(
+      "SELECT id, server_id, name, family, parameter_size, quantization, context_window, size_bytes, digest, last_seen, quality_score FROM ollama_models WHERE name = ? AND server_id = ?"
+    ).get(name, serverId);
+  } else {
+    row = db3.prepare(`
+      SELECT m.id, m.server_id, m.name, m.family, m.parameter_size, m.quantization, m.context_window, m.size_bytes, m.digest, m.last_seen, m.quality_score
+      FROM ollama_models m
+      JOIN ollama_servers s ON s.id = m.server_id
+      WHERE m.name = ? AND s.status = 'online'
+      ORDER BY m.quality_score DESC NULLS LAST
+      LIMIT 1
+    `).get(name);
+  }
+  return row ? mapModelRow(row) : void 0;
+}
+function updateModelQualityScore(modelId, score) {
+  getDb().prepare(
+    "UPDATE ollama_models SET quality_score = ? WHERE id = ?"
+  ).run(score, modelId);
+}
+function updateModelContextWindow(modelId, contextWindow) {
+  getDb().prepare(
+    "UPDATE ollama_models SET context_window = ? WHERE id = ?"
+  ).run(contextWindow, modelId);
+}
+function removeStaleModels(serverId, currentNames) {
+  if (currentNames.length === 0) {
+    const r2 = getDb().prepare(
+      "DELETE FROM ollama_models WHERE server_id = ?"
+    ).run(serverId);
+    return r2.changes;
+  }
+  const placeholders = currentNames.map(() => "?").join(", ");
+  const r = getDb().prepare(
+    `DELETE FROM ollama_models WHERE server_id = ? AND name NOT IN (${placeholders})`
+  ).run(serverId, ...currentNames);
+  return r.changes;
+}
+function getAvailableModels() {
+  const rows = getDb().prepare(`
+    SELECT m.id, m.server_id, m.name, m.family, m.parameter_size, m.quantization, m.context_window, m.size_bytes, m.digest, m.last_seen, m.quality_score
+    FROM ollama_models m
+    JOIN ollama_servers s ON s.id = m.server_id
+    WHERE s.status = 'online'
+    ORDER BY m.quality_score DESC NULLS LAST, m.size_bytes DESC
+  `).all();
+  return rows.map(mapModelRow);
+}
+function mapServerRow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    host: row.host,
+    port: row.port,
+    apiKey: row.api_key,
+    status: row.status,
+    lastHealthCheck: row.last_health_check,
+    createdAt: row.created_at
+  };
+}
+function mapModelRow(row) {
+  return {
+    id: row.id,
+    serverId: row.server_id,
+    name: row.name,
+    family: row.family,
+    parameterSize: row.parameter_size,
+    quantization: row.quantization,
+    contextWindow: row.context_window,
+    sizeBytes: row.size_bytes,
+    digest: row.digest,
+    lastSeen: row.last_seen,
+    qualityScore: row.quality_score
+  };
+}
+var init_store6 = __esm({
+  "src/services/ollama/store.ts"() {
+    "use strict";
+    init_store5();
+  }
+});
+
+// src/services/ollama/router.ts
+async function routeModelForTask(task, preferredModel) {
+  if (preferredModel) {
+    const model2 = getModelByName(preferredModel);
+    if (model2) {
+      const server2 = getServerById(model2.serverId);
+      if (server2 && server2.status === "online") {
+        return { model: model2, server: server2, reason: `User-pinned model "${preferredModel}"` };
+      }
+    }
+  }
+  const available = getAvailableModels();
+  if (available.length === 0) return void 0;
+  const loadedNames = await getLoadedModelNames();
+  const candidates = filterByTask(available, task);
+  if (candidates.length === 0) {
+    if (available.length === 0) return void 0;
+    const fallback = available[0];
+    const server2 = getServerById(fallback.serverId);
+    return server2 ? { model: fallback, server: server2, reason: "Fallback \u2014 no task-appropriate models" } : void 0;
+  }
+  const ranked = rankCandidates(candidates, task, loadedNames);
+  const best = ranked[0];
+  const server = getServerById(best.model.serverId);
+  if (!server) return void 0;
+  return { model: best.model, server, reason: best.reason };
+}
+function routeModelForTaskSync(task, preferredModel) {
+  if (preferredModel) {
+    const model2 = getModelByName(preferredModel);
+    if (model2) {
+      const server2 = getServerById(model2.serverId);
+      if (server2 && server2.status === "online") {
+        return { model: model2, server: server2, reason: `User-pinned model "${preferredModel}"` };
+      }
+    }
+  }
+  const available = getAvailableModels();
+  if (available.length === 0) return void 0;
+  const candidates = filterByTask(available, task);
+  const pool = candidates.length > 0 ? candidates : available;
+  const ranked = rankCandidates(pool, task, /* @__PURE__ */ new Set());
+  const best = ranked[0];
+  const server = getServerById(best.model.serverId);
+  if (!server) return void 0;
+  return { model: best.model, server, reason: best.reason };
+}
+async function getLoadedModelNames() {
+  const loaded = /* @__PURE__ */ new Set();
+  const servers = listServers().filter((s) => s.status === "online");
+  for (const server of servers) {
+    try {
+      const baseUrl = getBaseUrl(server);
+      const ps = await runningModels(baseUrl, {
+        apiKey: server.apiKey
+      });
+      for (const m of ps.models) {
+        loaded.add(m.name);
+      }
+    } catch {
+    }
+  }
+  if (loaded.size > 0) {
+    log(`[ollama/router] Loaded models: ${[...loaded].join(", ")}`);
+  }
+  return loaded;
+}
+function filterByTask(models, task) {
+  switch (task) {
+    case "summarize":
+      return models.filter((m) => {
+        const params = parseParamSize(m.parameterSize);
+        const ctxOk = (m.contextWindow ?? 4096) >= MIN_SUMMARIZE_CTX;
+        const sizeOk = params === null || params <= MAX_SUMMARIZER_PARAMS_B;
+        return ctxOk && sizeOk;
+      });
+    case "classify":
+      return models.filter((m) => {
+        const params = parseParamSize(m.parameterSize);
+        return params === null || params <= MAX_CLASSIFY_PARAMS_B;
+      });
+    case "cron":
+      return models.filter((m) => {
+        const params = parseParamSize(m.parameterSize);
+        const sizeOk = params === null || params <= MAX_SUMMARIZER_PARAMS_B;
+        const qualityOk = m.qualityScore === null || m.qualityScore >= MIN_CRON_QUALITY;
+        return sizeOk && qualityOk;
+      });
+    case "chat":
+      return [...models];
+    default:
+      return [...models];
+  }
+}
+function rankCandidates(models, task, loadedNames) {
+  const ranked = models.map((model2) => {
+    let score = 0;
+    const reasons = [];
+    if (model2.qualityScore !== null) {
+      score += model2.qualityScore * 100;
+      reasons.push(`quality=${model2.qualityScore.toFixed(2)}`);
+    }
+    if (loadedNames.has(model2.name)) {
+      score += LOADED_BONUS;
+      reasons.push("loaded");
+    }
+    switch (task) {
+      case "summarize":
+        score += (model2.contextWindow ?? 4096) / 1e3;
+        break;
+      case "chat":
+        score += (parseParamSize(model2.parameterSize) ?? 0) * 2;
+        break;
+      case "cron":
+        score += Math.max(0, 20 - (parseParamSize(model2.parameterSize) ?? 0));
+        break;
+      case "classify":
+        score += Math.max(0, 30 - (parseParamSize(model2.parameterSize) ?? 0) * 3);
+        break;
+    }
+    return {
+      model: model2,
+      score,
+      reason: reasons.length > 0 ? reasons.join(", ") : "default"
+    };
+  });
+  ranked.sort((a, b) => b.score - a.score);
+  return ranked;
+}
+function parseParamSize(size) {
+  if (!size) return null;
+  const match = size.match(/([\d.]+)\s*[Bb]/);
+  if (!match) return null;
+  return parseFloat(match[1]);
+}
+var MAX_SUMMARIZER_PARAMS_B, MAX_CLASSIFY_PARAMS_B, MIN_SUMMARIZE_CTX, MIN_CRON_QUALITY, LOADED_BONUS;
+var init_router = __esm({
+  "src/services/ollama/router.ts"() {
+    "use strict";
+    init_store6();
+    init_client();
+    init_log();
+    MAX_SUMMARIZER_PARAMS_B = 14;
+    MAX_CLASSIFY_PARAMS_B = 9;
+    MIN_SUMMARIZE_CTX = 4096;
+    MIN_CRON_QUALITY = 0.7;
+    LOADED_BONUS = 100;
+  }
+});
+
+// src/services/ollama/quality-gate.ts
+var quality_gate_exports = {};
+__export(quality_gate_exports, {
+  ensureQualityScore: () => ensureQualityScore,
+  runQualityGate: () => runQualityGate
+});
+async function runQualityGate(model2, server) {
+  const baseUrl = getBaseUrl(server);
+  const startTime = Date.now();
+  try {
+    const result = await generate(baseUrl, model2.name, TEST_PROMPT, {
+      timeoutMs: TEST_TIMEOUT_MS,
+      temperature: 0.3,
+      // Low temp for deterministic test
+      maxTokens: 300,
+      // Short response expected
+      apiKey: server.apiKey
+    });
+    const responseTimeMs = Date.now() - startTime;
+    const response = result.text.trim();
+    if (response.length < MIN_RESPONSE_LENGTH) {
+      const score = 0.1;
+      updateModelQualityScore(model2.id, score);
+      return {
+        passed: false,
+        score,
+        responseLength: response.length,
+        keywordsFound: [],
+        keywordsMissed: EXPECTED_KEYWORDS,
+        responseTimeMs,
+        hasRepetition: false,
+        error: `Response too short (${response.length} chars, min ${MIN_RESPONSE_LENGTH})`
+      };
+    }
+    const lowerResponse = response.toLowerCase();
+    const found = EXPECTED_KEYWORDS.filter((k) => lowerResponse.includes(k));
+    const missed = EXPECTED_KEYWORDS.filter((k) => !lowerResponse.includes(k));
+    const keywordScore = found.length / EXPECTED_KEYWORDS.length * 0.5;
+    const timeScore = responseTimeMs < 1e4 ? 0.3 : Math.max(0, 0.3 * (1 - (responseTimeMs - 1e4) / 2e4));
+    const hasRepetition = detectRepetition(response);
+    const repetitionScore = hasRepetition ? 0 : 0.2;
+    const totalScore = parseFloat((keywordScore + timeScore + repetitionScore).toFixed(3));
+    const passed = found.length >= 2 && response.length >= MIN_RESPONSE_LENGTH && !hasRepetition;
+    updateModelQualityScore(model2.id, totalScore);
+    log(`[ollama/quality] ${model2.name}: score=${totalScore} (keywords=${found.length}/${EXPECTED_KEYWORDS.length}, time=${responseTimeMs}ms, repetition=${hasRepetition})`);
+    return {
+      passed,
+      score: totalScore,
+      responseLength: response.length,
+      keywordsFound: found,
+      keywordsMissed: missed,
+      responseTimeMs,
+      hasRepetition
+    };
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    warn(`[ollama/quality] ${model2.name} test failed: ${errorMsg}`);
+    updateModelQualityScore(model2.id, 0);
+    return {
+      passed: false,
+      score: 0,
+      responseLength: 0,
+      keywordsFound: [],
+      keywordsMissed: EXPECTED_KEYWORDS,
+      responseTimeMs: Date.now() - startTime,
+      hasRepetition: false,
+      error: errorMsg
+    };
+  }
+}
+async function ensureQualityScore(model2, server) {
+  if (model2.qualityScore !== null) return model2.qualityScore;
+  const result = await runQualityGate(model2, server);
+  return result.score;
+}
+function detectRepetition(text) {
+  const tail = text.slice(-200);
+  for (let len = 6; len <= 50; len++) {
+    const pattern = tail.slice(-len);
+    if (!pattern.trim()) continue;
+    let count = 0;
+    let pos = 0;
+    while (pos < tail.length) {
+      const idx = tail.indexOf(pattern, pos);
+      if (idx === -1) break;
+      count++;
+      pos = idx + 1;
+    }
+    if (count >= 3) return true;
+  }
+  return false;
+}
+var TEST_PROMPT, EXPECTED_KEYWORDS, TEST_TIMEOUT_MS, MIN_RESPONSE_LENGTH;
+var init_quality_gate = __esm({
+  "src/services/ollama/quality-gate.ts"() {
+    "use strict";
+    init_client();
+    init_store6();
+    init_log();
+    TEST_PROMPT = `Summarize the following text in 2-3 sentences:
+
+The James Webb Space Telescope (JWST) launched in December 2021 and has revolutionized astronomy by capturing infrared images of the universe with unprecedented clarity. Its primary mirror, spanning 6.5 meters, is significantly larger than Hubble's 2.4-meter mirror, allowing it to observe galaxies formed shortly after the Big Bang. JWST operates at the second Lagrange point (L2), approximately 1.5 million kilometers from Earth, where it maintains a stable thermal environment shielded from solar radiation. Early discoveries include detailed atmospheric analysis of exoplanets, revealing the presence of water vapor and carbon dioxide in their atmospheres. The telescope has also identified some of the most distant galaxies ever observed, challenging existing models of galaxy formation in the early universe.`;
+    EXPECTED_KEYWORDS = ["webb", "telescope", "infrared", "galaxies"];
+    TEST_TIMEOUT_MS = 3e4;
+    MIN_RESPONSE_LENGTH = 80;
+  }
+});
+
+// src/services/ollama/service.ts
+var service_exports = {};
+__export(service_exports, {
+  addServer: () => addServer2,
+  discoverModels: () => discoverModels,
+  getLoadedModels: () => getLoadedModels,
+  getModelForTask: () => getModelForTask,
+  getModelForTaskAsync: () => getModelForTaskAsync,
+  getServer: () => getServer2,
+  getServerForModel: () => getServerForModel,
+  healthCheck: () => healthCheck,
+  isAnyServerOnline: () => isAnyServerOnline,
+  listServers: () => listServers2,
+  removeServer: () => removeServer2,
+  runQualityGateTest: () => runQualityGateTest
+});
+function addServer2(name, host, port = 11434, apiKey) {
+  const existing = getServer(name);
+  if (existing) throw new Error(`Server "${name}" already exists`);
+  const server = addServer(name, host, port, apiKey);
+  log(`[ollama] Added server: ${name} (${host}:${port})`);
+  return server;
+}
+function removeServer2(name) {
+  const removed = removeServer(name);
+  if (removed) log(`[ollama] Removed server: ${name}`);
+  return removed;
+}
+function listServers2() {
+  return listServers();
+}
+function getServer2(name) {
+  return getServer(name);
+}
+async function healthCheck(serverName) {
+  const servers = serverName ? [getServer(serverName)].filter(Boolean) : listServers();
+  if (servers.length === 0) {
+    warn("[ollama] No servers registered");
+    return [];
+  }
+  const results = [];
+  for (const server of servers) {
+    const baseUrl = getBaseUrl(server);
+    const ok = await ping(baseUrl, {
+      timeoutMs: HEALTH_PING_TIMEOUT_MS,
+      apiKey: server.apiKey
+    });
+    const newStatus = ok ? "online" : "offline";
+    updateServerStatus(server.id, newStatus);
+    results.push({ ...server, status: newStatus });
+    if (newStatus !== server.status) {
+      log(`[ollama] Server ${server.name}: ${server.status} \u2192 ${newStatus}`);
+    }
+  }
+  return results;
+}
+async function isAnyServerOnline() {
+  const servers = listServers();
+  if (servers.length === 0) return false;
+  for (const server of servers) {
+    const baseUrl = getBaseUrl(server);
+    const ok = await ping(baseUrl, {
+      timeoutMs: 2e3,
+      apiKey: server.apiKey
+    });
+    if (ok) {
+      if (server.status !== "online") {
+        updateServerStatus(server.id, "online");
+      }
+      return true;
+    }
+  }
+  return false;
+}
+async function discoverModels(serverName) {
+  const servers = serverName ? [getServer(serverName)].filter(Boolean) : listServers();
+  const allDiscovered = [];
+  for (const server of servers) {
+    const baseUrl = getBaseUrl(server);
+    try {
+      const tags = await listModels(baseUrl, { apiKey: server.apiKey });
+      const modelNames = [];
+      for (const m of tags.models) {
+        modelNames.push(m.name);
+        let contextWindow = 4096;
+        try {
+          const showData = await showModel(baseUrl, m.name, { apiKey: server.apiKey });
+          contextWindow = extractContextWindow(showData);
+        } catch {
+        }
+        upsertModel(server.id, {
+          name: m.name,
+          family: m.details.family ?? null,
+          parameterSize: m.details.parameter_size ?? null,
+          quantization: m.details.quantization_level ?? null,
+          contextWindow,
+          sizeBytes: m.size,
+          digest: m.digest
+        });
+      }
+      const staleCount = removeStaleModels(server.id, modelNames);
+      if (staleCount > 0) {
+        log(`[ollama] Removed ${staleCount} stale model(s) from ${server.name}`);
+      }
+      updateServerStatus(server.id, "online");
+      log(`[ollama] Discovered ${modelNames.length} model(s) on ${server.name}: ${modelNames.join(", ")}`);
+    } catch (err) {
+      error(`[ollama] Failed to discover models on ${server.name}:`, err);
+      updateServerStatus(server.id, "offline");
+    }
+  }
+  return getAvailableModels();
+}
+async function getLoadedModels(serverName) {
+  const servers = serverName ? [getServer(serverName)].filter(Boolean) : listServers().filter((s) => s.status === "online");
+  const loaded = [];
+  for (const server of servers) {
+    try {
+      const baseUrl = getBaseUrl(server);
+      const ps = await runningModels(baseUrl, { apiKey: server.apiKey });
+      for (const m of ps.models) {
+        loaded.push({ server: server.name, modelName: m.name, sizeVram: m.size_vram });
+      }
+    } catch {
+    }
+  }
+  return loaded;
+}
+function getModelForTask(task, preferredModel) {
+  return routeModelForTaskSync(task, preferredModel);
+}
+async function getModelForTaskAsync(task, preferredModel) {
+  return routeModelForTask(task, preferredModel);
+}
+async function runQualityGateTest(modelName, serverName) {
+  const model2 = serverName ? getModelByName(modelName, getServer(serverName)?.id) : getModelByName(modelName);
+  if (!model2) return void 0;
+  const server = getServerById(model2.serverId);
+  if (!server || server.status !== "online") return void 0;
+  const { runQualityGate: runQualityGate2 } = await Promise.resolve().then(() => (init_quality_gate(), quality_gate_exports));
+  return runQualityGate2(model2, server);
+}
+function getServerForModel(modelName) {
+  const model2 = getModelByName(modelName);
+  if (!model2) return void 0;
+  const server = getServerById(model2.serverId);
+  if (!server || server.status !== "online") return void 0;
+  return {
+    baseUrl: getBaseUrl(server),
+    apiKey: server.apiKey
+  };
+}
+function extractContextWindow(show) {
+  const info = show.model_info ?? {};
+  for (const key of Object.keys(info)) {
+    if (key.includes("context_length") || key.includes("context_window")) {
+      const val = info[key];
+      if (typeof val === "number" && val > 0) return val;
+    }
+  }
+  const paramLines = (show.parameters ?? "").split("\n");
+  for (const line of paramLines) {
+    const match = line.match(/num_ctx\s+(\d+)/);
+    if (match) return parseInt(match[1], 10);
+  }
+  return 4096;
+}
+var HEALTH_PING_TIMEOUT_MS;
+var init_service = __esm({
+  "src/services/ollama/service.ts"() {
+    "use strict";
+    init_client();
+    init_store6();
+    init_router();
+    init_log();
+    HEALTH_PING_TIMEOUT_MS = 3e3;
+  }
+});
+
+// src/services/ollama/prompt.ts
+var prompt_exports = {};
+__export(prompt_exports, {
+  stripForLocalModel: () => stripForLocalModel
+});
+function stripForLocalModel(prompt) {
+  return prompt.replace(/\[SEND_FILE:[^\]]*\]/g, "").replace(/\[GENERATE_IMAGE:[^\]]*\]/g, "").replace(/\[REACT:[^\]]*\]/g, "").replace(/\[HISTORY_SEARCH:[^\]]*\]/g, "").replace(/You have access to the following tools:[\s\S]*?(?=\n\n)/g, "").replace(/Available tools:[\s\S]*?(?=\n\n)/g, "").replace(/MCP servers?:[\s\S]*?(?=\n\n)/g, "").replace(/You are CC-Claw[\s\S]*?(?=\n\n)/g, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+var init_prompt = __esm({
+  "src/services/ollama/prompt.ts"() {
+    "use strict";
+  }
+});
+
+// src/services/ollama/index.ts
+var ollama_exports = {};
+__export(ollama_exports, {
+  OllamaClient: () => client_exports,
+  OllamaPrompt: () => prompt_exports,
+  OllamaService: () => service_exports,
+  OllamaStore: () => store_exports6
+});
+var init_ollama = __esm({
+  "src/services/ollama/index.ts"() {
+    "use strict";
+    init_client();
+    init_service();
+    init_store6();
+    init_prompt();
+  }
+});
+
+// src/backends/ollama.ts
+var OLLAMA_HTTP_SENTINEL, OllamaAdapter;
+var init_ollama2 = __esm({
+  "src/backends/ollama.ts"() {
+    "use strict";
+    init_ollama();
+    init_prompt();
+    OLLAMA_HTTP_SENTINEL = "__ollama_http__";
+    OllamaAdapter = class {
+      id = "ollama";
+      displayName = "Ollama (Local)";
+      // Dynamically populated — starts empty and is refreshed by discoverModels()
+      availableModels = {};
+      pricing = {};
+      contextWindow = {};
+      get defaultModel() {
+        try {
+          const route = service_exports.getModelForTask("chat");
+          return route?.model.name ?? "";
+        } catch {
+          return "";
+        }
       }
-      getSubagentInstructions() {
-        return "You have native sub-agent support via the Task tool. Built-in agent types: generalPurpose (multi-step tasks), explore (fast codebase search), shell (command execution), code-reviewer. Use them for parallel work.";
+      get summarizerModel() {
+        try {
+          const route = service_exports.getModelForTask("summarize");
+          return route?.model.name ?? "";
+        } catch {
+          return "";
+        }
+      }
+      // ── CLI stubs (Ollama doesn't use CLI spawning) ────────────────────
+      getExecutablePath() {
+        return OLLAMA_HTTP_SENTINEL;
+      }
+      getEnv() {
+        return {};
+      }
+      buildSpawnConfig(_opts) {
+        throw new Error(
+          "Ollama uses streamDirect(), not CLI spawning. If you're seeing this, askAgent's streamDirect check was bypassed."
+        );
+      }
+      applyThinkingConfig(_level, _model) {
+        return {};
+      }
+      parseLine(_raw) {
+        return [];
       }
       shouldKillOnResult() {
         return false;
       }
-      resolveModelWithThinking(model2, level) {
-        if (!model2 || !level || level === "auto") return model2;
-        const variants = THINKING_VARIANTS[model2];
-        if (!variants) return model2;
-        return variants[level] ?? model2;
+      // ── Direct execution (the real path) ───────────────────────────────
+      async streamDirect(prompt, model2, opts) {
+        const serverInfo = service_exports.getServerForModel(model2);
+        if (!serverInfo) {
+          throw new Error(`No online Ollama server found hosting model "${model2}"`);
+        }
+        const cleanPrompt = stripForLocalModel(prompt);
+        const result = await client_exports.generate(
+          serverInfo.baseUrl,
+          model2,
+          cleanPrompt,
+          {
+            systemPrompt: opts?.systemPrompt,
+            temperature: opts?.temperature,
+            maxTokens: opts?.maxTokens,
+            timeoutMs: opts?.timeoutMs,
+            signal: opts?.signal,
+            onStream: opts?.onStream,
+            apiKey: serverInfo.apiKey
+          }
+        );
+        return {
+          text: result.text,
+          usage: {
+            input: result.usage.promptTokens,
+            output: result.usage.completionTokens
+          }
+        };
+      }
+      /**
+       * Refresh the availableModels / pricing / contextWindow maps
+       * from the discovered models in the database.
+       * Called after discoverModels() or on startup.
+       */
+      refreshModelCatalog() {
+        for (const key of Object.keys(this.availableModels)) delete this.availableModels[key];
+        for (const key of Object.keys(this.pricing)) delete this.pricing[key];
+        for (const key of Object.keys(this.contextWindow)) delete this.contextWindow[key];
+        const { OllamaStore } = (init_ollama(), __toCommonJS(ollama_exports));
+        const models = OllamaStore.getAvailableModels();
+        for (const m of models) {
+          this.availableModels[m.name] = {
+            label: `${m.name}${m.parameterSize ? ` (${m.parameterSize})` : ""}`,
+            thinking: "none"
+          };
+          this.pricing[m.name] = { in: 0, out: 0, cache: 0 };
+          this.contextWindow[m.name] = m.contextWindow ?? 4096;
+        }
       }
     };
   }
@@ -5261,7 +6341,8 @@ var init_types = __esm({
       CLAUDE: "claude",
       GEMINI: "gemini",
       CODEX: "codex",
-      CURSOR: "cursor"
+      CURSOR: "cursor",
+      OLLAMA: "ollama"
     };
   }
 });
@@ -5276,14 +6357,17 @@ __export(backends_exports, {
   getAllBackendIds: () => getAllBackendIds,
   getAvailableAdapters: () => getAvailableAdapters,
   getAvailableBackendIds: () => getAvailableBackendIds,
+  getAvailableChatBackendIds: () => getAvailableChatBackendIds,
+  getChatBackendIds: () => getChatBackendIds,
   isBackendId: () => isBackendId,
   probeBackendAvailability: () => probeBackendAvailability
 });
 import { existsSync as existsSync6 } from "fs";
 import { execSync as execSync2 } from "child_process";
-function probeBackendAvailability() {
+async function probeBackendAvailability() {
   availableSet.clear();
   for (const [id, adapter] of Object.entries(adapters)) {
+    if (id === "ollama") continue;
     try {
       const exe = adapter.getExecutablePath();
       if (existsSync6(exe) || resolveOnPath(exe)) {
@@ -5292,6 +6376,14 @@ function probeBackendAvailability() {
     } catch {
     }
   }
+  try {
+    const { OllamaService } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+    const online = await OllamaService.isAnyServerOnline();
+    if (online) {
+      availableSet.add("ollama");
+    }
+  } catch {
+  }
   log(`[backends] Available: ${[...availableSet].join(", ") || "none"}`);
 }
 function resolveOnPath(name) {
@@ -5320,6 +6412,9 @@ function getAllAdapters() {
 function getAllBackendIds() {
   return Object.keys(adapters);
 }
+function getChatBackendIds() {
+  return CHAT_BACKEND_IDS;
+}
 function getAvailableAdapters() {
   if (availableSet.size === 0) return Object.values(adapters);
   return Object.values(adapters).filter((a) => availableSet.has(a.id));
@@ -5328,7 +6423,10 @@ function getAvailableBackendIds() {
   if (availableSet.size === 0) return Object.keys(adapters);
   return [...availableSet];
 }
-var adapters, availableSet;
+function getAvailableChatBackendIds() {
+  return CHAT_BACKEND_IDS.filter((id) => availableSet.size === 0 || availableSet.has(id));
+}
+var adapters, CHAT_BACKEND_IDS, availableSet;
 var init_backends = __esm({
   "src/backends/index.ts"() {
     "use strict";
@@ -5336,6 +6434,7 @@ var init_backends = __esm({
     init_gemini();
     init_codex();
     init_cursor();
+    init_ollama2();
     init_store5();
     init_log();
     init_types();
@@ -5343,8 +6442,10 @@ var init_backends = __esm({
       claude: new ClaudeAdapter(),
       gemini: new GeminiAdapter(),
       codex: new CodexAdapter(),
-      cursor: new CursorAdapter()
+      cursor: new CursorAdapter(),
+      ollama: new OllamaAdapter()
     };
+    CHAT_BACKEND_IDS = ["claude", "gemini", "codex", "cursor"];
     availableSet = /* @__PURE__ */ new Set();
   }
 });
@@ -6324,7 +7425,20 @@ function getTranscriptCap(model2) {
   if (model2 && /flash/i.test(model2)) return TRANSCRIPT_CAP_FLASH;
   return TRANSCRIPT_CAP_DEFAULT;
 }
-function buildTranscript(entries) {
+function getOllamaTranscriptCap(model2) {
+  try {
+    const { OllamaStore } = (init_ollama(), __toCommonJS(ollama_exports));
+    const models = OllamaStore.listModels();
+    const match = models.find((m) => m.name === model2);
+    if (match?.contextWindow && match.contextWindow > 0) {
+      return Math.min(Math.floor(match.contextWindow * 3 * 0.8), TRANSCRIPT_CAP_DEFAULT);
+    }
+  } catch {
+  }
+  return TRANSCRIPT_CAP_OLLAMA_DEFAULT;
+}
+function buildTranscript(entries, cap) {
+  const transcriptCap = cap ?? getTranscriptCap();
   const lines = [];
   let totalLen = 0;
   for (let i = entries.length - 1; i >= 0; i--) {
@@ -6333,7 +7447,7 @@ function buildTranscript(entries) {
     const label2 = e.role === "user" ? "User" : "Agent";
     const text = e.text.length > limit ? e.text.slice(0, limit) + "\n[...truncated]" : e.text;
     const line = `[${label2}] ${text}`;
-    if (totalLen + line.length > getTranscriptCap()) {
+    if (totalLen + line.length > transcriptCap) {
       lines.push("[...earlier messages truncated for length]");
       break;
     }
@@ -6343,6 +7457,17 @@ function buildTranscript(entries) {
   lines.reverse();
   return lines.join("\n\n");
 }
+function parseSummaryResult(rawText) {
+  const summaryMatch = rawText.match(/SUMMARY:\s*(.+?)(?=\nKEY_DETAILS:|\nTOPICS:|$)/s);
+  const keyDetailsMatch = rawText.match(/KEY_DETAILS:\s*(.+?)(?=\nTOPICS:|$)/s);
+  const topicsMatch = rawText.match(/TOPICS:\s*(.+)/);
+  let summary = summaryMatch?.[1]?.trim() ?? rawText.trim();
+  const keyDetails = keyDetailsMatch?.[1]?.trim();
+  if (keyDetails) summary += `
+Key details: ${keyDetails}`;
+  const topics = topicsMatch?.[1]?.trim() ?? "";
+  return { summary, topics };
+}
 async function attemptSummarize(chatId, adapter, model2, entries) {
   const transcript = buildTranscript(entries);
   const prompt = `${SUMMARIZE_PROMPT}
@@ -6430,14 +7555,7 @@ ${transcript}`;
       warn(`[summarize] ${adapter.id}:${model2} returned empty result for chat ${chatId}`);
       return { success: false, rawText: "" };
     }
-    const summaryMatch = resultText.match(/SUMMARY:\s*(.+?)(?=\nKEY_DETAILS:|\nTOPICS:|$)/s);
-    const keyDetailsMatch = resultText.match(/KEY_DETAILS:\s*(.+?)(?=\nTOPICS:|$)/s);
-    const topicsMatch = resultText.match(/TOPICS:\s*(.+)/);
-    let summary = summaryMatch?.[1]?.trim() ?? resultText.trim();
-    const keyDetails = keyDetailsMatch?.[1]?.trim();
-    if (keyDetails) summary += `
-Key details: ${keyDetails}`;
-    const topics = topicsMatch?.[1]?.trim() ?? "";
+    const { summary, topics } = parseSummaryResult(resultText);
     saveSessionSummaryWithEmbedding(chatId, summary, topics, Math.floor(entries.length / 2));
     log(`[summarize] Saved summary via ${adapter.id}:${model2} for chat ${chatId}`);
     return { success: true, rawText: resultText };
@@ -6446,6 +7564,35 @@ Key details: ${keyDetails}`;
     return { success: false, rawText: "" };
   }
 }
+async function attemptSummarizeDirect(chatId, directFn, backendId, model2, entries, transcriptCap) {
+  const transcript = buildTranscript(entries, transcriptCap);
+  const prompt = `${SUMMARIZE_PROMPT}
+
+Conversation:
+${transcript}`;
+  try {
+    const result = await Promise.race([
+      directFn(prompt),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Direct summarize timeout")), SUMMARIZE_TIMEOUT_MS)
+      )
+    ]);
+    if (result.usage) {
+      addUsage(chatId, result.usage.input, result.usage.output, 0, model2);
+    }
+    if (!result.text) {
+      warn(`[summarize] ${backendId}:${model2} (direct) returned empty for ${chatId}`);
+      return { success: false, rawText: "" };
+    }
+    const { summary, topics } = parseSummaryResult(result.text);
+    saveSessionSummaryWithEmbedding(chatId, summary, topics, Math.floor(entries.length / 2));
+    log(`[summarize] Saved summary via ${backendId}:${model2} (direct) for chat ${chatId}`);
+    return { success: true, rawText: result.text };
+  } catch (err) {
+    warn(`[summarize] ${backendId}:${model2} (direct) failed for ${chatId}: ${errorMessage(err)}`);
+    return { success: false, rawText: "" };
+  }
+}
 async function extractAndLogSignals(rawText, chatId, adapterId, model2) {
   try {
     const { getReflectionStatus: getReflectionStatus2, logSignal: logSignal2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
@@ -6493,6 +7640,26 @@ async function summarizeWithFallbackChain(chatId, targetBackendId, excludeBacken
       const excluded = getAdapter(excludeBackend);
       tried.add(`${excluded.id}:${excluded.summarizerModel}`);
     }
+    const globalConfig = getGlobalSummarizer();
+    if (globalConfig.backend === "ollama") {
+      try {
+        const ollamaAdapter = getAdapter("ollama");
+        if (ollamaAdapter.streamDirect) {
+          const ollamaModel = globalConfig.model ?? ollamaAdapter.summarizerModel;
+          const cap = getOllamaTranscriptCap(ollamaModel);
+          const key = `${ollamaAdapter.id}:${ollamaModel}`;
+          tried.add(key);
+          const directFn = (prompt) => ollamaAdapter.streamDirect(prompt, ollamaModel);
+          const result = await attemptSummarizeDirect(chatId, directFn, "ollama", ollamaModel, entries, cap);
+          if (result.success) {
+            await extractAndLogSignals(result.rawText, chatId, "ollama", ollamaModel);
+            if (clearLogAfter) clearLog(chatId);
+            return true;
+          }
+        }
+      } catch {
+      }
+    }
     try {
       const config2 = getSummarizer(chatId);
       if (config2.backend !== "off") {
@@ -6535,7 +7702,14 @@ async function summarizeWithFallbackChain(chatId, targetBackendId, excludeBacken
       if (!tried.has(key)) {
         tried.add(key);
         fallbackCount++;
-        const result = await attemptSummarize(chatId, adapter, model2, entries);
+        let result;
+        if (adapter.streamDirect) {
+          const cap = adapter.id === "ollama" ? getOllamaTranscriptCap(model2) : getTranscriptCap(model2);
+          const directFn = (prompt) => adapter.streamDirect(prompt, model2);
+          result = await attemptSummarizeDirect(chatId, directFn, adapter.id, model2, entries, cap);
+        } else {
+          result = await attemptSummarize(chatId, adapter, model2, entries);
+        }
         if (result.success) {
           await extractAndLogSignals(result.rawText, chatId, adapter.id, model2);
           if (clearLogAfter) clearLog(chatId);
@@ -6573,7 +7747,7 @@ async function summarizeAllPending() {
     await summarizeSession(chatId);
   }
 }
-var MIN_PAIRS, summarizationLocks, USER_MSG_LIMIT, AGENT_MSG_LIMIT, TRANSCRIPT_CAP_DEFAULT, TRANSCRIPT_CAP_FLASH, SUMMARIZE_TIMEOUT_MS, SUMMARIZE_PROMPT, VALID_SIGNAL_TYPES;
+var MIN_PAIRS, summarizationLocks, USER_MSG_LIMIT, AGENT_MSG_LIMIT, TRANSCRIPT_CAP_DEFAULT, TRANSCRIPT_CAP_FLASH, TRANSCRIPT_CAP_OLLAMA_DEFAULT, SUMMARIZE_TIMEOUT_MS, SUMMARIZE_PROMPT, VALID_SIGNAL_TYPES;
 var init_summarize = __esm({
   "src/memory/summarize.ts"() {
     "use strict";
@@ -6590,6 +7764,7 @@ var init_summarize = __esm({
     AGENT_MSG_LIMIT = 6e3;
     TRANSCRIPT_CAP_DEFAULT = 1e5;
     TRANSCRIPT_CAP_FLASH = 5e4;
+    TRANSCRIPT_CAP_OLLAMA_DEFAULT = 15e3;
     SUMMARIZE_TIMEOUT_MS = 6e4;
     SUMMARIZE_PROMPT = `You are summarizing a conversation session for long-term episodic memory. This summary will be injected into future conversations to provide context, so it must contain enough specific detail to be useful weeks or months later.
 
@@ -7647,7 +8822,8 @@ function spawnAgentProcess(runner, opts, callbacks) {
               } catch {
                 try {
                   child.kill("SIGTERM");
-                } catch {
+                } catch (killErr) {
+                  warn(`[spawn] Kill fallback failed for pid ${child.pid}: ${killErr}`);
                 }
               }
             }
@@ -7673,6 +8849,7 @@ var init_spawn = __esm({
     "use strict";
     init_env();
     init_roles();
+    init_log();
     SENSITIVE_ENV_KEYS = [
       "TELEGRAM_BOT_TOKEN",
       "GROQ_API_KEY",
@@ -7683,7 +8860,10 @@ var init_spawn = __esm({
       // Audit C15: API keys that should not leak to sub-agents
       "ANTHROPIC_API_KEY",
       "GEMINI_API_KEY",
-      "OPENAI_API_KEY"
+      "OPENAI_API_KEY",
+      // Audit C26: Cursor and Codex keys were missing — sub-agents inherited them
+      "CURSOR_API_KEY",
+      "CODEX_API_KEY"
     ];
   }
 });
@@ -11255,6 +12435,9 @@ var init_apply = __esm({
 });
 
 // src/dashboard/routes/evolve.ts
+function resolveChatId(body) {
+  return body.chatId || (process.env.ALLOWED_CHAT_ID ?? "").split(",")[0]?.trim() || null;
+}
 var handleAnalyze, handleApply, handleReject, handleUndo, handleEvolveOn, handleEvolveOff, handleEvolveModel, handleEvolveSettings;
 var init_evolve = __esm({
   "src/dashboard/routes/evolve.ts"() {
@@ -11265,8 +12448,9 @@ var init_evolve = __esm({
     handleAnalyze = async (req, res) => {
       try {
         const body = JSON.parse(await readBody(req));
+        const chatId = resolveChatId(body);
+        if (!chatId) return jsonResponse(res, { error: "No chatId provided and ALLOWED_CHAT_ID is not set" }, 400);
         const { runAnalysis: runAnalysis2 } = await Promise.resolve().then(() => (init_analyze(), analyze_exports));
-        const chatId = body.chatId || (process.env.ALLOWED_CHAT_ID ?? "").split(",")[0]?.trim() || "default";
         const insights = await runAnalysis2(chatId);
         jsonResponse(res, { success: true, insights: insights.length });
       } catch (err) {
@@ -11310,7 +12494,8 @@ var init_evolve = __esm({
         const { existsSync: fileExists, readFileSync: fileRead } = await import("fs");
         const { join: join35 } = await import("path");
         const { CC_CLAW_HOME: home } = await Promise.resolve().then(() => (init_paths(), paths_exports));
-        const chatId = body.chatId || (process.env.ALLOWED_CHAT_ID ?? "").split(",")[0]?.trim() || "default";
+        const chatId = resolveChatId(body);
+        if (!chatId) return jsonResponse(res, { error: "No chatId provided and ALLOWED_CHAT_ID is not set" }, 400);
         const soulPath = join35(home, "identity/SOUL.md");
         const userPath = join35(home, "identity/USER.md");
         const soul = fileExists(soulPath) ? fileRead(soulPath, "utf-8") : "";
@@ -11325,7 +12510,8 @@ var init_evolve = __esm({
       try {
         const body = JSON.parse(await readBody(req));
         const { setReflectionStatus: setReflectionStatus2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
-        const chatId = body.chatId || (process.env.ALLOWED_CHAT_ID ?? "").split(",")[0]?.trim() || "default";
+        const chatId = resolveChatId(body);
+        if (!chatId) return jsonResponse(res, { error: "No chatId provided and ALLOWED_CHAT_ID is not set" }, 400);
         setReflectionStatus2(getDb(), chatId, "frozen");
         jsonResponse(res, { success: true, status: "frozen" });
       } catch (err) {
@@ -11336,7 +12522,8 @@ var init_evolve = __esm({
       try {
         const body = JSON.parse(await readBody(req));
         const { setReflectionModelConfig: setReflectionModelConfig2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
-        const chatId = body.chatId || (process.env.ALLOWED_CHAT_ID ?? "").split(",")[0]?.trim() || "default";
+        const chatId = resolveChatId(body);
+        if (!chatId) return jsonResponse(res, { error: "No chatId provided and ALLOWED_CHAT_ID is not set" }, 400);
         setReflectionModelConfig2(getDb(), chatId, body.mode, body.backend, body.model);
         jsonResponse(res, { success: true });
       } catch (err) {
@@ -11347,7 +12534,8 @@ var init_evolve = __esm({
       try {
         const body = JSON.parse(await readBody(req));
         const { setReflectionSettings: setReflectionSettings2, getReflectionSettings: getReflectionSettings2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
-        const chatId = body.chatId || (process.env.ALLOWED_CHAT_ID ?? "").split(",")[0]?.trim() || "default";
+        const chatId = resolveChatId(body);
+        if (!chatId) return jsonResponse(res, { error: "No chatId provided and ALLOWED_CHAT_ID is not set" }, 400);
         const updates = {};
         if (body.perFileCap !== void 0) updates.perFileCap = body.perFileCap;
         if (body.backupRetentionDays !== void 0) updates.backupRetentionDays = body.backupRetentionDays;
@@ -11808,8 +12996,10 @@ __export(agent_exports, {
   getInFlightMessage: () => getInFlightMessage,
   isChatBusy: () => isChatBusy,
   isSyntheticChatId: () => isSyntheticChatId,
+  startStaleChatSweep: () => startStaleChatSweep,
   stopAgent: () => stopAgent,
-  stopAllActiveAgents: () => stopAllActiveAgents
+  stopAllActiveAgents: () => stopAllActiveAgents,
+  stopStaleChatSweep: () => stopStaleChatSweep
 });
 import { spawn as spawn6 } from "child_process";
 import { createInterface as createInterface5 } from "readline";
@@ -11830,6 +13020,26 @@ function killProcessGroup(proc, signal = "SIGTERM") {
     }
   }
 }
+function sweepStaleChatEntries() {
+  for (const [chatId, state] of activeChats) {
+    if (state.process && state.process.exitCode !== null) {
+      warn(`[agent] Sweeping stale activeChats entry for ${chatId} (process exited with code ${state.process.exitCode})`);
+      if (state.killTimer) clearTimeout(state.killTimer);
+      activeChats.delete(chatId);
+    }
+  }
+}
+function startStaleChatSweep() {
+  if (staleSweepTimer) return;
+  staleSweepTimer = setInterval(sweepStaleChatEntries, 15 * 60 * 1e3);
+  staleSweepTimer.unref();
+}
+function stopStaleChatSweep() {
+  if (staleSweepTimer) {
+    clearInterval(staleSweepTimer);
+    staleSweepTimer = void 0;
+  }
+}
 function withChatLock(chatId, fn) {
   const prev = chatLocks.get(chatId) ?? Promise.resolve();
   const isBlocked = activeChats.has(chatId);
@@ -11858,6 +13068,9 @@ function stopAgent(chatId) {
   const state = activeChats.get(chatId);
   if (!state) return false;
   state.cancelled = true;
+  if (state.abortController) {
+    state.abortController.abort();
+  }
   if (state.process) {
     killProcessGroup(state.process, "SIGTERM");
     state.killTimer = setTimeout(() => {
@@ -12324,6 +13537,49 @@ async function askAgentImpl(chatId, userMessage, opts) {
   const effectiveAgentMode = optsAgentMode ?? getAgentMode(settingsChat);
   const sideQuestCtx = settingsSourceChatId ? { parentChatId: settingsSourceChatId, actualChatId: chatId } : void 0;
   const fullPrompt = await assembleBootstrapPrompt(userMessage, tier, settingsChat, mode, responseStyle, effectiveAgentMode, sideQuestCtx, planningDirective);
+  if (adapter.streamDirect) {
+    const resolvedModel2 = model2 ?? adapter.defaultModel;
+    const abortController = new AbortController();
+    const cancelState2 = { cancelled: false, userMessage, abortController };
+    activeChats.set(chatId, cancelState2);
+    try {
+      const sdResult = await adapter.streamDirect(fullPrompt, resolvedModel2, {
+        timeoutMs: timeoutMs ?? 12e4,
+        onStream,
+        signal: abortController.signal
+      });
+      if (!isSyntheticChatId(chatId)) {
+        appendToLog(chatId, userMessage, sdResult.text, adapter.id, resolvedModel2, null);
+        const AUTO_SUMMARIZE_THRESHOLD = 30;
+        const pairCount = tier !== "chat" ? getMessagePairCount(chatId) : 0;
+        if (pairCount >= AUTO_SUMMARIZE_THRESHOLD) {
+          log(`[agent] Auto-summarizing chat ${chatId} after ${pairCount} turns`);
+          summarizeWithFallbackChain(chatId).then((saved) => {
+            if (saved) {
+              clearSession(chatId);
+              opts?.onCompaction?.(chatId);
+            }
+          }).catch((err) => {
+            warn(`[agent] Auto-summarize failed for chat ${chatId}: ${err}`);
+          });
+        }
+      }
+      const sdUsage = sdResult.usage ?? { input: 0, output: 0 };
+      if (sdUsage.input + sdUsage.output > 0) {
+        addUsage(chatId, sdUsage.input, sdUsage.output, 0, resolvedModel2);
+      }
+      if (cancelState2.cancelled) {
+        return { text: "Stopped.", usage: { input: sdUsage.input, output: sdUsage.output, cacheRead: 0 } };
+      }
+      return {
+        text: sdResult.text || `(No response from ${adapter.displayName})`,
+        usage: { input: sdUsage.input, output: sdUsage.output, cacheRead: 0 },
+        resolvedModel: resolvedModel2
+      };
+    } finally {
+      activeChats.delete(chatId);
+    }
+  }
   const existingSessionId = settingsSourceChatId ? null : getSessionId(settingsChat);
   const allowedTools = getEnabledTools(settingsChat);
   const mcpConfigPath = tier !== "slim" && effectiveAgentMode !== "native" && MCP_CONFIG_FLAG[adapter.id] ? getMcpConfigPath(chatId) : null;
@@ -12471,24 +13727,46 @@ async function askAgentImpl(chatId, userMessage, opts) {
         result = await spawnQuery(adapter, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, retryOpts);
       }
     } else if (errMsg.startsWith(CONTENT_SILENCE_TIMEOUT_ERROR) && existingSessionId) {
-      warn(`[agent] Content silence on ${adapter.id} \u2014 clearing session ${existingSessionId} and retrying fresh`);
-      clearSession(chatId);
-      if (useGeminiRotation) {
-        const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
-        const downgradeCb = onModelDowngrade ? (from, to, reason) => onModelDowngrade(chatId, from, to, reason) : void 0;
-        result = await spawnGeminiWithRotation(chatId, adapter, baseConfig, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, geminiRotationMode, spawnOpts, rotationCb, settingsSourceChatId, downgradeCb);
-      } else if (useBackendRotation) {
-        const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
-        result = await spawnWithSlotRotation(chatId, adapter, baseConfig, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, backendRotationMode, allowPaid, spawnOpts, rotationCb);
-      } else {
-        const retryOpts = (() => {
-          if (adapter.id !== "gemini") return spawnOpts;
-          const geminiAdapter = adapter;
-          const { env, slot } = geminiAdapter.resolveSlotEnv(chatId);
-          if (slot) return { ...spawnOpts, envOverride: env };
-          return spawnOpts;
-        })();
-        result = await spawnQuery(adapter, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, retryOpts);
+      warn(`[agent] Content silence on ${adapter.id} \u2014 retrying with session ${existingSessionId}`);
+      try {
+        if (useGeminiRotation) {
+          const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
+          const downgradeCb = onModelDowngrade ? (from, to, reason) => onModelDowngrade(chatId, from, to, reason) : void 0;
+          result = await spawnGeminiWithRotation(chatId, adapter, configWithSession, configWithSession, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, geminiRotationMode, spawnOpts, rotationCb, settingsSourceChatId, downgradeCb);
+        } else if (useBackendRotation) {
+          const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
+          result = await spawnWithSlotRotation(chatId, adapter, configWithSession, configWithSession, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, backendRotationMode, allowPaid, spawnOpts, rotationCb);
+        } else {
+          const retryOpts = (() => {
+            if (adapter.id !== "gemini") return spawnOpts;
+            const geminiAdapter = adapter;
+            const { env, slot } = geminiAdapter.resolveSlotEnv(chatId);
+            if (slot) return { ...spawnOpts, envOverride: env };
+            return spawnOpts;
+          })();
+          result = await spawnQuery(adapter, configWithSession, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, retryOpts);
+        }
+      } catch (retryErr) {
+        const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+        warn(`[agent] Content silence session retry also failed on ${adapter.id} \u2014 clearing session and retrying fresh`);
+        clearSession(chatId);
+        if (useGeminiRotation) {
+          const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
+          const downgradeCb = onModelDowngrade ? (from, to, reason) => onModelDowngrade(chatId, from, to, reason) : void 0;
+          result = await spawnGeminiWithRotation(chatId, adapter, baseConfig, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, geminiRotationMode, spawnOpts, rotationCb, settingsSourceChatId, downgradeCb);
+        } else if (useBackendRotation) {
+          const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
+          result = await spawnWithSlotRotation(chatId, adapter, baseConfig, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, backendRotationMode, allowPaid, spawnOpts, rotationCb);
+        } else {
+          const retryOpts = (() => {
+            if (adapter.id !== "gemini") return spawnOpts;
+            const geminiAdapter = adapter;
+            const { env, slot } = geminiAdapter.resolveSlotEnv(chatId);
+            if (slot) return { ...spawnOpts, envOverride: env };
+            return spawnOpts;
+          })();
+          result = await spawnQuery(adapter, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, retryOpts);
+        }
       }
     } else {
       if (!isSyntheticChatId(chatId)) {
@@ -12594,7 +13872,7 @@ function injectMcpConfig(adapterId, args, mcpConfigPath) {
   if (!flag) return args;
   return [...args, ...flag, mcpConfigPath];
 }
-var activeChats, chatLocks, SPAWN_TIMEOUT_MS, FIRST_RESPONSE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_ERROR, FIRST_RESPONSE_TIMEOUT_ERROR, FREE_SLOTS_EXHAUSTED, GEMINI_FALLBACK_CHAIN, GEMINI_DOWNGRADE_MODELS, MCP_CONFIG_FLAG;
+var activeChats, staleSweepTimer, chatLocks, SPAWN_TIMEOUT_MS, FIRST_RESPONSE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_ERROR, FIRST_RESPONSE_TIMEOUT_ERROR, FREE_SLOTS_EXHAUSTED, GEMINI_FALLBACK_CHAIN, GEMINI_DOWNGRADE_MODELS, MCP_CONFIG_FLAG;
 var init_agent = __esm({
   "src/agent.ts"() {
     "use strict";
@@ -14284,6 +15562,12 @@ var init_session_log2 = __esm({
 });
 
 // src/router/live-status.ts
+function canFlushGlobally() {
+  return Date.now() - globalLastFlushAt >= GLOBAL_MIN_GAP_MS;
+}
+function markGlobalFlush() {
+  globalLastFlushAt = Date.now();
+}
 function dedupThinking(entries) {
   const out = [];
   for (const e of entries) {
@@ -14327,7 +15611,7 @@ function makeLiveStatus(chatId, channel, modelLabel, verboseLevel, showThinking)
   };
   return { liveStatus, toolCb };
 }
-var FLUSH_INTERVAL_DM_MS, FLUSH_INTERVAL_GROUP_MS, MAX_THINKING_CHARS, TRIM_THRESHOLD, MAX_ENTRIES, LiveStatusMessage;
+var FLUSH_INTERVAL_DM_MS, FLUSH_INTERVAL_GROUP_MS, MAX_THINKING_CHARS, GLOBAL_MIN_GAP_MS, globalLastFlushAt, TRIM_THRESHOLD, MAX_ENTRIES, LiveStatusMessage;
 var init_live_status = __esm({
   "src/router/live-status.ts"() {
     "use strict";
@@ -14336,6 +15620,8 @@ var init_live_status = __esm({
     FLUSH_INTERVAL_DM_MS = 1e3;
     FLUSH_INTERVAL_GROUP_MS = 3e3;
     MAX_THINKING_CHARS = 800;
+    GLOBAL_MIN_GAP_MS = 500;
+    globalLastFlushAt = 0;
     TRIM_THRESHOLD = 3500;
     MAX_ENTRIES = 200;
     LiveStatusMessage = class {
@@ -14435,10 +15721,12 @@ var init_live_status = __esm({
       async flush() {
         if (this.finalized || !this.messageId || !this.channel.editText) return;
         if (Date.now() < this.nextFlushAllowedAt) return;
+        if (!canFlushGlobally()) return;
         const deduped = dedupThinking(this.entries);
         const body = renderEntries(deduped, this.modelLabel, Date.now() - this.startTime, this.hasTrimmed);
         if (body === this.lastRendered) return;
         this.lastRendered = body;
+        markGlobalFlush();
         try {
           await this.channel.editText(this.chatId, this.messageId, body, "plain");
         } catch (err) {
@@ -16101,10 +17389,21 @@ function assembleHeartbeatPrompt(chatId) {
   if (failedSinceLastBeat.length > 0) {
     healthLines.push(`${failedSinceLastBeat.length} job run(s) failed recently.`);
   }
-  for (const backend2 of ["claude", "gemini", "codex", "cursor"]) {
+  for (const backend2 of getAllBackendIds()) {
     const limitMsg = checkBackendLimits(backend2);
     if (limitMsg) healthLines.push(limitMsg);
   }
+  try {
+    const { OllamaService } = (init_ollama(), __toCommonJS(ollama_exports));
+    const servers = OllamaService.listServers();
+    if (servers.length > 0) {
+      const offline = servers.filter((s) => s.status === "offline");
+      if (offline.length > 0) {
+        healthLines.push(`Ollama: ${offline.length}/${servers.length} server(s) offline: ${offline.map((s) => s.name).join(", ")}`);
+      }
+    }
+  } catch {
+  }
   if (healthLines.length > 0) {
     sections.push(`[System health]
 ${healthLines.join("\n")}`);
@@ -17487,13 +18786,13 @@ async function handleEvolveCallback(chatId, data, channel) {
       const { getReflectionStatus: getReflectionStatus2, setReflectionStatus: setReflectionStatus2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
       const current = getReflectionStatus2(getDb(), chatId);
       if (current === "frozen") {
-        const { readFileSync: readFileSync27, existsSync: existsSync55 } = await import("fs");
+        const { readFileSync: readFileSync27, existsSync: existsSync56 } = await import("fs");
         const { join: join35 } = await import("path");
         const { CC_CLAW_HOME: CC_CLAW_HOME3 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
         const soulPath = join35(CC_CLAW_HOME3, "identity/SOUL.md");
         const userPath = join35(CC_CLAW_HOME3, "identity/USER.md");
-        const soul = existsSync55(soulPath) ? readFileSync27(soulPath, "utf-8") : "";
-        const user = existsSync55(userPath) ? readFileSync27(userPath, "utf-8") : "";
+        const soul = existsSync56(soulPath) ? readFileSync27(soulPath, "utf-8") : "";
+        const user = existsSync56(userPath) ? readFileSync27(userPath, "utf-8") : "";
         setReflectionStatus2(getDb(), chatId, "active", soul, user);
         const { logActivity: logActivity2 } = await Promise.resolve().then(() => (init_store3(), store_exports3));
         logActivity2(getDb(), { chatId, source: "telegram", eventType: "reflection_unfrozen", summary: "Reflection enabled" });
@@ -20393,6 +21692,278 @@ var init_command_handlers = __esm({
   }
 });
 
+// src/router/ollama.ts
+var ollama_exports2 = {};
+__export(ollama_exports2, {
+  handleOllamaCallback: () => handleOllamaCallback,
+  handleOllamaCommand: () => handleOllamaCommand
+});
+async function handleOllamaCommand(chatId, commandArgs, channel) {
+  const [sub, ...rest] = (commandArgs || "").trim().split(/\s+/);
+  switch (sub) {
+    case "models":
+      return sendModelList(chatId, channel, rest[0]);
+    case "health":
+      return sendHealthCheck(chatId, channel);
+    case "discover":
+      return sendDiscover(chatId, channel, rest[0]);
+    case "add":
+      if (rest.length >= 2) return handleAdd(chatId, channel, rest[0], rest[1], rest[2] ? parseInt(rest[2], 10) : void 0);
+      if (rest.length === 1) return handleAdd(chatId, channel, rest[0], rest[0]);
+      await channel.sendText(chatId, "Usage: /ollama add <name> <host> [port]", { parseMode: "plain" });
+      return;
+    case "remove":
+      if (rest[0]) return sendRemoveConfirm(chatId, channel, rest[0]);
+      await channel.sendText(chatId, "Usage: /ollama remove <server-name>", { parseMode: "plain" });
+      return;
+    default:
+      return sendOllamaDashboard(chatId, channel);
+  }
+}
+async function sendOllamaDashboard(chatId, channel) {
+  const { OllamaStore } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+  const servers = OllamaStore.listServers();
+  if (servers.length === 0) {
+    const text = [
+      "<b>\u{1F999} Ollama</b>",
+      "",
+      "No servers configured.",
+      "",
+      "Add your first server:",
+      "  <code>/ollama add &lt;name&gt; &lt;host&gt; [port]</code>",
+      "",
+      "Example:",
+      "  <code>/ollama add local 192.168.1.100</code>"
+    ].join("\n");
+    if (typeof channel.sendKeyboard === "function") {
+      await channel.sendKeyboard(chatId, text, [
+        [{ label: "\u{1F4D6} Help", data: "ollama:help" }]
+      ]);
+    } else {
+      await channel.sendText(chatId, text, { parseMode: "html" });
+    }
+    return;
+  }
+  const lines = ["<b>\u{1F999} Ollama Servers</b>", ""];
+  for (const s of servers) {
+    const dot = s.status === "online" ? "\u{1F7E2}" : "\u{1F534}";
+    const modelCount = OllamaStore.listModels(s.id).length;
+    lines.push(`${dot} <b>${s.name}</b>  <code>${s.host}:${s.port}</code>`);
+    lines.push(`    ${modelCount} model${modelCount !== 1 ? "s" : ""} \xB7 ${s.status}`);
+  }
+  const onlineCount = servers.filter((s) => s.status === "online").length;
+  lines.push("", `${onlineCount}/${servers.length} online`);
+  if (typeof channel.sendKeyboard === "function") {
+    const buttons = [
+      [
+        { label: "\u{1F50D} Discover", data: "ollama:discover" },
+        { label: "\u{1F49A} Health", data: "ollama:health", style: "success" }
+      ],
+      [
+        { label: "\u{1F4CB} Models", data: "ollama:models" },
+        { label: "\u2795 Add", data: "ollama:add_prompt" }
+      ]
+    ];
+    if (servers.length <= 4) {
+      const removeRow = servers.map((s) => ({
+        label: `\u{1F5D1} ${s.name}`,
+        data: `ollama:remove_confirm:${s.name}`,
+        style: "danger"
+      }));
+      buttons.push(removeRow);
+    }
+    await channel.sendKeyboard(chatId, lines.join("\n"), buttons);
+  } else {
+    await channel.sendText(chatId, lines.join("\n"), { parseMode: "html" });
+  }
+}
+async function handleAdd(chatId, channel, name, host, port) {
+  const { OllamaStore, OllamaClient, OllamaService } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+  const existing = OllamaStore.getServer(name);
+  if (existing) {
+    await channel.sendText(chatId, `Server "${name}" already exists. Remove it first.`, { parseMode: "plain" });
+    return;
+  }
+  const actualPort = port ?? 11434;
+  await channel.sendText(chatId, `Adding ${name} (${host}:${actualPort})...`, { parseMode: "plain" });
+  const online = await OllamaClient.ping(`http://${host}:${actualPort}`, { timeoutMs: 5e3 });
+  const server = OllamaStore.addServer(name, host, actualPort, null);
+  OllamaStore.updateServerStatus(server.id, online ? "online" : "offline");
+  if (!online) {
+    await channel.sendText(chatId, `\u26A0\uFE0F Server "${name}" added but not responding. Check connectivity.`, { parseMode: "plain" });
+    return;
+  }
+  const models = await OllamaService.discoverModels(name);
+  const lines = [
+    `\u2705 Added "${name}" (${host}:${actualPort})`,
+    "",
+    `Found ${models.length} model(s):`
+  ];
+  for (const m of models) {
+    lines.push(`  \u2022 ${m.name}${m.parameterSize ? ` (${m.parameterSize})` : ""}`);
+  }
+  await channel.sendText(chatId, lines.join("\n"), { parseMode: "plain" });
+}
+async function sendModelList(chatId, channel, serverName) {
+  const { OllamaStore } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+  let models;
+  if (serverName) {
+    const server = OllamaStore.getServer(serverName);
+    if (!server) {
+      await channel.sendText(chatId, `Server "${serverName}" not found.`, { parseMode: "plain" });
+      return;
+    }
+    models = OllamaStore.listModels(server.id);
+  } else {
+    models = OllamaStore.getAvailableModels();
+  }
+  if (models.length === 0) {
+    await channel.sendText(chatId, "No models discovered. Run /ollama discover first.", { parseMode: "plain" });
+    return;
+  }
+  const lines = [
+    `<b>\u{1F9E0} Ollama Models</b>${serverName ? ` (${serverName})` : ""}`,
+    ""
+  ];
+  for (const m of models) {
+    const sizeGB = m.sizeBytes > 0 ? `${(m.sizeBytes / 1e9).toFixed(1)}GB` : "";
+    const ctxK = m.contextWindow ? `${Math.round(m.contextWindow / 1e3)}K ctx` : "";
+    const meta = [m.parameterSize, m.quantization, sizeGB, ctxK].filter(Boolean).join(" \xB7 ");
+    lines.push(`  \u2022 <b>${m.name}</b>`);
+    if (meta) lines.push(`    <i>${meta}</i>`);
+  }
+  lines.push("", `${models.length} model${models.length !== 1 ? "s" : ""} total`);
+  await channel.sendText(chatId, lines.join("\n"), { parseMode: "html" });
+}
+async function sendDiscover(chatId, channel, serverName) {
+  await channel.sendText(chatId, "\u{1F50D} Discovering models...", { parseMode: "plain" });
+  try {
+    const { OllamaService } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+    const models = await OllamaService.discoverModels(serverName);
+    if (models.length === 0) {
+      await channel.sendText(chatId, "No models found. Check server connectivity.", { parseMode: "plain" });
+      return;
+    }
+    const lines = [`\u2705 Found ${models.length} model(s):`, ""];
+    for (const m of models) {
+      const meta = [m.parameterSize, m.contextWindow ? `${Math.round(m.contextWindow / 1e3)}K ctx` : ""].filter(Boolean).join(" \xB7 ");
+      lines.push(`  \u2022 ${m.name}${meta ? ` (${meta})` : ""}`);
+    }
+    await channel.sendText(chatId, lines.join("\n"), { parseMode: "plain" });
+  } catch (err) {
+    await channel.sendText(chatId, `Discovery failed: ${err instanceof Error ? err.message : String(err)}`, { parseMode: "plain" });
+  }
+}
+async function sendHealthCheck(chatId, channel) {
+  await channel.sendText(chatId, "\u{1F49A} Pinging servers...", { parseMode: "plain" });
+  try {
+    const { OllamaService } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+    const results = await OllamaService.healthCheck();
+    if (results.length === 0) {
+      await channel.sendText(chatId, "No servers configured.", { parseMode: "plain" });
+      return;
+    }
+    const lines = ["Health Check Results:", ""];
+    for (const s of results) {
+      const dot = s.status === "online" ? "\u{1F7E2}" : "\u{1F534}";
+      lines.push(`${dot} ${s.name} (${s.host}:${s.port}) \u2014 ${s.status}`);
+    }
+    const online = results.filter((s) => s.status === "online").length;
+    lines.push("", `${online}/${results.length} online`);
+    await channel.sendText(chatId, lines.join("\n"), { parseMode: "plain" });
+  } catch (err) {
+    await channel.sendText(chatId, `Health check failed: ${err instanceof Error ? err.message : String(err)}`, { parseMode: "plain" });
+  }
+}
+async function sendRemoveConfirm(chatId, channel, name) {
+  const { OllamaStore } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+  const server = OllamaStore.getServer(name);
+  if (!server) {
+    await channel.sendText(chatId, `Server "${name}" not found.`, { parseMode: "plain" });
+    return;
+  }
+  const modelCount = OllamaStore.listModels(server.id).length;
+  const text = [
+    `Remove server <b>${name}</b>?`,
+    "",
+    `Host: ${server.host}:${server.port}`,
+    `Status: ${server.status}`,
+    `Models: ${modelCount}`,
+    "",
+    "This will also remove all cached model data."
+  ].join("\n");
+  if (typeof channel.sendKeyboard === "function") {
+    await channel.sendKeyboard(chatId, text, [
+      [
+        { label: "\u2705 Confirm", data: `ollama:remove:${name}`, style: "danger" },
+        { label: "\u274C Cancel", data: "ollama:dashboard" }
+      ]
+    ]);
+  } else {
+    await channel.sendText(chatId, text + "\n\nUse /ollama remove <name> to confirm.", { parseMode: "html" });
+  }
+}
+async function handleOllamaCallback(chatId, data, channel) {
+  const parts = data.split(":");
+  const action = parts[1];
+  switch (action) {
+    case "dashboard":
+      return sendOllamaDashboard(chatId, channel);
+    case "models":
+      return sendModelList(chatId, channel);
+    case "discover":
+      return sendDiscover(chatId, channel);
+    case "health":
+      return sendHealthCheck(chatId, channel);
+    case "remove_confirm": {
+      const name = parts.slice(2).join(":");
+      return sendRemoveConfirm(chatId, channel, name);
+    }
+    case "remove": {
+      const name = parts.slice(2).join(":");
+      const { OllamaStore } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+      const removed = OllamaStore.removeServer(name);
+      if (removed) {
+        await channel.sendText(chatId, `\u2705 Removed server "${name}"`, { parseMode: "plain" });
+      } else {
+        await channel.sendText(chatId, `Server "${name}" not found.`, { parseMode: "plain" });
+      }
+      return sendOllamaDashboard(chatId, channel);
+    }
+    case "add_prompt":
+      await channel.sendText(chatId, [
+        "To add a server, send:",
+        "",
+        "  /ollama add <name> <host> [port]",
+        "",
+        "Examples:",
+        "  /ollama add local 192.168.1.100",
+        "  /ollama add mac-studio 10.0.0.5 11434",
+        "  /ollama add cloud api.ollama.example.com 443"
+      ].join("\n"), { parseMode: "plain" });
+      return;
+    case "help":
+      await channel.sendText(chatId, [
+        "\u{1F999} Ollama Commands:",
+        "",
+        "/ollama \u2014 Server dashboard",
+        "/ollama add <name> <host> [port] \u2014 Add server",
+        "/ollama remove <name> \u2014 Remove server",
+        "/ollama models [server] \u2014 List models",
+        "/ollama discover [server] \u2014 Discover models",
+        "/ollama health \u2014 Ping all servers"
+      ].join("\n"), { parseMode: "plain" });
+      return;
+    default:
+      await channel.sendText(chatId, "Unknown action.", { parseMode: "plain" });
+  }
+}
+var init_ollama3 = __esm({
+  "src/router/ollama.ts"() {
+    "use strict";
+  }
+});
+
 // src/router/commands.ts
 async function handleCommand(msg, channel) {
   const { chatId, command, commandArgs } = msg;
@@ -20567,9 +22138,33 @@ async function handleCommand(msg, channel) {
     case "evolve":
       await handleEvolveCommandWrapper(chatId, commandArgs, msg, channel);
       break;
+    case "reflect": {
+      const { runAnalysis: runAnalysis2 } = await Promise.resolve().then(() => (init_analyze(), analyze_exports));
+      const { formatNightlySummary: formatNightlySummary2 } = await Promise.resolve().then(() => (init_propose(), propose_exports));
+      const { getPrimaryChatId: getPrimaryChatId2 } = await Promise.resolve().then(() => (init_resolve(), resolve_exports));
+      const reflectionChatId = getPrimaryChatId2() || chatId;
+      await channel.sendText(chatId, "\u{1F50D} Running reflection analysis\u2026", { parseMode: "plain" });
+      try {
+        const insights = await runAnalysis2(reflectionChatId, { force: true });
+        if (insights.length > 0) {
+          const nightlyItems = insights.map((ins, i) => ({ id: i + 1, ...ins }));
+          await channel.sendText(chatId, formatNightlySummary2(nightlyItems), { parseMode: "plain" });
+        } else {
+          await channel.sendText(chatId, "No new insights from reflection analysis.", { parseMode: "plain" });
+        }
+      } catch (e) {
+        await channel.sendText(chatId, `Analysis failed: ${e}`, { parseMode: "plain" });
+      }
+      break;
+    }
     case "optimize":
       await handleOptimizeCommandWrapper(chatId, commandArgs, msg, channel);
       break;
+    case "ollama": {
+      const { handleOllamaCommand: handleOllamaCommand2 } = await Promise.resolve().then(() => (init_ollama3(), ollama_exports2));
+      await handleOllamaCommand2(chatId, commandArgs ?? "", channel);
+      break;
+    }
     default:
       await channel.sendText(chatId, `Unknown command: /${command}. Type /help for available commands.`, { parseMode: "plain" });
   }
@@ -20741,7 +22336,7 @@ ${PERM_MODES[chosen]}`,
     const pending = getPendingEscalation(chatId);
     if (pending) {
       removePendingEscalation(chatId);
-      const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router(), router_exports));
+      const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router2(), router_exports));
       await handleMessage2({ text: pending, chatId, source: "telegram", type: "text" }, channel);
     }
   } else if (data === "perm:deny") {
@@ -20800,7 +22395,7 @@ ${PERM_MODES[chosen]}`,
     removePendingPlan(chatId);
     await replaceWithText("\u2705 Approved. Executing...");
     bypassBusyCheck.add(chatId);
-    const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router(), router_exports));
+    const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router2(), router_exports));
     const overrideMsg = `[SYSTEM: Planning mode disabled. Execution APPROVED. Please execute the plan.]
 ${plan.originalMessage}`;
     await handleMessage2(
@@ -20828,7 +22423,7 @@ ${plan.originalMessage}`;
     setExecMode(chatId, "yolo");
     await channel.sendText(chatId, "\u26A1 Switched to YOLO mode. Executing without approval gate...", { parseMode: "plain" });
     bypassBusyCheck.add(chatId);
-    const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router(), router_exports));
+    const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router2(), router_exports));
     const overrideMsg = `[SYSTEM: Planning mode disabled. YOLO mode enabled. Proceed immediately without asking for approval.]
 ${plan.originalMessage}`;
     await handleMessage2(
@@ -21142,7 +22737,7 @@ ${rotationNote}`, { parseMode: "html" });
       const pending = pendingFallbackMessages2.get(chatId);
       if (pending) {
         pendingFallbackMessages2.delete(chatId);
-        const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router(), router_exports));
+        const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router2(), router_exports));
         await handleMessage2(pending.msg, pending.channel);
       }
     } else if (action === "deny") {
@@ -21216,14 +22811,14 @@ ${rotationNote}`, { parseMode: "html" });
       stopAgent(targetChatId);
       await channel.sendText(chatId, "\u26A1 Stopping current task and processing your message\u2026", { parseMode: "plain" });
       bypassBusyCheck.add(targetChatId);
-      const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router(), router_exports));
+      const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router2(), router_exports));
       handleMessage2(pending.msg, pending.channel).catch(() => {
       });
     } else if (action === "queue" && pending) {
       pendingInterrupts.delete(targetChatId);
       bypassBusyCheck.add(targetChatId);
       await channel.sendText(chatId, "\u{1F4E5} Message queued \u2014 will process after current task.", { parseMode: "plain" });
-      const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router(), router_exports));
+      const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router2(), router_exports));
       handleMessage2(pending.msg, pending.channel).catch(() => {
       });
     } else if (action === "sidequest") {
@@ -21267,7 +22862,7 @@ ${rotationNote}`, { parseMode: "html" });
       setBackend(targetChatId, targetBackend);
       const adapter = getAdapter(targetBackend);
       await channel.sendText(chatId, `Switched to ${adapter.displayName}. Resending your message\u2026`, { parseMode: "plain" });
-      const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router(), router_exports));
+      const { handleMessage: handleMessage2 } = await Promise.resolve().then(() => (init_router2(), router_exports));
       await handleMessage2(pendingMsg.msg, pendingMsg.channel);
     } else {
       await channel.sendText(chatId, "Fallback expired. Use /backend to switch manually.", { parseMode: "plain" });
@@ -21281,6 +22876,10 @@ ${rotationNote}`, { parseMode: "html" });
   } else if (data.startsWith("opt:")) {
     await handleOptimizeCallback(chatId, data, channel);
     return;
+  } else if (data.startsWith("ollama:")) {
+    const { handleOllamaCallback: handleOllamaCallback2 } = await Promise.resolve().then(() => (init_ollama3(), ollama_exports2));
+    await handleOllamaCallback2(chatId, data, channel);
+    return;
   } else if (data.startsWith("summ:")) {
     const action = data.slice(5);
     if (action === "all") {
@@ -22175,7 +23774,7 @@ Approve paid usage for this session?`,
     }
   }
 }
-var init_router = __esm({
+var init_router2 = __esm({
   "src/router.ts"() {
     "use strict";
     init_profile();
@@ -22499,7 +24098,7 @@ async function runWithRetry(job, model2, runId, t0) {
         const vLevel = getVerboseLevel3(chatId);
         let onToolAction;
         if (vLevel !== "off") {
-          const { makeToolActionCallback: makeToolActionCallback2 } = await Promise.resolve().then(() => (init_router(), router_exports));
+          const { makeToolActionCallback: makeToolActionCallback2 } = await Promise.resolve().then(() => (init_router2(), router_exports));
           const channelName = job.channel ?? "telegram";
           const { getChannelRegistry: getChannelRegistry2 } = await Promise.resolve().then(() => (init_delivery(), delivery_exports));
           const channel = getChannelRegistry2()?.get(channelName);
@@ -23178,7 +24777,7 @@ var init_telegram = __esm({
           return `<s>${text}</s>`;
         },
         codespan(code) {
-          return `<code>${escapeHtml2(code)}</code>`;
+          return `<code>${code}</code>`;
         },
         code(code, lang) {
           const langAttr = lang ? ` class="language-${escapeHtml2(lang)}"` : "";
@@ -23229,13 +24828,37 @@ ${body.replace(/<[^>]*>/g, "").trim()}</code>
 
 // src/channels/telegram.ts
 import { API_CONSTANTS, Bot, GrammyError, InlineKeyboard, InputFile } from "grammy";
+function tripCircuitBreaker(retrySec) {
+  const until = Date.now() + retrySec * 1e3;
+  if (until > circuitBreakerUntil) {
+    circuitBreakerUntil = until;
+    warn(`[telegram] Circuit breaker tripped \u2014 pausing ALL Telegram API calls for ${retrySec}s`);
+  }
+}
+async function waitForCircuitBreaker() {
+  const remaining = circuitBreakerUntil - Date.now();
+  if (remaining <= 0) return false;
+  if (remaining > GIVE_UP_THRESHOLD_SEC * 1e3) return true;
+  await new Promise((r) => setTimeout(r, remaining));
+  return false;
+}
 async function withRetry(label2, fn) {
   for (let attempt = 0; attempt <= MAX_RETRIES2; attempt++) {
+    const tooLong = await waitForCircuitBreaker();
+    if (tooLong) {
+      warn(`[telegram] 429 on ${label2} \u2014 circuit breaker cooldown too long, giving up`);
+      throw new GrammyError(`Circuit breaker active \u2014 skipping ${label2}`, { ok: false, error_code: 429, description: "Rate limited (circuit breaker)" }, label2, {});
+    }
     try {
       return await fn();
     } catch (err) {
       if (err instanceof GrammyError && err.error_code === 429) {
-        const retrySec = Math.min(err.parameters?.retry_after ?? FALLBACK_RETRY_SEC, MAX_RETRY_WAIT_SEC);
+        const retrySec = err.parameters?.retry_after ?? FALLBACK_RETRY_SEC;
+        tripCircuitBreaker(retrySec);
+        if (retrySec > GIVE_UP_THRESHOLD_SEC) {
+          warn(`[telegram] 429 on ${label2} \u2014 retry_after ${retrySec}s exceeds threshold, giving up`);
+          throw err;
+        }
         if (attempt < MAX_RETRIES2) {
           warn(`[telegram] 429 on ${label2} (attempt ${attempt + 1}/${MAX_RETRIES2}) \u2014 retrying in ${retrySec}s`);
           await new Promise((r) => setTimeout(r, retrySec * 1e3));
@@ -23267,7 +24890,7 @@ function numericChatId(chatId) {
   const raw = chatId.includes(":") ? chatId.split(":").pop() : chatId;
   return parseInt(raw);
 }
-var MAX_RETRIES2, FALLBACK_RETRY_SEC, MAX_RETRY_WAIT_SEC, FAST_PATH_COMMANDS, TelegramChannel;
+var MAX_RETRIES2, FALLBACK_RETRY_SEC, GIVE_UP_THRESHOLD_SEC, circuitBreakerUntil, FAST_PATH_COMMANDS, TelegramChannel;
 var init_telegram2 = __esm({
   "src/channels/telegram.ts"() {
     "use strict";
@@ -23276,7 +24899,8 @@ var init_telegram2 = __esm({
     init_store5();
     MAX_RETRIES2 = 3;
     FALLBACK_RETRY_SEC = 3;
-    MAX_RETRY_WAIT_SEC = 30;
+    GIVE_UP_THRESHOLD_SEC = 60;
+    circuitBreakerUntil = 0;
     FAST_PATH_COMMANDS = /* @__PURE__ */ new Set(["stop", "status", "new", "newchat"]);
     TelegramChannel = class {
       name = "telegram";
@@ -23347,7 +24971,6 @@ var init_telegram2 = __esm({
           { command: "summarizer", description: "Configure session summarization model" },
           // Permissions & tools
           { command: "permissions", description: "Permission mode (yolo/safe/readonly/plan)" },
-          { command: "mode", description: "Execution gate (approved/yolo)" },
           { command: "tools", description: "Configure which tools the agent can use" },
           { command: "verbose", description: "Tool visibility (off/normal/verbose)" },
           { command: "debug", description: "Toggle session debug logging (full tool I/O)" },
@@ -23392,7 +25015,9 @@ var init_telegram2 = __esm({
           { command: "intent", description: "Test intent classifier on a message" },
           { command: "evolve", description: "Self-learning & evolution controls" },
           { command: "reflect", description: "Trigger reflection analysis" },
-          { command: "optimize", description: "Audit identity files and skills" }
+          { command: "optimize", description: "Audit identity files and skills" },
+          // Ollama
+          { command: "ollama", description: "Manage Ollama local LLM servers" }
         ]);
         this.bot.on("message", async (ctx) => {
           const chatId = ctx.chat.id.toString();
@@ -23613,10 +25238,11 @@ var init_telegram2 = __esm({
         }
         const MAX_KEYBOARD_TEXT = 4e3;
         const safeText = text.length > MAX_KEYBOARD_TEXT ? text.slice(0, MAX_KEYBOARD_TEXT) + "\n\n\u2026(truncated)" : text;
+        const formatted = formatForTelegram(safeText);
         try {
           const msg = await withRetry(
             "sendKeyboard",
-            () => this.bot.api.sendMessage(numericChatId(chatId), safeText, {
+            () => this.bot.api.sendMessage(numericChatId(chatId), formatted, {
               parse_mode: "HTML",
               reply_markup: keyboard
             })
@@ -23624,6 +25250,28 @@ var init_telegram2 = __esm({
           return msg.message_id.toString();
         } catch (err) {
           error(`[telegram] sendKeyboard failed (chat=${chatId}, textLen=${text.length}):`, err);
+          try {
+            const escaped = safeText.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+            const retryMsg = await withRetry(
+              "sendKeyboard:plain",
+              () => this.bot.api.sendMessage(numericChatId(chatId), escaped, {
+                reply_markup: keyboard
+              })
+            );
+            return retryMsg.message_id.toString();
+          } catch (plainErr) {
+            error(`[telegram] sendKeyboard plain retry also failed:`, plainErr);
+          }
+          try {
+            const plainText = safeText.replace(/<[^>]+>/g, "");
+            if (plainText.trim()) {
+              await withRetry(
+                "sendKeyboard:text-rescue",
+                () => this.bot.api.sendMessage(numericChatId(chatId), plainText, {})
+              );
+            }
+          } catch {
+          }
           try {
             const fallbackMsg = await withRetry(
               "sendKeyboard:fallback",
@@ -24667,13 +26315,41 @@ async function main() {
   }
   try {
     const { getAdapter: getAdapter4, probeBackendAvailability: probeBackendAvailability2 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-    probeBackendAvailability2();
+    await probeBackendAvailability2();
     const claude = getAdapter4("claude");
     if ("getAuthMode" in claude) claude.getAuthMode();
     const cursor = getAdapter4("cursor");
     if ("probeTier" in cursor) cursor.probeTier();
   } catch {
   }
+  (async () => {
+    try {
+      const { OllamaService, OllamaStore } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+      const servers = OllamaStore.listServers();
+      if (servers.length === 0) return;
+      const checkedServers = await OllamaService.healthCheck();
+      const onlineCount = checkedServers.filter((s) => s.status === "online").length;
+      let modelCount = 0;
+      for (const server of checkedServers) {
+        if (server.status === "online") {
+          const models = await OllamaService.discoverModels(server.name);
+          modelCount += models.length;
+        }
+      }
+      if (modelCount > 0) {
+        try {
+          const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+          const adapter = getAdapter4("ollama");
+          if ("refreshModelCatalog" in adapter) {
+            adapter.refreshModelCatalog();
+          }
+        } catch {
+        }
+      }
+      log(`[cc-claw] Ollama: ${onlineCount}/${servers.length} server(s) online, ${modelCount} model(s) discovered`);
+    } catch {
+    }
+  })();
   let pendingSummarizeNotify = null;
   const { getLoggedChatIds: getLoggedChatIds2 } = await Promise.resolve().then(() => (init_session_log(), session_log_exports));
   const pendingCount = getLoggedChatIds2().length;
@@ -24730,6 +26406,8 @@ async function main() {
   startPersistedJobs();
   initRunnerRegistry();
   initOrchestrator();
+  const { startStaleChatSweep: startStaleChatSweep2 } = await Promise.resolve().then(() => (init_agent(), agent_exports));
+  startStaleChatSweep2();
   let notifyQueue = Promise.resolve();
   setNotifyCallback((chatId, message) => {
     notifyQueue = notifyQueue.then(async () => {
@@ -24808,8 +26486,9 @@ async function main() {
   const shutdown = async (signal) => {
     log(`[cc-claw] Received ${signal}, shutting down...`);
     try {
-      const { stopAllActiveAgents: stopAllActiveAgents2 } = await Promise.resolve().then(() => (init_agent(), agent_exports));
+      const { stopAllActiveAgents: stopAllActiveAgents2, stopStaleChatSweep: stopStaleChatSweep2 } = await Promise.resolve().then(() => (init_agent(), agent_exports));
       stopAllActiveAgents2();
+      stopStaleChatSweep2();
       stopAllHeartbeats();
       stopHealthMonitor3();
       stopMonitor();
@@ -24839,6 +26518,13 @@ async function main() {
   };
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("unhandledRejection", (reason, promise) => {
+    error("[cc-claw] Unhandled promise rejection:", reason);
+  });
+  process.on("uncaughtException", (err, origin) => {
+    error(`[cc-claw] Uncaught exception (${origin}):`, err);
+    setTimeout(() => process.exit(1), 500);
+  });
 }
 var LOG_MAX_BYTES;
 var init_index = __esm({
@@ -24854,7 +26540,7 @@ var init_index = __esm({
     init_server();
     init_registry3();
     init_telegram2();
-    init_router();
+    init_router2();
     init_summarize();
     init_detect();
     init_bootstrap();
@@ -24987,8 +26673,8 @@ var init_api_client = __esm({
 });
 
 // src/service.ts
-var service_exports = {};
-__export(service_exports, {
+var service_exports2 = {};
+__export(service_exports2, {
   installService: () => installService,
   serviceStatus: () => serviceStatus,
   uninstallService: () => uninstallService
@@ -25228,7 +26914,7 @@ function serviceStatus() {
   else console.error(`  Unsupported platform: ${os2}.`);
 }
 var PLIST_LABEL, PLIST_PATH, SYSTEMD_DIR, UNIT_PATH;
-var init_service = __esm({
+var init_service2 = __esm({
   "src/service.ts"() {
     "use strict";
     init_paths();
@@ -25403,7 +27089,7 @@ var init_daemon = __esm({
 
 // src/cli/resolve-chat.ts
 import { readFileSync as readFileSync19 } from "fs";
-function resolveChatId(globalOpts) {
+function resolveChatId2(globalOpts) {
   const explicit = globalOpts.chat;
   if (explicit) return explicit;
   if (_cachedDefault) return _cachedDefault;
@@ -25437,7 +27123,7 @@ async function statusCommand(globalOpts, localOpts) {
   try {
     const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
     const readDb = openDatabaseReadOnly2();
-    const chatId = resolveChatId(globalOpts);
+    const chatId = resolveChatId2(globalOpts);
     const { getAdapterForChat: getAdapterForChat2, getAdapter: getAdapter4, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
     let backend2 = null;
     let modelName = "not set";
@@ -25505,6 +27191,17 @@ async function statusCommand(globalOpts, localOpts) {
       },
       db: { path: DB_PATH, sizeBytes: dbStat?.size ?? 0, exists: !!dbStat }
     };
+    try {
+      const { OllamaStore } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+      const servers = OllamaStore.listServers();
+      if (servers.length > 0) {
+        const online = servers.filter((s) => s.status === "online").length;
+        const models = OllamaStore.getAvailableModels();
+        const topModel = models.length > 0 ? models.sort((a, b) => (b.qualityScore ?? 0) - (a.qualityScore ?? 0))[0].name : void 0;
+        data.ollama = { servers: servers.length, online, models: models.length, topModel };
+      }
+    } catch {
+    }
     readDb.close();
     output(data, (d) => {
       const s = d;
@@ -25530,9 +27227,20 @@ async function statusCommand(globalOpts, localOpts) {
         kvLine("Requests", String(s.usage.requests)),
         kvLine("In tokens", s.usage.input_tokens.toLocaleString()),
         kvLine("Out tokens", s.usage.output_tokens.toLocaleString()),
-        kvLine("Cache read", s.usage.cache_read_tokens.toLocaleString()),
-        ""
+        kvLine("Cache read", s.usage.cache_read_tokens.toLocaleString())
       );
+      if (s.ollama) {
+        lines.push(
+          "",
+          divider("Ollama (Local)"),
+          kvLine("Servers", `${s.ollama.online}/${s.ollama.servers} online`),
+          kvLine("Models", String(s.ollama.models))
+        );
+        if (s.ollama.topModel) {
+          lines.push(kvLine("Top model", s.ollama.topModel));
+        }
+      }
+      lines.push("");
       return lines.join("\n");
     });
   } catch (err) {
@@ -25679,15 +27387,42 @@ async function doctorCommand(globalOpts, localOpts) {
     try {
       const { readFileSync: readFileSync27 } = await import("fs");
       const logContent = readFileSync27(ERROR_LOG_PATH, "utf-8");
-      const recentLines = logContent.split("\n").filter(Boolean).slice(-100);
+      const recentLines = logContent.split("\n").filter(Boolean).slice(-500);
       const last24h = Date.now() - 864e5;
       const recentErrors = recentLines.filter((line) => {
-        const match = line.match(/^\[(\d{4}-\d{2}-\d{2}T[\d:]+)/);
-        if (match) return new Date(match[1]).getTime() > last24h;
+        const match = line.match(/^\[(\d{4}-\d{2}-\d{2})\s+([\d:]+)/);
+        if (match) return (/* @__PURE__ */ new Date(`${match[1]}T${match[2]}`)).getTime() > last24h;
         return false;
       });
       if (recentErrors.length > 0) {
-        checks.push({ name: "Recent errors", status: "warning", message: `${recentErrors.length} errors in last 24h`, fix: "cc-claw logs --error" });
+        let rate429 = 0;
+        let contentSilence = 0;
+        let spawnTimeout = 0;
+        let other = 0;
+        for (const line of recentErrors) {
+          if (/429|rate.?limit/i.test(line)) rate429++;
+          else if (/content silence/i.test(line)) contentSilence++;
+          else if (/spawn timeout|timeout after \d+s/i.test(line)) spawnTimeout++;
+          else other++;
+        }
+        const logFix = "cc-claw doctor --fix to clear stale errors";
+        if (rate429 > 10) {
+          checks.push({ name: "Telegram rate limits", status: "error", message: `${rate429} rate-limit (429) errors in last 24h \u2014 message delivery blocked`, fix: logFix });
+        } else if (rate429 > 0) {
+          checks.push({ name: "Telegram rate limits", status: "warning", message: `${rate429} rate-limit (429) errors in last 24h`, fix: logFix });
+        }
+        if (contentSilence > 0) {
+          checks.push({ name: "Content silence", status: "warning", message: `${contentSilence} agent silence timeout(s) in last 24h \u2014 API went unresponsive`, fix: logFix });
+        }
+        if (spawnTimeout > 0) {
+          checks.push({ name: "Spawn timeouts", status: "warning", message: `${spawnTimeout} backend timeout(s) in last 24h`, fix: logFix });
+        }
+        if (other > 0) {
+          checks.push({ name: "Other errors", status: "warning", message: `${other} other error(s) in last 24h`, fix: logFix });
+        }
+        if (rate429 === 0 && contentSilence === 0 && spawnTimeout === 0 && other === 0) {
+          checks.push({ name: "Recent errors", status: "ok", message: "none in last 24h" });
+        }
       } else {
         checks.push({ name: "Recent errors", status: "ok", message: "none in last 24h" });
       }
@@ -25697,6 +27432,35 @@ async function doctorCommand(globalOpts, localOpts) {
   } else {
     checks.push({ name: "Error log", status: "ok", message: "no error log file" });
   }
+  try {
+    const { OllamaStore } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+    const servers = OllamaStore.listServers();
+    if (servers.length > 0) {
+      const online = servers.filter((s) => s.status === "online");
+      const models = OllamaStore.getAvailableModels();
+      if (online.length === servers.length) {
+        checks.push({
+          name: "Ollama",
+          status: "ok",
+          message: `${online.length} server(s) online, ${models.length} model(s)`
+        });
+      } else if (online.length > 0) {
+        checks.push({
+          name: "Ollama",
+          status: "warning",
+          message: `${online.length}/${servers.length} server(s) online, ${models.length} model(s)`
+        });
+      } else {
+        checks.push({
+          name: "Ollama",
+          status: "warning",
+          message: `${servers.length} server(s) configured, all offline`,
+          fix: "Check Ollama is running: ollama serve"
+        });
+      }
+    }
+  } catch {
+  }
   if (localOpts.fix) {
     const fixable = checks.filter((c) => c.status !== "ok" && c.fix);
     for (const check of fixable) {
@@ -25745,6 +27509,21 @@ async function doctorCommand(globalOpts, localOpts) {
         }
       }
     }
+    const errorChecks = checks.filter(
+      (c) => ["Telegram rate limits", "Content silence", "Spawn timeouts", "Other errors"].includes(c.name) && c.status !== "ok"
+    );
+    if (errorChecks.length > 0 && existsSync30(ERROR_LOG_PATH)) {
+      try {
+        const { writeFileSync: writeFileSync13 } = await import("fs");
+        writeFileSync13(ERROR_LOG_PATH, "");
+        for (const c of errorChecks) {
+          c.status = "ok";
+          c.message = "cleared (log truncated)";
+          delete c.fix;
+        }
+      } catch {
+      }
+    }
   }
   const errors = checks.filter((c) => c.status === "error").length;
   const warnings = checks.filter((c) => c.status === "warning").length;
@@ -25770,8 +27549,9 @@ async function doctorCommand(globalOpts, localOpts) {
       lines.push(`  ${parts.join(", ")}`);
       const fixable = r.checks.filter((c) => c.fix);
       if (fixable.length > 0 && !localOpts.fix) {
-        for (const f of fixable) {
-          lines.push(muted(`  Fix: ${f.fix}`));
+        const uniqueFixes = [...new Set(fixable.map((f) => f.fix))];
+        for (const fix of uniqueFixes) {
+          lines.push(muted(`  Fix: ${fix}`));
         }
       }
     }
@@ -26555,6 +28335,271 @@ var init_backend_cmd_factory = __esm({
   }
 });
 
+// src/cli/commands/ollama.ts
+var ollama_exports3 = {};
+__export(ollama_exports3, {
+  ollamaAdd: () => ollamaAdd,
+  ollamaDiscover: () => ollamaDiscover,
+  ollamaHealth: () => ollamaHealth,
+  ollamaList: () => ollamaList,
+  ollamaModels: () => ollamaModels,
+  ollamaRemove: () => ollamaRemove,
+  ollamaTest: () => ollamaTest
+});
+import { existsSync as existsSync35 } from "fs";
+function requireDb3() {
+  if (!existsSync35(DB_PATH)) {
+    outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
+    process.exit(1);
+  }
+}
+async function requireWriteDb3() {
+  requireDb3();
+  if (!dbInitialized3) {
+    const { initDatabase: initDatabase2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    initDatabase2();
+    dbInitialized3 = true;
+  }
+}
+async function ollamaList(globalOpts) {
+  requireDb3();
+  const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+  const readDb = openDatabaseReadOnly2();
+  const servers = readDb.prepare(`
+    SELECT id, name, host, port, status, last_health_check, created_at
+    FROM ollama_servers ORDER BY name
+  `).all();
+  const models = readDb.prepare(`
+    SELECT server_id, COUNT(*) as count FROM ollama_models GROUP BY server_id
+  `).all();
+  readDb.close();
+  const modelCounts = new Map(models.map((r) => [r.server_id, r.count]));
+  if (servers.length === 0) {
+    output(
+      { servers: [] },
+      () => "\n  No Ollama servers configured.\n  Add one with: cc-claw ollama add <name> <host>\n"
+    );
+    return;
+  }
+  const data = servers.map((s) => ({
+    ...s,
+    modelCount: modelCounts.get(s.id) ?? 0
+  }));
+  output(data, (d) => {
+    const list = d;
+    const lines = ["", divider("Ollama Servers"), ""];
+    for (const s of list) {
+      const dot = statusDot(s.status === "online" ? "active" : "offline");
+      lines.push(`  ${dot}  ${s.name} ${muted(`(${s.host}:${s.port})`)}`);
+      lines.push(`       Models: ${s.modelCount} \xB7 Status: ${s.status === "online" ? success("online") : error2("offline")}`);
+      if (s.last_health_check) {
+        lines.push(`       Last check: ${muted(s.last_health_check)}`);
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  });
+}
+async function ollamaAdd(globalOpts, name, host, opts) {
+  await requireWriteDb3();
+  const port = opts.port ? parseInt(opts.port, 10) : 11434;
+  if (isNaN(port) || port < 1 || port > 65535) {
+    outputError("INVALID_PORT", "Port must be a number between 1 and 65535.");
+    process.exit(1);
+  }
+  const { OllamaStore } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+  const existing = OllamaStore.getServer(name);
+  if (existing) {
+    outputError("ALREADY_EXISTS", `Server "${name}" already exists. Remove it first with: cc-claw ollama remove ${name}`);
+    process.exit(1);
+  }
+  console.log(`  Checking ${host}:${port}...`);
+  const { OllamaClient } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+  const online = await OllamaClient.ping(`http://${host}:${port}`, {
+    timeoutMs: 5e3,
+    apiKey: opts.key ?? void 0
+  });
+  if (!online) {
+    console.log(warning("  \u26A0 Server did not respond \u2014 saving as offline."));
+  } else {
+    console.log(success("  \u2713 Server is reachable."));
+  }
+  const server = OllamaStore.addServer(name, host, port, opts.key ?? null);
+  OllamaStore.updateServerStatus(server.id, online ? "online" : "offline");
+  output(
+    { id: server.id, name, host, port, status: online ? "online" : "offline" },
+    () => success(`
+  Added Ollama server "${name}" (${host}:${port})
+`)
+  );
+  if (online) {
+    console.log("  Discovering models...");
+    const { OllamaService } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+    const discovered = await OllamaService.discoverModels(name);
+    console.log(success(`  \u2713 Found ${discovered.length} model(s)`));
+    if (discovered.length > 0) {
+      for (const m of discovered) {
+        console.log(`    \xB7 ${m.name}${m.parameterSize ? ` (${m.parameterSize})` : ""}`);
+      }
+    }
+    console.log("");
+  }
+}
+async function ollamaRemove(globalOpts, name) {
+  await requireWriteDb3();
+  const { OllamaStore } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+  const removed = OllamaStore.removeServer(name);
+  if (removed) {
+    output({ removed: true, name }, () => success(`Removed server "${name}"`));
+  } else {
+    outputError("NOT_FOUND", `Server "${name}" not found.`);
+  }
+}
+async function ollamaModels(globalOpts, opts) {
+  requireDb3();
+  const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+  const readDb = openDatabaseReadOnly2();
+  let query;
+  let params;
+  if (opts.server) {
+    const server = readDb.prepare("SELECT id FROM ollama_servers WHERE name = ?").get(opts.server);
+    if (!server) {
+      readDb.close();
+      outputError("NOT_FOUND", `Server "${opts.server}" not found.`);
+      return;
+    }
+    query = `
+      SELECT m.name, m.family, m.parameter_size, m.quantization, m.context_window, m.size_bytes, m.quality_score,
+             s.name as server_name
+      FROM ollama_models m
+      JOIN ollama_servers s ON s.id = m.server_id
+      WHERE m.server_id = ?
+      ORDER BY m.name
+    `;
+    params = [server.id];
+  } else {
+    query = `
+      SELECT m.name, m.family, m.parameter_size, m.quantization, m.context_window, m.size_bytes, m.quality_score,
+             s.name as server_name
+      FROM ollama_models m
+      JOIN ollama_servers s ON s.id = m.server_id
+      ORDER BY s.name, m.name
+    `;
+    params = [];
+  }
+  const rows = readDb.prepare(query).all(...params);
+  readDb.close();
+  if (rows.length === 0) {
+    output(
+      { models: [] },
+      () => opts.server ? `
+  No models discovered on "${opts.server}".
+  Run: cc-claw ollama discover --server ${opts.server}
+` : "\n  No models discovered.\n  Run: cc-claw ollama discover\n"
+    );
+    return;
+  }
+  output(rows, (d) => {
+    const models = d;
+    const lines = ["", divider("Ollama Models"), ""];
+    let lastServer = "";
+    for (const m of models) {
+      if (m.server_name !== lastServer) {
+        if (lastServer) lines.push("");
+        lines.push(`  ${muted(`\u2500\u2500 ${m.server_name} \u2500\u2500`)}`);
+        lastServer = m.server_name;
+      }
+      const sizeGB = m.size_bytes > 0 ? `${(m.size_bytes / 1e9).toFixed(1)}GB` : "";
+      const ctxK = m.context_window ? `${(m.context_window / 1e3).toFixed(0)}K ctx` : "";
+      const quality = m.quality_score !== null ? `Q:${m.quality_score}` : "";
+      const meta = [m.parameter_size, m.quantization, sizeGB, ctxK, quality].filter(Boolean).join(" \xB7 ");
+      lines.push(`    ${m.name} ${muted(meta ? `(${meta})` : "")}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  });
+}
+async function ollamaDiscover(globalOpts, opts) {
+  await requireWriteDb3();
+  const { OllamaService } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+  if (opts.server) {
+    const { OllamaStore } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+    const server = OllamaStore.getServer(opts.server);
+    if (!server) {
+      outputError("NOT_FOUND", `Server "${opts.server}" not found.`);
+      return;
+    }
+  }
+  console.log(opts.server ? `  Discovering models on ${opts.server}...` : "  Discovering models on all servers...");
+  const models = await OllamaService.discoverModels(opts.server);
+  output(models.map((m) => ({
+    name: m.name,
+    parameterSize: m.parameterSize,
+    contextWindow: m.contextWindow,
+    sizeBytes: m.sizeBytes
+  })), (d) => {
+    const list = d;
+    if (list.length === 0) {
+      return "\n  No models found. Check server connectivity.\n";
+    }
+    const lines = [`
+  ${success(`\u2713 Discovered ${list.length} model(s):`)}`, ""];
+    for (const m of list) {
+      const sizeGB = m.sizeBytes > 0 ? `${(m.sizeBytes / 1e9).toFixed(1)}GB` : "";
+      const ctxK = m.contextWindow ? `${(m.contextWindow / 1e3).toFixed(0)}K ctx` : "";
+      const meta = [m.parameterSize, sizeGB, ctxK].filter(Boolean).join(" \xB7 ");
+      lines.push(`    \xB7 ${m.name} ${muted(meta ? `(${meta})` : "")}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  });
+}
+async function ollamaHealth(globalOpts) {
+  await requireWriteDb3();
+  const { OllamaService } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+  console.log("  Pinging all Ollama servers...");
+  const results = await OllamaService.healthCheck();
+  if (results.length === 0) {
+    output({ servers: [] }, () => "\n  No Ollama servers configured.\n");
+    return;
+  }
+  output(
+    results.map((s) => ({ name: s.name, host: s.host, port: s.port, status: s.status })),
+    (d) => {
+      const servers = d;
+      const lines = ["", divider("Ollama Health"), ""];
+      for (const s of servers) {
+        const dot = statusDot(s.status === "online" ? "active" : "offline");
+        const statusLabel = s.status === "online" ? success("online") : error2("offline");
+        lines.push(`  ${dot}  ${s.name} ${muted(`(${s.host}:${s.port})`)} \u2014 ${statusLabel}`);
+      }
+      const online = servers.filter((s) => s.status === "online").length;
+      lines.push("");
+      lines.push(`  ${online}/${servers.length} servers online`);
+      lines.push("");
+      return lines.join("\n");
+    }
+  );
+}
+async function ollamaTest(globalOpts, model2) {
+  output(
+    { model: model2, status: "not_implemented" },
+    () => `
+  ${warning("Quality gate testing is coming in Phase 4.")}
+  Model: ${model2}
+`
+  );
+}
+var dbInitialized3;
+var init_ollama4 = __esm({
+  "src/cli/commands/ollama.ts"() {
+    "use strict";
+    init_format2();
+    init_paths();
+    dbInitialized3 = false;
+  }
+});
+
 // src/cli/commands/backend.ts
 var backend_exports = {};
 __export(backend_exports, {
@@ -26562,12 +28607,12 @@ __export(backend_exports, {
   backendList: () => backendList,
   backendSet: () => backendSet
 });
-import { existsSync as existsSync35 } from "fs";
+import { existsSync as existsSync36 } from "fs";
 async function backendList(globalOpts) {
   const { getAvailableAdapters: getAvailableAdapters3 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   let activeBackend = null;
-  if (existsSync35(DB_PATH)) {
+  if (existsSync36(DB_PATH)) {
     const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
     const readDb = openDatabaseReadOnly2();
     try {
@@ -26597,8 +28642,8 @@ async function backendList(globalOpts) {
   });
 }
 async function backendGet(globalOpts) {
-  const chatId = resolveChatId(globalOpts);
-  if (!existsSync35(DB_PATH)) {
+  const chatId = resolveChatId2(globalOpts);
+  if (!existsSync36(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -26615,7 +28660,7 @@ async function backendSet(globalOpts, name) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const res = await apiPost2("/api/backend/set", { chatId, backend: name });
   if (res.ok) {
     output({ backend: name, success: true }, () => `
@@ -26642,13 +28687,13 @@ __export(model_exports, {
   modelList: () => modelList,
   modelSet: () => modelSet
 });
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync37 } from "fs";
 async function modelList(globalOpts) {
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const { getAdapter: getAdapter4, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
   let backendId = "claude";
-  if (existsSync36(DB_PATH)) {
+  if (existsSync37(DB_PATH)) {
     const readDb = openDatabaseReadOnly2();
     try {
       const row = readDb.prepare("SELECT backend FROM chat_backend WHERE chat_id = ?").get(chatId);
@@ -26680,8 +28725,8 @@ async function modelList(globalOpts) {
   }
 }
 async function modelGet(globalOpts) {
-  const chatId = resolveChatId(globalOpts);
-  if (!existsSync36(DB_PATH)) {
+  const chatId = resolveChatId2(globalOpts);
+  if (!existsSync37(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -26698,7 +28743,7 @@ async function modelSet(globalOpts, name) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const res = await apiPost2("/api/model/set", { chatId, model: name });
   if (res.ok) {
     output({ model: name, success: true }, () => `
@@ -26725,9 +28770,9 @@ __export(memory_exports2, {
   memoryList: () => memoryList,
   memorySearch: () => memorySearch
 });
-import { existsSync as existsSync37 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 async function memoryList(globalOpts) {
-  if (!existsSync37(DB_PATH)) {
+  if (!existsSync38(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -26751,7 +28796,7 @@ async function memoryList(globalOpts) {
   });
 }
 async function memorySearch(globalOpts, query) {
-  if (!existsSync37(DB_PATH)) {
+  if (!existsSync38(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -26773,14 +28818,14 @@ async function memorySearch(globalOpts, query) {
   });
 }
 async function memoryHistory(globalOpts, opts) {
-  if (!existsSync37(DB_PATH)) {
+  if (!existsSync38(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
   const limit = parseInt(opts.limit ?? "10", 10);
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const summaries = readDb.prepare(
     "SELECT * FROM session_summaries WHERE chat_id = ? ORDER BY created_at DESC LIMIT ?"
   ).all(chatId, limit);
@@ -26821,7 +28866,7 @@ __export(cron_exports2, {
   cronList: () => cronList,
   cronRuns: () => cronRuns
 });
-import { existsSync as existsSync38 } from "fs";
+import { existsSync as existsSync39 } from "fs";
 function parseFallbacks(raw) {
   return raw.slice(0, 3).map((f) => {
     const [backend2, ...rest] = f.split(":");
@@ -26842,7 +28887,7 @@ function parseAndValidateTimeout(raw) {
   return val;
 }
 async function cronList(globalOpts) {
-  if (!existsSync38(DB_PATH)) {
+  if (!existsSync39(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -26880,7 +28925,7 @@ async function cronList(globalOpts) {
   });
 }
 async function cronHealth(globalOpts) {
-  if (!existsSync38(DB_PATH)) {
+  if (!existsSync39(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -26918,7 +28963,7 @@ async function cronCreate(globalOpts, opts) {
     outputError("MISSING_SCHEDULE", "Must specify one of: --cron, --at, or --every");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const { success: successFmt } = await Promise.resolve().then(() => (init_format2(), format_exports));
   const timeout = parseAndValidateTimeout(opts.timeout);
   try {
@@ -27039,7 +29084,7 @@ async function cronEdit(globalOpts, id, opts) {
   }
 }
 async function cronRuns(globalOpts, jobId, opts) {
-  if (!existsSync38(DB_PATH)) {
+  if (!existsSync39(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -27086,9 +29131,9 @@ __export(agents_exports, {
   runnersList: () => runnersList,
   tasksList: () => tasksList
 });
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 async function agentsList(globalOpts) {
-  if (!existsSync39(DB_PATH)) {
+  if (!existsSync40(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -27119,7 +29164,7 @@ async function agentsList(globalOpts) {
   });
 }
 async function tasksList(globalOpts) {
-  if (!existsSync39(DB_PATH)) {
+  if (!existsSync40(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -27149,7 +29194,7 @@ async function agentsSpawn(globalOpts, opts) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const res = await apiPost2("/api/orchestrator/spawn", {
     chatId,
     runner: opts.runner,
@@ -27192,7 +29237,7 @@ async function agentsCancelAll(globalOpts) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const res = await apiPost2("/api/orchestrator/cancel-all", { chatId });
   if (res.ok) {
     const { success: s } = await Promise.resolve().then(() => (init_format2(), format_exports));
@@ -27247,10 +29292,10 @@ __export(db_exports, {
   dbPath: () => dbPath,
   dbStats: () => dbStats
 });
-import { existsSync as existsSync40, statSync as statSync11, copyFileSync as copyFileSync3, mkdirSync as mkdirSync16 } from "fs";
+import { existsSync as existsSync41, statSync as statSync11, copyFileSync as copyFileSync3, mkdirSync as mkdirSync16 } from "fs";
 import { dirname as dirname7 } from "path";
 async function dbStats(globalOpts) {
-  if (!existsSync40(DB_PATH)) {
+  if (!existsSync41(DB_PATH)) {
     outputError("DB_NOT_FOUND", `Database not found at ${DB_PATH}`);
     process.exit(1);
   }
@@ -27258,7 +29303,7 @@ async function dbStats(globalOpts) {
   const readDb = openDatabaseReadOnly2();
   const mainSize = statSync11(DB_PATH).size;
   const walPath = DB_PATH + "-wal";
-  const walSize = existsSync40(walPath) ? statSync11(walPath).size : 0;
+  const walSize = existsSync41(walPath) ? statSync11(walPath).size : 0;
   const tableNames = readDb.prepare(
     "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '%_fts%' ORDER BY name"
   ).all();
@@ -27292,7 +29337,7 @@ async function dbPath(globalOpts) {
   output({ path: DB_PATH }, (d) => d.path);
 }
 async function dbBackup(globalOpts, destPath) {
-  if (!existsSync40(DB_PATH)) {
+  if (!existsSync41(DB_PATH)) {
     outputError("DB_NOT_FOUND", `Database not found at ${DB_PATH}`);
     process.exit(1);
   }
@@ -27301,7 +29346,7 @@ async function dbBackup(globalOpts, destPath) {
     mkdirSync16(dirname7(dest), { recursive: true });
     copyFileSync3(DB_PATH, dest);
     const walPath = DB_PATH + "-wal";
-    if (existsSync40(walPath)) copyFileSync3(walPath, dest + "-wal");
+    if (existsSync41(walPath)) copyFileSync3(walPath, dest + "-wal");
     output({ path: dest, sizeBytes: statSync11(dest).size }, (d) => {
       const b = d;
       return `
@@ -27330,9 +29375,9 @@ __export(usage_exports, {
   usageCost: () => usageCost,
   usageTokens: () => usageTokens
 });
-import { existsSync as existsSync41 } from "fs";
+import { existsSync as existsSync42 } from "fs";
 function ensureDb() {
-  if (!existsSync41(DB_PATH)) {
+  if (!existsSync42(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -27384,7 +29429,7 @@ async function usageCost(globalOpts, opts) {
       return lines.join("\n");
     });
   } else {
-    const chatId = resolveChatId(globalOpts);
+    const chatId = resolveChatId2(globalOpts);
     const usage2 = readDb.prepare("SELECT * FROM chat_usage WHERE chat_id = ?").get(chatId);
     readDb.close();
     if (!usage2 || usage2.request_count === 0) {
@@ -27522,15 +29567,15 @@ __export(config_exports2, {
   configList: () => configList,
   configSet: () => configSet
 });
-import { existsSync as existsSync42, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync43, readFileSync as readFileSync24 } from "fs";
 async function configList(globalOpts) {
-  if (!existsSync42(DB_PATH)) {
+  if (!existsSync43(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const config2 = {};
   for (const key of RUNTIME_KEYS) {
     const { table, col } = KEY_TABLE_MAP[key];
@@ -27558,13 +29603,13 @@ async function configGet(globalOpts, key) {
     outputError("INVALID_KEY", `Unknown config key "${key}". Valid keys: ${RUNTIME_KEYS.join(", ")}`);
     process.exit(1);
   }
-  if (!existsSync42(DB_PATH)) {
+  if (!existsSync43(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const { table, col } = KEY_TABLE_MAP[key];
   if (!ALLOWED_TABLES.has(table) || !ALLOWED_COLS.has(col)) {
     outputError("INVALID_KEY", `Invalid config mapping for "${key}".`);
@@ -27592,7 +29637,7 @@ async function configSet(globalOpts, key, value) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const res = await apiPost2("/api/config/set", { chatId, key, value });
   if (res.ok) {
     output({ key, value, success: true }, () => `
@@ -27604,7 +29649,7 @@ async function configSet(globalOpts, key, value) {
   }
 }
 async function configEnv(_globalOpts) {
-  if (!existsSync42(ENV_PATH)) {
+  if (!existsSync43(ENV_PATH)) {
     outputError("ENV_NOT_FOUND", `No .env file at ${ENV_PATH}. Run cc-claw setup.`);
     process.exit(1);
   }
@@ -27658,15 +29703,15 @@ __export(session_exports, {
   sessionGet: () => sessionGet,
   sessionNew: () => sessionNew
 });
-import { existsSync as existsSync43 } from "fs";
+import { existsSync as existsSync44 } from "fs";
 async function sessionGet(globalOpts) {
-  if (!existsSync43(DB_PATH)) {
+  if (!existsSync44(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const session2 = readDb.prepare("SELECT * FROM sessions WHERE chat_id = ?").get(chatId);
   readDb.close();
   const data = session2 ? { id: session2.session_id, active: true, updatedAt: session2.updated_at } : { id: null, active: false, updatedAt: null };
@@ -27689,7 +29734,7 @@ async function sessionNew(globalOpts) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const res = await apiPost2("/api/session/new", { chatId });
   if (res.ok) {
     output({ success: true }, () => `
@@ -27721,9 +29766,9 @@ __export(permissions_exports, {
   verboseGet: () => verboseGet,
   verboseSet: () => verboseSet
 });
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 function ensureDb2() {
-  if (!existsSync44(DB_PATH)) {
+  if (!existsSync45(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -27732,7 +29777,7 @@ async function permissionsGet(globalOpts) {
   ensureDb2();
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const row = readDb.prepare("SELECT mode FROM chat_mode WHERE chat_id = ?").get(chatId);
   readDb.close();
   const mode = row?.mode ?? "yolo";
@@ -27750,7 +29795,7 @@ async function permissionsSet(globalOpts, mode) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const res = await apiPost2("/api/permissions/set", { chatId, mode });
   if (res.ok) {
     output({ mode, success: true }, () => `
@@ -27765,7 +29810,7 @@ async function toolsList(globalOpts) {
   ensureDb2();
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const rows = readDb.prepare("SELECT tool, enabled FROM chat_tools WHERE chat_id = ?").all(chatId);
   readDb.close();
   const ALL_TOOLS3 = ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "WebFetch", "WebSearch", "Agent", "AskUserQuestion"];
@@ -27793,7 +29838,7 @@ async function toolsReset(globalOpts) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const res = await apiPost2("/api/tools/reset", { chatId });
   if (res.ok) {
     output({ success: true }, () => `
@@ -27810,7 +29855,7 @@ async function toggleTool4(globalOpts, name, enabled) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const res = await apiPost2("/api/tools/toggle", { chatId, tool: name, enabled });
   if (res.ok) {
     const label2 = enabled ? "enabled" : "disabled";
@@ -27826,7 +29871,7 @@ async function verboseGet(globalOpts) {
   ensureDb2();
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const row = readDb.prepare("SELECT level FROM chat_verbose WHERE chat_id = ?").get(chatId);
   readDb.close();
   const level = row?.level ?? "off";
@@ -27843,7 +29888,7 @@ async function verboseSet(globalOpts, level) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const res = await apiPost2("/api/verbose/set", { chatId, level });
   if (res.ok) {
     output({ level, success: true }, () => `
@@ -27870,15 +29915,15 @@ __export(cwd_exports, {
   cwdGet: () => cwdGet,
   cwdSet: () => cwdSet
 });
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 async function cwdGet(globalOpts) {
-  if (!existsSync45(DB_PATH)) {
+  if (!existsSync46(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const row = readDb.prepare("SELECT cwd FROM chat_cwd WHERE chat_id = ?").get(chatId);
   readDb.close();
   const cwd = row?.cwd ?? null;
@@ -27890,7 +29935,7 @@ async function cwdSet(globalOpts, path) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const resolved = path.startsWith("~") ? path.replace("~", process.env.HOME ?? "") : path;
   const res = await apiPost2("/api/cwd/set", { chatId, cwd: resolved });
   if (res.ok) {
@@ -27908,7 +29953,7 @@ async function cwdClear(globalOpts) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const res = await apiPost2("/api/cwd/clear", { chatId });
   if (res.ok) {
     output({ success: true }, () => `
@@ -27934,15 +29979,15 @@ __export(voice_exports, {
   voiceGet: () => voiceGet,
   voiceSet: () => voiceSet
 });
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync47 } from "fs";
 async function voiceGet(globalOpts) {
-  if (!existsSync46(DB_PATH)) {
+  if (!existsSync47(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const row = readDb.prepare("SELECT enabled FROM chat_voice WHERE chat_id = ?").get(chatId);
   readDb.close();
   const enabled = !!row?.enabled;
@@ -27959,7 +30004,7 @@ async function voiceSet(globalOpts, value) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const res = await apiPost2("/api/voice/set", { chatId, enabled: value === "on" });
   if (res.ok) {
     output({ enabled: value === "on", success: true }, () => `
@@ -27985,15 +30030,15 @@ __export(heartbeat_exports, {
   heartbeatGet: () => heartbeatGet,
   heartbeatSet: () => heartbeatSet
 });
-import { existsSync as existsSync47 } from "fs";
+import { existsSync as existsSync48 } from "fs";
 async function heartbeatGet(globalOpts) {
-  if (!existsSync47(DB_PATH)) {
+  if (!existsSync48(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const row = readDb.prepare("SELECT * FROM chat_heartbeat WHERE chat_id = ?").get(chatId);
   readDb.close();
   const data = row ? {
@@ -28025,7 +30070,7 @@ async function heartbeatSet(globalOpts, subcommand, value) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   let body = { chatId };
   let successMsg = "";
   switch (subcommand) {
@@ -28096,15 +30141,15 @@ __export(summarizer_exports, {
   summarizerGet: () => summarizerGet,
   summarizerSet: () => summarizerSet
 });
-import { existsSync as existsSync48 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 async function summarizerGet(globalOpts) {
-  if (!existsSync48(DB_PATH)) {
+  if (!existsSync49(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const row = readDb.prepare("SELECT backend, model FROM chat_summarizer WHERE chat_id = ?").get(chatId);
   readDb.close();
   const value = row?.backend === "off" ? "off" : row?.backend ? `${row.backend}:${row.model ?? "default"}` : "auto";
@@ -28116,7 +30161,7 @@ async function summarizerSet(globalOpts, value) {
     outputError("DAEMON_OFFLINE", "Daemon not running.");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const res = await apiPost2("/api/summarizer/set", { chatId, value });
   if (res.ok) {
     output({ success: true }, () => `
@@ -28142,15 +30187,15 @@ __export(thinking_exports, {
   thinkingGet: () => thinkingGet,
   thinkingSet: () => thinkingSet
 });
-import { existsSync as existsSync49 } from "fs";
+import { existsSync as existsSync50 } from "fs";
 async function thinkingGet(globalOpts) {
-  if (!existsSync49(DB_PATH)) {
+  if (!existsSync50(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const row = readDb.prepare("SELECT level FROM chat_thinking WHERE chat_id = ?").get(chatId);
   readDb.close();
   output({ level: row?.level ?? "auto" }, (d) => d.level);
@@ -28161,7 +30206,7 @@ async function thinkingSet(globalOpts, level) {
     outputError("DAEMON_OFFLINE", "Daemon not running.");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const res = await apiPost2("/api/thinking/set", { chatId, level });
   if (res.ok) {
     output({ success: true }, () => `
@@ -28188,9 +30233,9 @@ __export(chats_exports, {
   chatsList: () => chatsList,
   chatsRemoveAlias: () => chatsRemoveAlias
 });
-import { existsSync as existsSync50 } from "fs";
+import { existsSync as existsSync51 } from "fs";
 async function chatsList(_globalOpts) {
-  if (!existsSync50(DB_PATH)) {
+  if (!existsSync51(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -28318,9 +30363,9 @@ var mcps_exports2 = {};
 __export(mcps_exports2, {
   mcpsList: () => mcpsList
 });
-import { existsSync as existsSync51 } from "fs";
+import { existsSync as existsSync52 } from "fs";
 async function mcpsList(_globalOpts) {
-  if (!existsSync51(DB_PATH)) {
+  if (!existsSync52(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -28357,11 +30402,11 @@ __export(chat_exports2, {
   chatSend: () => chatSend
 });
 import { request as httpRequest2 } from "http";
-import { readFileSync as readFileSync25, existsSync as existsSync52 } from "fs";
+import { readFileSync as readFileSync25, existsSync as existsSync53 } from "fs";
 function getToken2() {
   if (process.env.CC_CLAW_API_TOKEN) return process.env.CC_CLAW_API_TOKEN;
   try {
-    if (existsSync52(TOKEN_PATH2)) return readFileSync25(TOKEN_PATH2, "utf-8").trim();
+    if (existsSync53(TOKEN_PATH2)) return readFileSync25(TOKEN_PATH2, "utf-8").trim();
   } catch {
   }
   return null;
@@ -28372,7 +30417,7 @@ async function chatSend(globalOpts, message, cmdOpts) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const token = getToken2();
   const payload = JSON.stringify({
     chatId,
@@ -28506,7 +30551,7 @@ async function tuiCommand(globalOpts, cmdOpts) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const { chatSend: chatSend2 } = await Promise.resolve().then(() => (init_chat2(), chat_exports2));
   const rl2 = createInterface10({
     input: process.stdin,
@@ -28831,9 +30876,9 @@ __export(evolve_exports2, {
   evolveStatus: () => evolveStatus,
   evolveUndo: () => evolveUndo
 });
-import { existsSync as existsSync53 } from "fs";
+import { existsSync as existsSync54 } from "fs";
 function ensureDb3() {
-  if (!existsSync53(DB_PATH)) {
+  if (!existsSync54(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -28849,7 +30894,7 @@ async function evolveStatus(globalOpts) {
   ensureDb3();
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const { getReflectionStatus: getReflectionStatus2, getPendingInsightCount: getPendingInsightCount2, getReflectionModelConfig: getReflectionModelConfig2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
   const status = getReflectionStatus2(readDb, chatId);
   const pendingCount = getPendingInsightCount2(readDb, chatId);
@@ -28889,7 +30934,7 @@ async function evolveStatus(globalOpts) {
 }
 async function evolveAnalyze(globalOpts) {
   await ensureDaemon();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const { apiPost: apiPost2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
   const res = await apiPost2("/api/evolve/analyze", { chatId });
   if (res.ok) {
@@ -28906,7 +30951,7 @@ async function evolveList(globalOpts) {
   ensureDb3();
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const { getPendingInsights: getPendingInsights2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
   const insights = getPendingInsights2(readDb, chatId);
   readDb.close();
@@ -29051,7 +31096,7 @@ async function evolveUndo(globalOpts, idStr) {
 }
 async function evolveOn(globalOpts) {
   await ensureDaemon();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const { apiPost: apiPost2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
   const res = await apiPost2("/api/evolve/on", { chatId });
   if (res.ok) {
@@ -29065,7 +31110,7 @@ async function evolveOn(globalOpts) {
 }
 async function evolveOff(globalOpts) {
   await ensureDaemon();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const { apiPost: apiPost2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
   const res = await apiPost2("/api/evolve/off", { chatId });
   if (res.ok) {
@@ -29082,7 +31127,7 @@ async function evolveModel(globalOpts, mode, opts) {
     ensureDb3();
     const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
     const readDb = openDatabaseReadOnly2();
-    const chatId2 = resolveChatId(globalOpts);
+    const chatId2 = resolveChatId2(globalOpts);
     const { getReflectionModelConfig: getReflectionModelConfig2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
     const config2 = getReflectionModelConfig2(readDb, chatId2);
     readDb.close();
@@ -29095,7 +31140,7 @@ async function evolveModel(globalOpts, mode, opts) {
     return;
   }
   await ensureDaemon();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   if (!["auto", "pinned", "cheap"].includes(mode)) {
     outputError("INVALID_MODE", "Mode must be auto, pinned, or cheap.");
     process.exit(1);
@@ -29120,7 +31165,7 @@ async function evolveStats(globalOpts, opts) {
   ensureDb3();
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const days = parseInt(opts.days ?? "30", 10);
   const { buildGrowthReportData: buildGrowthReportData2 } = await Promise.resolve().then(() => (init_metrics(), metrics_exports));
   const report = buildGrowthReportData2(readDb, chatId, days);
@@ -29149,7 +31194,7 @@ async function evolveHistory(globalOpts, opts) {
   ensureDb3();
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const readDb = openDatabaseReadOnly2();
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const limit = parseInt(opts.limit ?? "20", 10);
   let insights;
   if (opts.status) {
@@ -29186,7 +31231,7 @@ async function evolveHistory(globalOpts, opts) {
 async function evolveSettings(globalOpts, opts) {
   ensureDb3();
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
-  const chatId = resolveChatId(globalOpts);
+  const chatId = resolveChatId2(globalOpts);
   const hasUpdates = opts.perFileCap !== void 0 || opts.backupRetentionDays !== void 0;
   if (hasUpdates) {
     await ensureDaemon();
@@ -29307,7 +31352,7 @@ var init_optimize2 = __esm({
 
 // src/setup.ts
 var setup_exports = {};
-import { existsSync as existsSync54, writeFileSync as writeFileSync12, readFileSync as readFileSync26, copyFileSync as copyFileSync4, mkdirSync as mkdirSync18, statSync as statSync12 } from "fs";
+import { existsSync as existsSync55, writeFileSync as writeFileSync12, readFileSync as readFileSync26, copyFileSync as copyFileSync4, mkdirSync as mkdirSync18, statSync as statSync12 } from "fs";
 import { execFileSync as execFileSync5 } from "child_process";
 import { createInterface as createInterface11 } from "readline";
 import { join as join34 } from "path";
@@ -29385,10 +31430,10 @@ async function setup() {
   }
   console.log("");
   for (const dir of [CC_CLAW_HOME, DATA_PATH, LOGS_PATH, SKILLS_PATH, RUNNERS_PATH, AGENTS_PATH]) {
-    if (!existsSync54(dir)) mkdirSync18(dir, { recursive: true });
+    if (!existsSync55(dir)) mkdirSync18(dir, { recursive: true });
   }
   const env = {};
-  const envSource = existsSync54(ENV_PATH) ? ENV_PATH : existsSync54(".env") ? ".env" : null;
+  const envSource = existsSync55(ENV_PATH) ? ENV_PATH : existsSync55(".env") ? ".env" : null;
   if (envSource) {
     console.log(yellow(`  Found existing config at ${envSource} \u2014 your values will be preserved`));
     console.log(yellow("  unless you enter new ones. Just press Enter to keep existing values.\n"));
@@ -29399,7 +31444,7 @@ async function setup() {
     }
   }
   const cwdDb = join34(process.cwd(), "cc-claw.db");
-  if (existsSync54(cwdDb) && !existsSync54(DB_PATH)) {
+  if (existsSync55(cwdDb) && !existsSync55(DB_PATH)) {
     const { size } = statSync12(cwdDb);
     console.log(yellow(`  Found existing database at ${cwdDb} (${(size / 1024).toFixed(0)}KB)`));
     const migrate = await confirm("Copy database to ~/.cc-claw/? (preserves memories & history)", true);
@@ -29624,7 +31669,7 @@ async function setup() {
   const installDaemon = await confirm("Install CC-Claw as a background service?", true);
   if (installDaemon) {
     try {
-      const { installService: installService2 } = await Promise.resolve().then(() => (init_service(), service_exports));
+      const { installService: installService2 } = await Promise.resolve().then(() => (init_service2(), service_exports2));
       installService2();
       console.log("");
       console.log(dim("  Useful commands:"));
@@ -29700,7 +31745,7 @@ function registerServiceCommands(cmd) {
     if (opts.foreground) {
       await Promise.resolve().then(() => (init_index(), index_exports));
     } else {
-      const { installService: installService2 } = await Promise.resolve().then(() => (init_service(), service_exports));
+      const { installService: installService2 } = await Promise.resolve().then(() => (init_service2(), service_exports2));
       installService2();
     }
   });
@@ -29713,15 +31758,15 @@ function registerServiceCommands(cmd) {
     await restartService2();
   });
   cmd.command("status").description("Service health (launchd/systemd)").action(async () => {
-    const { serviceStatus: serviceStatus2 } = await Promise.resolve().then(() => (init_service(), service_exports));
+    const { serviceStatus: serviceStatus2 } = await Promise.resolve().then(() => (init_service2(), service_exports2));
     serviceStatus2();
   });
   cmd.command("install").description("Install as background service").action(async () => {
-    const { installService: installService2 } = await Promise.resolve().then(() => (init_service(), service_exports));
+    const { installService: installService2 } = await Promise.resolve().then(() => (init_service2(), service_exports2));
     installService2();
   });
   cmd.command("uninstall").description("Remove background service").action(async () => {
-    const { uninstallService: uninstallService2 } = await Promise.resolve().then(() => (init_service(), service_exports));
+    const { uninstallService: uninstallService2 } = await Promise.resolve().then(() => (init_service2(), service_exports2));
     uninstallService2();
   });
 }
@@ -29824,6 +31869,35 @@ function registerUnifiedSlotCommands(parentCmd, backendId, displayName) {
 }
 registerUnifiedSlotCommands(program, "claude", "Claude");
 registerUnifiedSlotCommands(program, "codex", "Codex");
+var ollama = program.command("ollama").description("Manage Ollama local LLM servers and models");
+ollama.command("list").description("List all configured Ollama servers").action(async () => {
+  const { ollamaList: ollamaList2 } = await Promise.resolve().then(() => (init_ollama4(), ollama_exports3));
+  await ollamaList2(program.opts());
+});
+ollama.command("add <name> <host>").description("Add an Ollama server").option("--port <n>", "Port (default: 11434)").option("--key <apiKey>", "API key (for remote/proxy servers)").action(async (name, host, opts) => {
+  const { ollamaAdd: ollamaAdd2 } = await Promise.resolve().then(() => (init_ollama4(), ollama_exports3));
+  await ollamaAdd2(program.opts(), name, host, opts);
+});
+ollama.command("remove <name>").description("Remove an Ollama server and its cached models").action(async (name) => {
+  const { ollamaRemove: ollamaRemove2 } = await Promise.resolve().then(() => (init_ollama4(), ollama_exports3));
+  await ollamaRemove2(program.opts(), name);
+});
+ollama.command("models").description("List discovered models across all servers").option("--server <name>", "Filter to a specific server").action(async (opts) => {
+  const { ollamaModels: ollamaModels2 } = await Promise.resolve().then(() => (init_ollama4(), ollama_exports3));
+  await ollamaModels2(program.opts(), opts);
+});
+ollama.command("discover").description("Discover models on servers (syncs to local DB)").option("--server <name>", "Discover on a specific server only").action(async (opts) => {
+  const { ollamaDiscover: ollamaDiscover2 } = await Promise.resolve().then(() => (init_ollama4(), ollama_exports3));
+  await ollamaDiscover2(program.opts(), opts);
+});
+ollama.command("health").description("Ping all servers and update status").action(async () => {
+  const { ollamaHealth: ollamaHealth2 } = await Promise.resolve().then(() => (init_ollama4(), ollama_exports3));
+  await ollamaHealth2(program.opts());
+});
+ollama.command("test <model>").description("Run quality gate test on a model (Phase 4)").action(async (model2) => {
+  const { ollamaTest: ollamaTest2 } = await Promise.resolve().then(() => (init_ollama4(), ollama_exports3));
+  await ollamaTest2(program.opts(), model2);
+});
 var backend = program.command("backend").description("Manage AI backend");
 backend.command("list").description("Available backends with status").action(async () => {
   const { backendList: backendList2 } = await Promise.resolve().then(() => (init_backend(), backend_exports));
@@ -30118,12 +32192,12 @@ mcps.command("list").description("All registered MCP servers").action(async () =
   const { mcpsList: mcpsList2 } = await Promise.resolve().then(() => (init_mcps2(), mcps_exports2));
   await mcpsList2(program.opts());
 });
-var chat = program.command("chat").description("Chat with the AI");
-chat.command("send <message>").description("Send a message and get a response").option("--backend <name>", "Override backend").option("--model <name>", "Override model").option("--thinking <level>", "Override thinking level").option("--cwd <path>", "Override working directory").option("--stream", "Stream response tokens as they arrive").action(async (message, opts) => {
+var chat2 = program.command("chat").description("Chat with the AI");
+chat2.command("send <message>").description("Send a message and get a response").option("--backend <name>", "Override backend").option("--model <name>", "Override model").option("--thinking <level>", "Override thinking level").option("--cwd <path>", "Override working directory").option("--stream", "Stream response tokens as they arrive").action(async (message, opts) => {
   const { chatSend: chatSend2 } = await Promise.resolve().then(() => (init_chat2(), chat_exports2));
   await chatSend2(program.opts(), message, opts);
 });
-chat.command("stop").description("Cancel the current running task").action(async () => {
+chat2.command("stop").description("Cancel the current running task").action(async () => {
   const { isDaemonRunning: isDaemonRunning2, apiPost: apiPost2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
   if (!await isDaemonRunning2()) {
     const { outputError: outputError3 } = await Promise.resolve().then(() => (init_format2(), format_exports));
@@ -30143,7 +32217,7 @@ chat.command("stop").description("Cancel the current running task").action(async
     process.exit(1);
   }
 });
-chat.argument("[message]", "Message to send (shorthand for chat send)").action(async (message, opts) => {
+chat2.argument("[message]", "Message to send (shorthand for chat send)").action(async (message, opts) => {
   if (message && !["send", "stop"].includes(message)) {
     const { chatSend: chatSend2 } = await Promise.resolve().then(() => (init_chat2(), chat_exports2));
     await chatSend2(program.opts(), message, opts);
@@ -30223,11 +32297,11 @@ program.command("start", { hidden: true }).description("Run the bot in the foreg
   await Promise.resolve().then(() => (init_index(), index_exports));
 });
 program.command("install", { hidden: true }).description("Install as background service \u2014 alias for service install").action(async () => {
-  const { installService: installService2 } = await Promise.resolve().then(() => (init_service(), service_exports));
+  const { installService: installService2 } = await Promise.resolve().then(() => (init_service2(), service_exports2));
   installService2();
 });
 program.command("uninstall", { hidden: true }).description("Remove background service \u2014 alias for service uninstall").action(async () => {
-  const { uninstallService: uninstallService2 } = await Promise.resolve().then(() => (init_service(), service_exports));
+  const { uninstallService: uninstallService2 } = await Promise.resolve().then(() => (init_service2(), service_exports2));
   uninstallService2();
 });
 program.command("setup").description("Interactive configuration wizard").action(async () => {