switchroom 0.18.20 → 0.18.22

package/telegram-plugin/flushed-turn-supersede.ts

@@ -0,0 +1,230 @@
+/**
+ * Turn-flush supersede registry (2026-07 duplicate-reply fix).
+ *
+ * The duplicate-reply class this closes:
+ *
+ *   1. A turn-flush (the answer-ready quiescence flush OR the older turn-end
+ *      backstop) posts the model's terminal text as a Telegram message, because
+ *      the turn appeared to end without a `reply` tool call.
+ *   2. ~10 s later the model's REAL `reply` tool call lands (it was still
+ *      composing it when the flush fired, or claude-code replayed an un-acked
+ *      tool_call after a bridge reconnect).
+ *   3. The gateway sends that as a SECOND message → the user sees a duplicate.
+ *
+ * The pre-existing `OutboundDedupCache` did NOT catch this because it matches on
+ * EXACT normalised-text equality: a flush that dumped `narration\n\nanswer`
+ * never equals the clean `answer`-only reply, so the containment case slipped
+ * through (216 occurrences in older logs via the turn-end backstop alone).
+ *
+ * This registry SUBSTANTIALLY REDUCES the class, keyed on the turn IDENTITY
+ * (the per-turn `turnId` nonce) rather than on text. When a flush sends, it
+ * records `{ turnId, messageIds }` for the chat/thread. When a `reply` for the
+ * SAME turn later lands, the gateway SUPERSEDES the flushed message(s) — deletes
+ * them and lets the canonical reply send path deliver exactly one clean message
+ * (delete+resend; the caller may also edit-in-place). A reply for a DIFFERENT
+ * (newer) turn never supersedes — that turn owns its own message.
+ *
+ * NOT fully deterministic — a residual race remains. The flush→reply direction
+ * this registry covers, plus the controller's fire-time recount for the
+ * reply→flush direction, close the COMMON ~10 s replay-gap case; but if a reply
+ * and a flush interleave so the reply's `take()` runs BEFORE the flush's
+ * `record()` (a much smaller window), `take` finds no record and the duplicate
+ * can still slip through. We deliberately trade that residual window for the
+ * safety guarantee that we NEVER delete a message we cannot positively attribute
+ * to the reply's own turn (identity-only supersede — see `decideSupersede`).
+ *
+ * Pure module: no I/O, no globals, no clock reads beyond the caller-supplied
+ * `now`. Fully unit-testable; the gateway wires the actual delete/send.
+ */
+
+/** TTL after which a recorded flush is forgotten. 60 s comfortably spans the
+ *  observed ~10 s flush→reply replay gap with margin, and matches the outbound
+ *  dedup window so the two mechanisms age out together. */
+export const DEFAULT_SUPERSEDE_TTL_MS = 60_000
+
+export interface FlushedTurnRecord {
+  /** The per-turn `turnId` nonce (`deriveTurnId` shape) of the flushed turn.
+   *  Keying on this — NOT the stable `chatId:threadId` statusKey — is what makes
+   *  the supersede turn-identity-scoped: a later, unrelated turn on the same
+   *  chat has a different `turnId` and must NOT clobber this record's message. */
+  turnId: string | null
+  /** The Telegram message id(s) the flush posted (edit target + any extra
+   *  chunk messages). Superseding deletes all of them. */
+  messageIds: number[]
+  /** The text the flush delivered — retained for diagnostics/logging only. The
+   *  supersede decision NEVER compares text (that is the whole point: it fires
+   *  even when the flushed text differs from the reply text). */
+  text: string
+  /** Wall-clock ms when recorded. */
+  ts: number
+}
+
+/**
+ * The supersede decision for a landing reply. Pure so the gateway runs the
+ * exact code the regression tests exercise (`gateway.ts` is not importable in
+ * tests — the repo's `decideTurnFlush` / `decideCapturedProseDelivery` pattern).
+ */
+export interface SupersedeDecision {
+  /** True → the reply belongs to an already-flushed turn; the gateway must
+   *  delete `deleteMessageIds` and deliver the reply as the single message. */
+  supersede: boolean
+  /** Message ids the gateway must delete before/instead of the fresh send.
+   *  Empty when `supersede` is false. */
+  deleteMessageIds: number[]
+  /** Machine-readable reason (for logs / tests). */
+  reason: 'supersede' | 'no-record' | 'expired' | 'different-turn'
+}
+
+/**
+ * Decide whether a landing reply supersedes a recorded flush.
+ *
+ * Supersede IFF the record is present, fresh (within TTL), AND positively
+ * attributable to the reply's turn by IDENTITY:
+ *   - a turnId-bearing record is superseded ONLY by a reply whose resolved
+ *     `liveTurnId` equals `record.turnId`;
+ *   - a null-turnId record (a synthetic/no-nonce flush) is superseded ONLY by a
+ *     reply that ALSO has no resolvable turn (`liveTurnId == null`).
+ *
+ * Crucially, a reply with `liveTurnId == null` does NOT supersede a
+ * turnId-bearing record: we never delete a message we cannot positively
+ * attribute to the reply's own turn. (The earlier revision superseded ANY
+ * record on a null live turn, which — combined with a single overwriting lane
+ * slot — could late-delete a DIFFERENT turn's legitimate message. The gateway
+ * now resolves a last-known turnId for the reply before calling in, so the
+ * common late-replay case still matches by identity rather than relying on the
+ * promiscuous null branch.)
+ */
+export function decideSupersede(
+  record: FlushedTurnRecord | undefined,
+  args: { liveTurnId: string | null; now: number; ttlMs?: number },
+): SupersedeDecision {
+  const ttlMs = args.ttlMs ?? DEFAULT_SUPERSEDE_TTL_MS
+  if (record == null) return { supersede: false, deleteMessageIds: [], reason: 'no-record' }
+  if (args.now - record.ts > ttlMs) {
+    return { supersede: false, deleteMessageIds: [], reason: 'expired' }
+  }
+  const sameTurn =
+    record.turnId != null
+      ? record.turnId === args.liveTurnId
+      : args.liveTurnId == null
+  if (!sameTurn) {
+    return { supersede: false, deleteMessageIds: [], reason: 'different-turn' }
+  }
+  return { supersede: true, deleteMessageIds: [...record.messageIds], reason: 'supersede' }
+}
+
+/** Sentinel key for records whose flush carried no turnId nonce. */
+const NULL_TURN_KEY = '<<null-turn>>'
+
+function turnKey(turnId: string | null): string {
+  return turnId == null ? NULL_TURN_KEY : turnId
+}
+
+/**
+ * In-memory registry of recently-flushed turns, keyed by `chatId|threadId` and
+ * then by the flush's `turnId` nonce WITHIN that lane. Holding a per-turnId map
+ * (rather than a single overwriting slot) is what makes the identity guarantee
+ * airtight: two turns can each flush a message on the same lane, and each turn's
+ * later reply supersedes ONLY its own flushed message — turn B's reply can never
+ * reach turn A's record, and a late turn-A reply can never reach turn B's.
+ *
+ * Bounded by TTL eviction (swept on every `record`); chat count per gateway is
+ * small and a lane holds at most a handful of concurrent-turn records.
+ */
+export class FlushedTurnSupersedeRegistry {
+  private readonly entries = new Map<string, Map<string, FlushedTurnRecord>>()
+  private readonly ttlMs: number
+
+  constructor(opts: { ttlMs?: number } = {}) {
+    this.ttlMs = opts.ttlMs ?? DEFAULT_SUPERSEDE_TTL_MS
+  }
+
+  /** Record a flush's posted message(s) so a later same-turn reply supersedes
+   *  them, keyed on the flush's `turnId` within the chat/thread lane. No record
+   *  is kept when the flush posted zero messages. Sweeps expired records first
+   *  (lightweight active GC — LOW-2) so orphan records never accumulate. */
+  record(
+    chatId: string,
+    threadId: number | undefined,
+    rec: { turnId: string | null; messageIds: number[]; text: string },
+    now: number,
+  ): void {
+    if (rec.messageIds.length === 0) return
+    this.sweep(now)
+    const lane = makeKey(chatId, threadId)
+    let laneMap = this.entries.get(lane)
+    if (laneMap == null) {
+      laneMap = new Map<string, FlushedTurnRecord>()
+      this.entries.set(lane, laneMap)
+    }
+    laneMap.set(turnKey(rec.turnId), {
+      turnId: rec.turnId,
+      messageIds: [...rec.messageIds],
+      text: rec.text,
+      ts: now,
+    })
+  }
+
+  /** Decide supersede for a landing reply WITHOUT consuming the record. Selects
+   *  the record whose turnId matches the reply's resolved `liveTurnId` (or the
+   *  null-turnId record when `liveTurnId == null`). */
+  peek(
+    chatId: string,
+    threadId: number | undefined,
+    args: { liveTurnId: string | null; now: number },
+  ): SupersedeDecision {
+    const rec = this.entries.get(makeKey(chatId, threadId))?.get(turnKey(args.liveTurnId))
+    return decideSupersede(rec, { liveTurnId: args.liveTurnId, now: args.now, ttlMs: this.ttlMs })
+  }
+
+  /** Decide supersede AND, on a supersede, consume the matched record (so a
+   *  second replay of the same reply doesn't try to delete the same — now gone —
+   *  messages again). Returns the same decision `peek` would. */
+  take(
+    chatId: string,
+    threadId: number | undefined,
+    args: { liveTurnId: string | null; now: number },
+  ): SupersedeDecision {
+    const lane = makeKey(chatId, threadId)
+    const decision = this.peek(chatId, threadId, args)
+    if (decision.supersede) {
+      const laneMap = this.entries.get(lane)
+      laneMap?.delete(turnKey(args.liveTurnId))
+      if (laneMap != null && laneMap.size === 0) this.entries.delete(lane)
+    }
+    return decision
+  }
+
+  /** Drop all records for a chat/thread (e.g. after the flushed message was
+   *  deleted through another path). Idempotent. */
+  forget(chatId: string, threadId: number | undefined): void {
+    this.entries.delete(makeKey(chatId, threadId))
+  }
+
+  /** Test-only: clear all entries. */
+  clear(): void {
+    this.entries.clear()
+  }
+
+  /** Evict every record past its TTL and prune emptied lanes. */
+  private sweep(now: number): void {
+    for (const [lane, laneMap] of this.entries) {
+      for (const [tk, rec] of laneMap) {
+        if (now - rec.ts > this.ttlMs) laneMap.delete(tk)
+      }
+      if (laneMap.size === 0) this.entries.delete(lane)
+    }
+  }
+
+  /** Test-only: live record count after TTL eviction. */
+  size(now: number): number {
+    this.sweep(now)
+    let total = 0
+    for (const laneMap of this.entries.values()) total += laneMap.size
+    return total
+  }
+}
+
+function makeKey(chatId: string, threadId: number | undefined): string {
+  return threadId == null ? chatId : `${chatId}|${threadId}`
+}

