switchroom 0.13.13 → 0.13.14

package/telegram-plugin/gateway/gateway.ts

@@ -76,6 +76,7 @@ import {
 import { emitRuntimeMetric } from '../runtime-metrics.js'
 import { classifyInbound } from '../inbound-classifier.js'
 import * as silencePoke from '../silence-poke.js'
+import * as pendingProgress from '../pending-work-progress.js'
 import { writeSilentEndState, clearSilentEndState, recordUndeliveredTurnEnd } from '../silent-end.js'
 import { isFinalAnswerReply } from '../final-answer-detect.js'
 import { createAnswerStream, type AnswerStreamHandle } from '../answer-stream.js'
@@ -3149,6 +3150,7 @@ silencePoke.startTimer({
     // Drop silence-poke state and clear turn-active so the next inbound
     // for this chat starts a fresh turn instead of queueing forever.
     silencePoke.endTurn(fbKey)
+    pendingProgress.noteTurnEnd(fbKey)
     purgeReactionTracking(fbKey)
     // Defense-in-depth: the fallback's purgeReactionTracking above
     // clears the canonical statusKey(chatId, threadId) for fbKey
@@ -3206,6 +3208,34 @@ silencePoke.startTimer({
   },
 })
 
+// #1445 cross-turn pending-async ambient. When a turn ends after the
+// model dispatched background async work (Agent / Task / Bash run-in-
+// background) and the model has stopped speaking, keep editing the
+// model's last reply in place at 60s intervals so the user sees
+// ambient liveness during the wait. Edits are silent, never spawn a
+// new pinged message, and stop the moment the user re-engages or the
+// model synthesises a handback. The full design rationale lives in
+// `pending-work-progress.ts`'s header docblock. Kill switch:
+// `SWITCHROOM_DISABLE_PENDING_PROGRESS=1`.
+pendingProgress.startTimer({
+  editMessage: async (ctx) => {
+    await swallowingApiCall(
+      () =>
+        lockedBot.api.editMessageText(
+          ctx.chatId,
+          ctx.messageId,
+          ctx.newText,
+        ),
+      {
+        chat_id: ctx.chatId,
+        verb: 'pending-progress-edit',
+        ...(ctx.threadId != null ? { threadId: ctx.threadId } : {}),
+      },
+    )
+  },
+  emitMetric: (event) => emitRuntimeMetric(event),
+})
+
 // Per-agent buffer for synthetic inbounds the gateway couldn't deliver
 // because the bridge wasn't connected at send-time. Drained on
 // bridge-register so a fresh client picks up missed wake-ups before
@@ -3578,6 +3608,22 @@ const ipcServer: IpcServer = createIpcServer({
             label.length > 0 ? label : null,
             Date.now(),
           )
+          // #1445 cross-turn pending-async ambient. Mark the chat as
+          // having dispatched background work this turn so a turn_end
+          // that follows activates the edit-in-place ambient line.
+          // Covers `Agent` / `Task` (the harness-managed async path
+          // — handback channel turn clears it) and `Bash` with
+          // run_in_background:true (model is expected to poll
+          // BashOutput; the ambient ticks until next inbound or the
+          // 30-min budget cap).
+          const evInput = ev.input as { run_in_background?: boolean } | undefined
+          if (
+            ev.toolName === 'Agent'
+            || ev.toolName === 'Task'
+            || (ev.toolName === 'Bash' && evInput?.run_in_background === true)
+          ) {
+            pendingProgress.noteAsyncDispatch(key)
+          }
         }
       } else if (ev.kind === 'tool_result') {
         // #1292: drain the in-flight entry. Idempotent on unknown ids
@@ -4391,6 +4437,22 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
     }
   }
 
+  // #1445 cross-turn pending-async ambient. Capture the last text
+  // chunk as the anchor — if this turn ends with a pending async
+  // dispatch, the framework edits THIS message in place every 60s
+  // with a `— still working (Nm)` suffix until the user re-engages.
+  // Multi-chunk replies: anchor is the LAST chunk (edits append to
+  // the visually-trailing message; earlier chunks are left intact).
+  if (sentIds.length === chunks.length && chunks.length > 0) {
+    const anchorMsgId = sentIds[chunks.length - 1]
+    if (typeof anchorMsgId === 'number') {
+      pendingProgress.noteOutbound(statusKey(chat_id, threadId), {
+        messageId: anchorMsgId,
+        text: chunks[chunks.length - 1],
+      })
+    }
+  }
+
   // #273: when files is 2-10 photos, batch them into a single
   // sendMediaGroup album rather than N separate sendPhoto calls. The
   // user's device fires one notification for the album instead of N
