switchroom 0.19.37 → 0.19.38

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.19.37", COMMIT_SHA = "5d2f9a17";
+var VERSION = "0.19.38", COMMIT_SHA = "9ec88983";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -45994,13 +45994,15 @@ var init_install_cron = () => {};
 function inParts(memories) {
   return Math.round(memories * PARTS_PER_MEMORY);
 }
-var RING_MAX = 8, MAX_SAMPLE_AGE_MS, MIN_RETAIN_SAMPLES = 20, RETAIN_FAILURE_RATE = 0.1, PARTS_PER_MEMORY = 6, QUEUE_FLOOR_MEMORIES = 100, QUEUE_FLOOR, QUEUE_GROWTH_FRACTION = 0.1, QUEUE_GROWTH_MIN_ABS_MEMORIES = 20, QUEUE_GROWTH_MIN_ABS, BREACHES_TO_FIRE_LEVEL = 2, BREACHES_TO_FIRE_EDGE = 1, CLEARS_TO_RESOLVE = 2, RENOTIFY_MS, DEFAULT_METRICS_URL = "http://127.0.0.1:18888/metrics", DEFAULT_CONTAINER = "switchroom-hindsight", METRICS_MAX_BYTES, METRICS_TIMEOUT_MS = 1e4, RECALL_OWN_BANK_TIMEOUT_WARN = 0.05, RECALL_OWN_BANK_TIMEOUT_PAGE = 0.15, RECALL_ZERO_MEMORY_WARN = 0.25, RECALL_ZERO_MEMORY_PAGE = 0.4, RECALL_POOL_MEDIAN_WARN = 8, RECALL_POOL_MEDIAN_PAGE = 3, RECALL_SCORE_P50_WARN = 0.02, RECALL_SCORE_P50_PAGE = 0.01, CONSOLIDATION_AGE_WARN_S, CONSOLIDATION_AGE_PAGE_S, CONSOLIDATION_FAILURE_STREAK_WARN = 3, CONSOLIDATION_FAILURE_STREAK_PAGE = 10, CONSOLIDATION_STREAK_RECENCY_S, PENDING_CONSOLIDATION_FLOOR = 500, PENDING_CONSOLIDATION_GROWTH_FRACTION = 0.5, PENDING_CONSOLIDATION_GROWTH_WARN_ABS = 500, PENDING_CONSOLIDATION_GROWTH_PAGE_ABS = 5000, VECTOR_INDEX_SAMPLE_ROWS = 3, RECALL_MIN_SAMPLES = 30, LLM_FAILURE_RATE_WARN = 0.02, LLM_FAILURE_RATE_PAGE = 0.1, LLM_MIN_SAMPLES = 20;
+var RING_MAX = 8, MAX_SAMPLE_AGE_MS, MIN_RETAIN_SAMPLES = 20, RETAIN_FAILURE_RATE = 0.1, PARTS_PER_MEMORY = 6, QUEUE_FLOOR_MEMORIES = 100, QUEUE_FLOOR, QUEUE_GROWTH_FRACTION = 0.1, QUEUE_GROWTH_MIN_ABS_MEMORIES = 20, QUEUE_GROWTH_MIN_ABS, BREACHES_TO_FIRE_LEVEL = 2, BREACHES_TO_FIRE_EDGE = 1, CLEARS_TO_RESOLVE = 2, RENOTIFY_MS, DEFAULT_METRICS_URL = "http://127.0.0.1:18888/metrics", DEFAULT_CONTAINER = "switchroom-hindsight", METRICS_MAX_BYTES, METRICS_TIMEOUT_MS = 1e4, RECALL_OWN_BANK_TIMEOUT_WARN = 0.05, RECALL_OWN_BANK_TIMEOUT_PAGE = 0.15, RECALL_ZERO_MEMORY_WARN = 0.25, RECALL_ZERO_MEMORY_PAGE = 0.4, RECALL_POOL_MEDIAN_WARN = 8, RECALL_POOL_MEDIAN_PAGE = 3, RECALL_SCORE_P50_WARN = 0.02, RECALL_SCORE_P50_PAGE = 0.01, RECALL_WALL_MS, CONSOLIDATION_AGE_WARN_S, CONSOLIDATION_AGE_PAGE_S, CONSOLIDATION_FAILURE_STREAK_WARN = 3, CONSOLIDATION_FAILURE_STREAK_PAGE = 10, CONSOLIDATION_STREAK_RECENCY_S, PENDING_CONSOLIDATION_FLOOR = 500, PENDING_CONSOLIDATION_GROWTH_FRACTION = 0.5, PENDING_CONSOLIDATION_GROWTH_WARN_ABS = 500, PENDING_CONSOLIDATION_GROWTH_PAGE_ABS = 5000, VECTOR_INDEX_SAMPLE_ROWS = 3, RECALL_MIN_SAMPLES = 30, LLM_FAILURE_RATE_WARN = 0.02, LLM_FAILURE_RATE_PAGE = 0.1, LLM_MIN_SAMPLES = 20;
 var init_thresholds = __esm(() => {
+  init_hindsight_recall_tunables();
   MAX_SAMPLE_AGE_MS = 3 * 60 * 60000;
   QUEUE_FLOOR = inParts(QUEUE_FLOOR_MEMORIES);
   QUEUE_GROWTH_MIN_ABS = inParts(QUEUE_GROWTH_MIN_ABS_MEMORIES);
   RENOTIFY_MS = 6 * 60 * 60 * 1000;
   METRICS_MAX_BYTES = 16 * 1024 * 1024;
+  RECALL_WALL_MS = resolveHindsightRecallTunables(undefined).parallelDeadlineSeconds * 1000;
   CONSOLIDATION_AGE_WARN_S = 2 * 60 * 60;
   CONSOLIDATION_AGE_PAGE_S = 12 * 60 * 60;
   CONSOLIDATION_STREAK_RECENCY_S = 2 * 60 * 60;
@@ -105312,7 +105314,7 @@ function latencySuffix(r) {
     return "";
   const n = typeof r.elapsedConsidered === "number" ? r.elapsedConsidered : 0;
   return `
-  recall wall time p95 ${Math.round(p95)}ms over ${n} fire(s) (not thresholded \u2014 the 8000ms per-bank budget leaves no healthy band below it)`;
+  recall wall time p95 ${Math.round(p95)}ms over ${n} fire(s) (not thresholded \u2014 the ${RECALL_WALL_MS}ms recall deadline leaves no healthy band below it)`;
 }
 function evaluateRecallOwnBankTimeout(ring) {
   const signal = "recall-own-bank-timeout";
@@ -105911,14 +105913,25 @@ function runInstallCron(cronUser) {
 `);
   return 0;
 }
-async function notifyOperator(agentsDir, text, log) {
+var PREFERRED_RELAY_AGENT = "overlord";
+function orderRelayCandidates(candidates, preferred = PREFERRED_RELAY_AGENT) {
+  const first = candidates.filter((c) => c.agent === preferred);
+  const rest = candidates.filter((c) => c.agent !== preferred);
+  return [...first, ...rest];
+}
+function collectRelayCandidates(agentsDir) {
   const candidates = [];
+  for (const name of readdirSync45(agentsDir).sort()) {
+    const sock = resolve63(agentsDir, name, "telegram", "gateway.sock");
+    if (existsSync112(sock))
+      candidates.push({ agent: name, sock });
+  }
+  return orderRelayCandidates(candidates);
+}
+async function notifyOperator(agentsDir, text, log) {
+  let candidates = [];
   try {
-    for (const name of readdirSync45(agentsDir).sort()) {
-      const sock = resolve63(agentsDir, name, "telegram", "gateway.sock");
-      if (existsSync112(sock))
-        candidates.push({ agent: name, sock });
-    }
+    candidates = collectRelayCandidates(agentsDir);
   } catch (e) {
     log(`hindsight-watch: agents dir unreadable (${e.message})`);
   }

package/dist/host-control/main.js

@@ -21311,7 +21311,7 @@ function allocateAgentUid(name) {
 }
 
 // src/build-info.ts
-var VERSION = "0.19.37";
+var VERSION = "0.19.38";
 
 // src/setup/hindsight-recall-tunables.ts
 var RECALL_DEADLINE_HEADROOM_SECONDS = 2;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "switchroom",
   "//version": "NOT the release version — source of truth is the git tag, resolved by scripts/build.mjs:resolveVersion() (see CLAUDE.md > Standard release process). This field is stale by design and only the Layer-4 dev/non-tag fallback for build.mjs + src/cli/resolve-version.ts; do NOT bump it expecting a release to pick it up. npm-pack tarball naming needs a real version — do that as an UNCOMMITTED pack-time bump (see release step 6), never a committed one.",
-  "version": "0.19.37",
+  "version": "0.19.38",
   "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

@@ -53405,6 +53405,12 @@ function createHandbackPreturnSignal(deps) {
     entry.reapTimer = null;
     if (entry.consumed)
       return;
+    if (deps.isClaudeBusy?.() === true) {
+      log(`handback-preturn-signal: reap deferred key=${entry.statusKey} ` + `(claude busy \u2014 handback enqueued behind an in-flight turn, not orphaned)
+`);
+      entry.reapTimer = setTimer(() => reap(entry), adoptTimeoutMs);
+      return;
+    }
     entry.consumed = true;
     stopTypingUnlessTurnLive(entry, "orphan reap");
     if (entry.activityMessageId != null) {
@@ -99672,10 +99678,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.19.37";
-var COMMIT_SHA = "5d2f9a17";
-var COMMIT_DATE = "2026-07-30T08:57:38Z";
-var LATEST_PR = 4023;
+var VERSION2 = "0.19.38";
+var COMMIT_SHA = "9ec88983";
+var COMMIT_DATE = "2026-07-30T09:50:08Z";
+var LATEST_PR = 4031;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -104885,7 +104891,7 @@ async function runMidSessionCardReaper() {
       const { finalized, vanished, total } = await runActivityCardMidSessionReaper({
         path: ACTIVITY_CARD_STORE_PATH,
         fs: activityCardStoreFs,
-        isLive: (record2) => topicKeys.has(record2.turnKey),
+        isLive: (record2) => topicKeys.has(record2.turnKey) || handbackPreturnSignal.isPreTurnRecord(record2.turnKey) && isMachineInTurn(),
         ttlMs: MID_SESSION_CARD_REAPER_TTL_MS,
         now,
         finalizeCard: (record2) => {
@@ -107525,7 +107531,8 @@ var handbackPreturnSignal = createHandbackPreturnSignal({
     if (live == null || live.endedAt != null)
       return false;
     return statusKey(live.sessionChatId, live.sessionThreadId) === key;
-  }
+  },
+  isClaudeBusy: () => isMachineInTurn()
 });
 var memoryLegibilityStager = new MemoryLegibilityStager;
 function sendMemoryLegibilityLine(event, chatId, threadId) {

package/telegram-plugin/gateway/gateway.ts

@@ -8909,10 +8909,14 @@ async function runMidSessionCardReaper(): Promise<void> {
       const { finalized, vanished, total } = await runActivityCardMidSessionReaper({
         path: ACTIVITY_CARD_STORE_PATH,
         fs: activityCardStoreFs,
-        // A synthetic pre-turn record's key is never a live topic key, so it is
-        // correctly seen as ownerless here (the seam's own age-based self-reap is
-        // the fast path; this is the crash / long-lived backstop).
-        isLive: (record) => topicKeys.has(record.turnKey),
+        // A synthetic pre-turn key reads as ownerless here (self-reap is the fast
+        // path; this is the crash backstop). EXCEPTION: a pre-turn handback still
+        // enqueued behind an in-flight turn is NOT an orphan — keep it live while
+        // claude is busy, else this 15-min backstop re-posts the false nudge the
+        // self-reap gate removed. (Boot reaper stays ungated: boot is never mid-turn.)
+        isLive: (record) =>
+          topicKeys.has(record.turnKey) ||
+          (handbackPreturnSignal.isPreTurnRecord(record.turnKey) && isMachineInTurn()),
         ttlMs: MID_SESSION_CARD_REAPER_TTL_MS,
         now,
         finalizeCard: (record) => {
@@ -13827,6 +13831,10 @@ const handbackPreturnSignal = createHandbackPreturnSignal({
     // dark-indicator bug). Flag-ON is already per-key; the check is a no-op there.
     return statusKey(live.sessionChatId, live.sessionThreadId) === key
   },
+  // Queue-state gate for the orphan reap (see the signal's `isClaudeBusy` doc):
+  // while a turn is in flight the handback is enqueued behind it, not orphaned.
+  // False for both `bridge_alive_idle` and `bridge_dead` → genuine orphan reaps.
+  isClaudeBusy: () => isMachineInTurn(),
 })
 
 /**

package/telegram-plugin/gateway/handback-preturn-signal.ts

@@ -54,9 +54,23 @@
  *     On adoption the durable record is re-keyed from its synthetic pre-turn key
  *     to the real `statusKey` so that teardown matches.
  *
- *   • NEVER-ADOPTED ORPHAN REAP. A degenerate case (bridge death after release,
- *     no enqueue ever arrives) would leave a frozen card + a forever `typing…`
- *     loop. The pre-turn card is persisted as a COMPLETE `ActivityCardRecord`
+ *   • NEVER-ADOPTED ORPHAN REAP — GATED ON A GLOBAL-BUSY QUEUE CHECK. A
+ *     degenerate case (bridge death after release, no enqueue ever arrives)
+ *     would leave a frozen card + a forever `typing…` loop. But the reap must
+ *     fire ONLY for that genuine orphan, never for a handback that is correctly
+ *     enqueued and simply waiting behind a long in-flight turn: claude has ONE
+ *     bridge / ONE input queue, so a released handback mints its adopting turn
+ *     only when claude next goes idle. A flat age-based reap cannot tell the two
+ *     apart and (before this gate) posted a false "never started — needs a
+ *     nudge" card every time a parent turn out-ran the timeout (the 3-cards-in-
+ *     4-min incident). The reap therefore consults `isClaudeBusy()` — the
+ *     machine-level "a turn is in flight right now" signal — and DEFERS
+ *     (re-arms for another `adoptTimeoutMs`) while claude is busy, finalizing
+ *     only once claude is idle AND the handback still has not been adopted. That
+ *     idle-with-no-adoption state is the genuine bridge-death / dropped-inbound
+ *     degenerate case. Lengthening the flat timeout would merely move the false
+ *     positive; the queue-state gate removes it. The pre-turn card is persisted
+ *     as a COMPLETE `ActivityCardRecord`
  *     under a SYNTHETIC `turnKey` (`preturn:<statusKey>:<startedAt>`) — synthetic
  *     so a sibling REAL turn on the same topic key can neither upsert-clobber it
  *     nor keep it "live" (the mid-session reaper's `isLive` keys on live topic
@@ -171,6 +185,22 @@ export interface HandbackPreturnSignalDeps {
    *  canonical turn-end owns the stop. Optional; defaults to "no live turn"
    *  (the pre-#3544 behaviour). */
   hasLiveTurn?: (statusKey: string) => boolean
+  /** True IFF claude is CURRENTLY producing a turn (ANY topic — the machine has
+   *  ONE bridge / ONE input queue). Consulted by the orphan reap: a released
+   *  handback is delivered into that single queue and only mints its adopting
+   *  turn when claude next goes idle, so while claude is busy the handback is
+   *  NOT orphaned — it is correctly enqueued BEHIND the in-flight turn (a long
+   *  parent turn can run many minutes). Finalizing it as an orphan in that
+   *  window posts a false "never started — needs a nudge" card. The reap
+   *  therefore DEFERS (re-arms) while this is true and finalizes only once
+   *  claude is idle and the handback still has not been adopted — the genuine
+   *  bridge-death / dropped-inbound degenerate case the reap exists for.
+   *  Distinct from `hasLiveTurn`, which is PER-KEY and only governs the
+   *  typing-loop stop; this is the GLOBAL busy signal because the handback
+   *  queues behind whatever turn is running, regardless of topic. Optional;
+   *  defaults to "not busy" (immediate reap — the pre-fix behaviour), so the
+   *  genuine-orphan path is unchanged. */
+  isClaudeBusy?: () => boolean
   now?: () => number
   /** Debounce before painting the pre-turn card (kills sub-second flicker). */
   debounceMs?: number
@@ -349,6 +379,25 @@ export function createHandbackPreturnSignal(
   function reap(entry: PreTurnEntry): void {
     entry.reapTimer = null
     if (entry.consumed) return
+    // PRIMARY GATE (queue state, not a flat timeout): a released handback is
+    // delivered into claude's SINGLE input queue and mints its adopting turn
+    // only when claude next goes idle. If claude is STILL in a turn, this
+    // handback is not orphaned — it is correctly enqueued behind the in-flight
+    // turn (a long parent turn can run many minutes). Finalizing now would post
+    // a false "never started — needs a nudge" card (the 3-cards-in-4-min
+    // incident). Defer: re-arm and re-check. We finalize only once claude is
+    // idle AND the handback still has not been adopted (the genuine bridge-
+    // death / dropped-inbound case). This cannot loop forever on a healthy
+    // agent: claude processes its queue FIFO, so the handback is either adopted
+    // (cancelling the reap) or claude eventually goes idle (letting it fire).
+    if (deps.isClaudeBusy?.() === true) {
+      log(
+        `handback-preturn-signal: reap deferred key=${entry.statusKey} ` +
+          `(claude busy — handback enqueued behind an in-flight turn, not orphaned)\n`,
+      )
+      entry.reapTimer = setTimer(() => reap(entry), adoptTimeoutMs)
+      return
+    }
     entry.consumed = true
     // Stop the forever-running typing loop and finalize the frozen card.
     stopTypingUnlessTurnLive(entry, 'orphan reap')

package/telegram-plugin/tests/handback-preturn-signal.test.ts

@@ -300,6 +300,73 @@ describe('handback-preturn-signal — dead-air pre-turn emit→adopt→reap', ()
     expect(h.signal.pendingCount()).toBe(0) // map empty
   })
 
+  // ── queued-behind-a-long-turn is NOT an orphan (the 3-cards-in-4-min bug) ──
+  // A handback released while the parent is mid-turn on a long task is delivered
+  // into claude's single input queue and mints its adopting turn only when the
+  // parent turn ends. The flat 30 s reap could not tell "enqueued and waiting"
+  // from "bridge died, never enqueued" and finalized a false "handback never
+  // started — needs a nudge" card. With the queue-state gate (`isClaudeBusy`)
+  // the reap DEFERS while claude is busy and the late adoption finalizes the
+  // card honestly. This test FAILS on the pre-fix flat-30 s behaviour: without
+  // the gate the reap fires at 30 s, finalizes the orphan text, and consumes the
+  // entry so the later adoption returns null.
+  it('does NOT finalize a handback whose turn adopts late because the parent was busy', async () => {
+    let busy = false
+    const h = makeHarness({ isClaudeBusy: () => busy })
+    h.signal.noteHandbackRelease(handbackInbound({ chatId: 'chatBusy', messageId: 700 }))
+    await h.sched.advance(700) // debounce: card painted, reap armed
+    const resolvedId = await h.openCard.mock.results[0]!.value
+    expect(h.records.size).toBe(1)
+
+    // The parent turn is now in flight (a long Wave-2 assembly). The handback is
+    // enqueued behind it.
+    busy = true
+
+    // Two full reap intervals elapse — well beyond the flat 30 s. The reap must
+    // DEFER each time: no false orphan card, entry still live, typing still lit.
+    await h.sched.advance(30_000)
+    await h.sched.advance(30_000)
+    expect(h.finalizedIds).toEqual([]) // NEVER posted the "never started" nudge
+    expect(h.signal.pendingCount()).toBe(1) // still queued, not reaped
+    expect(h.typing.activeCount()).toBe(1) // indicator kept while queued
+
+    // The parent turn finally ends and the handback mints its own turn: it
+    // adopts the SAME card (an edit, not a second send / not an orphan finalize).
+    busy = false
+    const turnId = deriveTurnId('chatBusy', null, 700)!
+    const adoption = h.signal.tryAdopt(turnId)
+    expect(adoption).not.toBeNull()
+    expect(adoption!.activityMessageId).toBe(resolvedId)
+    expect(h.finalizedIds).toEqual([]) // adopted, never finalized as orphan
+    expect(h.openCard).toHaveBeenCalledTimes(1) // no double-send
+    expect(h.signal.pendingCount()).toBe(0)
+  })
+
+  // The deferred reap is not a leak: once claude goes idle and the handback has
+  // STILL not been adopted (genuine bridge-death / dropped inbound), the re-armed
+  // reap finalizes honestly — the degenerate case the reap exists for.
+  it('finalizes a genuine orphan once claude goes idle, even after deferring while busy', async () => {
+    let busy = true
+    const h = makeHarness({ isClaudeBusy: () => busy })
+    h.signal.noteHandbackRelease(handbackInbound({ chatId: 'chatIdleOrphan', messageId: 710 }))
+    await h.sched.advance(700)
+    const resolvedId = await h.openCard.mock.results[0]!.value
+
+    // Busy: the first reap defers.
+    await h.sched.advance(30_000)
+    expect(h.finalizedIds).toEqual([])
+    expect(h.signal.pendingCount()).toBe(1)
+
+    // Claude goes idle but NO adopting turn ever mints (the inbound was dropped).
+    // The re-armed reap now finalizes the genuine orphan.
+    busy = false
+    await h.sched.advance(30_000)
+    expect(h.finalizedIds).toEqual([resolvedId])
+    expect(h.typing.activeCount()).toBe(0)
+    expect(h.records.size).toBe(0)
+    expect(h.signal.pendingCount()).toBe(0)
+  })
+
   it('identity race: a user inbound on the same topic never mis-adopts the handback, no double-send', async () => {
     const h = makeHarness()
     h.signal.noteHandbackRelease(handbackInbound({ chatId: 'chatE', messageId: 200 }))