switchroom 0.18.3 → 0.18.7

package/telegram-plugin/gateway/resume-inbound-builder.ts

@@ -49,12 +49,127 @@ export function humanizeElapsed(ms: number): string {
   return `~${days} day${days === 1 ? '' : 's'}`
 }
 
+/**
+ * A sub-agent that was still in flight when the turn was interrupted. The
+ * gateway derives these from the registry (`listNonTerminalSubagentsForTurn`)
+ * — every non-terminal (`running` / `stalled`) worker of the interrupted turn.
+ * Kept to just the display fields so the builder stays pure (no SQLite import).
+ */
+export interface InterruptedSubagent {
+  /** Agent type / label (e.g. 'worker', 'researcher'). */
+  agentType?: string | null
+  /** Human-readable dispatch prompt / task description. */
+  description?: string | null
+  /** Current registry status ('running' | 'stalled'). Informational only. */
+  status?: string | null
+}
+
+/** Max chars of each sub-agent's dispatch prompt included in the inbound. */
+const SUBAGENT_PROMPT_MAX = 200
+/** Max number of sub-agents listed (the rest are summarised as a count). */
+const SUBAGENT_LIST_CAP = 10
+
+function truncatePrompt(s: string, max: number): string {
+  const t = s.trim()
+  if (t.length <= max) return t
+  // Codepoint-safe truncation: slice by code POINTS, not UTF-16 code units —
+  // a naive `.slice()` can split a surrogate pair (emoji, astral-plane CJK)
+  // and leave a lone surrogate that renders as U+FFFD in the inbound.
+  const points = Array.from(t)
+  if (points.length <= max) return t
+  return points.slice(0, max - 1).join('').trimEnd() + '…'
+}
+
+/**
+ * Render the compact "these workers died with the restart" block appended to
+ * an interrupted-turn inbound. Empty string when there were no in-flight
+ * sub-agents (so the inbound is unchanged in the common case). Bounded: at
+ * most `SUBAGENT_LIST_CAP` entries, each prompt truncated to
+ * `SUBAGENT_PROMPT_MAX` chars, with an overflow count for the remainder.
+ *
+ * The closing instruction is mode-aware, mirroring the two builders'
+ * contracts:
+ *   - `assertive: true` (the `resume_interrupted` path, whose inbound already
+ *     says "just resume") → imperative: re-dispatch the ones still needed
+ *     before declaring the task done.
+ *   - `assertive: false` (the `resume_watchdog_timeout` path — an ask-first
+ *     contract: "Do NOT silently resume … ask whether to retry") → deferred:
+ *     IF the user asks to retry, the workers will need re-dispatching. An
+ *     unconditional re-dispatch imperative here would contradict that
+ *     hang-safety gate.
+ */
+export function renderInterruptedSubagentsBlock(
+  subs: InterruptedSubagent[] | undefined,
+  opts: { assertive: boolean } = { assertive: true },
+): string {
+  if (!subs || subs.length === 0) return ''
+  const shown = subs.slice(0, SUBAGENT_LIST_CAP)
+  const lines = shown.map((s, i) => {
+    const type = s.agentType?.trim() ? s.agentType.trim() : 'sub-agent'
+    const desc = s.description?.trim()
+      ? truncatePrompt(s.description, SUBAGENT_PROMPT_MAX)
+      : '(no task description recorded)'
+    return `  ${i + 1}. [${type}] ${desc}`
+  })
+  const overflow =
+    subs.length > SUBAGENT_LIST_CAP
+      ? `\n  …and ${subs.length - SUBAGENT_LIST_CAP} more.`
+      : ''
+  const count = subs.length
+  const closing = opts.assertive
+    ? `\nRe-dispatch the ones still needed before declaring the task done — ` +
+      `don't assume their work landed.`
+    : `\nIf the user asks you to retry, they'll need re-dispatching — ` +
+      `don't assume their work landed.`
+  return (
+    `\n\nWhen the restart hit, ${count} sub-agent${count === 1 ? ' was' : 's were'} still ` +
+    `in flight. These sub-agents were killed by the restart and did NOT complete:\n` +
+    lines.join('\n') +
+    overflow +
+    closing
+  )
+}
+
 export interface ResumeInboundContext {
   /** The interrupted turn, straight from the registry. */
   turn: Turn
   /** Wall-clock ms. Drives `ts`, `messageId`, and the elapsed framing.
    *  Defaults to Date.now(). */
   nowMs?: number
+  /** Sub-agents that were still non-terminal when the turn was interrupted.
+   *  Rendered into the inbound so the resumed session knows what to
+   *  re-dispatch. Omitted / empty → the inbound is unchanged. */
+  subagents?: InterruptedSubagent[]
+}
+
+/**
+ * Machine-stable leading token shared by EVERY synthetic boot inbound this
+ * module mints (resume, watchdog-report, deferred-report). It is the anchor
+ * the loop-guard keys on: a turn whose `user_prompt_preview` starts with
+ * this string was itself started by a synthetic boot inbound, so building
+ * ANOTHER resume for it would replay already-resumed work and could chain
+ * unboundedly across repeated restarts.
+ *
+ * `extractUserPromptPreview` strips the `<channel …>` wrapper before storing
+ * the preview, so the stored text begins with this prose prefix (not the
+ * `meta.source` attribute, which the preview drops). Every builder below
+ * MUST keep this as the first characters of its `text`; `resume-inbound-
+ * builder.test.ts` pins that contract so a prose edit can't silently break
+ * the loop-guard.
+ */
+export const RESUME_SYNTHETIC_PROMPT_PREFIX = 'You just restarted.'
+
+/**
+ * Loop-guard predicate: was this interrupted turn ITSELF started by one of
+ * this module's synthetic boot inbounds? Detected via the stored
+ * `user_prompt_preview` prefix. Used at boot to cap the auto-resume chain at
+ * depth 1 — a resume turn that is itself interrupted is NOT re-resumed
+ * (which would double-execute the resumed side effects and could loop
+ * forever); the caller downgrades to a passive deferred-report instead.
+ */
+export function isResumeSyntheticTurn(turn: Turn): boolean {
+  const p = turn.user_prompt_preview
+  return typeof p === 'string' && p.startsWith(RESUME_SYNTHETIC_PROMPT_PREFIX)
 }
 
 function threadIdNum(turn: Turn): number | undefined {
@@ -131,7 +246,8 @@ export function buildResumeInterruptedInbound(ctx: ResumeInboundContext): Inboun
       `plain language) so they're not left wondering — then carry on with the ` +
       `actual task. Do not ask whether to resume; just resume. If even after ` +
       `reading the recent messages you genuinely can't tell what the work was, ` +
-      `say so and ask.`,
+      `say so and ask.` +
+      renderInterruptedSubagentsBlock(ctx.subagents),
     meta,
   }
 }
