switchroom 0.18.3 → 0.18.7

package/telegram-plugin/registry/subagents.test.ts

@@ -26,9 +26,11 @@ import {
   recordSubagentStall,
   recordSubagentResume,
   bumpSubagentActivity,
+  recordSubagentModel,
   getSubagent,
   reapStuckRunningRows,
   countRunningBackgroundSubagents,
+  listNonTerminalSubagentsForTurn,
 } from './subagents-schema.js'
 
 // ---------------------------------------------------------------------------
@@ -68,6 +70,54 @@ describe('migration on fresh DB', () => {
     expect(() => applySubagentsSchema(db)).not.toThrow()
     db.close()
   })
+
+  it('creates the model column on a fresh DB', () => {
+    const db = openFreshSubagentsDbInMemory()
+    const cols = db.prepare("SELECT name FROM pragma_table_info('subagents')").all() as { name: string }[]
+    expect(cols.map((c) => c.name)).toContain('model')
+    db.close()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Live-model column — migration + record helper
+// ---------------------------------------------------------------------------
+
+describe('live-model column', () => {
+  it('migrates a pre-model subagents table by adding the model column (idempotent)', () => {
+    const db = openFreshSubagentsDbInMemory()
+    // Simulate a legacy table with no model column.
+    db.exec('ALTER TABLE subagents DROP COLUMN model')
+    let cols = db.prepare("SELECT name FROM pragma_table_info('subagents')").all() as { name: string }[]
+    expect(cols.map((c) => c.name)).not.toContain('model')
+    // Re-applying the schema must add it back, and be safe to repeat.
+    applySubagentsSchema(db)
+    applySubagentsSchema(db)
+    cols = db.prepare("SELECT name FROM pragma_table_info('subagents')").all() as { name: string }[]
+    expect(cols.map((c) => c.name)).toContain('model')
+    db.close()
+  })
+
+  it('recordSubagentStart leaves model null; recordSubagentModel persists on change', () => {
+    const db = openFreshSubagentsDbInMemory()
+    const now = Date.now()
+    recordSubagentStart(db, { id: 'toolu_m1', background: true, startedAt: now, jsonlAgentId: 'a1' })
+    expect(getSubagent(db, 'toolu_m1')?.model).toBeNull()
+
+    recordSubagentModel(db, { id: 'toolu_m1', model: 'claude-opus-4-8' })
+    expect(getSubagent(db, 'toolu_m1')?.model).toBe('claude-opus-4-8')
+
+    // Update-on-change: a later model overwrites.
+    recordSubagentModel(db, { id: 'toolu_m1', model: 'sr-glm-5' })
+    expect(getSubagent(db, 'toolu_m1')?.model).toBe('sr-glm-5')
+    db.close()
+  })
+
+  it('recordSubagentModel no-ops gracefully on a missing id', () => {
+    const db = openFreshSubagentsDbInMemory()
+    expect(() => recordSubagentModel(db, { id: 'nope', model: 'claude-opus-4-8' })).not.toThrow()
+    db.close()
+  })
 })
 
 // ---------------------------------------------------------------------------
@@ -616,3 +666,43 @@ describe('reapStuckRunningRows', () => {
     expect(result.ids.sort()).toEqual(['sa-0', 'sa-1', 'sa-2', 'sa-3', 'sa-4'])
   })
 })
+
+// ---------------------------------------------------------------------------
+// listNonTerminalSubagentsForTurn — the boot-resume accessor
+// ---------------------------------------------------------------------------
+
+describe('listNonTerminalSubagentsForTurn', () => {
+  it('returns running + stalled workers of a turn, excluding terminals, ordered by started_at', () => {
+    const db = openFreshSubagentsDbInMemory()
+    const turn = 'chat-1:7'
+    recordSubagentStart(db, { id: 'sa-run', parentTurnKey: turn, agentType: 'worker', description: 'refactor auth', background: true, startedAt: 1000 })
+    recordSubagentStart(db, { id: 'sa-stall', parentTurnKey: turn, agentType: 'researcher', description: 'survey competitors', background: true, startedAt: 2000 })
+    recordSubagentStall(db, { id: 'sa-stall', stalledAt: 3000 })
+    recordSubagentStart(db, { id: 'sa-done', parentTurnKey: turn, agentType: 'worker', description: 'done work', background: true, startedAt: 500 })
+    recordSubagentEnd(db, { id: 'sa-done', endedAt: 4000, status: 'completed' })
+    recordSubagentStart(db, { id: 'sa-fail', parentTurnKey: turn, background: true, startedAt: 600 })
+    recordSubagentEnd(db, { id: 'sa-fail', endedAt: 4100, status: 'failed' })
+
+    const rows = listNonTerminalSubagentsForTurn(db, turn)
+    expect(rows.map((r) => r.id)).toEqual(['sa-run', 'sa-stall']) // started_at ASC, terminals excluded
+    expect(rows[0].agent_type).toBe('worker')
+    expect(rows[0].description).toBe('refactor auth')
+    expect(rows[1].status).toBe('stalled')
+    db.close()
+  })
+
+  it('does not return workers of a different turn', () => {
+    const db = openFreshSubagentsDbInMemory()
+    recordSubagentStart(db, { id: 'sa-a', parentTurnKey: 'chat:1', background: true, startedAt: 1000 })
+    recordSubagentStart(db, { id: 'sa-b', parentTurnKey: 'chat:2', background: true, startedAt: 1000 })
+    const rows = listNonTerminalSubagentsForTurn(db, 'chat:1')
+    expect(rows.map((r) => r.id)).toEqual(['sa-a'])
+    db.close()
+  })
+
+  it('returns empty for a turn with no in-flight workers', () => {
+    const db = openFreshSubagentsDbInMemory()
+    expect(listNonTerminalSubagentsForTurn(db, 'nope:0')).toEqual([])
+    db.close()
+  })
+})

