switchroom 0.5.0 → 0.7.9

package/telegram-plugin/shared/bot-runtime.ts

@@ -25,9 +25,54 @@ import { GrammyError, type Bot, type Context } from 'grammy'
 import { run, type RunnerHandle } from '@grammyjs/runner'
 import { execFileSync, spawnSync } from 'child_process'
 import { createHash } from 'crypto'
+import { AsyncLocalStorage } from 'async_hooks'
 import { clearStaleTelegramPollingState } from '../startup-reset.js'
 import { createRetryApiCall } from '../retry-api-call.js'
 
+// ─── tg-post tag plumbing ─────────────────────────────────────────────────
+
+/**
+ * Per-call tag context for `tg-post` log lines. Callers wrap a Telegram
+ * API invocation in `withTgPostTags({ turnKey, cardMessageId, ... }, () => ...)`
+ * and the transformer reads the tags off the active store and appends them
+ * `key=value` after the existing fields. Used to correlate progress-card
+ * sends/edits to a turnKey + cardMessageId in days-old session audits.
+ *
+ * Untagged callers are unaffected — when no store is active, no tag fields
+ * are emitted and the existing log shape is byte-for-byte unchanged.
+ */
+export type TgPostTags = Record<string, string | number>
+
+const tgPostTagStore = new AsyncLocalStorage<TgPostTags>()
+
+/**
+ * Run `fn` with the given tags attached to any `tg-post` lines emitted from
+ * the inner Telegram API calls. Tags are inherited across awaits within
+ * the same async chain (AsyncLocalStorage semantics). Pass an empty record
+ * or omit tags entirely to fall back to the untagged shape.
+ */
+export function withTgPostTags<T>(tags: TgPostTags, fn: () => T): T {
+  return tgPostTagStore.run(tags, fn)
+}
+
+/** Exposed for the transformer (and tests). Returns undefined when no store is active. */
+export function _getTgPostTags(): TgPostTags | undefined {
+  return tgPostTagStore.getStore()
+}
+
+function formatTgPostTags(tags: TgPostTags | undefined): string {
+  if (!tags) return ''
+  const parts: string[] = []
+  for (const [k, v] of Object.entries(tags)) {
+    if (v == null) continue
+    // Sanitise: tag values land in a single-line space-separated log
+    // record. Strip whitespace + collapse to keep grep happy.
+    const s = String(v).replace(/\s+/g, '_')
+    parts.push(`${k}=${s}`)
+  }
+  return parts.length > 0 ? ' ' + parts.join(' ') : ''
+}
+
 // ─── tg-post observability transformer ────────────────────────────────────
 
 /**
@@ -64,10 +109,11 @@ export function installTgPostLogger(bot: Bot): void {
     const hash = bytes > 0
       ? createHash('sha1').update(text).digest('hex').slice(0, 12)
       : '-'
+    const tagSuffix = formatTgPostTags(_getTgPostTags())
     try {
       const res = await prev(method, payload, signal)
       process.stderr.write(
-        `tg-post method=${method} chat=${chat} thread=${thread} parse_mode=${parseMode} bytes=${bytes} hash=${hash} status=ok err=- code=- desc=-\n`,
+        `tg-post method=${method} chat=${chat} thread=${thread} parse_mode=${parseMode} bytes=${bytes} hash=${hash} status=ok err=- code=- desc=-${tagSuffix}\n`,
       )
       return res
     } catch (err) {
@@ -85,7 +131,7 @@ export function installTgPostLogger(bot: Bot): void {
         ? rawDesc.replace(/\s+/g, ' ').slice(0, 80).replace(/[\r\n]/g, ' ') || '-'
         : '-'
       process.stderr.write(
-        `tg-post method=${method} chat=${chat} thread=${thread} parse_mode=${parseMode} bytes=${bytes} hash=${hash} status=err err=${errClass} code=${code} desc=${desc}\n`,
+        `tg-post method=${method} chat=${chat} thread=${thread} parse_mode=${parseMode} bytes=${bytes} hash=${hash} status=err err=${errClass} code=${code} desc=${desc}${tagSuffix}\n`,
       )
       throw err
     }

package/telegram-plugin/subagent-watcher.ts

@@ -43,7 +43,7 @@ import { homedir } from 'os'
 import { projectSubagentLine } from './session-tail.js'
 import { sanitiseToolArg } from './fleet-state.js'
 import { escapeHtml, truncate } from './card-format.js'
-import { bumpSubagentActivity, recordSubagentStall, recordSubagentEnd, reapStuckRunningRows } from './registry/subagents-schema.js'
+import { bumpSubagentActivity, recordSubagentStall, recordSubagentResume, recordSubagentEnd, reapStuckRunningRows } from './registry/subagents-schema.js'
 import { touchTurnActiveMarker } from './gateway/turn-active-marker.js'
 
 // ─── Types ───────────────────────────────────────────────────────────────────
@@ -119,10 +119,24 @@ export interface SubagentWatcherConfig {
    */
   rescanMs?: number
   /**
-   * How long without JSONL activity before a worker is considered stalled (ms).
-   * Default 60_000.
+   * How long without JSONL activity before a worker is considered stalled
+   * **once at least one tool has been used**. Default 60_000ms. Tool-call
+   * loops emit JSONL events frequently, so 60s of silence in that phase
+   * is a strong signal the sub-agent is stuck on a single tool.
    */
   stallThresholdMs?: number
