@gotcos/glasses-server 6.39.3 → 6.40.1

package/.env.example

@@ -69,7 +69,7 @@ BIND_HOST=0.0.0.0
 #
 # Local Ollama (https://ollama.com) as a fourth G2 picker. Hidden unless
 # GET http://127.0.0.1:11434/api/tags succeeds with at least one pulled model.
-# Direct POST /api/chat — chat/summarize only, no tools, no Codex --oss.
+# Ollama runs read-only COS tools when the pulled tag advertises tools and COS_SCRIPTS_DIR is set; no vision, no Codex --oss.
 #   brew install ollama
 #   ollama serve
 #   ollama run qwen2.5-coder

package/CHANGELOG.md

@@ -1,3 +1,64 @@
+## 6.40.1
+
+The local model can read your meetings and memories.
+
+Until now the Ollama path appended "You have no tools" to every prompt, so a
+local model could only answer from what was already in the window. It now gets
+a closed allowlist of three READ-ONLY COS tools -- `search_meetings`,
+`search_memories`, `read_meeting` -- but only when two things are true: the
+pulled tag advertises `tools` on `/api/show`, and `COS_SCRIPTS_DIR` is a real
+directory. A standalone npm install with no operations tree is unchanged, and
+so is any tag that cannot call tools.
+
+Writes, Bash, MCP, web search, web fetch, photos, Continue, Fork and Live Cues
+are all still off this path. There is no in-process search or fetch executor in
+this package, so advertising `WebSearch` would name a capability that cannot
+run; those names stay out of the tools array deliberately.
+
+The loop is bounded at five `/api/chat` POSTs per turn. Posts one through four
+may execute a tool batch; the fifth is a closing fetch, and tool calls returned
+there are refused rather than executed, so there is never a sixth. Tool results
+are capped by DROPPING whole hits, never by cutting mid-string, so the model
+always receives parseable JSON. `read_meeting` serializes a picked subset and
+never the unbounded transcript the ops helpers still attach.
+
+Search results always carry `semanticReason`, defaulting to `"none"`. Empty
+hits with a reason describe THAT call; without the field a model reads an empty
+list as proof the archive is empty and tells you that you have no meetings. The
+prompt also states that the cached context block is today's calendar and not the
+meeting library, because "No more meetings today" was being read as an archive
+claim.
+
+The Ollama system prompt is now built here rather than borrowed from the Claude
+path, which instructs the model to search the web and read photo files. Cached
+context is always included instead of keyword-gated, so a question about today's
+schedule no longer arrives with no calendar attached unless it happened to use
+the word "meeting".
+
+Cancelling a turn mid-tool reports it as cancelled rather than as a timeout, and
+an abort landing between tool calls now ends the turn instead of quietly issuing
+another POST. A cancelled `semantic_search.py` child still runs to its own 15s
+timeout; killing children is deferred.
+
+## 6.40.0
+
+Local thinking now follows the effort you asked for.
+
+6.39.3 turned thinking off wholesale. This release makes it a ladder: the
+default effort keeps local turns instant, and raising the effort raises the
+thinking budget with it -- xhigh maps to a high thinking level, max and
+ultracode to the maximum. That is what the escalation means: in a controlled
+flag benchmark against an Opus 5 reference (10/10), a local Qwen model WITH
+thinking also scored 10/10, where the same model without it scored 6-7. The
+daemon accepts level strings on Qwen-class models and silently tolerates
+think:false on models without the capability (both probed live).
+
+COS_OLLAMA_THINK becomes a PIN rather than the only switch: "1"/"true"
+always think, "0"/"false" never think, an explicit level forces that level,
+and unset defers to the effort map. Pairs with COS Control 0.5.79, which
+adds a local-model picker writing COS_OLLAMA_MODEL so multi-model daemons
+stop depending on pull order.
+
 ## 6.39.3
 
 Local turns answer in seconds again: thinking is off by default.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.39.3",