@@ -190,7 +306,129 @@ export function buildResumeWatchdogReportInbound(
       `after ${idle} of no progress, and roughly what it was doing. Then ask ` +
       `whether they want you to retry it or take a different angle. Report ` +
       `only the honest cause — no observable progress for that long — don't ` +
-      `speculate about a deeper root cause you can't see.`,
+      `speculate about a deeper root cause you can't see.` +
+      // Deferred (non-assertive) form: this is the ask-first path — the killed
+      // workers are listed as facts, but re-dispatch waits on the user's call.
+      renderInterruptedSubagentsBlock(ctx.subagents, { assertive: false }),
+    meta,
+  }
+}
+
+/** Why an auto-resume was declined in favour of a passive notice. */
+export type ResumeDeferReason = 'clean-restart-suppressed' | 'loop-guard'
+
+/**
+ * The inbound the boot-resume block should mint for an interrupted turn:
+ *   - 'resume'           → active resume (buildResumeInterruptedInbound)
+ *   - 'report'           → watchdog report (buildResumeWatchdogReportInbound)
+ *   - 'defer-loop'       → loop-guard passive notice (deferred-report)
+ *   - 'defer-suppressed' → boot_resume:never passive notice (deferred-report)
+ *   - null               → nothing (turn finished cleanly)
+ */
+export type BootResumeKind = 'resume' | 'report' | 'defer-loop' | 'defer-suppressed' | null
+
+/**
+ * Pure boot-resume decision, extracted from the gateway so the precedence
+ * (esp. the bounded resume-chain loop-guard) is unit-testable without
+ * booting a gateway. Precedence, highest first:
+ *
+ *   1. loop-guard — the interrupted turn was ITSELF a synthetic resume/report
+ *      turn (`isResumeSyntheticTurn`). NEVER mint another resume for it: that
+ *      would replay already-partly-executed work and could chain
+ *      restart→resume→restart forever. The at-most-once `resumed_at` ledger
+ *      bounds each individual turn, but each resume spawns a NEW turn, so
+ *      without this the CHAIN is unbounded. Cap it at one auto-resume by
+ *      downgrading to a passive deferred-report ('defer-loop').
+ *   2. suppressed — `boot_resume: never` on a fresh clean restart. Downgrade
+ *      to a passive deferred-report ('defer-suppressed') — a notice, never
+ *      silence.
+ *   3. otherwise — the normal age/ended_via policy (`selectResumeBuilder`).
+ */
+export function decideBootResumeKind(args: {
+  pending: Turn
+  suppressed: boolean
+  ageMs: number
+  maxAgeMs: number
+}): BootResumeKind {
+  if (isResumeSyntheticTurn(args.pending)) return 'defer-loop'
+  if (args.suppressed) return 'defer-suppressed'
+  return selectResumeBuilder(args.pending.ended_via, {
+    ageMs: args.ageMs,
+    maxAgeMs: args.maxAgeMs,
+  })
+}
+
+/**
+ * Build the `resume_deferred` inbound — a passive notice delivered when the
+ * framework declines to AUTO-resume interrupted work but must NOT stay
+ * silent (silence when work was in flight is never acceptable). Two reasons:
+ *
+ *   - 'clean-restart-suppressed' — `session_continuity.boot_resume: never`
+ *     is set and the prior shutdown was a fresh, deliberate restart. Per
+ *     that opt-in posture we don't replay the work unprompted, but we still
+ *     tell the user what was in flight so they can ask us to continue.
+ *
+ *   - 'loop-guard' — the interrupted turn was ITSELF a synthetic resume/
+ *     report turn (see `isResumeSyntheticTurn`). Auto-resuming a resume that
+ *     was interrupted again risks an unbounded restart→resume→restart chain
+ *     and double-executed side effects, so we cap the chain: report instead
+ *     of resuming, and let the user decide whether to keep going.
+ *
+ * Like the watchdog report, this is a REPORT (source `resume_deferred`), not
+ * a resume: the agent must not silently pick the work back up. The text
+ * starts with RESUME_SYNTHETIC_PROMPT_PREFIX so a further restart during
+ * THIS turn is itself detected as a synthetic turn and stays capped.
+ */
+export function buildResumeDeferredReportInbound(
+  ctx: ResumeInboundContext & { reason: ResumeDeferReason },
+): InboundMessage {
+  const ts = ctx.nowMs ?? Date.now()
+  const elapsed = humanizeElapsed(ts - ctx.turn.started_at)
+  const threadId = threadIdNum(ctx.turn)
+  const meta: Record<string, string> = {
+    source: 'resume_deferred',
+    // Origin chat/topic as channel attributes so the report turn gets a
+    // currentTurn (progress card + silence-poke) and the notice lands in the
+    // topic the work lived in. Same rationale as the other builders.
+    chat_id: ctx.turn.chat_id,
+    ...(threadId != null ? { message_thread_id: String(threadId) } : {}),
+    resume_turn_key: ctx.turn.turn_key,
+    interrupted_via: ctx.turn.ended_via ?? 'restart',
+    defer_reason: ctx.reason,
+    started_at: String(ctx.turn.started_at),
+  }
+  if (ctx.turn.user_prompt_preview) meta.original_prompt = ctx.turn.user_prompt_preview
+  const cause =
+    ctx.reason === 'loop-guard'
+      ? `Your previous turn was ALREADY a resume of earlier interrupted work, ` +
+        `and it was interrupted again by another restart ${elapsed} ago. To ` +
+        `avoid an endless restart→resume loop (and re-running work that may ` +
+        `have already partly executed), the framework has stopped ` +
+        `auto-resuming this chain.`
+      : `Your previous turn was interrupted ${elapsed} ago by a deliberate ` +
+        `restart, before it finished. This agent is configured NOT to ` +
+        `auto-resume work across deliberate restarts (boot_resume: never), so ` +
+        `it was not replayed automatically.`
+  return {
+    type: 'inbound',
+    chatId: ctx.turn.chat_id,
+    ...(threadId != null ? { threadId } : {}),
+    messageId: ts,
+    user: 'switchroom',
+    userId: 0,
+    ts,
+    text:
+      `${RESUME_SYNTHETIC_PROMPT_PREFIX} ${cause}` +
+      promptClause(ctx.turn) +
+      ` Do NOT silently resume it. Instead, briefly tell the user what was in ` +
+      `flight (call get_recent_messages for this chat if you need the full ` +
+      `original request — the quoted preview is only the first ~200 ` +
+      `characters), then ask whether they want you to pick it back up or drop ` +
+      `it. If you genuinely can't tell what the work was, say so and ask.` +
+      // Deferred (non-assertive) form, same as the watchdog path: this is an
+      // ask-first inbound — killed workers are named as facts, but
+      // re-dispatch waits on the user's call.
+      renderInterruptedSubagentsBlock(ctx.subagents, { assertive: false }),
     meta,
   }
 }