+  /**
+   * Stall threshold (ms) used **before any tool has been used** —
+   * "silent synthesis" mode where the model is composing a response without
+   * emitting events yet. Long-running plan / synthesis sub-agents commonly
+   * spend 2-5 minutes in this state legitimately, so the active-loop
+   * threshold (60s) misfires. Default 300_000 (5 min).
+   *
+   * The watcher selects between this and `stallThresholdMs` per-entry
+   * based on `entry.toolCount`: 0 ⇒ silent synthesis, ≥1 ⇒ active loop.
+   * Both can be overridden for tests.
+   */
+  silentSynthesisStallThresholdMs?: number
   /**
    * Reaper TTL (ms): background rows in `status='running'` whose
    * `last_activity_at` (or `started_at` if liveness never wrote) is older
@@ -171,6 +185,39 @@ export interface SubagentWatcherConfig {
    * the same sub-agent across subsequent poll ticks.
    */
   onStall?: (agentId: string, idleMs: number, description: string) => void
+  /**
+   * Symmetric to `onStall`: fires when a previously-stalled sub-agent's
+   * JSONL grows again (text emission, tool use, turn_end — anything that
+   * moves last_activity_at). Wired to `progressDriver.onSubAgentUnstall`
+   * in gateway.ts so the pinned card clears the ⚠ Stalled badge as soon
+   * as activity resumes, instead of waiting on the next render tick.
+   *
+   * Each stall→resume cycle fires exactly once: the watcher resets
+   * `entry.stallNotified` on resume, so a sub-agent that stalls again
+   * later in the same lifetime is detected (and reported) again.
+   */
+  onUnstall?: (agentId: string, description: string) => void
+  /**
+   * Called exactly once per sub-agent when its watcher observes a terminal
+   * transition (`done` or `failed`). Mirrors the existing `sub_agent_started`
+   * surface (emitted from session-tail) so the audit trail is symmetric.
+   *
+   * `outcome`:
+   *   - 'completed' — the JSONL contained a `turn_duration` line.
+   *   - 'failed'    — reserved (no caller flips state to 'failed' today).
+   *   - 'orphan'    — the entry was historical at boot and its terminal
+   *                   transition fires after watcher startup. (Pre-existing
+   *                   `done` files at boot do NOT fire — see registerAgent.)
+   * Background-vs-foreground classification is the gateway's call (it owns
+   * the registry DB); the watcher just reports the lifecycle.
+   */
+  onFinish?: (args: {
+    agentId: string
+    state: WorkerState
+    outcome: 'completed' | 'failed' | 'orphan'
+    toolCount: number
+    durationMs: number
+  }) => void
   /** `Date.now` override for tests. */
   now?: () => number
   /** `setInterval` override for tests. */