package/telegram-plugin/session-tail.ts

@@ -42,6 +42,7 @@ function isMultiAgentEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
 }
 import { classifyClaudeError, type OperatorEventKind } from './operator-events.js'
 import { createToolLabelSidecar, type ToolLabelSidecar } from './tool-label-sidecar.js'
+import { isModelSentinel } from './model-label.js'
 
 /** Match Claude Code's cli.js VX() function. */
 export function sanitizeCwdToProjectName(cwd: string): string {
@@ -92,6 +93,13 @@ export type SessionEvent =
   | { kind: 'enqueue'; chatId: string | null; messageId: string | null; threadId: string | null; rawContent: string; isSync?: boolean }
   | { kind: 'dequeue' }
   | { kind: 'thinking' }
+  // Live model in use for the MAIN session, extracted from `message.model` on
+  // each `type:"assistant"` transcript line (the exact model that served that
+  // API call). Emitted FIRST among a line's events so a card rendered on the
+  // same batch already reflects the current model. Sentinels (`<synthetic>` on
+  // compaction lines, fixture junk) are filtered at projection — see
+  // isModelSentinel — so this only ever carries a real resolved model id.
+  | { kind: 'model'; model: string }
   | { kind: 'tool_use'; toolName: string; toolUseId?: string | null; input?: Record<string, unknown>; precomputedLabel?: string }
   // Real-time tool label from the PreToolUse-hook sidecar — fires when the
   // hook writes the label (synchronous at tool-call time), independent of
@@ -115,6 +123,11 @@ export type SessionEvent =
   // filename stem (e.g. "aac6f1…"). Routed through the same ingest path
   // as parent events; the reducer fans them out to per-sub-agent state.
   | { kind: 'sub_agent_started'; agentId: string; firstPromptText: string; subagentType?: string }
+  // Live model in use for a SUB-AGENT, extracted from `message.model` on each
+  // of its `type:"assistant"` transcript lines. Same contract as the main
+  // `model` kind (sentinel-filtered, emitted first) but agent-scoped so the
+  // watcher can track it per WorkerEntry and thread it onto the worker card.
+  | { kind: 'sub_agent_model'; agentId: string; model: string }
   | { kind: 'sub_agent_tool_use'; agentId: string; toolUseId: string | null; toolName: string; input?: Record<string, unknown>; precomputedLabel?: string }
   // Same shared contract as the main-agent `text` kind — see its doc above
   // (including the `lastInMessage` projection-artifact note). The wire-kind
@@ -320,6 +333,15 @@ export function projectTranscriptLine(line: string): SessionEvent[] {
     const content = message?.content as Array<Record<string, unknown>> | undefined
     if (!Array.isArray(content)) return []
     const events: SessionEvent[] = []
+    // Live model capture: `message.model` is the exact resolved model that
+    // served THIS assistant API call. Emit it FIRST (before the content events)
+    // so a card rendered on the same read batch already carries the current
+    // model. Sentinels (`<synthetic>` on compaction lines, fixture junk) are
+    // skipped — the reducer keeps the last real value.
+    const mainModel = message?.model
+    if (typeof mainModel === 'string' && !isModelSentinel(mainModel)) {
+      events.push({ kind: 'model', model: mainModel })
+    }
     // Text→narrative projection comes from the ONE shared kernel
     // (projectAssistantTextBlocks): it owns the empty-drop + blockIndex +
     // lastInMessage contract. We emit its events at their source positions
@@ -468,6 +490,12 @@ export function projectSubagentLine(
     const content = message?.content as Array<Record<string, unknown>> | undefined
     if (!Array.isArray(content)) return []
     const events: SessionEvent[] = []
+    // Live model capture (sub-agent tier): same contract as the main-agent
+    // branch — emit the sub-agent's resolved model first, sentinel-filtered.
+    const subModel = message?.model
+    if (typeof subModel === 'string' && !isModelSentinel(subModel)) {
+      events.push({ kind: 'sub_agent_model', agentId, model: subModel })
+    }
     // Text→narrative projection comes from the SAME shared kernel as the
     // main agent (projectAssistantTextBlocks): one source for the empty-drop
     // + blockIndex + lastInMessage contract. The `make` adapter only changes

package/telegram-plugin/silent-end.ts

@@ -60,6 +60,8 @@ export interface SilentEndDeps {
    * never suppress on doubt.
    */
   hasOutboundDeliveredSince?: (chatId: string, sinceMs: number, threadId?: number | null) => boolean
+  /** Wall-clock now, ms. Defaults to `Date.now`; injectable for tests. */
+  now?: () => number
 }
 
 /**
@@ -80,6 +82,31 @@ export interface SilentEndDeps {
  */
 export const SILENT_END_MAX_RETRIES = 2
 
+/**
+ * Fix #8 (adversarial-validation progress-card fix pass): `turnKey` is the
+ * STABLE `statusKey(chatId, threadId)` — it never changes across turns on
+ * the same chat/thread — so `writeSilentEndState`'s "inherit retryCount IFF
+ * turnKey matches" rule has no per-turn discriminator on its own. Normally
+ * that's fine because `clearSilentEndState` always fires the moment a reply
+ * lands, wiping the exhausted record before the next turn starts. But if the
+ * gateway's own exhaust-read-and-clear is bypassed (crash/interrupt mid-turn,
+ * `gateway.ts` ~turn_end handler never runs), an exhausted
+ * (`retryCount >= SILENT_END_MAX_RETRIES`) record can survive into a LATER,
+ * unrelated turn. That later turn's first silent-end would then misread the
+ * old record as "this turn already exhausted its ladder" and skip its own
+ * re-prompt entirely.
+ *
+ * A record legitimately re-written within one turn's own retry ladder is
+ * always fresh (each Stop-hook block re-writes `timestamp`), so bounding by
+ * age is a safe, cheap staleness signal that doesn't require a new identity
+ * field: any record older than a turn's plausible lifetime could not still
+ * be "this turn's" in-flight retry state, and is therefore stale-carryover,
+ * not an active ladder. 30 minutes comfortably exceeds any real single-turn
+ * Stop-hook retry cycle (seconds, not minutes) while staying well inside the
+ * fleet's other staleness bounds (e.g. the 3h boot-resume window).
+ */
+export const SILENT_END_STALE_RECORD_MAX_AGE_MS = 30 * 60_000
+
 /**
  * User-facing fallback text delivered when a user-message turn ends with no
  * final answer AND the deterministic Stop-hook re-prompt has already been
@@ -313,12 +340,30 @@ export function recordSilentTurnEnd(
     // If so, the record is satisfied-but-misdetected — drop it silently
     // and let this dark turn start its OWN fresh retry cycle instead of
     // inheriting someone else's spent budget.
-    if (deps?.hasOutboundDeliveredSince?.(args.chatId, prev.timestamp, args.threadId)) {
+    // Fix #8: age-based staleness bound. `turnKey` has no per-turn nonce
+    // (see SILENT_END_STALE_RECORD_MAX_AGE_MS doc), so a record whose
+    // `timestamp` is older than a turn's plausible lifetime cannot belong to
+    // THIS dark turn's own retry ladder even absent any delivery evidence —
+    // it's carryover from a prior turn whose gateway-side clear was
+    // bypassed (crash/interrupt). Check this before (and independent of)
+    // the delivery-based check below so a bypassed-clear record is caught
+    // even when no reply was ever delivered on the chat/thread at all.
+    const now = deps?.now?.() ?? Date.now()
+    const staleByAge = now - prev.timestamp > SILENT_END_STALE_RECORD_MAX_AGE_MS
+    if (
+      staleByAge ||
+      deps?.hasOutboundDeliveredSince?.(args.chatId, prev.timestamp, args.threadId)
+    ) {
       emitLog(
         deps,
-        `silent-end: stale exhausted record for turnKey=${args.turnKey} ` +
-          `(retryCount=${prev.retryCount}) but a reply was delivered since ` +
-          `${prev.timestamp} — treating as satisfied-but-misdetected, not exhausted\n`,
+        staleByAge
+          ? `silent-end: stale exhausted record for turnKey=${args.turnKey} ` +
+              `(retryCount=${prev.retryCount}, age=${now - prev.timestamp}ms > ` +
+              `${SILENT_END_STALE_RECORD_MAX_AGE_MS}ms) — treating as carryover ` +
+              `from a prior turn, not exhausted\n`
+          : `silent-end: stale exhausted record for turnKey=${args.turnKey} ` +
+              `(retryCount=${prev.retryCount}) but a reply was delivered since ` +
+              `${prev.timestamp} — treating as satisfied-but-misdetected, not exhausted\n`,
       )
       // MUST clear before writing (adversarial review of #2892):
       // writeSilentEndState re-inherits retryCount whenever the on-disk