switchroom 0.18.3 → 0.18.7

package/telegram-plugin/tests/worker-feed-dispatch.test.ts

@@ -17,6 +17,7 @@ function makeSub(over: Partial<Subagent>): Subagent {
     result_summary: null,
     jsonl_agent_id: 'a37ad7639ae61476c',
     parent_agent_id: null,
+    model: null,
     ...over,
   }
 }
@@ -61,6 +62,85 @@ describe('resolveWorkerFeedDispatch (#2002 regression pin)', () => {
     // flip a foreground turn into a background one.
     expect(resolveWorkerFeedDispatch(null, '').isBackground).toBe(false)
   })
+
+  it('surfaces the persisted registry model as feedModel (first-paint fallback)', () => {
+    const sub = makeSub({ background: true, model: 'claude-opus-4-8' })
+    expect(resolveWorkerFeedDispatch(sub, 'sub-agent').feedModel).toBe('claude-opus-4-8')
+  })
+
+  it('feedModel is null when the row is missing or carries no model', () => {
+    expect(resolveWorkerFeedDispatch(null, 'sub-agent').feedModel).toBeNull()
+    expect(resolveWorkerFeedDispatch(makeSub({ model: null }), 'sub-agent').feedModel).toBeNull()
+  })
+})
+
+describe('gateway onFinish — fix #1: resultText-driven handback fallback (model)', () => {
+  // Mirrors the exact fallback gateway.ts's onFinish handler applies on top
+  // of `resolveWorkerFeedDispatch`'s own result (gateway.ts, onFinish
+  // handler, right after computing `dispatch`):
+  //
+  //   let isBackground = dispatch.isBackground
+  //   if (!dispatch.hasRow && entryBackground == null && resultText.trim().length > 0) {
+  //     isBackground = true
+  //   }
+  //
+  // This is the worst case of the #1 bug: the DB row was never linked
+  // (unlinked `jsonl_agent_id`) AND the watcher's own cached
+  // `entry.background` was also never observed (both `resolveWorkerFeedDispatch`
+  // fallbacks came up empty). A finished worker with actual narrative
+  // result text is far more likely a dropped background handback than a
+  // legitimate foreground no-op, so this degrades to background rather
+  // than silently discarding the result.
+  function applyOnFinishBackgroundFallback(
+    dispatch: { isBackground: boolean; hasRow: boolean },
+    entryBackground: boolean | undefined,
+    resultText: string,
+  ): boolean {
+    let isBackground = dispatch.isBackground
+    if (!dispatch.hasRow && entryBackground == null && resultText.trim().length > 0) {
+      isBackground = true
+    }
+    return isBackground
+  }
+
+  it('meta-missing path: no row, no entry.background, non-empty resultText → routes a handback', () => {
+    const dispatch = resolveWorkerFeedDispatch(null, 'sub-agent', undefined)
+    const result = applyOnFinishBackgroundFallback(dispatch, undefined, 'Here is what I found...')
+    expect(result).toBe(true)
+  })
+
+  it('no-fuzzy-candidate path: no row, no entry.background, non-empty resultText → routes a handback', () => {
+    // Same shape as above — the ambiguous-fuzzy-match-refused case (fix #3)
+    // also leaves jsonl_agent_id unlinked, landing in the same no-row state.
+    const dispatch = resolveWorkerFeedDispatch(null, 'sub-agent', undefined)
+    const result = applyOnFinishBackgroundFallback(dispatch, undefined, 'Task complete: 3 files changed.')
+    expect(result).toBe(true)
+  })
+
+  it('empty resultText with no row/no entry.background does NOT escalate (true foreground no-op preserved)', () => {
+    const dispatch = resolveWorkerFeedDispatch(null, 'sub-agent', undefined)
+    const result = applyOnFinishBackgroundFallback(dispatch, undefined, '   ')
+    expect(result).toBe(false)
+  })
+
+  it('entry.background=false (watcher DID observe it as foreground) is trusted over resultText', () => {
+    const dispatch = resolveWorkerFeedDispatch(null, 'sub-agent', false)
+    const result = applyOnFinishBackgroundFallback(dispatch, false, 'Some prose result anyway.')
+    expect(result).toBe(false)
+  })
+
+  it('entry.background=true (watcher DID observe it) is trusted directly, no resultText fallback needed', () => {
+    const dispatch = resolveWorkerFeedDispatch(null, 'sub-agent', true)
+    const result = applyOnFinishBackgroundFallback(dispatch, true, '')
+    expect(result).toBe(true)
+  })
+
+  it('a present DB row is authoritative — the resultText fallback never overrides a real foreground row', () => {
+    const sub = makeSub({ background: false })
+    const dispatch = resolveWorkerFeedDispatch(sub, 'sub-agent', undefined)
+    const result = applyOnFinishBackgroundFallback(dispatch, undefined, 'Long narrative result...')
+    expect(result).toBe(false)
+  })
 })
 
 // Deterministic PRNG (mulberry32) so a failing case is reproducible from the