@@ -205,6 +252,11 @@ export interface SubagentWatcherHandle {
 
 const DEFAULT_RESCAN_MS = 1000
 const DEFAULT_STALL_THRESHOLD_MS = 60_000
+/** Silent-synthesis threshold (no tools used yet). 5min covers plan /
+ *  research sub-agents that legitimately think for several minutes
+ *  before emitting their first event — the 60s active-loop threshold
+ *  misfires on those and freezes the card at ⚠. */
+const DEFAULT_SILENT_SYNTHESIS_STALL_THRESHOLD_MS = 300_000
 const DEFAULT_REAPER_TTL_MS = 60 * 60_000          // 1 hour
 const DEFAULT_REAPER_INTERVAL_MS = 15 * 60_000     // 15 minutes
 /**
@@ -317,6 +369,10 @@ function readSubTail(
   log?: (msg: string) => void,
   db?: SubagentLivenessDb | null,
   parentStateDir?: string | null,
+  /** Fires when the watcher observes JSONL activity returning for a
+   *  previously-stalled entry. Closes the resume edge the schema doc
+   *  has always promised. */
+  onUnstall?: (agentId: string, description: string) => void,
 ): void {
   try {
     const stat = fs.statSync(entry.filePath)
@@ -390,7 +446,39 @@ function readSubTail(
       if (!line) continue
       const events = projectSubagentLine(line, entry.agentId, startState)
       for (const ev of events) {
+        const idleSecBeforeBump = Math.round((now - entry.lastActivityAt) / 1000)
         entry.lastActivityAt = now
+        // Un-stall transition (#previously-missing). The schema doc
+        // promised "stalled → running (may resume)" but neither the
+        // in-memory `stallNotified` flag nor the DB `status` column was
+        // ever flipped back. That left the pinned card stuck at ⚠ until
+        // terminal completion, by which point the user had often
+        // already interrupted or redispatched. Reset both halves on the
+        // first activity tick after a stall + fire onUnstall for the
+        // driver to clear its render-time badge.
+        if (entry.stallNotified) {
+          entry.stallNotified = false
+          if (db != null) {
+            try {
+              const rowRef = db
+                .prepare('SELECT id FROM subagents WHERE jsonl_agent_id = ?')
+                .get(entry.agentId) as { id: string } | null
+              if (rowRef != null) {
+                recordSubagentResume(db, { id: rowRef.id, resumedAt: now })
+              }
+            } catch (dbErr) {
+              log?.(`subagent-watcher: resume DB write error ${entry.agentId}: ${(dbErr as Error).message}`)
+            }
+          }
+          if (onUnstall != null) {
+            try {
+              onUnstall(entry.agentId, entry.description)
+            } catch (cbErr) {
+              log?.(`subagent-watcher: onUnstall callback error ${entry.agentId}: ${(cbErr as Error).message}`)
+            }
+          }
+          log?.(`subagent-watcher: stall cleared for ${entry.agentId} (activity resumed after ${idleSecBeforeBump}s — re-arming detection)`)
+        }
         if (ev.kind === 'sub_agent_tool_use') {
           entry.toolCount++
           // P0 of #662: surface the most recent tool name + sanitised
@@ -446,6 +534,8 @@ function readSubTail(
 export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWatcherHandle {
   const agentDir = config.agentDir
   const stallThresholdMs = config.stallThresholdMs ?? DEFAULT_STALL_THRESHOLD_MS
+  const silentSynthesisStallThresholdMs =
+    config.silentSynthesisStallThresholdMs ?? DEFAULT_SILENT_SYNTHESIS_STALL_THRESHOLD_MS
   const reaperTtlMs = config.reaperTtlMs ?? DEFAULT_REAPER_TTL_MS
   const reaperIntervalMs = config.reaperIntervalMs ?? DEFAULT_REAPER_INTERVAL_MS
   const rescanMs = config.rescanMs ?? DEFAULT_RESCAN_MS
@@ -562,7 +652,7 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
     // Initial read
     readSubTail(entry, tail, n, (desc) => {
       log?.(`subagent-watcher: description updated for ${agentId}: ${desc}`)
-    }, fs, log, db, parentStateDir)
+    }, fs, log, db, parentStateDir, config.onUnstall)
 
     // If the JSONL already contained a turn_end at registration time
     // (file written-then-watched), fire the state-transition + completion
@@ -593,7 +683,7 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
         if (!entry || !t) return
         readSubTail(entry, t, nowFn(), (desc) => {
           log?.(`subagent-watcher: description updated for ${agentId}: ${desc}`)
-        }, fs, log, db, parentStateDir)
+        }, fs, log, db, parentStateDir, config.onUnstall)
         maybySendStateTransition(agentId)
       })
     } catch (err) {
@@ -619,11 +709,43 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
       } catch (err) {
         log?.(`subagent-watcher: completion notification error: ${(err as Error).message}`)
       }