+  "version": "6.40.1",
   "description": "COS Glasses \u2014 self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, Cursor Agent CLI, or local Ollama",
   "type": "module",
   "bin": {

package/server/lib/ollama-bridge.ts

@@ -1,7 +1,6 @@
-// Direct Ollama chat — POST /api/chat. No Codex --oss, no tools, text only.
+// Direct Ollama chat — POST /api/chat. Optional read-only COS tools. No Codex --oss. Text only.
 
 import type { CallOptions, StreamCallbacks } from './claude-bridge.js'
-import { buildLightweightSystemPrompt } from './context-builder.js'
 import {
   addExchange,
   formatHistoryForPrompt,
@@ -19,6 +18,7 @@ import {
   getOllamaCatalog,
   isOllamaProviderReady,
   ollamaFetch,
+  ollamaModelSupportsTools,
 } from './ollama-catalog.js'
 import {
   classifyOllamaError,
@@ -26,52 +26,134 @@ import {
   startOllamaRun,
 } from './ollama-run-ledger.js'
 import { notifyExchange, notifySessionStart } from './telegram-notify.js'
-import { OLLAMA_MODEL } from '../../shared/model-preference.js'
+import { OLLAMA_MODEL, type EffortPreference } from '../../shared/model-preference.js'
+import { getCachedContextInstant } from './context-builder.js'
+import { getOwnerName } from './profile.js'
+import {
+  buildOllamaSystemPrompt,
+  buildOllamaToolDefs,
+  executeOllamaTool,
+  ollamaCosPipelineConfigured,
+  ollamaToolStatusLabel,
+  parseToolArguments,
+} from './ollama-tools.js'
 
 const INACTIVITY_MS = 60_000
 const WALL_MAX_MS = 180_000
+/** A turn may EXTEND past the 180s wall while tools run, but never past this. */
+const WALL_HARD_MAX_MS = 300_000
+/** POSTs to /api/chat per turn. Counted as fetches, not as "rounds" in prose:
+ *  POSTs 1-4 may execute a tool batch, POST 5 is the closing fetch. */
+const MAX_CHAT_POSTS = 5
+/** While a tool runs there is no NDJSON, so inactivity must be bumped on a
+ *  timer or a slow search trips the 60s idle abort. */
+const TOOL_HEARTBEAT_MS = 5_000
 
 /**
- * Thinking is OFF by default. A thinking-class model spends a hidden
- * reasoning chain before its first visible token -- measured 2026-08-26 on
- * qwen3.5:35b: 6,265 generated tokens for a 150-word answer (~20K thinking
- * chars), 98.6s wall against 2.2s with thinking disabled, at the same
- * visible answer quality. On the lens that is a dead screen for a minute
- * and a half, and a hard prompt can out-run WALL_MAX_MS entirely. The
- * daemon silently tolerates `think: false` on models WITHOUT the thinking
- * capability (verified live against llama3.2:1b -- HTTP 200), so no
- * capability gate is needed. COS_OLLAMA_THINK opts back in: "1"/"true"
- * enables it, or an explicit budget level passes through.
+ * Thinking follows the REQUESTED EFFORT, not a blanket switch.
+ *
+ * The default effort ('high' -- every ordinary lens turn) keeps thinking
+ * OFF: measured 2026-08-26 on qwen3.5:35b, a hidden chain turned a
+ * 2.2-second answer into 98.6 seconds of dead screen at the same visible
+ * quality, and a hard prompt can out-run WALL_MAX_MS entirely. Raising the
+ * effort raises the thinking budget with it (xhigh -> 'high', max and
+ * ultracode -> 'max'), because that is what the escalation MEANS -- the
+ * flag benchmark showed a thinking local model matching Opus 5 (10/10)
+ * where the same model without thinking scored 6-7. Level strings are
+ * accepted by the daemon on Qwen-class models (probed live), and
+ * `think: false` is silently tolerated by models WITHOUT the thinking
+ * capability (verified against llama3.2:1b -- HTTP 200), so no capability
+ * gate is needed.
+ *
+ * COS_OLLAMA_THINK, when set, PINS the behavior regardless of effort:
+ * "1"/"true" always think, "0"/"false" never think, or an explicit level.
+ * Anything unrecognized reads as unset and defers to the effort map.
  */
-export function resolveOllamaThink(raw: string | undefined): boolean | string {
+export function resolveOllamaThink(
+  raw: string | undefined,
+  effort?: EffortPreference,
+): boolean | string {
   const value = (raw ?? '').trim().toLowerCase()
   if (value === '1' || value === 'true') return true
+  if (value === '0' || value === 'false') return false
   if (value === 'low' || value === 'medium' || value === 'high' || value === 'max') return value
-  return false
+  switch (effort) {
+    case 'xhigh': return 'high'
+    case 'max':
+    case 'ultracode': return 'max'
+    default: return false
+  }
 }
 const HISTORY_LIMIT = 20
 
 type OllamaChatMessage = { role: 'system' | 'user' | 'assistant'; content: string }
 
-export function parseOllamaChatDelta(line: string): { content: string; done: boolean; error?: string } {
+/** One tool call as the daemon streams it. `arguments` is an OBJECT on the
+ *  live probe, though the wire format also permits a JSON string. */
+export interface OllamaToolCall {
+  id?: string
+  function: { name: string; arguments: unknown }
+}
+
+/**
+ * Parse one NDJSON line.
+ *
+ * `toolCalls` is OMITTED, not set to undefined or [], when a line carries no
+ * calls. Existing tests assert `toEqual({ content: 'Hi', done: false })` on an
+ * exact object, and an always-present key fails them — which would be a real
+ * signal that every consumer now has to think about tool calls, so the shape
+ * stays honest instead.
+ *
+ * Calls can ride the `done: true` line as easily as a mid-stream one, so this
+ * reads them on every line and the READER accumulates across lines (the live
+ * C3 shape puts calls on line 1 and an empty done on line 2).
+ */
+export function parseOllamaChatDelta(line: string): {
+  content: string
+  done: boolean
+  error?: string
+  toolCalls?: OllamaToolCall[]
+} {
   const trimmed = line.trim()
   if (!trimmed) return { content: '', done: false }
   try {
     const event = JSON.parse(trimmed) as {
       error?: unknown
       done?: unknown
-      message?: { content?: unknown }
+      message?: { content?: unknown; tool_calls?: unknown }
     }
     if (typeof event.error === 'string' && event.error.trim()) {
       return { content: '', done: true, error: event.error.trim() }
     }
     const content = typeof event.message?.content === 'string' ? event.message.content : ''
-    return { content, done: event.done === true }
+    const raw = event.message?.tool_calls
+    const calls: OllamaToolCall[] = Array.isArray(raw)
+      ? raw.flatMap(entry => {
+          const row = entry as { id?: unknown; function?: { name?: unknown; arguments?: unknown } }
+          const name = typeof row?.function?.name === 'string' ? row.function.name.trim() : ''
+          if (!name) return []
+          return [{
+            ...(typeof row.id === 'string' && row.id ? { id: row.id } : {}),
+            function: { name, arguments: row.function?.arguments },
+          }]
+        })
+      : []
+    return {
+      content,
+      done: event.done === true,
+      ...(calls.length > 0 ? { toolCalls: calls } : {}),
+    }
   } catch {
     return { content: '', done: false }
   }
 }
 
+/** In-loop only. Never written to history. */
+export type OllamaLoopMessage =
+  | { role: 'system' | 'user'; content: string }
+  | { role: 'assistant'; content: string; tool_calls?: OllamaToolCall[] }
+  | { role: 'tool'; content: string; tool_name: string; tool_call_id?: string }
+
 export function historyToOllamaMessages(
   exchanges: Exchange[],
   contextBreaks: number[],
@@ -94,6 +176,10 @@ function safeOllamaUserError(message: string): string {
   if (code === 'ollama.unavailable') return 'Ollama is not running. Start ollama serve on this Mac.'
   if (code === 'ollama.no_model') return 'Ollama has no pulled models. Run ollama pull, then retry.'
   if (code === 'ollama.text_only') return 'Ollama is text-only here. Remove the photo and retry.'
+  if (code === 'ollama.tool_cap') {
+    return 'The local model hit its tool round cap without finishing an answer. Rephrase, or ask a narrower question.'
+  }
+  if (code === 'ollama.tool_abort') return 'That tool call was cancelled before it finished.'
   if (code === 'ollama.timeout') return 'Ollama timed out. Retry or pick another model.'
   return `Ollama failed (${code}). Retry or check that ollama serve is running.`
 }
@@ -131,7 +217,22 @@ export async function callOllamaStreaming(
   const contextBreaks = session?.contextBreaks ?? []
   const historyPrompt = formatHistoryForPrompt(history, contextBreaks, reference)
   const handoffPrompt = options?.handoffContext?.promptBlock ? `\n\n${options.handoffContext.promptBlock}` : ''
-  const systemPrompt = `${buildLightweightSystemPrompt(query, `${historyPrompt}${handoffPrompt}`)}\n\nYou have no tools. Answer from the prompt and conversation only. Plain text.`
+  // Tools are advertised only when the pulled tag says it can call them AND
+  // the COS pipeline is really on disk. Either missing means no `tools` key at
+  // all and the original no-tools sentence, so a standalone npm install is
+  // unchanged by this release.
+  const modelSupportsTools = await ollamaModelSupportsTools(catalog.model)
+  const toolDefs = modelSupportsTools && ollamaCosPipelineConfigured() ? buildOllamaToolDefs() : []
+  const toolNames = toolDefs.map(def => def.function.name)
+  const systemPrompt = buildOllamaSystemPrompt({
+    ownerName: getOwnerName(),
+    // ALWAYS, never keyword-gated: the old path omitted the calendar unless the
+    // query happened to match schedule|meeting|..., so "what's left today"
+    // answered with no calendar at all. Cached read, so it cannot block.
+    cachedContext: getCachedContextInstant(),
+    historyPrompt: `${historyPrompt}${handoffPrompt}`,
+    toolNames,
+  })
 
   const startTime = Date.now()
   const run = startOllamaRun({
@@ -165,7 +266,11 @@ export async function callOllamaStreaming(
     markSessionNotified(sid)
   }
 
-  const messages: OllamaChatMessage[] = [
+  // Wider than OllamaChatMessage on purpose, and used ONLY for this turn's
+  // array. Tool turns are never persisted: Exchange.role stays user|assistant,
+  // and historyToOllamaMessages drops empty content — which would silently eat
+  // the C3 assistant turn whose content is '' and whose payload is the calls.
+  const messages: OllamaLoopMessage[] = [
     { role: 'system', content: systemPrompt },
     ...historyToOllamaMessages(history, contextBreaks),
     { role: 'user', content: query },
@@ -177,9 +282,13 @@ export async function callOllamaStreaming(
 
   let inactivityTimer: ReturnType<typeof setTimeout> | undefined
   let wallTimer: ReturnType<typeof setTimeout> | undefined
+  // Tracked here so clearTimers can kill it: a heartbeat still ticking after
+  // finalize would keep bumping a dead turn's inactivity timer.
+  let toolHeartbeat: ReturnType<typeof setInterval> | undefined
   const clearTimers = () => {
     if (inactivityTimer) clearTimeout(inactivityTimer)
     if (wallTimer) clearTimeout(wallTimer)
+    if (toolHeartbeat) { clearInterval(toolHeartbeat); toolHeartbeat = undefined }
   }
   const bumpInactivity = () => {
     if (inactivityTimer) clearTimeout(inactivityTimer)
@@ -218,32 +327,96 @@ export async function callOllamaStreaming(
   bumpInactivity()
   wallTimer = setTimeout(() => abort.abort(), WALL_MAX_MS)
 
-  try {
+  /**
+   * Extend the wall while a tool runs, never past the hard max.
+   *
+   * Clears and RE-ARMS: leaving the original 180s timer armed would abort the
+   * turn on schedule no matter how much time was granted. Remaining time is
+   * min(hardMax - elapsed, current + 60s), so extension cannot outrun the cap.
+   */
+  const bumpWall = () => {
+    const elapsed = Date.now() - startTime
+    const remainingToHardMax = WALL_HARD_MAX_MS - elapsed
+    if (remainingToHardMax <= 0) return
+    const current = Math.max(0, WALL_MAX_MS - elapsed)
+    const next = Math.min(remainingToHardMax, current + 60_000)
+    if (wallTimer) clearTimeout(wallTimer)
+    wallTimer = setTimeout(() => abort.abort(), next)
+  }
+
+  let postCount = 0
+  let toolsRetried = false
+
+  /** One POST + its stream. Returns what the round produced. */
+  const runChatPost = async (sendTools: boolean): Promise<
+    | { kind: 'text' }
+    | { kind: 'tools'; calls: OllamaToolCall[] }
+    | { kind: 'empty' }
+    | { kind: 'handled' }
+  > => {
+    postCount += 1
+    const body: Record<string, unknown> = {
+      model: catalog.model,
+      messages,
+      stream: true,
+      think: resolveOllamaThink(process.env.COS_OLLAMA_THINK, options?.effort),
+    }
+    if (sendTools && toolDefs.length > 0) body.tools = toolDefs
+
+    // First-byte grace on EVERY post: a silent think (effort xhigh/max) emits
+    // nothing for a long time, and without this the 60s idle abort fires
+    // before the first token rather than during a stall.
+    bumpInactivity()
     const response = await ollamaFetch(`${catalog.origin}/api/chat`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        model: catalog.model,
-        messages,
-        stream: true,
-        think: resolveOllamaThink(process.env.COS_OLLAMA_THINK),
-      }),
+      body: JSON.stringify(body),
       signal: abort.signal,
     })
     if (!response.ok) {
       const detail = (await response.text().catch(() => '')).trim().slice(0, 240)
+      // A daemon that rejects the tools key gets ONE retry without it, and only
+      // on the first POST of the turn. A later-round 400 is a real failure, and
+      // the retry deliberately does not consume a cap slot.
+      if (
+        response.status === 400 && sendTools && body.tools && !toolsRetried && postCount === 1
+        && /tool/i.test(detail)
+      ) {
+        toolsRetried = true
+        postCount -= 1
+        console.warn(`[ollama-bridge] tools rejected by ${catalog.model}: ${detail.slice(0, 120)}`)
+        return runChatPost(false)
+      }
       await finalizeError(`ollama-bridge: HTTP ${response.status}${detail ? ` — ${detail}` : ''}`)
-      return sid
+      return { kind: 'handled' }
     }
     if (!response.body) {
       await finalizeError('ollama-bridge: empty stream')
-      return sid
+      return { kind: 'handled' }
     }
 
     const reader = response.body.getReader()
     const decoder = new TextDecoder()
     let buffer = ''
-    while (true) {
+    let sawText = false
+    // Accumulated across NDJSON LINES: the live shape puts calls on line 1 and
+    // an empty done:true on line 2, so judging the done line alone sees nothing.
+    const calls: OllamaToolCall[] = []
+
+    const absorb = (line: string): 'error' | 'done' | 'ok' => {
+      const delta = parseOllamaChatDelta(line)
+      if (delta.error) return 'error'
+      if (delta.toolCalls) calls.push(...delta.toolCalls)
+      if (delta.content) {
+        sawText = true
+        fullText += delta.content
+        callbacks.onChunk(delta.content)
+      }
+      return delta.done ? 'done' : 'ok'
+    }
+
+    let streamDone = false
+    while (!streamDone) {
       const { done, value } = await reader.read()
       if (done) break
       bumpInactivity()
@@ -251,34 +424,82 @@ export async function callOllamaStreaming(
       const lines = buffer.split('\n')
       buffer = lines.pop() ?? ''
       for (const line of lines) {
-        const delta = parseOllamaChatDelta(line)
-        if (delta.error) {
-          await finalizeError(`ollama-bridge: ${delta.error}`)
-          return sid
+        const outcome = absorb(line)
+        if (outcome === 'error') {
+          await finalizeError(`ollama-bridge: ${parseOllamaChatDelta(line).error}`)
+          return { kind: 'handled' }
         }
-        if (delta.content) {
-          fullText += delta.content
-          callbacks.onChunk(delta.content)
+        if (outcome === 'done') { streamDone = true; break }
+      }
+    }
+    if (!streamDone && buffer.trim()) {
+      const outcome = absorb(buffer)
+      if (outcome === 'error') {
+        await finalizeError(`ollama-bridge: ${parseOllamaChatDelta(buffer).error}`)
+        return { kind: 'handled' }
+      }
+    }
+
+    if (calls.length > 0) return { kind: 'tools', calls }
+    return sawText ? { kind: 'text' } : { kind: 'empty' }
+  }
+
+  try {
+    for (;;) {
+      const round = await runChatPost(toolDefs.length > 0)
+      if (round.kind === 'handled') return sid
+      if (round.kind === 'text') { await finalizeDone(); return sid }
+
+      if (round.kind === 'empty') {
+        await finalizeError('ollama-bridge: Ollama completed without a response.')
+        return sid
+      }
+
+      // POST 5 is the closing fetch. Calls returned there are NOT executed and
+      // there is never a sixth POST, even if text came with them.
+      if (postCount >= MAX_CHAT_POSTS) {
+        await finalizeError('ollama-bridge: tool round cap reached without a final answer.')
+        return sid
+      }
+
+      // The assistant turn carries the calls with empty content. It must be
+      // appended as-is; dropping empty content here loses the call payload.
+      messages.push({ role: 'assistant', content: '', tool_calls: round.calls })
+
+      // Sequential. A batch runs to completion before the next POST, and a
+      // late promise from an aborted call is ignored rather than appended.
+      for (const call of round.calls) {
+        if (finalized || abort.signal.aborted) break
+        const name = call.function.name
+        callbacks.onToolStatus?.(name)
+        toolHeartbeat = setInterval(bumpInactivity, TOOL_HEARTBEAT_MS)
+        let result: string
+        try {
+          result = await executeOllamaTool(name, parseToolArguments(call.function.arguments), abort.signal)
+        } finally {
+          if (toolHeartbeat) { clearInterval(toolHeartbeat); toolHeartbeat = undefined }
         }
-        if (delta.done) {
-          await finalizeDone()
+        if (result === 'aborted' || abort.signal.aborted) {
+          await finalizeError('ollama-bridge: tool call aborted.')
           return sid
         }
+        messages.push({
+          role: 'tool',
+          content: result,
+          tool_name: name,
+          ...(call.id ? { tool_call_id: call.id } : {}),
+        })
       }
-    }
-    if (buffer.trim()) {
-      const delta = parseOllamaChatDelta(buffer)
-      if (delta.error) {
-        await finalizeError(`ollama-bridge: ${delta.error}`)
+      if (finalized) return sid
+      // An abort that lands BETWEEN calls must end the turn. Without this the
+      // loop simply fell out of the batch and issued another POST, so a
+      // cancelled turn kept talking to the daemon until it hit the cap.
+      if (abort.signal.aborted) {
+        await finalizeError('ollama-bridge: tool call aborted.')
         return sid
       }
-      if (delta.content) {
-        fullText += delta.content
-        callbacks.onChunk(delta.content)
-      }
+      bumpWall()
     }
-    await finalizeDone()
-    return sid
   } catch (error: any) {
     const aborted = abort.signal.aborted || options?.abortSignal?.aborted
     await finalizeError(

package/server/lib/ollama-catalog.ts

@@ -105,6 +105,57 @@ export function isOllamaProviderReady(): boolean {
 export function _resetOllamaCatalogCache(): void {
   catalogSnapshot = unavailableCatalog(DEFAULT_OLLAMA_ORIGIN, 'unprobed')
   refreshPromise = null
+  // The show map MUST clear with the rest. A tools-on entry surviving a reset
+  // leaks into the next test's llama3.2 stub and it passes for the wrong reason.
+  showCache.clear()
+}
+
+/** Per-model `/api/show` capability cache. Deliberately separate from the
+ *  catalog snapshot: capabilities are per TAG, and folding them into the boot
+ *  `/api/tags` probe would make the health payload carry them too. */
+const showCache = new Map<string, { tools: boolean; at: number }>()
+
+/**
+ * Does this pulled tag advertise tool support?
+ *
+ * True only for a parsed `capabilities` array containing 'tools'. A timeout or
+ * a throw returns false for THIS call but writes NO cache entry — caching a
+ * failed probe as `tools=false` would be inferring absence from silence, and
+ * the tag would stay toolless for the full TTL after one slow probe.
+ */
+export async function ollamaModelSupportsTools(model: string): Promise<boolean> {
+  const tag = (model || '').trim()
+  if (!tag) return false
+  const cached = showCache.get(tag)
+  if (cached && Date.now() - cached.at < CACHE_TTL_MS) return cached.tools
+
+  const origin = catalogSnapshot.origin || DEFAULT_OLLAMA_ORIGIN
+  try {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS)
+    let body: unknown
+    try {
+      // ollamaFetch, never raw fetch: raw fetch bypasses the test mock and can
+      // reach a live daemon from a unit test.
+      const response = await ollamaFetch(`${origin}/api/show`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: tag }),
+        signal: controller.signal,
+      })
+      if (!response.ok) return false
+      body = await response.json()
+    } finally {
+      clearTimeout(timer)
+    }
+    const capabilities = (body as { capabilities?: unknown } | null)?.capabilities
+    if (!Array.isArray(capabilities)) return false
+    const tools = capabilities.includes('tools')
+    showCache.set(tag, { tools, at: Date.now() })
+    return tools
+  } catch {
+    return false
+  }
 }
 
 async function probeOllamaCatalog(): Promise<OllamaCatalog> {

package/server/lib/ollama-run-ledger.ts

@@ -92,6 +92,13 @@ export function classifyOllamaError(message: string): string {
   if (/unreachable|econnrefused|fetch failed|enotfound/.test(text)) return 'ollama.unavailable'
   if (/no models|not ready/.test(text)) return 'ollama.no_model'
   if (/text-only|photo|image/.test(text)) return 'ollama.text_only'
+  // BOTH tool codes must precede the /aborted/ branch below. A cancelled tool
+  // reads "aborted" and would otherwise be reported to the user as a timeout,
+  // and the round-cap message would fall all the way through to the generic
+  // 'ollama.error' and surface as "Ollama failed (ollama.error)" — which tells
+  // the user nothing about what actually stopped the turn.
+  if (/tool round cap/.test(text)) return 'ollama.tool_cap'
+  if (/tool aborted|tool call aborted/.test(text)) return 'ollama.tool_abort'
   if (/timeout|timed out|aborted/.test(text)) return 'ollama.timeout'
   return 'ollama.error'
 }

package/server/lib/ollama-tools.ts

@@ -0,0 +1,368 @@
+// Read-only COS tools for the Ollama path.
+//
+// A CLOSED ALLOWLIST of three. These are not Claude CLI tool names and this
+// file must never grow toward parity: glasses-server has no in-process search
+// or fetch executor (deps are cors/express/tsx), so putting `WebSearch` or
+// `WebFetch` in the tools array would advertise a capability that cannot run.
+// Writes, Bash, MCP and photos stay off this path entirely.
+//
+// Nothing here is named `Read`. `TOOL_STATUS_MESSAGES.Read` already means
+// 'Analyzing photo...' in both HUD maps, so a tool called Read would put the
+// wrong sentence on the lens.
+
+import { statSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import {
+  cosOperationsMeetingsConfigured,
+  getCosOperationsMeetingDetail,
+  getDirectLibraryMeetingDetail,
+} from './cos-operations-meetings.js'
+import { searchMemories } from './context-library-search.js'
+import { searchMeetingLibrary } from './meeting-library-search.js'
+import { getMeetingStore, MeetingStoreError } from './meeting-store.js'
+import { TOOL_HONESTY_CLAUSE, UNTRUSTED_CONTENT_CLAUSE } from './claude-tool-access.js'
+
+export const OLLAMA_COS_TOOL_NAMES = ['search_meetings', 'search_memories', 'read_meeting'] as const
+export type OllamaCosToolName = (typeof OLLAMA_COS_TOOL_NAMES)[number]
+
+/** One tool result may not exceed this. Enforced by DROPPING hits, never by
+ *  cutting mid-string: a truncated JSON body is worse than fewer results. */
+const TOOL_RESULT_MAX_CHARS = 24_000
+
+/**
+ * Is the COS Python pipeline actually present?
+ *
+ * DUPLICATED from `cosPipelineConfigured` in claude-tool-access.ts on purpose:
+ * that one is module-private (not exported), and importing it is impossible
+ * without widening a Claude-owned surface. Same live `statSync` shape, so a
+ * standalone npm install with no operations tree advertises no COS tools and
+ * gets a prompt that never mentions them.
+ *
+ * Read live, never cached at import: `python-bridge.ts` binds COS_SCRIPTS_DIR
+ * at module load, and a test that sets the env after import would be lying to
+ * itself.
+ */
+export function ollamaCosPipelineConfigured(): boolean {
+  const dir = process.env.COS_SCRIPTS_DIR
+  if (!dir || !dir.trim()) return false
+  try {
+    return statSync(resolve(dir.trim())).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+/** Ollama's function-tool schema, matching the live C2/C4 probe. */
+export interface OllamaToolDef {
+  type: 'function'
+  function: {
+    name: string
+    description: string
+    parameters: { type: 'object'; properties: Record<string, unknown>; required: string[] }
+  }
+}
+
+export function buildOllamaToolDefs(): OllamaToolDef[] {
+  if (!ollamaCosPipelineConfigured()) return []
+  return [
+    {
+      type: 'function',
+      function: {
+        name: 'search_meetings',
+        description:
+          'Search the meeting library by meaning and keyword. Returns hits with title, date, domain, month and filename. Use the returned domain/month/filename with read_meeting to read one.',
+        parameters: {
+          type: 'object',
+          properties: {
+            query: { type: 'string', description: 'What to look for.' },
+            domain: { type: 'string', description: "Optional domain filter, e.g. quilt. Omit for all." },
+          },
+          required: ['query'],
+        },
+      },
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'search_memories',
+        description:
+          'Search stored COS memories (past session summaries, decisions and corrections) by meaning and keyword.',
+        parameters: {
+          type: 'object',
+          properties: { query: { type: 'string', description: 'What to look for.' } },
+          required: ['query'],
+        },
+      },
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'read_meeting',
+        description:
+          'Read one meeting by its exact domain, month and filename, as returned by search_meetings.',
+        parameters: {
+          type: 'object',
+          properties: {
+            domain: { type: 'string', description: "Domain, or 'library'." },
+            month: { type: 'string', description: 'YYYY-MM.' },
+            filename: { type: 'string', description: 'Exact filename from search_meetings.' },
+          },
+          required: ['domain', 'month', 'filename'],
+        },
+      },
+    },
+  ]
+}
+
+/** HUD label. Never `Analyzing photo...`, never a bare `Read`. */
+export function ollamaToolStatusLabel(name: string): string {
+  switch (name) {
+    case 'search_meetings': return 'Searching meetings...'
+    case 'search_memories': return 'Searching memory...'
+    case 'read_meeting': return 'Reading meeting...'
+    default: return 'Working...'
+  }
+}
+
+function asString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+/**
+ * `function.arguments` arrives as an OBJECT from the live daemon (C2) but the
+ * wire format also permits a JSON string. Accept both; a malformed string is a
+ * tool result, never a throw.
+ */
+export function parseToolArguments(raw: unknown): Record<string, unknown> {
+  if (raw && typeof raw === 'object' && !Array.isArray(raw)) return raw as Record<string, unknown>
+  if (typeof raw === 'string') {
+    try {
+      const parsed = JSON.parse(raw)
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        return parsed as Record<string, unknown>
+      }
+    } catch { /* falls through to empty */ }
+  }
+  return {}
+}
+
+/**
+ * Shrink by DROPPING whole hits until the JSON fits, so the string a model
+ * receives is always parseable. Mid-string truncation would hand the model
+ * broken JSON and invite it to hallucinate the rest.
+ */
+function capHits<T>(payload: Record<string, unknown>, hits: T[]): string {
+  let kept = hits.slice()
+  for (;;) {
+    const body = JSON.stringify({ ...payload, hits: kept, truncated: kept.length < hits.length })
+    if (body.length <= TOOL_RESULT_MAX_CHARS || kept.length === 0) return body
+    kept = kept.slice(0, Math.max(0, Math.floor(kept.length / 2)))
+  }
+}
+
+/**
+ * A search result ALWAYS carries its counts and its semantic reason, even when
+ * it found nothing.
+ *
+ * Empty hits plus a reason describe THIS call. Without the reason a model reads
+ * an empty list as proof the archive is empty and tells Miles he has no
+ * meetings. `semanticReason` is `"none"` rather than absent so the field can
+ * never be silently missing.
+ */
+function serializeSearch(
+  result: { hits: unknown[]; keywordCount: number; semanticCount: number; semanticAvailable: boolean; semanticReason?: string },
+  extra: Record<string, unknown> = {},
+): string {
+  return capHits(
+    {
+      ...extra,
+      keywordCount: result.keywordCount,
+      semanticCount: result.semanticCount,
+      semanticAvailable: result.semanticAvailable,
+      semanticReason: result.semanticReason ?? 'none',
+    },
+    result.hits,
+  )
+}
+
+/**
+ * Serialize a meeting as a PICKED SUBSET.
+ *
+ * Never `JSON.stringify(detail)`: the ops helpers still attach an unbounded
+ * `transcript`, and MEETING_SOURCE_MAX_BYTES is 100_000 — an order of magnitude
+ * past the tool cap. Only these fields cross into the model's context.
+ */
+function serializeMeeting(detail: Record<string, unknown>, ref: { domain: string; month: string; filename: string }): string {
+  const source = asString(detail.sourceContent)
+  const capped = source.length > TOOL_RESULT_MAX_CHARS ? source.slice(0, TOOL_RESULT_MAX_CHARS) : source
+  const picked: Record<string, unknown> = {
+    title: asString(detail.title),
+    date: asString(detail.date),
+    domain: ref.domain,
+    month: ref.month,
+    filename: ref.filename,
+    sourceContent: capped,
+    sourceTruncated: detail.sourceTruncated === true || capped.length < source.length,
+  }
+  const summary = asString(detail.summary)
+  if (summary && summary.length < 4_000) picked.summary = summary
+  if (Array.isArray(detail.topics) && detail.topics.length <= 40) picked.topics = detail.topics
+  return JSON.stringify(picked)
+}
+
+/**
+ * Copy of the routing in routes/meetings.ts ~238-256.
+ *
+ * The route reaches its store through `createMeetingsRouter(store)`, a factory
+ * parameter — there is no importable `store` binding, so this calls
+ * `getMeetingStore()` directly. A null from either helper is NOT terminal: an
+ * ops miss still falls through to the standalone store, which is what serves
+ * G2-local recordings sharing the same shape.
+ */
+function readMeetingDetail(domain: string, month: string, filename: string): string {
+  if (domain === 'library') {
+    const detail = getDirectLibraryMeetingDetail(month, filename)
+    if (detail) return serializeMeeting(detail as unknown as Record<string, unknown>, { domain, month, filename })
+  }
+  if (cosOperationsMeetingsConfigured()) {
+    const detail = getCosOperationsMeetingDetail(domain, month, filename)
+    if (detail) return serializeMeeting(detail as unknown as Record<string, unknown>, { domain, month, filename })
+  }
+  try {
+    const detail = getMeetingStore().detail(domain, month, filename)
+    if (!detail) return JSON.stringify({ error: 'not found for this path', domain, month, filename })
+    return serializeMeeting(detail as unknown as Record<string, unknown>, { domain, month, filename })
+  } catch (error) {
+    if (error instanceof MeetingStoreError) {
+      return JSON.stringify({ error: 'not found for this path', domain, month, filename })
+    }
+    throw error
+  }
+}
+
+/**
+ * Run one tool call.
+ *
+ * Returns a STRING for every outcome the model could plausibly cause — unknown
+ * name, missing argument, nothing found — because a thrown error would end the
+ * whole turn where the model could simply have tried again. Only an abort
+ * escapes as the sentinel `aborted`.
+ *
+ * `AbortSignal` is not thenable, so cancellation is a listener race rather than
+ * an await. The signal is optional purely so unit tests can call this directly.
+ */
+export async function executeOllamaTool(
+  name: string,
+  args: Record<string, unknown>,
+  abortSignal?: AbortSignal,
+): Promise<string> {
+  if (abortSignal?.aborted) return 'aborted'
+  const work = runTool(name, args)
+  if (!abortSignal) return work
+  return Promise.race([
+    work,
+    new Promise<string>(resolveRace => {
+      abortSignal.addEventListener('abort', () => resolveRace('aborted'), { once: true })
+    }),
+  ])
+}
+
+async function runTool(name: string, args: Record<string, unknown>): Promise<string> {
+  try {
+    if (name === 'search_meetings') {
+      const query = asString(args.query)
+      if (!query) return JSON.stringify({ error: 'query is required' })
+      const domain = asString(args.domain)
+      const result = await searchMeetingLibrary({ query, ...(domain ? { domain } : {}) })
+      return serializeSearch(result, { query, domain: domain || 'all' })
+    }
+    if (name === 'search_memories') {
+      const query = asString(args.query)
+      if (!query) return JSON.stringify({ error: 'query is required' })
+      const result = await searchMemories({ query })
+      return serializeSearch(result, { query })
+    }
+    if (name === 'read_meeting') {
+      const domain = asString(args.domain)
+      const month = asString(args.month)
+      const filename = asString(args.filename)
+      if (!domain || !month || !filename) {
+        return JSON.stringify({ error: 'domain, month and filename are all required' })
+      }
+      return readMeetingDetail(domain, month, filename)
+    }
+    return `unknown tool ${name}`
+  } catch (error) {
+    // Call-local wording. Helper keys like `qdrant_unreachable` describe one
+    // probe, and repeating them as prose invites the model to announce a
+    // service outage it cannot actually observe.
+    const detail = error instanceof Error ? error.message.slice(0, 200) : 'failed'
+    return JSON.stringify({ error: 'tool call failed', detail })
+  }
+}
+
+/**
+ * What the model is told it can do. Deliberately NOT `readOnlyCapabilityPrompt`
+ * (it asserts MCP reachability) and NOT `claudeToolCapabilityPrompt`.
+ *
+ * The escalation line must never name Ollama: Codex once offered to re-run a
+ * failed task on itself, which is a loop dressed as a suggestion.
+ */
+export function ollamaToolCapabilityPrompt(toolNames: readonly string[]): string {
+  return [
+    'This request runs on the READ-ONLY Ollama path.',
+    `Available tools: ${toolNames.join(', ')}. Writes, Bash, MCP, web search, web fetch, and photos are not available here.`,
+    'An absent name means it is not on this path — do not ToolSearch and do not claim a connector is down.',
+    'Empty search hits plus a reason report the result of THIS call; they are not proof that no meetings or memories exist.',
+    'A read_meeting miss means not found for that path, not that the meeting does not exist.',
+    'If the user needs a write or a web search, say so and offer Opus or Codex/GPT (workspace-write), never this local slot.',
+    TOOL_HONESTY_CLAUSE,
+    UNTRUSTED_CONTENT_CLAUSE,
+  ].join('\n')
+}
+
+/** The sentence used when no tools are advertised. Preserved verbatim. */
+export const OLLAMA_NO_TOOLS_SENTENCE =
+  'You have no tools. Answer from the prompt and conversation only. Plain text.'
+
+/**
+ * The Ollama system prompt.
+ *
+ * Built here rather than through `buildSystemPrompt`, which instructs the model
+ * to search the web and read photo files — neither of which exists on this
+ * path. The glasses display constraints are copied from
+ * `buildLightweightSystemPrompt` WITHOUT its Siri framing ("NOT a work
+ * productivity tool"), which is wrong the moment COS tools are advertised.
+ *
+ * Cached context is included ALWAYS, not keyword-gated: the old gate meant a
+ * question about today's schedule got no calendar unless it happened to use the
+ * word "meeting". The cached read is instant, so this cannot block a glasses
+ * turn the way an awaited build would.
+ */
+export function buildOllamaSystemPrompt(input: {
+  ownerName: string
+  cachedContext: string
+  historyPrompt: string
+  toolNames: readonly string[]
+}): string {
+  const owner = input.ownerName.trim() || 'the wearer'
+  const parts = [
+    `You are COS, ${owner}'s chief of staff, answering on smart glasses.`,
+    'Answer in plain text. No markdown, no bullet characters, no emoji.',
+    'Aim for 300 to 600 characters. Up to about 2000 when the answer genuinely needs it.',
+  ]
+  if (input.cachedContext.trim()) {
+    parts.push(input.cachedContext.trim())
+    parts.push(
+      "The context block above is TODAY'S calendar and tasks. It is not the meeting archive. \"No more meetings today\" describes today's schedule only.",
+    )
+  }
+  if (input.historyPrompt.trim()) parts.push(input.historyPrompt.trim())
+  parts.push(
+    input.toolNames.length > 0
+      ? ollamaToolCapabilityPrompt(input.toolNames)
+      : OLLAMA_NO_TOOLS_SENTENCE,
+  )
+  return parts.join('\n\n')
+}

package/server/lib/query-job-runtime.ts

@@ -38,6 +38,9 @@ const TOOL_STATUS_MESSAGES: Record<string, string> = {
   WebSearch: 'Searching web...',
   WebFetch: 'Reading page...',
   Read: 'Analyzing photo...',
+  search_meetings: 'Searching meetings...',
+  search_memories: 'Searching memory...',
+  read_meeting: 'Reading meeting...',
 }
 
 export class QueryJobAdmissionPreparationError extends Error {

package/server/routes/query.ts

@@ -24,6 +24,9 @@ const TOOL_STATUS_MESSAGES: Record<string, string> = {
   WebSearch: 'Searching web...',
   WebFetch: 'Reading page...',
   Read: 'Analyzing photo...',
+  search_meetings: 'Searching meetings...',
+  search_memories: 'Searching memory...',
+  read_meeting: 'Reading meeting...',
 }
 
 export const queryRouter = Router()