switchroom 0.14.47 → 0.14.48

package/dist/cli/switchroom.js

@@ -49462,8 +49462,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.47";
-var COMMIT_SHA = "fbd2e491";
+var VERSION = "0.14.48";
+var COMMIT_SHA = "a6517652";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.47",
+  "version": "0.14.48",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/telegram-plugin/dist/gateway/gateway.js

@@ -46927,7 +46927,7 @@ function escapeHtml7(s) {
 
 // gateway/pending-inbound-buffer.ts
 var DEFAULT_PENDING_INBOUND_CAP = 32;
-function redeliverBufferedInbound(buffer, agent, send, spool) {
+function redeliverBufferedInbound(buffer, agent, send, spool, onDelivered) {
   const pending = buffer.drain(agent);
   let redelivered = 0;
   let rebuffered = 0;
@@ -46942,6 +46942,7 @@ function redeliverBufferedInbound(buffer, agent, send, spool) {
       for (const o of originals)
         spool?.ack(o);
       redelivered += originals.length;
+      onDelivered?.(merged, originals);
     } else {
       for (const o of originals)
         buffer.push(agent, o);
@@ -47004,14 +47005,14 @@ function mergeRun(run2) {
     merged.attachment = mediaEntry.attachment;
   return merged;
 }
-function idleDrainTick(buffer, agent, isBridgeAlive, send, spool) {
+function idleDrainTick(buffer, agent, isBridgeAlive, send, spool, onDelivered) {
   if (!agent)
     return null;
   if (buffer.depth(agent) === 0)
     return null;
   if (!isBridgeAlive())
     return null;
-  return redeliverBufferedInbound(buffer, agent, send, spool);
+  return redeliverBufferedInbound(buffer, agent, send, spool, onDelivered);
 }
 function createPendingInboundBuffer(opts = {}) {
   const cap = opts.capPerAgent ?? DEFAULT_PENDING_INBOUND_CAP;
@@ -47618,7 +47619,7 @@ function formatEventDetail(event) {
 }
 
 // gateway/pending-inbound-buffer.ts
-function redeliverBufferedInbound2(buffer, agent, send, spool) {
+function redeliverBufferedInbound2(buffer, agent, send, spool, onDelivered) {
   const pending = buffer.drain(agent);
   let redelivered = 0;
   let rebuffered = 0;
@@ -47633,6 +47634,7 @@ function redeliverBufferedInbound2(buffer, agent, send, spool) {
       for (const o of originals)
         spool?.ack(o);
       redelivered += originals.length;
+      onDelivered?.(merged, originals);
     } else {
       for (const o of originals)
         buffer.push(agent, o);
@@ -47725,7 +47727,7 @@ function dispatchOne(effect, ctx) {
         }
         return ctx.ipcServer.sendToAgent(ctx.selfAgent, msg);
       };
-      const result = redeliverBufferedInbound2(ctx.pendingInboundBuffer, ctx.selfAgent, send, ctx.inboundSpool ?? undefined);
+      const result = redeliverBufferedInbound2(ctx.pendingInboundBuffer, ctx.selfAgent, send, ctx.inboundSpool ?? undefined, ctx.onUserInboundDelivered ? (merged) => ctx.onUserInboundDelivered(merged) : undefined);
       if (result.drained > 0) {
         log(`telegram gateway: dispatch drainBuffer agent=${ctx.selfAgent} ` + `drained=${result.drained} redelivered=${result.redelivered} ` + `rebuffered=${result.rebuffered}
 `);
@@ -52097,10 +52099,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.47";
-var COMMIT_SHA = "fbd2e491";
-var COMMIT_DATE = "2026-06-03T07:22:07Z";
-var LATEST_PR = 2119;
+var VERSION = "0.14.48";
+var COMMIT_SHA = "a6517652";
+var COMMIT_DATE = "2026-06-03T07:57:29Z";
+var LATEST_PR = 2120;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -52665,14 +52667,20 @@ function buildResumeWatchdogReportInbound(ctx) {
     meta
   };
 }
-function selectResumeBuilder(endedVia) {
+function selectResumeBuilder(endedVia, opts) {
+  let kind;
   if (endedVia === "timeout")
+    kind = "report";
+  else if (endedVia === "restart" || endedVia === "sigterm" || endedVia === "unknown")
+    kind = "resume";
+  else if (endedVia == null)
+    kind = "resume";
+  else
+    kind = null;
+  if (kind === "resume" && opts?.ageMs != null && opts?.maxAgeMs != null && opts.ageMs > opts.maxAgeMs) {
     return "report";
-  if (endedVia === "restart" || endedVia === "sigterm" || endedVia === "unknown")
-    return "resume";
-  if (endedVia == null)
-    return "resume";
-  return null;
+  }
+  return kind;
 }
 
 // registry/subagents-schema.ts
@@ -53123,7 +53131,14 @@ try {
   const pending2 = findLatestTurnIfInterrupted(turnsDb);
   const selfAgent = process.env.SWITCHROOM_AGENT_NAME ?? "";
   if (pending2 != null && selfAgent) {
-    const kind = selectResumeBuilder(pending2.ended_via);
+    const RESUME_MAX_AGE_MS = (() => {
+      const v = Number(process.env.SWITCHROOM_RESUME_MAX_AGE_MS);
+      return Number.isFinite(v) && v > 0 ? v : 10800000;
+    })();
+    const kind = selectResumeBuilder(pending2.ended_via, {
+      ageMs: Math.max(0, Date.now() - pending2.started_at),
+      maxAgeMs: RESUME_MAX_AGE_MS
+    });
     if (kind === "resume") {
       bootResumeInbound = { agent: selfAgent, msg: buildResumeInterruptedInbound({ turn: pending2 }) };
     } else if (kind === "report") {
@@ -53390,7 +53405,7 @@ function purgeReactionTracking(key, endingTurn) {
         if (d)
           markClaudeBusyForInbound(m);
         return d;
-      }, inboundSpool);
+      }, inboundSpool, trackRedeliveredInbound);
       if (fr.redelivered > 0) {
         process.stderr.write(`telegram gateway: turn-complete flushed ${fr.redelivered}/${fr.drained} held inbound for ${selfAgentForFlush}${fr.rebuffered > 0 ? ` (${fr.rebuffered} re-buffered)` : ""}
 `);
@@ -53420,7 +53435,7 @@ function releaseTurnBufferGate(key) {
         if (d)
           markClaudeBusyForInbound(m);
         return d;
-      }, inboundSpool);
+      }, inboundSpool, trackRedeliveredInbound);
       if (fr.redelivered > 0) {
         process.stderr.write(`telegram gateway: reply-released-gate flushed ${fr.redelivered}/${fr.drained} held inbound for ${selfAgentForFlush}${fr.rebuffered > 0 ? ` (${fr.rebuffered} re-buffered)` : ""}
 `);
@@ -54406,7 +54421,7 @@ startTimer({
       if (d)
         markClaudeBusyForInbound(m);
       return d;
-    }, inboundSpool);
+    }, inboundSpool, trackRedeliveredInbound);
     process.stderr.write(`telegram gateway: silence-poke framework-fallback ended wedged turn chat=${fbChatId} thread=${ctx.threadId ?? "-"} silence_ms=${ctx.silenceMs} currentTurn_nulled=${turnMatchesFallback} drained_buffered=${fbRedeliver.redelivered}/${fbRedeliver.drained}${fbRedeliver.rebuffered > 0 ? ` rebuffered=${fbRedeliver.rebuffered}` : ""}${fbExtraPurge.purged.length > 0 ? ` extra_keys_purged=${fbExtraPurge.purged.length}` : ""}
 `);
   }
@@ -54416,6 +54431,20 @@ var _deliveryMachineTick = setInterval(() => {
   shadowEmit({ kind: "tick", now: Date.now() });
 }, DELIVERY_MACHINE_TICK_MS);
 _deliveryMachineTick.unref?.();
+function trackRedeliveredInbound(merged) {
+  if (!DELIVERY_CONFIRM_ENABLED)
+    return;
+  if (!shouldTrackDelivery({
+    isSteering: false,
+    isInterrupt: false,
+    hasSource: merged.meta?.source != null,
+    effectiveText: merged.text
+  })) {
+    return;
+  }
+  const key = chatKey2(merged.chatId, merged.threadId != null ? Number(merged.threadId) : null);
+  trackDelivery(deliveryQueue, key, merged, Date.now(), merged.messageId != null ? String(merged.messageId) : null);
+}
 async function redeliverStrandedInbound(p) {
   const selfAgent = process.env.SWITCHROOM_AGENT_NAME ?? "";
   process.stderr.write(`telegram gateway: inbound strand (no enqueue ack) key=${p.key} \u2014 re-clearing composer + re-delivering
@@ -54522,7 +54551,8 @@ var ipcServer = createIpcServer({
           pendingInboundBuffer,
           inboundSpool: inboundSpool ?? null,
           pendingPermissionBuffer,
-          client: client3
+          client: client3,
+          onUserInboundDelivered: trackRedeliveredInbound
         });
       } else {
         const pending2 = pendingInboundBuffer.drain(client3.agentName);
@@ -54530,6 +54560,7 @@ var ipcServer = createIpcServer({
           try {
             client3.send(msg);
             inboundSpool?.ack(msg);
+            trackRedeliveredInbound(msg);
           } catch (err) {
             process.stderr.write(`telegram gateway: pending-inbound drain failed agent=${client3.agentName} source=${msg.meta?.source ?? "-"}: ${err.message}
 `);
@@ -55085,7 +55116,7 @@ if (!STATIC) {
       if (d)
         markClaudeBusyForInbound(m);
       return d;
-    }, inboundSpool);
+    }, inboundSpool, trackRedeliveredInbound);
     if (r != null && r.redelivered > 0) {
       process.stderr.write(`telegram gateway: idle-drain flushed ${r.redelivered}/${r.drained} buffered inbound for ${selfAgent}${r.rebuffered > 0 ? ` (${r.rebuffered} re-buffered)` : ""}
 `);

package/telegram-plugin/gateway/gateway.ts

@@ -1064,7 +1064,19 @@ try {
   const pending = findLatestTurnIfInterrupted(turnsDb)
   const selfAgent = process.env.SWITCHROOM_AGENT_NAME ?? ''
   if (pending != null && selfAgent) {
-    const kind = selectResumeBuilder(pending.ended_via)
+    // 3h staleness failsafe (operator spec, 2026-06-03): never AUTO-resume
+    // interrupted work older than RESUME_MAX_AGE_MS — selectResumeBuilder
+    // downgrades a stale 'resume' to the passive 'report' so the user is told
+    // ("I was working on X ~Nh ago") but nothing replays unprompted. Env
+    // override SWITCHROOM_RESUME_MAX_AGE_MS (ms); set very high to disable.
+    const RESUME_MAX_AGE_MS = (() => {
+      const v = Number(process.env.SWITCHROOM_RESUME_MAX_AGE_MS)
+      return Number.isFinite(v) && v > 0 ? v : 10_800_000 // 3h
+    })()
+    const kind = selectResumeBuilder(pending.ended_via, {
+      ageMs: Math.max(0, Date.now() - pending.started_at),
+      maxAgeMs: RESUME_MAX_AGE_MS,
+    })
     if (kind === 'resume') {
       bootResumeInbound = { agent: selfAgent, msg: buildResumeInterruptedInbound({ turn: pending }) }
     } else if (kind === 'report') {
@@ -1801,6 +1813,7 @@ function purgeReactionTracking(key: string, endingTurn?: CurrentTurn): void {
           return d
         },
         inboundSpool,
+        trackRedeliveredInbound,
       )
       if (fr.redelivered > 0) {
         process.stderr.write(
@@ -1896,6 +1909,7 @@ function releaseTurnBufferGate(key: string): void {
           return d
         },
         inboundSpool,
+        trackRedeliveredInbound,
       )
       if (fr.redelivered > 0) {
         process.stderr.write(
@@ -4134,6 +4148,7 @@ silencePoke.startTimer({
         return d
       },
       inboundSpool,
+      trackRedeliveredInbound,
     )
     process.stderr.write(
       `telegram gateway: silence-poke framework-fallback ended wedged turn ` +
@@ -4163,6 +4178,45 @@ const _deliveryMachineTick = setInterval(() => {
 }, DELIVERY_MACHINE_TICK_MS)
 _deliveryMachineTick.unref?.()
 
+// Enrol a buffer-redelivered inbound in the deliver-until-acked queue so the
+// existing sweep re-delivers it until claude's `enqueue` ack lands. Wired into
+// EVERY redelivery path (bridgeUp drain, silence-poke fallback, flap/reply-gate
+// flushes) — `send` returning true only means the bytes reached the bridge, NOT
+// that claude consumed them. Right after a restart (esp. a slow MCP boot) the
+// inject can hit a not-ready session and be silently dropped, and nothing
+// retried it: the clerk 2026-06-03 lost-message incident. Mirrors the
+// live-delivery tracking at the handleInbound site (chatKey + messageId), so
+// DMs and supergroup forum topics are handled identically. Only real user
+// inbounds are tracked — shouldTrackDelivery excludes steer/interrupt/
+// synthetic-source/empty, which never produce an `enqueue` and would otherwise
+// re-deliver forever.
+function trackRedeliveredInbound(merged: InboundMessage): void {
+  if (!DELIVERY_CONFIRM_ENABLED) return
+  if (
+    !shouldTrackDelivery({
+      isSteering: false,
+      isInterrupt: false,
+      // Synthetic inbounds (cron / vault / handback / resume) carry a source
+      // and are NOT tracked here — they enqueue under their own semantics, and
+      // (for the resume synthetics) tracking them safely first needs the
+      // resume builder to emit meta.message_id so the deliver-until-acked ack
+      // matches its enqueue. Tracked separately as a follow-up (see PR notes).
+      hasSource: merged.meta?.source != null,
+      effectiveText: merged.text,
+    })
+  ) {
+    return
+  }
+  const key = chatKey(merged.chatId, merged.threadId != null ? Number(merged.threadId) : null)
+  trackDelivery(
+    deliveryQueue,
+    key,
+    merged,
+    Date.now(),
+    merged.messageId != null ? String(merged.messageId) : null,
+  )
+}
+
 // Re-deliver stranded inbounds until claude acks (the marko drop-wedge).
 // Every few seconds, re-send any inbound that was handed to claude but never
 // acked by an `enqueue` — it stranded unsubmitted in the composer. Re-clear
@@ -4400,6 +4454,11 @@ const ipcServer: IpcServer = createIpcServer({
           inboundSpool: inboundSpool ?? null,
           pendingPermissionBuffer,
           client,
+          // Enrol each drained user inbound in the deliver-until-acked queue
+          // so the 5s sweep re-delivers until claude's `enqueue` ack lands —
+          // a socket-write into a still-booting session is NOT consumption
+          // (clerk lost-message incident, 2026-06-03).
+          onUserInboundDelivered: trackRedeliveredInbound,
         })
       } else {
         // Kill-switch fallback: imperative drain (parity with pre-cutover
@@ -4410,6 +4469,10 @@ const ipcServer: IpcServer = createIpcServer({
           try {
             client.send(msg)
             inboundSpool?.ack(msg)
+            // Same enrol as the cutover drain path: a socket-write success is
+            // not proof claude consumed it — enrol so the sweep re-delivers
+            // until `enqueue` (clerk lost-message incident, 2026-06-03).
+            trackRedeliveredInbound(msg)
           } catch (err) {
             process.stderr.write(
               `telegram gateway: pending-inbound drain failed agent=${client.agentName} ` +
@@ -5318,6 +5381,7 @@ if (!STATIC) {
         return d
       },
       inboundSpool,
+      trackRedeliveredInbound,
     )
     if (r != null && r.redelivered > 0) {
       process.stderr.write(

package/telegram-plugin/gateway/inbound-delivery-machine-dispatch.ts

@@ -45,6 +45,15 @@ export interface DispatchCtx {
   readonly client?: IpcClient
   /** Optional log sink — default stderr. Test hook. */
   readonly log?: (line: string) => void
+  /**
+   * Optional: enrol a drained+redelivered inbound in the deliver-until-acked
+   * queue. The bridgeUp drain's socket-write "success" is NOT proof claude
+   * consumed the message — right after a restart (esp. with a slow MCP boot)
+   * the inject can hit a not-ready session and be dropped. Wiring this makes
+   * the existing 5s sweep re-deliver until claude's `enqueue` ack lands.
+   * (clerk lost-message incident, 2026-06-03.)
+   */
+  readonly onUserInboundDelivered?: (merged: InboundMessage) => void
 }
 
 const enabled = process.env.SWITCHROOM_DELIVERY_MACHINE_CUTOVER !== '0'
@@ -103,6 +112,9 @@ function dispatchOne(effect: Effect, ctx: DispatchCtx): void {
         ctx.selfAgent,
         send,
         ctx.inboundSpool ?? undefined,
+        ctx.onUserInboundDelivered
+          ? (merged) => ctx.onUserInboundDelivered!(merged)
+          : undefined,
       )
       if (result.drained > 0) {
         log(

package/telegram-plugin/gateway/pending-inbound-buffer.ts

@@ -87,6 +87,14 @@ export function redeliverBufferedInbound(
   agent: string,
   send: (msg: InboundMessage) => boolean,
   spool?: InboundSpool,
+  // Called once per merged group on CONFIRMED delivery (after spool.ack).
+  // The caller uses it to enrol the redelivered inbound in the
+  // deliver-until-acked queue (`trackDelivery`) so it is re-sent until
+  // claude's `enqueue` ack lands — closing the restart boot-race where a
+  // socket-write "succeeds" into a not-ready session and the message is
+  // silently dropped (clerk 2026-06-03). `send` returning true only means
+  // the bytes reached the bridge, NOT that claude consumed them.
+  onDelivered?: (merged: InboundMessage, originals: InboundMessage[]) => void,
 ): { drained: number; redelivered: number; rebuffered: number } {
   const pending = buffer.drain(agent)
   let redelivered = 0
@@ -110,6 +118,10 @@ export function redeliverBufferedInbound(
       // originals are, so we ack by original identity.
       for (const o of originals) spool?.ack(o)
       redelivered += originals.length
+      // Enrol in the deliver-until-acked queue (caller's hook). A bare
+      // socket-write success is NOT proof claude consumed it; the queue's
+      // sweep re-delivers until the `enqueue` ack lands.
+      onDelivered?.(merged, originals)
     } else {
       // Re-buffer the originals (not the merged synthetic) so the spool
       // identity is preserved and the next drain re-merges them losslessly.
@@ -258,11 +270,15 @@ export function idleDrainTick(
   isBridgeAlive: () => boolean,
   send: (msg: InboundMessage) => boolean,
   spool?: InboundSpool,
+  // Forwarded to redeliverBufferedInbound so the post-flap-settle drain also
+  // enrols redelivered inbounds in the deliver-until-acked queue (parity with
+  // the bridgeUp drain — clerk lost-message incident, 2026-06-03).
+  onDelivered?: (merged: InboundMessage, originals: InboundMessage[]) => void,
 ): { drained: number; redelivered: number; rebuffered: number } | null {
   if (!agent) return null
   if (buffer.depth(agent) === 0) return null
   if (!isBridgeAlive()) return null
-  return redeliverBufferedInbound(buffer, agent, send, spool)
+  return redeliverBufferedInbound(buffer, agent, send, spool, onDelivered)
 }
 
 export function createPendingInboundBuffer(

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

@@ -172,9 +172,25 @@ export function buildResumeWatchdogReportInbound(
  */
 export function selectResumeBuilder(
   endedVia: TurnEndedVia | null,
+  // 3h staleness failsafe (operator spec, 2026-06-03): when the interrupted
+  // turn is older than `maxAgeMs`, an AUTO-resume is downgraded to the passive
+  // `report` — silently re-injecting hours-old work could act on long-stale
+  // context (a tax figure, a "send it" the user has moved on from). Pass both
+  // to enable; omit (default) keeps the legacy blanket-resume behaviour.
+  opts?: { ageMs?: number; maxAgeMs?: number },
 ): 'resume' | 'report' | null {
-  if (endedVia === 'timeout') return 'report'
-  if (endedVia === 'restart' || endedVia === 'sigterm' || endedVia === 'unknown') return 'resume'
-  if (endedVia == null) return 'resume' // still-open at boot = killed mid-flight
-  return null
+  let kind: 'resume' | 'report' | null
+  if (endedVia === 'timeout') kind = 'report'
+  else if (endedVia === 'restart' || endedVia === 'sigterm' || endedVia === 'unknown') kind = 'resume'
+  else if (endedVia == null) kind = 'resume' // still-open at boot = killed mid-flight
+  else kind = null
+  if (
+    kind === 'resume' &&
+    opts?.ageMs != null &&
+    opts?.maxAgeMs != null &&
+    opts.ageMs > opts.maxAgeMs
+  ) {
+    return 'report' // too old to safely auto-resume — passive notice only
+  }
+  return kind
 }

package/telegram-plugin/tests/pending-inbound-buffer.test.ts

@@ -220,6 +220,33 @@ describe('redeliverBufferedInbound — wedge-clear self-heal (fleet-update incid
     expect(calls).toBe(0)
   })
 
+  // onDelivered: the deliver-until-acked enrol hook (clerk lost-message
+  // incident 2026-06-03). A socket-write "success" is not proof claude
+  // consumed it; the caller uses onDelivered to enrol the redelivered inbound
+  // in the deliver-until-acked queue so the sweep re-delivers until `enqueue`.
+  it('calls onDelivered for each CONFIRMED-delivered group (per merged identity)', () => {
+    const buf = createPendingInboundBuffer({ log: () => {} })
+    buf.push('klanker', inbound('user', 1))
+    buf.push('klanker', inbound('cron', 2)) // source-tagged → its own group
+    const delivered: number[] = []
+    const r = redeliverBufferedInbound(buf, 'klanker', () => true, undefined, (merged) => {
+      delivered.push(merged.messageId as number)
+    })
+    expect(r.redelivered).toBe(2)
+    expect(delivered).toEqual([1, 2]) // fired once per group, carrying the merged identity
+  })
+
+  it('does NOT call onDelivered for a group that failed to send (re-buffered, not enrolled)', () => {
+    const buf = createPendingInboundBuffer({ log: () => {} })
+    buf.push('klanker', inbound('user', 1))
+    const delivered: number[] = []
+    const r = redeliverBufferedInbound(buf, 'klanker', () => false, undefined, (m) =>
+      delivered.push(m.messageId as number),
+    )
+    expect(r.rebuffered).toBe(1)
+    expect(delivered).toEqual([]) // never enrolled — buffer/spool still own it
+  })
+
   it('only touches the named agent', () => {
     const buf = createPendingInboundBuffer({ log: () => {} })
     buf.push('klanker', inbound('user', 1))

package/telegram-plugin/tests/resume-inbound-builder.test.ts

@@ -179,4 +179,23 @@ describe('selectResumeBuilder', () => {
       expect(selectResumeBuilder(endedVia)).toBe(expected)
     })
   }
+
+  // 3h staleness failsafe (operator spec, 2026-06-03).
+  const MAX = 10_800_000 // 3h
+  it('downgrades a fresh resume to report when older than maxAgeMs (no auto-resume of stale work)', () => {
+    expect(selectResumeBuilder('restart', { ageMs: MAX + 1, maxAgeMs: MAX })).toBe('report')
+    expect(selectResumeBuilder(null, { ageMs: MAX + 60_000, maxAgeMs: MAX })).toBe('report')
+  })
+  it('keeps resume when within maxAgeMs', () => {
+    expect(selectResumeBuilder('restart', { ageMs: MAX - 1, maxAgeMs: MAX })).toBe('resume')
+    expect(selectResumeBuilder('sigterm', { ageMs: 1000, maxAgeMs: MAX })).toBe('resume')
+  })
+  it('age cap never UPGRADES — report/null stay as-is regardless of age', () => {
+    expect(selectResumeBuilder('timeout', { ageMs: MAX + 1, maxAgeMs: MAX })).toBe('report')
+    expect(selectResumeBuilder('stop', { ageMs: MAX + 1, maxAgeMs: MAX })).toBe(null)
+  })
+  it('legacy behaviour preserved when age/maxAge omitted (blanket resume)', () => {
+    expect(selectResumeBuilder('restart')).toBe('resume')
+    expect(selectResumeBuilder('restart', { ageMs: MAX + 1 })).toBe('resume') // needs BOTH to cap
+  })
 })