+      // Symmetric `sub_agent_finished` surface (#card-audit-log). Emit
+      // before the deferred cleanup runs so the callback always sees a
+      // live registry entry. Historical entries that already-completed at
+      // boot get their `completionNotified=true` shortcut in registerAgent
+      // and skip this path entirely — only post-boot transitions fire.
+      if (config.onFinish) {
+        try {
+          config.onFinish({
+            agentId,
+            state: entry.state,
+            outcome: entry.historical ? 'orphan' : 'completed',
+            toolCount: entry.toolCount,
+            durationMs: nowFn() - entry.dispatchedAt,
+          })
+        } catch (cbErr) {
+          log?.(`subagent-watcher: onFinish callback error ${agentId}: ${(cbErr as Error).message}`)
+        }
+      }
       scheduleTerminalCleanup(agentId)
     }
     // Defensive: if state ever flips to 'failed' (currently no caller
     // sets this, but the type allows it), still clean up the FSWatcher.
     if (entry.state === 'failed') {
+      if (config.onFinish && !entry.completionNotified) {
+        entry.completionNotified = true
+        try {
+          config.onFinish({
+            agentId,
+            state: entry.state,
+            outcome: 'failed',
+            toolCount: entry.toolCount,
+            durationMs: nowFn() - entry.dispatchedAt,
+          })
+        } catch (cbErr) {
+          log?.(`subagent-watcher: onFinish callback error ${agentId}: ${(cbErr as Error).message}`)
+        }
+      }
       scheduleTerminalCleanup(agentId)
     }
   }
@@ -678,7 +800,17 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
       if (entry.historical) continue
       if (entry.stallNotified) continue
       const idleMs = n - entry.lastActivityAt
-      if (idleMs >= stallThresholdMs) {
+      // Adaptive: a sub-agent that hasn't fired any tools yet is in
+      // "silent synthesis" mode (model thinking before its first emit).
+      // 60s is way too aggressive for plan / research sub-agents that
+      // legitimately spend 2-5 minutes composing before their first
+      // tool_use. Once tools have started, switch to the tighter loop
+      // threshold — frequent JSONL writes mean 60s of silence is a
+      // strong signal the sub-agent is genuinely stuck.
+      const threshold = entry.toolCount === 0
+        ? silentSynthesisStallThresholdMs
+        : stallThresholdMs
+      if (idleMs >= threshold) {
         entry.stallNotified = true
         const desc = escapeHtml(truncate(entry.description, 80))
         const idleSec = Math.floor(idleMs / 1000)
@@ -807,7 +939,7 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
       if (!tail) continue
       readSubTail(entry, tail, n, (desc) => {
         log?.(`subagent-watcher: description updated for ${agentId}: ${desc}`)
-      }, fs, log, db, parentStateDir)
+      }, fs, log, db, parentStateDir, config.onUnstall)
       maybySendStateTransition(agentId)
     }
 

package/telegram-plugin/tests/_progress-card-harness.ts