package/telegram-plugin/gateway/gateway.ts

@@ -88,6 +88,7 @@ import {
   type TelegraphAccount,
 } from '../telegraph.js'
 import { OutboundDedupCache } from '../recent-outbound-dedup.js'
+import { FlushedTurnSupersedeRegistry } from '../flushed-turn-supersede.js'
 import { createInboundCoalescer, inboundCoalesceKey } from './inbound-coalesce.js'
 import {
   splitCoalescedAttachments,
@@ -2220,6 +2221,14 @@ const deferredDoneReactions = new DeferredDoneReactions<StatusReactionController
 // path threw `outboundDedup is not defined` at runtime, blocking ALL outbound
 // from the agent. Restore the module-level singleton here.
 const outboundDedup = new OutboundDedupCache()
+// 2026-07 duplicate-reply fix — turnId-keyed supersede. When a turn-flush
+// (answer-ready quiescence OR the turn-end backstop) posts the model's terminal
+// text and the model's REAL `reply` for the SAME turn lands later, the reply
+// SUPERSEDES the flushed message (delete + canonical resend) instead of shipping
+// a second message. Keyed on the per-turn `turnId` nonce, NOT on text — so it
+// catches the containment case the exact-text `outboundDedup` misses (a
+// `narration\n\nanswer` flush never equals the clean `answer`-only reply).
+const flushedTurnSupersede = new FlushedTurnSupersedeRegistry()
 /**
  * Per-chat cache of `available_reactions` from `getChat`. Populated lazily —
  * the FIRST message in a chat creates a controller without the filter (null
@@ -12902,6 +12911,50 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
     }
   }
 
+  // 2026-07 duplicate-reply fix — turnId-keyed supersede (consumption side).
+  // If an earlier turn-flush (answer-ready quiescence OR the turn-end backstop)
+  // already posted THIS turn's terminal text and the model's REAL `reply` for
+  // the same turn is landing now (it was still composing the tool call when the
+  // flush fired, or claude-code replayed the tool_call after a bridge
+  // reconnect), delete the flushed message(s) so the canonical reply below
+  // delivers exactly one clean message instead of a second one. Keyed on the
+  // per-turn `turnId` nonce, so it fires even when the flushed narration+answer
+  // blob differs from the clean answer-only reply — the containment case the
+  // exact-text `outboundDedup` above structurally cannot catch. A reply for a
+  // DIFFERENT newer live turn never supersedes (decideSupersede → different-turn),
+  // so a fresh turn's answer is never clobbered.
+  {
+    const replyThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined
+    // Resolve the turnId this reply belongs to by IDENTITY, not just the live
+    // `currentTurn`. A late reply lands with `currentTurn == null` (silence poke
+    // cleared it — Bug D) or with a transiently-cleared currentTurn while its own
+    // turn is really still the owner (LOW-1); in both cases the turn is still
+    // resolvable from the `origin_turn_id` nonce the model echoes back (Tier 2 —
+    // the same last-known-turn resolver the chat-routing / obligation code uses).
+    // Passing this resolved turnId means supersede matches the flushed record by
+    // identity instead of falling back to a null-liveTurnId branch that would
+    // otherwise be free to delete a DIFFERENT turn's legitimate message.
+    const resolvedTurnId =
+      turn?.turnId ?? findTurnByOriginId(args.origin_turn_id as string | undefined)?.turnId ?? null
+    const decision = flushedTurnSupersede.take(
+      chat_id,
+      replyThreadId,
+      { liveTurnId: resolvedTurnId, now: Date.now() },
+    )
+    if (decision.supersede) {
+      process.stderr.write(
+        `telegram gateway: reply: superseding flushed turn message(s) ` +
+        `chatId=${chat_id} ids=${JSON.stringify(decision.deleteMessageIds)}\n`,
+      )
+      for (const id of decision.deleteMessageIds) {
+        await swallowingApiCall(
+          () => lockedBot.api.deleteMessage(chat_id, id),
+          { chat_id, verb: 'reply.supersedeFlushed' },
+        )
+      }
+    }
+  }
+
   const files = (args.files as string[] | undefined) ?? []
   const quoteOptIn = args.quote !== false
   let reply_to = args.reply_to != null ? Number(args.reply_to) : undefined
@@ -18264,6 +18317,22 @@ function handleSessionEvent(ev: SessionEvent): void {
               Date.now(),
               currentTurn?.registryKey ?? null,
             )
+            // 2026-07 duplicate-reply fix — record the flushed message id(s)
+            // keyed on THIS turn's `turnId` nonce so a late `reply` for the same
+            // turn supersedes them (delete + canonical resend) instead of
+            // shipping a duplicate. `turn` is the ending turn atom captured at
+            // the top of this branch (endCurrentTurnAtomic nulled currentTurn,
+            // but the captured `turn` still carries the honest turnId). Covers
+            // BOTH flush paths — answer-ready quiescence and the turn-end
+            // backstop both funnel through this single IIFE.
+            if (sentIds.length > 0) {
+              flushedTurnSupersede.record(
+                backstopChatId,
+                backstopThreadId,
+                { turnId: turn.turnId, messageIds: sentIds, text: capturedText },
+                Date.now(),
+              )
+            }
             // #1713: route the backstop terminal through finalize() —
             // single terminal path keeps the controller contract clean.
             if (backstopCtrl) backstopCtrl.finalize('done')
@@ -30542,7 +30611,7 @@ void (async () => {
               // suppresses stale-after-restart delivery (a 4-h-old
               // "still working (5m)" would be a lie). Sweep on handback
               // lives in the `onFinish` block just above.
-              onProgress: ({ agentId, description, latestSummary, elapsedMs, prevBucketIdx, setBucketIdx, lastTool, toolCount, progressLine, model }) => {
+              onProgress: ({ agentId, description, latestSummary, elapsedMs, prevBucketIdx, setBucketIdx, lastTool, toolCount, progressLine, model, skeleton }) => {
                 let fleetChatId = ''
                 try {
                   const fleets = progressDriver?.peekAllFleets() ?? []
@@ -30632,6 +30701,15 @@ void (async () => {
                     return
                   }
                   if (surface !== 'nest') return // 'skip' — orphan-status off
+                  // #3233: a skeleton liveness cue carries NO step content by
+                  // construction (empty latestSummary/progressLine) — it exists
+                  // ONLY to create/keep-alive the orphan worker-feed row handled
+                  // just above. Branch EXPLICITLY on the `skeleton` discriminator
+                  // rather than inferring "no content" from an empty step line:
+                  // a skeleton cue must never nest into the parent's live turn
+                  // card (there is nothing to render, and the parent's own card
+                  // already owns the turn). Deterministic, controls-in-code.
+                  if (skeleton) return
                   const turn = currentTurn
                   if (turn == null) return // defensive: 'nest' implies a live turn
                   // Render regardless of `replyCalled` — a foreground Task
@@ -30777,8 +30855,17 @@ void (async () => {
                   return
                 }
 
+                // #3233: with the worker feed DISABLED, the legacy bucket relay
+                // below injects a synthesized "still working" inbound turn. A
+                // skeleton liveness cue carries an EMPTY latestSummary, so
+                // letting it reach the relay would queue a blank/contentless
+                // progress card. The `skeleton` discriminator is threaded into
+                // the pure decision (gate 1b → 'skeleton-liveness'), which drops
+                // it deterministically (controls-in-code, unit-tested) rather
+                // than an opaque inline return here.
                 const progressOrigin = resolveSubagentOriginChat(agentId)
                 const decision = decideSubagentProgress({
+                  skeleton: skeleton === true,
                   disableEnvValue: process.env.SWITCHROOM_DISABLE_SUBAGENT_PROGRESS,
                   isBackground,
                   // Prefer the conversation the Task was dispatched from over

package/telegram-plugin/gateway/subagent-progress-inbound-builder.ts

@@ -176,12 +176,20 @@ export interface SubagentProgressDecisionInput {
    *  passes it in; the decision returns the new bucket idx on
    *  `deliver: true` so the caller can update its tracker. */
   lastBucketIdx: number | null
+  /** #3233: true for a growth-independent SKELETON liveness cue (empty
+   *  `latestSummary`, no step content). It exists ONLY to first-paint /
+   *  keep-alive the in-message worker-feed row; the legacy bucket relay would
+   *  turn it into a synthesized "still working" inbound with no content — a
+   *  blank card. Suppressed deterministically here so the worker-feed-DISABLED
+   *  path degrades to a no-op rather than a blank envelope. */
+  skeleton?: boolean
   /** Deterministic clock for tests. */
   nowMs?: number
 }
 
 export type SubagentProgressSkipReason =
   | 'env-disabled'