package/telegram-plugin/gateway/session-model-source.ts

@@ -0,0 +1,73 @@
+/**
+ * Freshness-aware source of truth for the /status session model.
+ *
+ * Two independent signals report what model the live session is running:
+ *
+ *   - the TRANSCRIPT: `message.model` on each assistant line (session-tail's
+ *     `model` event) — ground truth for the model that served the LAST API
+ *     call, but only advances when a new assistant line lands;
+ *   - the OVERRIDE: the in-memory `/model` switch record (#2982) — set the
+ *     moment a switch is positively confirmed, ahead of any assistant line.
+ *
+ * Neither is unconditionally right. Preferring the transcript regresses the
+ * idle-after-switch window (#2982's core fix): a native `/model` inject while
+ * idle sets the override to the NEW model, but the transcript still holds the
+ * OLD one until the next assistant line — /status would lie. Preferring the
+ * override goes stale the other way (a relaunch carrier that never applied).
+ *
+ * The invariant is "prefer the NEWER observation": every write from either
+ * source is stamped with a shared monotonic sequence, and `resolve()` returns
+ * whichever was observed last. A fresh assistant line always reclaims the
+ * transcript as the source; a confirmed switch always beats an older
+ * transcript line. Pinned by tests/session-model-source.test.ts.
+ */
+
+export interface SessionModelResolution {
+  /** The raw value from the winning source. Transcript entries are resolved
+   *  model ids (`claude-opus-4-8`); override entries may be friendly labels
+   *  ("Opus 4.8") or sr-* ids depending on the /model path that set them. */
+  model: string
+  source: 'transcript' | 'override'
+}
+
+export interface SessionModelSource {
+  /** Record a transcript observation (an assistant line's `message.model`,
+   *  already sentinel-filtered by the session-tail projection). */
+  noteTranscriptModel(model: string): void
+  /** Record an override set (a positively-confirmed /model switch), or clear
+   *  it with null. Setting stamps a fresh sequence, so the override wins over
+   *  every EARLIER transcript observation until a new assistant line lands. */
+  setOverride(model: string | null): void
+  /** Current override value (the #2982 in-memory record), independent of
+   *  freshness — for callers that need the override itself (e.g. the model
+   *  menu's "session" marker), not the /status resolution. */
+  getOverride(): string | null
+  /** The freshest observation across both sources, or null when neither has
+   *  reported yet. */
+  resolve(): SessionModelResolution | null
+}
+
+export function createSessionModelSource(): SessionModelSource {
+  let seq = 0
+  let transcript: { model: string; seq: number } | null = null
+  let override: { model: string; seq: number } | null = null
+  return {
+    noteTranscriptModel(model: string): void {
+      transcript = { model, seq: ++seq }
+    },
+    setOverride(model: string | null): void {
+      override = model == null ? null : { model, seq: ++seq }
+    },
+    getOverride(): string | null {
+      return override?.model ?? null
+    },
+    resolve(): SessionModelResolution | null {
+      if (transcript == null && override == null) return null
+      if (override == null) return { model: transcript!.model, source: 'transcript' }
+      if (transcript == null || transcript.seq < override.seq) {
+        return { model: override.model, source: 'override' }
+      }
+      return { model: transcript.model, source: 'transcript' }
+    },
+  }
+}