@@ -21,6 +21,7 @@ export interface HarnessOpts {
   minIntervalMs?: number
   coalesceMs?: number
   initialDelayMs?: number
+  initialDelayMsBackground?: number
   heartbeatMs?: number
   maxIdleMs?: number
   deferredCompletionTimeoutMs?: number
@@ -43,6 +44,9 @@ export function makeHarness(opts: HarnessOpts = {}): DriverHarness {
     minIntervalMs: opts.minIntervalMs ?? 0,
     coalesceMs: opts.coalesceMs ?? 0,
     initialDelayMs: opts.initialDelayMs ?? 0,
+    ...(opts.initialDelayMsBackground != null
+      ? { initialDelayMsBackground: opts.initialDelayMsBackground }
+      : {}),
     heartbeatMs: opts.heartbeatMs ?? 1_000,
     maxIdleMs: opts.maxIdleMs ?? 30_000,
     deferredCompletionTimeoutMs: opts.deferredCompletionTimeoutMs ?? 10_000,

package/telegram-plugin/tests/bg-agent-progress-card-757.test.ts

@@ -0,0 +1,201 @@
+/**
+ * Regression tests for #757 — progress card goes silent for background
+ * Agent workers (run_in_background: true).
+ *
+ * Root cause: `applyToolUse` in fleet-state.ts only promoted `stuck →
+ * running`; background members stayed at `status: 'background'` even
+ * while actively running tools. The fleet row rendered ⏸ idle instead
+ * of ↻ + last-tool, so the card appeared frozen.
+ *
+ * Fix: applyToolUse now also promotes `background → running` on the
+ * first live tool event. A separate sticky `isBackgroundDispatch` flag
+ * preserves the background-carry semantics used by hasLiveBackground
+ * (keeps PerChatState alive past parent turn_end until bg member
+ * reaches terminal status).
+ */
+
+import { describe, it, expect } from 'vitest'
+import { createProgressDriver } from '../progress-card-driver.js'
+import { applyToolUse, createFleetMember, hasLiveBackground } from '../fleet-state.js'
+import type { SessionEvent } from '../session-tail.js'
+
+const T0 = 1_700_000_000_000
+
+// ─── Pure-function unit tests ────────────────────────────────────────────────
+
+describe('applyToolUse: background → running promotion (#757)', () => {
+  it('promotes background to running on first tool event', () => {
+    const m = { ...createFleetMember({ agentId: 'a', role: 'worker', startedAt: T0, originatingTurnKey: 'k', isBackgroundDispatch: true }), status: 'background' as const }
+    const after = applyToolUse(m, 'Read', { file_path: '/foo/bar.ts' }, T0 + 1000)
+    expect(after.status).toBe('running')
+    expect(after.lastTool?.name).toBe('Read')
+  })
+
+  it('preserves isBackgroundDispatch after promotion', () => {
+    const m = { ...createFleetMember({ agentId: 'a', role: 'worker', startedAt: T0, originatingTurnKey: 'k', isBackgroundDispatch: true }), status: 'background' as const }
+    const after = applyToolUse(m, 'Bash', { command: 'ls' }, T0 + 1000)
+    expect(after.isBackgroundDispatch).toBe(true)
+  })
+
+  it('does not affect foreground members (status stays running)', () => {
+    const m = createFleetMember({ agentId: 'a', role: 'worker', startedAt: T0, originatingTurnKey: 'k' })
+    const after = applyToolUse(m, 'Read', { file_path: '/x' }, T0 + 1000)
+    expect(after.status).toBe('running')
+    expect(after.isBackgroundDispatch).toBe(false)
+  })
+})
+
+describe('hasLiveBackground: sticky flag survives status promotion (#757)', () => {
+  it('returns true when background member is promoted to running (not yet terminal)', () => {
+    const fleet = new Map([
+      ['a', { ...createFleetMember({ agentId: 'a', role: 'w', startedAt: T0, originatingTurnKey: 'k', isBackgroundDispatch: true }), status: 'running' as const }],
+    ])
+    expect(hasLiveBackground(fleet)).toBe(true)
+  })
+
+  it('returns false when background member reaches terminal status', () => {
+    const fleet = new Map([
+      ['a', { ...createFleetMember({ agentId: 'a', role: 'w', startedAt: T0, originatingTurnKey: 'k', isBackgroundDispatch: true }), status: 'done' as const, terminalAt: T0 + 5000 }],
+    ])
+    expect(hasLiveBackground(fleet)).toBe(false)
+  })
+
+  it('returns false when no members are background dispatches', () => {
+    const fleet = new Map([
+      ['a', createFleetMember({ agentId: 'a', role: 'w', startedAt: T0, originatingTurnKey: 'k' })],
+    ])
+    expect(hasLiveBackground(fleet)).toBe(false)
+  })
+})
+
+// ─── Integration: driver-level lifecycle ─────────────────────────────────────
+
+function harness() {
+  let now = 1000
+  const timers: Array<{ fireAt: number; fn: () => void; ref: number; repeat?: number }> = []
+  let nextRef = 0
+  const completions: string[] = []
+  const driver = createProgressDriver({
+    emit: () => {},
+    minIntervalMs: 500,
+    coalesceMs: 400,
+    initialDelayMs: 0,
+    promoteAfterMs: 999_999,
+    onTurnComplete: (s) => completions.push(s.turnKey),
+    now: () => now,
+    setTimeout: (fn, ms) => {
+      const ref = nextRef++
+      timers.push({ fireAt: now + ms, fn, ref })
+      return { ref }
+    },
+    clearTimeout: (h) => {
+      const ref = (h as { ref: number }).ref
+      const idx = timers.findIndex((t) => t.ref === ref)
+      if (idx !== -1) timers.splice(idx, 1)
+    },
+    setInterval: (fn, ms) => {
+      const ref = nextRef++
+      timers.push({ fireAt: now + ms, fn, ref, repeat: ms })
+      return { ref }
+    },
+    clearInterval: (h) => {
+      const ref = (h as { ref: number }).ref
+      const idx = timers.findIndex((t) => t.ref === ref)
+      if (idx !== -1) timers.splice(idx, 1)
+    },
+  })
+  function advance(ms: number) {
+    const target = now + ms
+    while (true) {
+      const due = timers.filter((t) => t.fireAt <= target).sort((a, b) => a.fireAt - b.fireAt)
+      if (due.length === 0) break
+      const t = due[0]
+      now = t.fireAt
+      t.fn()
+      if (t.repeat) t.fireAt = now + t.repeat
+      else timers.splice(timers.indexOf(t), 1)
+    }
+    now = target
+  }
+  return { driver, completions, advance, getNow: () => now }
+}
+
+const enqueue = (chatId: string): SessionEvent => ({
+  kind: 'enqueue',
+  chatId,
+  messageId: '1',
+  threadId: null,
+  rawContent: `<channel chat_id="${chatId}">go</channel>`,
+})
+
+describe('driver integration: bg worker tool activity (#757)', () => {
+  it('background fleet member promotes to running when tool events arrive', () => {
+    const { driver } = harness()
+    const CHAT = 'c1'
+    driver.ingest(enqueue(CHAT), null)
+    driver.ingest(
+      { kind: 'tool_use', toolName: 'Agent', toolUseId: 'tu1', input: { prompt: 'bg work', run_in_background: true } },
+      CHAT,
+    )
+    driver.ingest({ kind: 'sub_agent_started', agentId: 'sa1', firstPromptText: 'bg work' }, CHAT)
+
+    // Initial state: background.
+    expect(driver.peekFleet(CHAT)!.get('sa1')!.status).toBe('background')
+
+    // Tool activity arrives from the sub-agent JSONL.
+    driver.ingest({ kind: 'sub_agent_tool_use', agentId: 'sa1', toolUseId: 't1', toolName: 'Bash', input: { command: 'npm test' } }, CHAT)
+
+    const m = driver.peekFleet(CHAT)!.get('sa1')!
+    // Promoted to running — card now shows active tool work.
+    expect(m.status).toBe('running')
+    expect(m.lastTool?.name).toBe('Bash')
+    // Sticky flag preserved — bg-carry still works.
+    expect(m.isBackgroundDispatch).toBe(true)
+  })
+
+  it('background carry survives promotion: turn completion holds until bg reaches terminal', () => {
+    const { driver, completions } = harness()
+    const CHAT = 'c2'
+    driver.ingest(enqueue(CHAT), null)
+    driver.ingest(
+      { kind: 'tool_use', toolName: 'Agent', toolUseId: 'tu1', input: { prompt: 'bg', run_in_background: true } },
+      CHAT,
+    )
+    driver.ingest({ kind: 'sub_agent_started', agentId: 'sa1', firstPromptText: 'bg' }, CHAT)
+    // Bg worker starts doing tool work — status becomes running.
+    driver.ingest({ kind: 'sub_agent_tool_use', agentId: 'sa1', toolUseId: 't1', toolName: 'Read', input: { file_path: '/a' } }, CHAT)
+    expect(driver.peekFleet(CHAT)!.get('sa1')!.status).toBe('running')
+
+    driver.ingest({ kind: 'tool_use', toolName: 'mcp__switchroom-telegram__reply' }, CHAT)
+    driver.recordOutboundDelivered(CHAT)
+    // Parent ends while bg worker is still running.
+    driver.ingest({ kind: 'turn_end', durationMs: 100 }, CHAT)
+
+    // Turn completion must NOT fire — bg worker is still active.
+    expect(completions.length).toBe(0)
+
+    // Bg worker finishes.
+    driver.ingest({ kind: 'sub_agent_turn_end', agentId: 'sa1' }, CHAT)
+    expect(completions.length).toBe(1)
+  })
+
+  it('terminal state reached after promotion fires completion correctly', () => {
+    const { driver, completions } = harness()
+    const CHAT = 'c3'
+    driver.ingest(enqueue(CHAT), null)
+    driver.ingest(
+      { kind: 'tool_use', toolName: 'Agent', toolUseId: 'tu1', input: { prompt: 'bg', run_in_background: true } },
+      CHAT,
+    )
+    driver.ingest({ kind: 'sub_agent_started', agentId: 'sa1', firstPromptText: 'bg' }, CHAT)
+    driver.ingest({ kind: 'sub_agent_tool_use', agentId: 'sa1', toolUseId: 't1', toolName: 'Write', input: { file_path: '/out.ts' } }, CHAT)
+
+    driver.ingest({ kind: 'tool_use', toolName: 'mcp__switchroom-telegram__reply' }, CHAT)
+    driver.recordOutboundDelivered(CHAT)
+    driver.ingest({ kind: 'turn_end', durationMs: 100 }, CHAT)
+    // Peek before sub_agent_turn_end so fleet is still live.
+    expect(driver.peekFleet(CHAT)!.get('sa1')!.status).toBe('running')
+    driver.ingest({ kind: 'sub_agent_turn_end', agentId: 'sa1' }, CHAT)
+    expect(completions.length).toBe(1)
+  })
+})

package/telegram-plugin/tests/boot-card-probe-target.test.ts

@@ -2,14 +2,19 @@
  * Tests for #309: boot card uses the agent slug (not display name) for
  * systemd unit probes.
  *
- * Root cause: probeAgentProcess and probeCronTimers were called with
- * opts.agentName (the persona display name, e.g. "Klanker") instead of
- * the lowercase slug ("klanker"). systemctl returns LoadState=not-found
- * for the capitalised name because unit files are always lowercase.
+ * Root cause: probeAgentProcess was called with opts.agentName (the
+ * persona display name, e.g. "Klanker") instead of the lowercase slug
+ * ("klanker"). systemctl returns LoadState=not-found for the
+ * capitalised name because unit files are always lowercase.
  *
  * Fix: RunProbesOpts.agentSlug carries the slug separately; runAllProbes
  * passes opts.agentSlug (falling back to opts.agentName for compat) to
- * both probeAgentProcess and probeCronTimers.
+ * probeAgentProcess.
+ *
+ * (Pre-Phase-4 this also covered probeCronTimers; that probe was
+ * replaced by probeScheduler when the singleton switchroom-cron
+ * container was retired and cron moved in-container — the slug now
+ * only matters for the systemd Agent probe.)
  */
 
 import { describe, it, expect } from 'vitest'
@@ -102,35 +107,6 @@ describe('#309: runAllProbes — slug vs display name for systemd calls', () =>
     }
   })
 