@@ -4715,6 +4777,15 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
     const sChatId = args.chat_id as string
     const sThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined
     outboundDedup.record(sChatId, sThreadId, args.text as string, Date.now())
+    // #1445 cross-turn pending-async ambient. The terminal stream_reply
+    // (done=true) is the user-visible anchor for any cross-turn wait
+    // that follows. Capture it so if this turn ends with a pending
+    // async dispatch, the framework edits THIS message in place at
+    // intervals.
+    pendingProgress.noteOutbound(statusKey(sChatId, sThreadId), {
+      messageId: result.messageId,
+      text: args.text as string,
+    })
   }
   // #1664 — mark the turn's final answer as delivered. For stream_reply a
   // call with done=true IS the final answer by definition (the model
@@ -5728,6 +5799,25 @@ function handleSessionEvent(ev: SessionEvent): void {
       // Drain any orphaned typing-wrap entries left over from a crashed
       // prior turn before resetting focus.
       typingWrapper.drainAll()
+      if (ev.chatId) {
+        // #1445 cross-turn pending-async ambient — backstop for the
+        // `handleInbound` path's `clearPending('inbound')`. The
+        // inbound path covers real user messages, but synthesised
+        // wakes (subagent-handback channel turn, cron fires, vault
+        // grant resumes, restart markers) push directly to
+        // `pendingInboundBuffer` and bypass `handleInbound`. The
+        // `enqueue` session-event fires for EVERY fresh turn atom
+        // regardless of source — clearing here drops any prior turn's
+        // ambient before the new turn's `noteOutbound` lands. The
+        // call is idempotent so it's safe to fire in addition to the
+        // inbound-path clear (for the real-inbound case, this is a
+        // no-op because state was already deleted by then).
+        const enqThreadId = ev.threadId != null ? Number(ev.threadId) : undefined
+        pendingProgress.clearPending(
+          statusKey(ev.chatId, enqThreadId),
+          'handback',
+        )
+      }
       if (ev.chatId) {
         // Issue #195: if a previous turn left an answer-lane stream open
         // (rapid steer/queue), force it to a new generation so its in-flight
@@ -6045,6 +6135,7 @@ function handleSessionEvent(ev: SessionEvent): void {
         // full message above). Match the pattern used at the regular
         // turn-end path (line ~5039) and the wedged-turn path (~5290).
         silencePoke.endTurn(ceKey)
+        pendingProgress.noteTurnEnd(ceKey)
         // Issue #195: tear down the answer-lane stream on context-exhaustion
         // bail-out. The user is being told the session needs /restart, so any
         // partially-streamed answer would be misleading.
@@ -6230,6 +6321,7 @@ function handleSessionEvent(ev: SessionEvent): void {
           try { removeTurnActiveMarker(STATE_DIR) } catch { /* best-effort */ }
           signalTracker.clear(tKey)
           silencePoke.endTurn(tKey)
+          pendingProgress.noteTurnEnd(tKey)
         }
         lastPtyPreviewByChat.delete(statusKey(chatId, threadId))
         pendingPtyPartial = null
@@ -6304,6 +6396,7 @@ function handleSessionEvent(ev: SessionEvent): void {
           const tKey = statusKey(chatId, threadId)
           signalTracker.clear(tKey)
           silencePoke.endTurn(tKey)
+          pendingProgress.noteTurnEnd(tKey)
         }
 
         void (async () => {
@@ -6550,6 +6643,7 @@ function handleSessionEvent(ev: SessionEvent): void {
         }
         signalTracker.clear(tKey)
         silencePoke.endTurn(tKey)
+        pendingProgress.noteTurnEnd(tKey)
       }
       lastPtyPreviewByChat.delete(statusKey(chatId, threadId))
       pendingPtyPartial = null
@@ -7772,6 +7866,18 @@ async function handleInbound(
         // the framework can nudge the model if it goes quiet past the
         // soft / firm thresholds.
         silencePoke.startTurn(statusKey(chat_id, messageThreadId), Date.now())
+        // #1445 cross-turn pending-async ambient. A new turn starting
+        // (user inbound, synthesised wake, or handback channel) is the
+        // signal that the model is about to re-engage — clear any
+        // pending-progress edits anchored to the *prior* turn's
+        // outbound so the framework stops talking over the new turn.
+        // clearPending drops the per-key state outright, so the new
+        // turn's `tool_use(Agent|Task|Bash bg)` + outbound capture
+        // afresh via `noteAsyncDispatch` / `noteOutbound`.
+        pendingProgress.clearPending(
+          statusKey(chat_id, messageThreadId),
+          'inbound',
+        )
         // Human-feel UX: hold a continuous `typing…` indicator for the
         // WHOLE turn, not just the split-second a reply is transmitted.
         // A person you message shows as typing the entire time they

package/telegram-plugin/pending-work-progress.ts

@@ -0,0 +1,377 @@
+/**
+ * Cross-turn pending-async progress — issue #1445.
+ *
+ * When a turn ends with pending background async work (the model
+ * dispatched `Agent` / `Task` and ended its turn before the worker
+ * returned), keep editing the model's last reply *in place* at
+ * intervals so the user sees ambient liveness during the wait — without
+ * any new pinged messages and without re-introducing the retired
+ * progress card.
+ *
+ * Background data justifying this module (2026-05-23 forensic + UAT):
+ *
+ * - silence-poke success rate is 0–7% across hundreds of fires
+ *   (finn: 0/78, clerk: 6/91, klanker: 5/158) — the polite levels
+ *   reach the model as `<system-reminder>`s piggybacked on the next
+ *   tool result, so they (a) only land if the model is actively
+ *   cycling tools, (b) compete with hundreds of other tokens, and (c)
+ *   only ever exist while the turn is open. The 300s framework
+ *   fallback is the only user-visible silence-poke output, and its
+ *   first job is to *kill the wedged turn*.
+ *
+ * - The dominant user-visible failure mode (issue #1445) is in fact
+ *   cross-turn: the model calls `Agent` (or `Bash` with
+ *   `run_in_background:true`), sends one ack reply that pings, then
+ *   ends the turn. The silence-poke ladder is *gone* the moment
+ *   endTurn() fires. The user then sees nothing for 10–30+ minutes
+ *   until the worker returns. A live UAT confirmed: a deliberate
+ *   `sleep 350` prompt produced one `[PING] Background sleep running;
+ *   awaiting completion notification.` at +19s and the turn ended.
+ *
+ * Mechanism:
+ *
+ *   tool_use(Agent|Task)        → mark chat key `pending=true`
+ *   outbound reply              → capture anchor (messageId, text)
+ *   turn_end with pending+anchor → activate the timer for the key
+ *   tick (every 5s, edit every  → editMessageText against the anchor
+ *     EDIT_INTERVAL_MS)            appending/refreshing the suffix
+ *                                  " — still working (Nm)"
+ *   inbound user message        → clear (user re-engaged or moved on)
+ *   subagent_handback inject    → clear (model about to re-engage)
+ *   MAX_LIFETIME_MS budget cap  → clear (give up; 30 min default)
+ *
+ * Single shared timer for the whole gateway — like silence-poke's
+ * `tick()`, the per-key cost is O(map size) per poll. The poll
+ * interval is short (5s) but edits are spaced at EDIT_INTERVAL_MS so
+ * the Telegram bot.api editMessageText rate stays well under limits.
+ *
+ * Edits are plain text (no parseMode). The suffix is appended to the
+ * model's authored text; on subsequent edits the prior suffix is
+ * stripped before re-appending so the message never accumulates
+ * duplicate suffixes.
+ *
+ * Kill switch: `SWITCHROOM_DISABLE_PENDING_PROGRESS=1` disables the
+ * whole subsystem. The conversational-pacing prompt is unaffected.
+ */
+
+export const EDIT_INTERVAL_MS = 60_000
+export const POLL_INTERVAL_MS = 5_000
+export const MAX_LIFETIME_MS = 30 * 60_000
+/** Telegram message length limit is 4096; budget headroom for the
+ *  suffix and any escape expansion. If the anchor text plus suffix
+ *  would exceed this, we skip the edit (the user still sees the
+ *  original) rather than truncate the model's authored prose. */
+export const TELEGRAM_MSG_CAP = 4000
+
+/**
+ * Regex matching the suffix we append. Used to strip a prior suffix
+ * before appending the next one. The (\d+) covers "1m" / "12m" / etc.
+ * Kept anchored to end-of-string so it only matches OUR suffix, not
+ * something the model happened to write.
+ */
+const SUFFIX_RE = /\n\n— still working \(\d+m\)$/
+
+export interface PendingProgressEditCtx {
+  chatId: string
+  threadId: number | null
+  messageId: number
+  newText: string
+}
+
+/**
+ * Discriminated union — kept structurally identical to the
+ * `pending_progress_*` variants in `runtime-metrics.ts:RuntimeMetricEvent`
+ * so the gateway's `emitMetric: emitRuntimeMetric` wire-up typechecks
+ * cleanly with no cast. `started` carries only the chat key; `edited`
+ * always carries the cumulative elapsed time; `cleared` carries an
+ * optional elapsed + the reason (`inbound` | `handback` | `timeout` |
+ * `manual`).
+ */
+export type PendingProgressMetric =
+  | { kind: 'pending_progress_started'; chatKey: string }
+  | { kind: 'pending_progress_edited'; chatKey: string; elapsedMs: number }
+  | {
+      kind: 'pending_progress_cleared'
+      chatKey: string
+      elapsedMs?: number
+      reason?: string
+    }
+
+export interface PendingProgressDeps {
+  editMessage: (ctx: PendingProgressEditCtx) => Promise<void>
+  emitMetric?: (event: PendingProgressMetric) => void
+  /** Optional clock override for tests. */
+  nowMs?: () => number
+  /** Optional poll interval override for tests. */
+  pollIntervalMs?: number
+}
+
+interface State {
+  /** True after a `tool_use(Agent|Task)` was observed for this key in
+   *  the current turn. Cleared on next turn start. */
+  pending: boolean
+  /** The captured anchor — last outbound reply message_id for this
+   *  key. */
+  anchorMessageId: number | null
+  /** The captured anchor text — what the model wrote, *minus* any
+   *  prior pending-progress suffix. Used as the base for every edit. */
+  anchorOriginalText: string
+  /** Wall-clock ms when the cross-turn ambient state was *activated*
+   *  (at turn_end with pending+anchor). null before activation. */
+  activatedAt: number | null
+  /** Wall-clock ms of last edit fire — gates the EDIT_INTERVAL_MS
+   *  cadence. null until first edit fires. */
+  lastEditAt: number | null
+}
+
+const stateByKey = new Map<string, State>()
+let timer: ReturnType<typeof setInterval> | null = null
+let activeDeps: PendingProgressDeps | null = null
+
+function enabled(): boolean {
+  const v = process.env.SWITCHROOM_DISABLE_PENDING_PROGRESS
+  return !(v === '1' || v === 'true')
+}
+
+function nowMs(): number {
+  return activeDeps?.nowMs ? activeDeps.nowMs() : Date.now()
+}
+
+function ensure(key: string): State {
+  let s = stateByKey.get(key)
+  if (!s) {
+    s = {
+      pending: false,
+      anchorMessageId: null,
+      anchorOriginalText: '',
+      activatedAt: null,
+      lastEditAt: null,
+    }
+    stateByKey.set(key, s)
+  }
+  return s
+}
+
+/**
+ * Fresh turn — reset the per-turn `pending` flag and the per-turn
+ * anchor. The cross-turn `activated` state is per-PRIOR-turn and is
+ * cleared by the explicit clear paths (`clearPending` with reason
+ * `inbound` / `handback` / `timeout`), not by a new turn. The gateway
+ * wires those clears at TWO sites for full coverage:
+ *
+ *   1. `handleInbound` (real user message) → `clearPending('inbound')`
+ *      — the fast path; fires the moment the gateway sees an inbound,
+ *      before the new turn atom is even built.
+ *   2. `handleSessionEvent` `enqueue` case (every fresh turn atom)
+ *      → `clearPending('handback')` — the backstop covering
+ *      synthesised wakes (subagent-handback, cron, vault grant,
+ *      restart marker) that push directly to `pendingInboundBuffer`
+ *      and bypass `handleInbound`. Idempotent w/r/t the first clear.
+ *
+ * `startTurn` itself only matters if the state map already has an
+ * entry for `key` — which post-fix is impossible (the clears
+ * delete it). Kept for test ergonomics and as defence-in-depth.
+ */
+export function startTurn(key: string): void {
+  if (!enabled()) return
+  const s = stateByKey.get(key)
+  if (s == null) return
+  // Only the per-turn fields reset. activatedAt/lastEditAt belong to
+  // the prior turn's pending-progress and are cleared separately.
+  s.pending = false
+  s.anchorMessageId = null
+  s.anchorOriginalText = ''
+}
+
+/**
+ * Mark this chat as having dispatched async background work in the
+ * current turn. Idempotent. Called when the gateway sees a `tool_use`
+ * for `Agent` or `Task`.
+ */
+export function noteAsyncDispatch(key: string): void {
+  if (!enabled()) return
+  ensure(key).pending = true
+}
+
+/**
+ * Capture an outbound reply as a candidate anchor for cross-turn
+ * editing. Called on every successful bot reply send. If a prior
+ * pending-progress suffix is present in the text (rare — should only
+ * happen if we sent something to ourselves), strip it before storing
+ * so subsequent edits don't double-suffix.
+ */
+export function noteOutbound(
+  key: string,
+  opts: { messageId: number; text: string },
+): void {
+  if (!enabled()) return
+  const s = ensure(key)
+  s.anchorMessageId = opts.messageId
+  s.anchorOriginalText = opts.text.replace(SUFFIX_RE, '')
+}
+
+/**
+ * Called at turn_end. If the turn had a pending async dispatch AND
+ * captured an anchor, activate the cross-turn ambient state — the
+ * timer will start editing.
+ *
+ * If pending=false OR no anchor was captured, drop the state entry
+ * entirely (nothing for us to do).
+ */
+export function noteTurnEnd(key: string): void {
+  if (!enabled()) return
+  const s = stateByKey.get(key)
+  if (s == null) return
+  if (s.pending && s.anchorMessageId != null) {
+    s.activatedAt = nowMs()
+    // lastEditAt is null so the first edit fires after one full
+    // EDIT_INTERVAL_MS from activation — not immediately.
+    s.lastEditAt = s.activatedAt
+    activeDeps?.emitMetric?.({
+      kind: 'pending_progress_started',
+      chatKey: key,
+    })
+  } else {
+    stateByKey.delete(key)
+  }
+}
+
+/**
+ * Clear pending-progress for a chat — reasons:
+ *   'inbound'   — user sent a new message, they're re-engaged
+ *   'handback'  — switchroom injected a subagent_handback channel turn
+ *   'timeout'   — exceeded MAX_LIFETIME_MS
+ *   'manual'    — test / debug
+ */
+export function clearPending(
+  key: string,
+  reason: 'inbound' | 'handback' | 'timeout' | 'manual',
+): void {
+  if (!stateByKey.has(key)) return
+  const s = stateByKey.get(key)!
+  const elapsed = s.activatedAt != null ? nowMs() - s.activatedAt : 0
+  stateByKey.delete(key)
+  activeDeps?.emitMetric?.({
+    kind: 'pending_progress_cleared',
+    chatKey: key,
+    elapsedMs: elapsed,
+    reason,
+  })
+}
+
+/**
+ * Start the shared interval timer. Idempotent. Honours the kill
+ * switch — no-op when disabled.
+ */
+export function startTimer(deps: PendingProgressDeps): void {
+  if (!enabled()) return
+  if (timer != null) return
+  activeDeps = deps
+  const interval = deps.pollIntervalMs ?? POLL_INTERVAL_MS
+  timer = setInterval(() => tick(nowMs()), interval)
+  if (typeof timer.unref === 'function') timer.unref()
+}
+
+/** Stop the timer. Idempotent. */
+export function stopTimer(): void {
+  if (timer != null) {
+    clearInterval(timer)
+    timer = null
+  }
+  activeDeps = null
+}
+
+/**
+ * Parse `<chatId>:<threadIdOrEmpty>` back into structured fields,
+ * matching the `statusKey` shape used throughout the gateway.
+ */
+function parseKey(key: string): { chatId: string; threadId: number | null } {
+  const idx = key.indexOf(':')
+  if (idx < 0) return { chatId: key, threadId: null }
+  const chatId = key.slice(0, idx)
+  const tail = key.slice(idx + 1)
+  if (tail === '' || tail === 'undefined') return { chatId, threadId: null }
+  const n = Number(tail)
+  return { chatId, threadId: Number.isFinite(n) ? n : null }
+}
+
+function tick(now: number): void {
+  if (activeDeps == null) return
+  for (const [key, s] of stateByKey.entries()) {
+    if (s.activatedAt == null || s.anchorMessageId == null) continue
+
+    const elapsed = now - s.activatedAt
+    if (elapsed >= MAX_LIFETIME_MS) {
+      clearPending(key, 'timeout')
+      continue
+    }
+
+    const sinceEdit = s.lastEditAt == null ? 0 : now - s.lastEditAt
+    if (sinceEdit < EDIT_INTERVAL_MS) continue
+
+    // Build suffix from elapsed wall-clock. Always at least 1m so the
+    // user-visible counter reads honestly (we only edit at intervals
+    // ≥ EDIT_INTERVAL_MS = 60s).
+    const minutes = Math.max(1, Math.round(elapsed / 60_000))
+    const suffix = `\n\n— still working (${minutes}m)`
+    const newText = s.anchorOriginalText + suffix
+
+    if (newText.length > TELEGRAM_MSG_CAP) {
+      // Don't truncate the model's prose — just skip this edit.
+      // The previous edit (or the original) is still visible.
+      s.lastEditAt = now
+      continue
+    }
+
+    const { chatId, threadId } = parseKey(key)
+    s.lastEditAt = now
+
+    const editCtx: PendingProgressEditCtx = {
+      chatId,
+      threadId,
+      messageId: s.anchorMessageId,
+      newText,
+    }
+    // Fire-and-forget so a slow edit doesn't block the tick loop.
+    // Errors are logged but never bubble (a 429 / "message not modified"
+    // / chat-deleted is a soft failure).
+    void Promise.resolve()
+      .then(() => activeDeps!.editMessage(editCtx))
+      .then(() => {
+        activeDeps!.emitMetric?.({
+          kind: 'pending_progress_edited',
+          chatKey: key,
+          elapsedMs: elapsed,
+        })
+      })
+      .catch((err) => {
+        process.stderr.write(
+          `pending-work-progress: edit failed key=${key} ` +
+            `msg=${editCtx.messageId}: ${(err as Error).message}\n`,
+        )
+      })
+  }
+}
+
+// ─── Test helpers ─────────────────────────────────────────────────────────
+
+/** Test-only: drive one tick deterministically. */
+export function __tickForTests(now: number): void {
+  tick(now)
+}
+
+/** Test-only: install deps without starting the real timer. */
+export function __setDepsForTests(deps: PendingProgressDeps | null): void {
+  activeDeps = deps
+}
+
+/** Test-only: peek at per-key state. */
+export function __getStateForTests(key: string): State | undefined {
+  return stateByKey.get(key)
+}
+
+/** Test-only: full reset. */
+export function __resetAllForTests(): void {
+  stateByKey.clear()
+  stopTimer()
+}

package/telegram-plugin/runtime-metrics.ts

@@ -104,6 +104,26 @@ export type RuntimeMetricEvent =
       fallback_kind: 'working' | 'thinking'
       silence_ms: number
     }
+  /**
+   * #1445 cross-turn pending-async ambient lifecycle. `started` fires
+   * when a turn ends with a captured anchor AND a pending Agent/Task/
+   * Bash-background dispatch — i.e. the framework will now edit the
+   * model's last reply in place every ~60s until cleared. `edited`
+   * fires on each successful in-place edit; `elapsed_ms` is how long
+   * ambient has been running for this chat. `cleared` fires when
+   * ambient stops — `reason` says why (inbound / handback / timeout).
+   * Targets: edited/started ratio is the "still alive minutes per
+   * activation" health proxy; cleared.reason='inbound' should
+   * dominate (model + user resolving naturally).
+   */
+  | { kind: 'pending_progress_started'; chatKey: string }
+  | { kind: 'pending_progress_edited'; chatKey: string; elapsedMs: number }
+  | {
+      kind: 'pending_progress_cleared'
+      chatKey: string
+      elapsedMs?: number
+      reason?: string
+    }
 
 /**
  * The JSONL sink lives under the runtime state dir so it's per-agent