package/telegram-plugin/gateway/unhandled-rejection-policy.ts

@@ -126,7 +126,27 @@ export function classifyRejection(
     // handler shut the process down. reconcileStatusPin now absorbs its own
     // errors (primary fix); this entry is defense-in-depth so ANY leaked
     // pin-rights 400 from any path is log-only, not fatal.
-    desc.includes('not enough rights')
+    desc.includes('not enough rights') ||
+    // 'group chat was upgraded to a supergroup chat' fires when a send
+    // targets a basic-group chat_id that Telegram has since migrated to
+    // a supergroup (new id format -100xxxxxxxxxx). Telegram sometimes
+    // surfaces the replacement id via `error.parameters.migrate_to_chat_id`
+    // but not reliably for every send method, so this handler can't always
+    // auto-repair the stale id — it can only make the failure non-fatal.
+    // This crashed marko's gateway on 2026-07-09 (and recurred from the
+    // same stale-id root cause on 2026-06-07 and 2026-06-09): a send to an
+    // old pre-migration group id crashed the WHOLE gateway process for
+    // every agent/chat, not just the one stale chat. A single unmigrated
+    // chat_id in cached state must never be fatal — log it so the stale id
+    // can be tracked down and fixed, but keep serving every other chat.
+    desc.includes('group chat was upgraded to a supergroup chat') ||
+    // Broader class: any 400 whose description signals the target
+    // chat_id itself is no longer valid (migrated, deactivated, or
+    // otherwise unresolvable). These are all "this one destination is
+    // broken", never "the gateway is broken" — same log-only posture as
+    // 'chat not found' above.
+    desc.includes('chat_id is empty') ||
+    desc.includes('group chat was deactivated')
   ) {
     return 'log_only'
   }