-  it('probeCronTimers target is switchroom-<slug>-cron-*, not switchroom-<displayName>-cron-*', async () => {
-    const tmpDir = makeTmpAgentDir()
-    try {
-      const { fn: execFileMock, calls } = makeDispatchingExecFile('klanker')
-
-      await runAllProbes({
-        agentName: 'Klanker',
-        agentSlug: 'klanker',
-        version: 'v0.3.0',
-        agentDir: tmpDir,
-        gatewayInfo: { pid: 12345, startedAtMs: Date.now() },
-        fetchImpl: async () => new Response('', { status: 200 }),
-        settleWindowMs: 0,
-        agentLiveWindowMs: 0,
-        probeExecFileImpl: execFileMock,
-      })
-
-      // probeCronTimers calls: systemctl --user list-timers switchroom-<name>-cron-*
-      const cronProbeCall = calls.find(c =>
-        c.cmd === 'systemctl' && c.args.includes('list-timers'),
-      )
-      expect(cronProbeCall, 'probeCronTimers must call systemctl list-timers').toBeDefined()
-      const cronGlob = cronProbeCall!.args.find(a => a.includes('cron'))
-      expect(cronGlob).toBe('switchroom-klanker-cron-*')
-    } finally {
-      rmSync(tmpDir, { recursive: true })
-    }
-  })
-
   it('no systemctl call uses the capitalised display name as the unit target', async () => {
     const tmpDir = makeTmpAgentDir()
     try {

package/telegram-plugin/tests/boot-card-render.test.ts

@@ -94,27 +94,28 @@ describe('renderBootCard — degraded conditions', () => {
     expect(out).not.toContain('Agent</b>')
     expect(out).not.toContain('Gateway</b>')
     expect(out).not.toContain('Hindsight</b>')
-    expect(out).not.toContain('Crons</b>')
+    expect(out).not.toContain('Scheduler</b>')
   })
 
   it('orders probe rows in PROBE_KEYS canonical order regardless of object iteration', () => {
     // Insert in a non-canonical order; renderer must still output Account first,
-    // then Hindsight, then Crons (matching PROBE_KEYS).
+    // then Hindsight, then Scheduler (matching PROBE_KEYS — Phase 4 renamed
+    // crons → scheduler when the in-container agent-scheduler took over).
     const out = renderBootCard({
       agentName: 'a',
       version: 'v',
       probes: {
-        crons:     { status: 'fail',     label: 'Crons',     detail: 'bad' },
+        scheduler: { status: 'fail',     label: 'Scheduler', detail: 'sidecar not running' },
         hindsight: { status: 'fail',     label: 'Hindsight', detail: 'unreachable' },
         account:   { status: 'degraded', label: 'Account',   detail: 'expiring' },
       },
     })
     const accountIdx = out.indexOf('Account</b>')
     const hindsightIdx = out.indexOf('Hindsight</b>')
-    const cronsIdx = out.indexOf('Crons</b>')
+    const schedulerIdx = out.indexOf('Scheduler</b>')
     expect(accountIdx).toBeGreaterThan(-1)
     expect(hindsightIdx).toBeGreaterThan(accountIdx)
-    expect(cronsIdx).toBeGreaterThan(hindsightIdx)
+    expect(schedulerIdx).toBeGreaterThan(hindsightIdx)
   })
 
   it('crash + degraded probe = both rows render', () => {