@@ -140,6 +220,52 @@ describe('resolveWorkerFeedDispatch — randomized property sweep', () => {
   })
 })
 
+describe('resolveWorkerFeedDispatch — fix #1(+#2): entryBackground fallback', () => {
+  it('falls back to entryBackground=true when the registry row is missing (unlinked jsonl_agent_id)', () => {
+    // Simulates onFinish firing for a background worker whose DB row was
+    // never linked via `jsonl_agent_id` (meta.json missing, or the fuzzy
+    // backfill match never fired) — the watcher's own cached
+    // `entry.background` (seeded at dispatch time / kept fresh by
+    // `readSubTail`'s liveness lookup) is the only signal left.
+    const out = resolveWorkerFeedDispatch(null, 'sub-agent', true)
+    expect(out.isBackground).toBe(true)
+    expect(out.hasRow).toBe(false)
+  })
+
+  it('falls back to entryBackground=false when the row is missing and the entry was foreground', () => {
+    const out = resolveWorkerFeedDispatch(null, 'sub-agent', false)
+    expect(out.isBackground).toBe(false)
+  })
+
+  it('defaults to false when the row is missing AND entryBackground was never observed (undefined)', () => {
+    // Both fallbacks come up empty — worst case, matches pre-fix
+    // behaviour (isBackground=false) at the resolver level. The gateway's
+    // onFinish handler applies its OWN further fallback on top of this
+    // (routing a handback anyway when resultText is non-empty) — that's
+    // pinned separately in the gateway-level test, not here.
+    const out = resolveWorkerFeedDispatch(null, 'sub-agent', undefined)
+    expect(out.isBackground).toBe(false)
+    expect(out.hasRow).toBe(false)
+  })
+
+  it('a present registry row always wins over entryBackground, even when they disagree', () => {
+    // The DB row is the authoritative source whenever it's actually
+    // linked — entryBackground is a pure fallback for the unlinked case,
+    // never a second vote.
+    const sub = makeSub({ background: true })
+    const out = resolveWorkerFeedDispatch(sub, 'sub-agent', false)
+    expect(out.isBackground).toBe(true)
+  })
+
+  it('omitting entryBackground entirely preserves prior 2-arg call-site behaviour', () => {
+    // #2002-era callers pass only 2 args — the optional 3rd param must not
+    // change their observed result.
+    expect(resolveWorkerFeedDispatch(null, 'sub-agent')).toEqual(
+      resolveWorkerFeedDispatch(null, 'sub-agent', undefined),
+    )
+  })
+})
+
 describe('resolveWorkerFeedDispatch — nested/row-presence signals (unified progress cards)', () => {
   it('hasRow=false for a missing registry row (never silently foreground-nest it)', () => {
     const out = resolveWorkerFeedDispatch(null, 'sub-agent')

package/telegram-plugin/tool-activity-summary.ts

@@ -91,6 +91,7 @@ import {
 } from './status-no-truncate.js'
 import { escapeMarkdown, stripMarkdown, truncate, stackCardLines } from './card-format.js'
 import { isTelegramSurfaceTool } from './tool-names.js'
+import { formatModelLabel } from './model-label.js'
 
 /**
  * Optional header for the main-session activity card, matching the worker
@@ -106,6 +107,14 @@ export interface SessionActivityHeader {
   elapsedMs: number
   toolCount: number
   state: 'running' | 'done'
+  /**
+   * Live model in use, as a raw resolved model id (e.g. `claude-opus-4-8`,
+   * `sr-glm-5`) sourced from the transcript. Rendered as a short friendly form
+   * appended to the metrics line (`… · opus 4.8`). Omitted when unknown — the
+   * card never guesses from config. Formatting + sentinel-filtering live in
+   * `formatModelLabel` (model-label.ts).
+   */
+  model?: string
 }
 
 /**
@@ -173,14 +182,19 @@ export function renderActivityHeader(
   elapsedMs: number,
   toolCount: number,
   state: 'running' | 'done' | 'failed',
+  model?: string,
 ): [string, string] {
   const toolWord = toolCount === 1 ? 'tool' : 'tools'
   const elapsed = formatFeedElapsed(elapsedMs)
   const descPart = description.length > 0 ? ` · _${escapeMarkdown(description)}_` : ''
   const line1 = `${emoji} **${escapeMarkdown(label)}**${descPart}`
+  // Subtle live-model tag: joins the existing dot-separated metrics (never a new
+  // line). formatModelLabel returns null for absent/sentinel values → no suffix.
+  const modelLabel = formatModelLabel(model)
+  const modelPart = modelLabel != null ? ` · ${escapeMarkdown(modelLabel)}` : ''
   const line2 = state === 'running'
-    ? `_${elapsed} · ${toolCount} ${toolWord}_`
-    : `_${state} · ${toolCount} ${toolWord} · ${elapsed}_`
+    ? `_${elapsed} · ${toolCount} ${toolWord}${modelPart}_`
+    : `_${state} · ${toolCount} ${toolWord} · ${elapsed}${modelPart}_`
   return [line1, line2]
 }
 
@@ -270,6 +284,9 @@ export interface StatusCardHeader {
   elapsedMs: number
   toolCount: number
   state: 'running' | 'done' | 'failed'
+  /** Live model id (raw, e.g. `claude-opus-4-8`) — rendered as a short friendly
+   *  tag on the metrics line via `formatModelLabel`. Omitted when unknown. */
+  model?: string
 }
 
 /** Inputs to the unified status-card renderer. */
@@ -321,6 +338,7 @@ export function renderStatusCard(opts: StatusCardOpts): string | null {
         // when the result block is empty. The agent surface never passes
         // 'failed', so only the worker card is affected.
         header.state,
+        header.model,
       )
     : []
 
@@ -476,6 +494,7 @@ export function renderActivityFeed(
           elapsedMs: header.elapsedMs,
           toolCount: header.toolCount,
           state: header.state,
+          model: header.model,
         }
       : undefined,
     steps: lines,
@@ -527,6 +546,7 @@ export function renderActivityFeedWithNested(
           elapsedMs: header.elapsedMs,
           toolCount: header.toolCount,
           state: header.state,
+          model: header.model,
         }
       : undefined,
     steps: lines,

package/telegram-plugin/typing-wrap.ts

@@ -1,10 +1,15 @@
 // Auto-wrap tool dispatch with a Telegram typing-indicator loop so the user
-// sees a live "agent is working" signal during the 3–30s gap where the
-// progress card is deliberately suppressed (its initialDelayMs is 3s).
-// The first tool call on a given (chat, thread) fires the typing loop
-// immediately so there's no silent dead window before the progress card
-// appears. Subsequent calls on the same lane honour the debounce to avoid
-// churn. Surface tools own their own loop — see isSurfaceTool.
+// sees a live "agent is working" signal for the run of a turn. This is now
+// the PRIMARY liveness signal for short tool-using turns, not a bridge to a
+// soon-to-appear pinned progress card: the pinned card is retired
+// (`unpinProgressCardForChat = null`, see
+// `docs/diagrams/deterministic-status-anatomy.spec.md`), and the worker
+// progress card only gates in at `elapsed >= 60s OR sub-agent appeared` — for
+// most short turns it never appears at all. The first tool call on a given
+// (chat, thread) fires the typing loop immediately so there's no silent dead
+// window at turn start. Subsequent calls on the same lane honour the
+// debounce to avoid churn. Surface tools own their own loop — see
+// isSurfaceTool.
 //
 // Keying changed from `chatId` to `(chatId, threadId)` in PR3 of the
 // supergroup-mode rollout. In supergroup mode one agent owns many topics
@@ -38,17 +43,55 @@ export interface TypingWrapper {
 interface Entry {
   chatId: string
   threadId: number | null
+  lane: string
   timer: ReturnType<typeof setTimeout>
+}
+
+/**
+ * Per-lane bookkeeping: `count` is the number of outstanding (dispatched but
+ * not yet resulted) tool-uses on the lane; `started` is whether the typing
+ * loop is currently believed to be running for it. Ref-counted rather than a
+ * boolean-per-lane `Set` (pre-fix#7 shape) because two PARALLEL tool_use
+ * blocks on one lane must both hold the lane open: with a plain Set,
+ * `onToolResult` for the first one deleted the lane and stopped the loop
+ * while the second tool was still running, flickering the typing indicator
+ * off until the next tool re-fired it. Only the count reaching zero may stop
+ * the loop.
+ */
+interface LaneState {
+  count: number
   started: boolean
 }
 
 export function createTypingWrapper(deps: TypingWrapperDeps): TypingWrapper {
   const debounceMs = deps.debounceMs ?? 500
   const pending = new Map<string, Entry>()
-  // Track per-(chat,thread) lanes that already have an active typing loop
-  // so the first tool call on a lane fires immediately while subsequent
-  // calls on the same lane use the debounce.
-  const activeLanes = new Set<string>()
+  const lanes = new Map<string, LaneState>()
+
+  function laneFor(lane: string): LaneState {
+    let s = lanes.get(lane)
+    if (s == null) {
+      s = { count: 0, started: false }
+      lanes.set(lane, s)
+    }
+    return s
+  }
+
+  // Decrement the lane's outstanding count. Returns true iff the count just
+  // reached zero AND the loop was running — i.e. iff the CALLER must now
+  // call `stopTypingLoop`. This is the ref-count release: the loop only
+  // stops once every outstanding tool-use on the lane has resulted.
+  function release(lane: string): boolean {
+    const s = lanes.get(lane)
+    if (s == null) return false
+    s.count = Math.max(0, s.count - 1)
+    if (s.count === 0) {
+      const wasStarted = s.started
+      lanes.delete(lane)
+      return wasStarted
+    }
+    return false
+  }
 
   return {
     onToolUse(toolUseId, chatId, toolName, threadId) {
@@ -60,19 +103,21 @@ export function createTypingWrapper(deps: TypingWrapperDeps): TypingWrapper {
       const prior = pending.get(toolUseId)
       if (prior) {
         clearTimeout(prior.timer)
-        if (prior.started) deps.stopTypingLoop(prior.chatId, prior.threadId)
+        if (release(prior.lane)) deps.stopTypingLoop(prior.chatId, prior.threadId)
         pending.delete(toolUseId)
       }
-      // First tool on this lane: fire immediately rather than waiting for
-      // the debounce — this closes the silent dead window before the first
-      // progress card appears.
-      if (!activeLanes.has(lane)) {
+      const state = laneFor(lane)
+      state.count += 1
+      // First outstanding tool-use on this lane: fire immediately rather
+      // than waiting for the debounce — this closes the silent dead window
+      // at turn start.
+      if (state.count === 1) {
         deps.startTypingLoop(chatId, tid)
-        activeLanes.add(lane)
+        state.started = true
         const entry: Entry = {
           chatId,
           threadId: tid,
-          started: true,
+          lane,
           timer: setTimeout(() => {}, 0), // no-op sentinel
         }
         pending.set(toolUseId, entry)
@@ -81,10 +126,10 @@ export function createTypingWrapper(deps: TypingWrapperDeps): TypingWrapper {
       const entry: Entry = {
         chatId,
         threadId: tid,
-        started: false,
+        lane,
         timer: setTimeout(() => {
           deps.startTypingLoop(chatId, tid)
-          entry.started = true
+          state.started = true
         }, debounceMs),
       }
       pending.set(toolUseId, entry)
@@ -95,20 +140,22 @@ export function createTypingWrapper(deps: TypingWrapperDeps): TypingWrapper {
       const entry = pending.get(toolUseId)
       if (!entry) return
       clearTimeout(entry.timer)
-      if (entry.started) {
-        deps.stopTypingLoop(entry.chatId, entry.threadId)
-        activeLanes.delete(chatKey(entry.chatId, entry.threadId) as string)
-      }
+      if (release(entry.lane)) deps.stopTypingLoop(entry.chatId, entry.threadId)
       pending.delete(toolUseId)
     },
 
     drainAll() {
+      const stoppedLanes = new Set<string>()
       for (const entry of pending.values()) {
         clearTimeout(entry.timer)
-        if (entry.started) deps.stopTypingLoop(entry.chatId, entry.threadId)
+        const state = lanes.get(entry.lane)
+        if (state?.started && !stoppedLanes.has(entry.lane)) {
+          deps.stopTypingLoop(entry.chatId, entry.threadId)
+          stoppedLanes.add(entry.lane)
+        }
       }
       pending.clear()
-      activeLanes.clear()
+      lanes.clear()
     },
   }
 }