package/telegram-plugin/gateway/worker-feed-dispatch.ts

@@ -25,6 +25,15 @@ export interface WorkerFeedDispatch {
    * result returns to its dispatching worker as the Task tool result).
    */
   isNested: boolean
+  /**
+   * Dispatch-time / last-persisted model for the worker, from the registry
+   * row's `model` column (seeded by the pretool hook from `tool_input.model`,
+   * later updated by the watcher from the worker's transcript). The FIRST-PAINT
+   * fallback the worker card renders before the live watcher entry has observed
+   * a transcript model. Null when the row is missing or never carried a model —
+   * the card then omits the model rather than guessing from config.
+   */
+  feedModel: string | null
 }
 
 /**
@@ -43,14 +52,28 @@ export interface WorkerFeedDispatch {
  * decision again: a regression here silently reverts the feed header to
  * "· sub-agent".
  */
+/**
+ * `entryBackground` (fix #1(+#2)): the in-memory watcher entry's own cached
+ * `background` flag (`WorkerEntry.background`), passed by the gateway as a
+ * graceful-degradation fallback for when the registry row (`sub`) is
+ * missing — most often because `jsonl_agent_id` never linked (unreadable
+ * meta.json, or an ambiguous fuzzy backfill — see fix #3). Without this, a
+ * missing row hard-defaults `isBackground` to `false`, silently dropping a
+ * completed background worker's handback (the gateway's `onFinish` treats
+ * `false` as "nothing to deliver — it returns inline"). Ignored entirely
+ * when `sub` resolves — the registry row is always the authoritative
+ * source once it links.
+ */
 export function resolveWorkerFeedDispatch(
   sub: Subagent | null,
   watcherDescription: string,
+  entryBackground?: boolean,
 ): WorkerFeedDispatch {
   return {
-    isBackground: sub?.background ?? false,
+    isBackground: sub?.background ?? entryBackground ?? false,
     feedDescription: (sub?.description ?? '') || watcherDescription,
     hasRow: sub != null,
     isNested: sub?.parent_agent_id != null,
+    feedModel: sub?.model ?? null,
   }
 }