@gotcos/glasses-server 6.50.4 → 6.52.0

package/server/lib/occupancy-probes.ts

@@ -834,6 +834,58 @@ export function withHookTurnClock(
   }
 }
 
+/**
+ * Add the Codex turn clock (6.51.0) to a probe set, keeping whatever the set already
+ * answers for other providers.
+ *
+ * `codexTurnEndedAtMs` reads the thread's rollout tail and answers a time only when the
+ * newest turn marker CLOSED a turn (`task_complete`/`turn_complete`); a `task_started`
+ * after it, an unreadable file, or a tail with no marker all answer null, which keeps
+ * the 30 s transcript window. Measured on codex-cli 0.155: the app starts a turn queued
+ * in its own queue 10 ms after the `task_complete`, and that `task_started` is what the
+ * next read sees.
+ */
+export function withCodexTurnClock(
+  probes: OccupancyProbes,
+  codexTurnEndedAtMs: (threadId: string) => number | null,
+): OccupancyProbes {
+  const inner = probes.holderTurnEndedAtMs
+  return {
+    ...probes,
+    holderTurnEndedAtMs: (provider, threadId) => {
+      if (provider === 'codex') {
+        if (!NATIVE_THREAD_ID_RE.test(threadId)) return null
+        return codexTurnEndedAtMs(threadId)
+      }
+      return typeof inner === 'function' ? inner(provider, threadId) : null
+    },
+  }
+}
+
+/**
+ * Add the Cursor composer turn signal (6.51.0). `signalFor` is the hook signal store's
+ * reader; Cursor's hook events land there under the composer's conversation id. Open
+ * means: a turn was opened (prompt or tool) and no Stop has closed it, nothing ended the
+ * session, and the newest event is inside the open-turn ceiling -- a composer that died
+ * mid-turn must not read working for ever.
+ */
+export function withCursorComposerTurn(
+  probes: OccupancyProbes,
+  signalFor: (sessionId: string) => { turnOpen: boolean; ended: { at: number; reason: string } | null; lastEventAt: number } | undefined,
+  now: () => number,
+  ceilingMs: number,
+): OccupancyProbes {
+  return {
+    ...probes,
+    cursorComposerTurnOpen: (threadId: string) => {
+      if (!NATIVE_THREAD_ID_RE.test(threadId)) return null
+      const signal = signalFor(threadId)
+      if (!signal) return null
+      return signal.turnOpen === true && signal.ended === null && now() - signal.lastEventAt <= ceilingMs
+    },
+  }
+}
+
 /** The facts the hook turn clock reads off a session signal. */
 export interface HookTurnSignal {
   lastEvent: string

package/server/lib/ollama-bridge.ts

@@ -37,6 +37,7 @@ import {
   ollamaToolStatusLabel,
   parseToolArguments,
 } from './ollama-tools.js'
+import { ollamaTrailOutcome, ollamaTrailStep, type JobTrailDraft } from './job-trail.js'
 
 const INACTIVITY_MS = 60_000
 const WALL_MAX_MS = 180_000
@@ -347,6 +348,14 @@ export async function callOllamaStreaming(
   let postCount = 0
   let toolsRetried = false
 
+  // 6.52.0, the Messages trail. This bridge owns its loop, so it reports each round's words
+  // and each tool call itself (there is no stdout to tee). A no-op without `onTrail`, and
+  // it never throws into the loop.
+  const trail = (draft: JobTrailDraft) => {
+    if (!callbacks.onTrail) return
+    try { callbacks.onTrail(draft) } catch { /* observation only */ }
+  }
+
   /** One POST + its stream. Returns what the round produced. */
   const runChatPost = async (sendTools: boolean): Promise<
     | { kind: 'text' }
@@ -446,8 +455,14 @@ export async function callOllamaStreaming(
 
   try {
     for (;;) {
+      const roundStart = fullText.length
       const round = await runChatPost(toolDefs.length > 0)
       if (round.kind === 'handled') return sid
+      // One prose entry per round: what the model wrote before its calls, or its answer.
+      if (callbacks.onTrail && (round.kind === 'text' || round.kind === 'tools')) {
+        const roundText = fullText.slice(roundStart)
+        if (roundText.trim()) trail({ kind: 'prose', text: roundText })
+      }
       if (round.kind === 'text') { await finalizeDone(); return sid }
 
       if (round.kind === 'empty') {
@@ -472,6 +487,7 @@ export async function callOllamaStreaming(
         if (finalized || abort.signal.aborted) break
         const name = call.function.name
         callbacks.onToolStatus?.(name)
+        if (callbacks.onTrail) trail(ollamaTrailStep(name, parseToolArguments(call.function.arguments)))
         toolHeartbeat = setInterval(bumpInactivity, TOOL_HEARTBEAT_MS)
         let result: string
         try {
@@ -483,6 +499,7 @@ export async function callOllamaStreaming(
           await finalizeError('ollama-bridge: tool call aborted.')
           return sid
         }
+        if (callbacks.onTrail) trail(ollamaTrailOutcome(result))
         messages.push({
           role: 'tool',
           content: result,