+  | 'skeleton-liveness'
   | 'foreground'
   | 'no-chat'
   | 'bucket-already-fired'
@@ -199,6 +207,8 @@ export type SubagentProgressDecision =
  *
  * Gates, in order:
  *   1. kill-switch — `SWITCHROOM_DISABLE_SUBAGENT_PROGRESS=1` disables.
+ *   1b. skeleton-liveness (#3233) — a contentless skeleton cue is never
+ *       relayed as a synthesized inbound (worker-feed row only).
  *   2. foreground — foreground sub-agents stream natively.
  *   3. no-chat    — nowhere to deliver.
  *   4. missing-jsonl-id — the dedup key. Without it we'd lose
@@ -233,6 +243,13 @@ export function decideSubagentProgress(
   if (isEnvFlagOn(input.disableEnvValue)) {
     return { deliver: false, reason: 'env-disabled' }
   }
+  // #3233: a skeleton liveness cue carries no step content — never relay it as
+  // a synthesized progress inbound (that would be a blank card). Its whole job
+  // is the in-message worker-feed row; when that surface is off, degrade to a
+  // no-op. Checked before bucketing so it can never advance the bucket tracker.
+  if (input.skeleton === true) {
+    return { deliver: false, reason: 'skeleton-liveness' }
+  }
   if (!input.isBackground) {
     return { deliver: false, reason: 'foreground' }
   }

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

@@ -277,6 +277,12 @@ export function applySubagentsSchema(db: SqliteDatabase): void {
   // column is guaranteed to exist (either created with the table or added by
   // the migration above).
   db.exec('CREATE INDEX IF NOT EXISTS subagents_jsonl_id ON subagents(jsonl_agent_id)')
+  // Same deferred-index rationale as jsonl_agent_id above: parent_agent_id is
+  // added by the ALTER migration for pre-existing tables, so its index must be
+  // created here (after the column is guaranteed to exist), not in the base SQL.
+  // Backs the per-poll child-existence probe in subagent-watcher.ts
+  // (`SELECT 1 FROM subagents WHERE parent_agent_id = ? LIMIT 1`).
+  db.exec('CREATE INDEX IF NOT EXISTS subagents_parent_agent ON subagents(parent_agent_id)')
 }
 
 // ---------------------------------------------------------------------------

package/telegram-plugin/subagent-watcher.ts

@@ -628,6 +628,12 @@ export interface SubagentWatcherConfig {
      *  assistant line — the gateway then falls back to the registry's
      *  dispatch-time model. */
     model?: string
+    /** True for a growth-INDEPENDENT skeleton liveness cue (#3231): fired on a
+     *  no-growth poll for a running entry so the card can first-paint / stay
+     *  alive without waiting for JSONL growth. Carries the entry's real state
+     *  but an EMPTY `latestSummary`/`progressLine` — never fabricated content.
+     *  Consumers that count real narrative/tool cues must exclude it. */
+    skeleton?: boolean
   }) => void
   /** `Date.now` override for tests. */
   now?: () => number
@@ -1088,6 +1094,9 @@ export function readSubTail(
     progressLine?: string
     /** Live model this worker is running (see SubagentWatcherConfig.onProgress). */
     model?: string
+    /** Growth-independent skeleton liveness cue (#3231). See the identically
+     *  named field on SubagentWatcherConfig.onProgress. */
+    skeleton?: boolean
   }) => void,
 ): void {
   try {
@@ -1103,7 +1112,83 @@ export function readSubTail(
       tail.cursor = 0
       tail.pendingPartial = ''
     }
-    if (stat.size === tail.cursor) return
+    if (stat.size === tail.cursor) {
+      // First-paint independence (#3231): the worker card is otherwise driven
+      // ONLY by growth-triggered progress cues below, so a running worker whose
+      // JSONL is not currently growing surfaces NOTHING. That is the ~90-205s
+      // invisible-card bug observed live (a57fbf, 2026-07-13): an async
+      // foreground sub-agent did two Bash calls, then its first tool BLOCKED for
+      // ~99s (no JSONL growth → no cue), and — because its spawning turn had
+      // already ended — no nest and no worker-feed row existed to paint. Its
+      // card did not appear until 205s after registration, on the next growth
+      // event that happened to be classified to the feed. Fire a growth-INDEPENDENT
+      // skeleton liveness cue on every no-growth poll for a live entry so the
+      // gateway can paint (and keep alive) the card from registration onward,
+      // uniformly across ALL spawn origins/nesting levels. The cue carries the
+      // entry's REAL current state (lastTool/toolCount/model) but an EMPTY step
+      // line — no fabricated content: it is inert on the foreground-nest path
+      // (empty child → no-op, the parent's own card owns the live turn) and
+      // creates/refreshes the orphan/background worker-feed row (→ "starting…",
+      // whose first paint the feed's own firstPaintMin + heartbeat then owns).
+      if (onProgress != null && entry.state === 'running' && !entry.historical) {
+        // Child-aware suppression (#3233): the skeleton cue exists to paint a
+        // LEAF worker whose card would otherwise be invisible (the 205s
+        // blackout). A pure-ORCHESTRATOR parent — one that has dispatched a
+        // descendant of its own — must NOT earn a redundant "starting…"
+        // liveness row: the child surfaces its own live row in the same worker
+        // feed, so an extra skeleton row for the parent is pure feed clutter
+        // (fails the no-noise / never-storm bar). The discriminator is
+        // deliberately NOT "0 own tools" — a leaf that registers and BLOCKS on
+        // its very first tool has 0 completed tools and MUST still paint.
+        // Instead, suppress when THIS entry has EVER dispatched a child (any
+        // child registry row keyed by parent_agent_id = this entry's jsonl
+        // agentId; recordNestedSubagentDispatch stamps it). "Ever", not "a
+        // currently-running child": the skeleton cue is only the NO-GROWTH
+        // fallback, so suppressing it for an orchestrator never hides real
+        // work — if the parent does its own tools, those fire real growth
+        // cues and paint the row; if it only orchestrates, its children carry
+        // the liveness. Using "currently running" instead would re-paint a
+        // spurious orchestrator "starting…" the moment its child finished. A
+        // genuine leaf has no child row at all, so it keeps firing the
+        // skeleton cue and paints promptly — the 205s-blackout class is intact.
+        let hasChild = false
+        if (db != null) {
+          try {
+            const kid = db
+              .prepare(
+                'SELECT 1 FROM subagents WHERE parent_agent_id = ? LIMIT 1',
+              )
+              .get(entry.agentId)
+            hasChild = kid != null
+          } catch (kidErr) {
+            // Best-effort: an absent/failed linkage read is treated as "leaf"
+            // so we never suppress a genuine blackout paint on a DB hiccup.
+            log?.(`subagent-watcher: skeleton child-check error ${entry.agentId}: ${(kidErr as Error).message}`)
+          }
+        }
+        if (!hasChild) {
+          try {
+            onProgress({
+              agentId: entry.agentId,
+              description: entry.description,
+              latestSummary: '',
+              elapsedMs: now - entry.dispatchedAt,
+              prevBucketIdx: entry.lastProgressBucketIdx,
+              setBucketIdx: (b: number) => {
+                entry.lastProgressBucketIdx = b
+              },
+              lastTool: entry.lastTool,
+              toolCount: entry.toolCount,
+              model: entry.currentModel,
+              skeleton: true,
+            })
+          } catch (cbErr) {
+            log?.(`subagent-watcher: onProgress (skeleton) callback error ${entry.agentId}: ${(cbErr as Error).message}`)
+          }
+        }
+      }
+      return
+    }
 
     const buf = Buffer.alloc(stat.size - tail.cursor)
     const fd = fs.openSync(entry.filePath, 'r')