switchroom 0.13.20 → 0.13.22

package/telegram-plugin/tests/inbound-delivery-gate.test.ts

@@ -41,13 +41,86 @@ describe('decideInboundDelivery', () => {
     ).toBe('deliver')
   })
 
-  it('is total: the ONLY deferral path is mid-turn AND not steering', () => {
+  it('is total: the ONLY deferral path is mid-turn AND not steering AND not interrupt', () => {
     for (const turnInFlight of [true, false]) {
       for (const isSteering of [true, false]) {
-        const decision = decideInboundDelivery({ turnInFlight, isSteering })
-        const expectBuffer = turnInFlight && !isSteering
-        expect(decision).toBe(expectBuffer ? 'buffer-until-idle' : 'deliver')
+        for (const isInterrupt of [true, false]) {
+          const decision = decideInboundDelivery({ turnInFlight, isSteering, isInterrupt })
+          const expectBuffer = turnInFlight && !isSteering && !isInterrupt
+          expect(decision).toBe(expectBuffer ? 'buffer-until-idle' : 'deliver')
+        }
       }
     }
   })
+
+  // ─── Interrupt-marker carve-out (2026-05-24 fix for the stranded-body bug) ──
+  // Live UAT trace: user fires `! actually do X` mid-turn. SIGINT delivered
+  // to claude via tmux send-keys. The killed turn does NOT emit
+  // turn_complete in many cases (mid-tool-call kill, in-flight subagent),
+  // so the post-`!` body sits in pendingInboundBuffer forever — the
+  // turn-complete drain trigger never fires. The user never gets a reply
+  // to their replacement instruction.
+  //
+  // The carve-out is a peer of isSteering: an interrupt body is by
+  // definition an intentional mid-turn delivery — the user explicitly
+  // asked for "stop and do this instead".
+  describe('interrupt-marker carve-out', () => {
+    it('delivers a `!`-interrupt body mid-turn (does NOT buffer)', () => {
+      // The headline regression fix. Without the carve-out the killed turn
+      // strands the body indefinitely.
+      expect(
+        decideInboundDelivery({
+          turnInFlight: true,
+          isSteering: false,
+          isInterrupt: true,
+        }),
+      ).toBe('deliver')
+    })
+
+    it('delivers a `!`-interrupt body even when claude is idle (no harm)', () => {
+      expect(
+        decideInboundDelivery({
+          turnInFlight: false,
+          isSteering: false,
+          isInterrupt: true,
+        }),
+      ).toBe('deliver')
+    })
+
+    it('isInterrupt is optional — omitting it preserves legacy behavior', () => {
+      // Backward-compat for callers that haven't been updated yet. Mirrors
+      // the optional-default pattern used in other gateway predicates this
+      // session (silent-reply-anchor wasOverPingSuppressed, recent-outbound-
+      // dedup turnKey).
+      expect(
+        decideInboundDelivery({ turnInFlight: true, isSteering: false }),
+      ).toBe('buffer-until-idle')
+      expect(
+        decideInboundDelivery({ turnInFlight: false, isSteering: false }),
+      ).toBe('deliver')
+    })
+
+    it('explicit isInterrupt:false is identical to omitting it', () => {
+      expect(
+        decideInboundDelivery({
+          turnInFlight: true,
+          isSteering: false,
+          isInterrupt: false,
+        }),
+      ).toBe('buffer-until-idle')
+    })
+
+    it('interrupt + steering combination delivers (both are exempt paths)', () => {
+      // Pathological prompt: `! /steer change tactics`. parseInterruptMarker
+      // strips the `!`, then steering parse sees `/steer`. Either flag
+      // alone delivers; both together still deliver. No regression.
+      expect(
+        decideInboundDelivery({
+          turnInFlight: true,
+          isSteering: true,
+          isInterrupt: true,
+        }),
+      ).toBe('deliver')
+    })
+  })
 })

package/telegram-plugin/tests/recent-outbound-dedup.test.ts

@@ -190,3 +190,75 @@ describe('OutboundDedupCache — multiple entries per chat', () => {
     expect(cache.check('chat', undefined, LONG_HTML, 6000)).not.toBeNull()
   })
 })
+
+// ─── turnKey carve-out (2026-05-23 cross-turn-swallow fix) ───────────────────
+// Without turnKey awareness, the 60s TTL eats the SECOND turn's reply when a
+// user asks similar questions back-to-back (forensic audit on midturn-silent
+// UAT). The carve-out: both sides non-null + distinct ⇒ treat as miss.
+// Within-turn (#546 retry race) protection unchanged: same turnKey on both
+// sides ⇒ legacy hit. Null on either side ⇒ legacy hit.
+
+const LONG_TEXT = 'long enough text to count as content for the dedup floor'
+
+describe('OutboundDedupCache — turnKey carve-out', () => {
+  it('cross-turn identical content with distinct non-null turnKeys MISSES', () => {
+    // The headline bug: dedup was eating user replies across turns.
+    const cache = new OutboundDedupCache()
+    cache.record('chat', undefined, LONG_TEXT, 1000, 'turn-A')
+    expect(
+      cache.check('chat', undefined, LONG_TEXT, 5000, 'turn-B'),
+    ).toBeNull()
+  })
+
+  it('within-turn duplicates (same turnKey) STILL HIT — preserves #546 protection', () => {
+    // Same-turn retry race the module was built for.
+    const cache = new OutboundDedupCache()
+    cache.record('chat', undefined, LONG_TEXT, 1000, 'turn-A')
+    expect(
+      cache.check('chat', undefined, LONG_TEXT, 10_000, 'turn-A'),
+    ).not.toBeNull()
+  })
+
+  it('record-null + check-non-null → legacy hit', () => {
+    // Boot-time / silent-marker callers pass null on record; later
+    // executeReply checks with a turnKey. Legacy match must persist
+    // for the #546 protection to cover these cross-context cases.
+    const cache = new OutboundDedupCache()
+    cache.record('chat', undefined, LONG_TEXT, 1000, null)
+    expect(
+      cache.check('chat', undefined, LONG_TEXT, 5000, 'turn-A'),
+    ).not.toBeNull()
+  })
+
+  it('record-non-null + check-null → legacy hit', () => {
+    // Symmetric direction: turn-flush records with turnKey, a later
+    // null-context probe (rare but possible) still matches.
+    const cache = new OutboundDedupCache()
+    cache.record('chat', undefined, LONG_TEXT, 1000, 'turn-A')
+    expect(
+      cache.check('chat', undefined, LONG_TEXT, 5000, null),
+    ).not.toBeNull()
+  })
+
+  it('cross-turn entry does NOT shadow a same-turn match later in the list', () => {
+    // Edge case the predicate must handle: when the scan hits a stale
+    // cross-turn entry whose hash matches, it must keep scanning past
+    // it to find a real same-turn match. (The carve-out is implemented
+    // as `continue`, not `return null`.)
+    const cache = new OutboundDedupCache()
+    cache.record('chat', undefined, LONG_TEXT, 1000, 'turn-A') // older, cross-turn
+    cache.record('chat', undefined, LONG_TEXT, 3000, 'turn-B') // newer, same turn as query
+    expect(
+      cache.check('chat', undefined, LONG_TEXT, 5000, 'turn-B'),
+    ).not.toBeNull()
+  })
+
+  it('legacy 4-arg API still compiles + matches (default turnKey=null)', () => {
+    // Backward-compat smoke test — older callers that haven't been
+    // updated to pass turnKey continue to behave as the original test
+    // suite pins.
+    const cache = new OutboundDedupCache()
+    cache.record('chat', undefined, LONG_TEXT, 1000)
+    expect(cache.check('chat', undefined, LONG_TEXT, 5000)).not.toBeNull()
+  })
+})

package/telegram-plugin/tests/subagent-watcher-enoent-deregister.test.ts

@@ -0,0 +1,152 @@
+/**
+ * Tests for the readSubTail ENOENT/EACCES deregister path.
+ *
+ * Production symptom: clerk agent's gateway-supervisor.log was growing
+ * at ~30 ENOENT lines/sec sustained (540k+ in 3 days) because the
+ * watcher's poll loop kept statx-ing JSONL files Claude Code had
+ * already reaped along with the parent session's `subagents/` dir.
+ * Same shape on klanker with EACCES (635 events) — likely a perm
+ * flip during cleanup.
+ *
+ * Fix shape: when readSubTail's statSync throws ENOENT or EACCES,
+ * log ONE line + invoke the onFileVanished callback so the watcher
+ * factory can call cleanupTerminalAgent and stop polling. Other
+ * errors (parse, malformed JSONL) keep the legacy per-poll log line.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import { readSubTail } from '../subagent-watcher.js'
+import type { WorkerEntry } from '../subagent-watcher.js'
+
+function fakeFsThrowingFromStat(code: 'ENOENT' | 'EACCES' | 'EOTHER') {
+  const err = new Error(`fake ${code}`) as NodeJS.ErrnoException
+  err.code = code
+  return {
+    existsSync: () => true,
+    readdirSync: () => [],
+    statSync: () => { throw err },
+    openSync: () => -1,
+    closeSync: () => {},
+    readSync: () => 0,
+    watch: () => ({ close: () => {} } as ReturnType<typeof require>),
+  } as unknown as Parameters<typeof readSubTail>[4]
+}
+
+function makeEntry(): WorkerEntry {
+  return {
+    agentId: 'a1234567890abcdef',
+    filePath: '/tmp/fake/agent-a1234567890abcdef.jsonl',
+    dispatchedAt: 0,
+    lastActivityAt: 0,
+    toolCount: 0,
+    state: 'running',
+    completionNotified: false,
+    stallNotified: false,
+    historical: false,
+    description: '',
+    lastSummaryLine: '',
+    lastResultText: '',
+  }
+}
+
+function makeTail() {
+  return {
+    cursor: 0,
+    pendingPartial: '',
+    hasEmittedStart: false,
+    watcher: null,
+  }
+}
+
+describe('readSubTail — ENOENT/EACCES deregister', () => {
+  it('fires onFileVanished and logs ONCE on ENOENT', () => {
+    const onFileVanished = vi.fn()
+    const log = vi.fn()
+    const entry = makeEntry()
+
+    readSubTail(
+      entry,
+      makeTail(),
+      0,
+      vi.fn(),
+      fakeFsThrowingFromStat('ENOENT'),
+      log,
+      null,
+      null,
+      undefined,
+      onFileVanished,
+    )
+
+    expect(onFileVanished).toHaveBeenCalledTimes(1)
+    expect(onFileVanished).toHaveBeenCalledWith('a1234567890abcdef', 'ENOENT')
+    expect(log).toHaveBeenCalledTimes(1)
+    expect(log.mock.calls[0][0]).toMatch(/JSONL vanished for a1234567890abcdef \(ENOENT\) — deregistering/)
+    expect(log.mock.calls[0][0]).not.toMatch(/read error/)
+  })
+
+  it('fires onFileVanished and logs ONCE on EACCES (klanker pattern)', () => {
+    const onFileVanished = vi.fn()
+    const log = vi.fn()
+
+    readSubTail(
+      makeEntry(),
+      makeTail(),
+      0,
+      vi.fn(),
+      fakeFsThrowingFromStat('EACCES'),
+      log,
+      null,
+      null,
+      undefined,
+      onFileVanished,
+    )
+
+    expect(onFileVanished).toHaveBeenCalledTimes(1)
+    expect(onFileVanished).toHaveBeenCalledWith('a1234567890abcdef', 'EACCES')
+    expect(log).toHaveBeenCalledTimes(1)
+    expect(log.mock.calls[0][0]).toMatch(/EACCES/)
+  })
+
+  it('still logs the legacy "read error" for unexpected error codes', () => {
+    // Regression guard: parse errors, EIO, EBUSY, etc. must still
+    // surface their detail. Only file-vanished codes are deregistered.
+    const onFileVanished = vi.fn()
+    const log = vi.fn()
+
+    readSubTail(
+      makeEntry(),
+      makeTail(),
+      0,
+      vi.fn(),
+      fakeFsThrowingFromStat('EOTHER'),
+      log,
+      null,
+      null,
+      undefined,
+      onFileVanished,
+    )
+
+    expect(onFileVanished).not.toHaveBeenCalled()
+    expect(log).toHaveBeenCalledTimes(1)
+    expect(log.mock.calls[0][0]).toMatch(/read error a1234567890abcdef/)
+  })
+
+  it('omitting onFileVanished is safe (optional callback)', () => {
+    const log = vi.fn()
+
+    expect(() =>
+      readSubTail(
+        makeEntry(),
+        makeTail(),
+        0,
+        vi.fn(),
+        fakeFsThrowingFromStat('ENOENT'),
+        log,
+        null,
+        null,
+        undefined,
+      ),
+    ).not.toThrow()
+    expect(log).toHaveBeenCalledTimes(1)
+  })
+})

package/telegram-plugin/uat/scenarios/jtbd-rapid-followup-dm.test.ts

@@ -1,38 +1,35 @@
 /**
  * JTBD scenario — rapid follow-ups (steering vs queued classification).
  *
- * Production behaviour codified in `_shared/telegram-style.md.hbs`:
+ * Live contract codified in `_shared/telegram-style.md.hbs` and
+ * `reference/steer-or-queue-mid-flight.md` (default-flip commits
+ * `4fff90bf` + `597a58af`, 2026-04-17):
  *
- * - A follow-up message arriving while a turn is in flight, with no
- *   `/queue` prefix, is `steering="true"` — treated as a course
- *   correction on the in-flight task.
- * - A follow-up prefixed with `/queue ` or `/q ` is `queued="true"` —
- *   a new independent task; the agent should NOT reference the
- *   in-flight work.
+ * - A mid-turn follow-up with NO prefix is `queued="true"` — new
+ *   independent task. The agent should NOT reference the in-flight
+ *   work.
+ * - A mid-turn follow-up prefixed with `/steer ` or `/s ` is
+ *   `steering="true"` — course-correction; the agent continues the
+ *   in-flight task incorporating the new guidance.
+ * - Legacy `/queue ` / `/q ` is a redundant alias for the default;
+ *   still works.
  *
- * This UAT fires both shapes and asserts the agent responds in a way
- * that reflects the classification — for steering it should mention
- * the correction; for queued it should treat the new task fresh.
- *
- * We can't assert directly on the internal channel meta (`steering`,
- * `queued`) from the driver side without inspecting the gateway log
- * — but the conversational pacing prompt instructs the agent to
- * "self-narrate the classification" with a small italic line at the
- * top of its reply. So we can pattern-match on that.
+ * This UAT fires both shapes and asserts the agent narrates the
+ * classification correctly. The prior version of this scenario
+ * (2026-05-13 / PR #1132) tested the pre-flip contract with
+ * too-loose assertions (`/md5/i` regex passes on the queued path
+ * by coincidence — the model answers "use md5" fresh and the reply
+ * contains "md5"). After unskipping with the corrected contract,
+ * the assertions check for the italic classification line the
+ * prompt instructs the agent to emit.
  */
 
 import { describe, it, expect } from "vitest";
 import { spinUp } from "../harness.js";
 
-// Skipped in CI: both cases failed in #1132 overnight (steering didn't
-// surface "md5"; queued didn't produce the expected fresh-task reply).
-// May be real classification bugs, may be prompt fragility — neither
-// has been root-caused. Excluded from the buildkite gate so it doesn't
-// block every PR touching telegram-plugin/. Run locally via
-// `bun run test:uat` once classification has been investigated.
-describe.skip("uat: rapid follow-ups — steering vs queued", () => {
+describe("uat: rapid follow-ups — steering vs queued classification", () => {
   it(
-    "follow-up WITHOUT /queue → agent treats as steering",
+    "follow-up with /steer prefix → agent self-narrates as steering",
     async () => {
       const sc = await spinUp({ agent: "test-harness" });
       try {
@@ -43,26 +40,39 @@ describe.skip("uat: rapid follow-ups — steering vs queued", () => {
           + "Show the work step by step with a 2-second pause between.",
         );
         await new Promise((r) => setTimeout(r, 3_000));
-        // Steer: change the algorithm
-        await sc.sendDM("actually use md5 not sha256");
+        // Steer: change the algorithm using the explicit /steer prefix.
+        await sc.sendDM("/steer actually use md5 not sha256");
 
-        // The agent should reply mentioning md5 (the steered
-        // algorithm), AND ideally surface the italic classification
-        // line per the prompt.
-        const reply = await sc.expectMessage(/md5/i, {
-          from: "bot",
-          timeout: 120_000,
-        });
+        // The agent should reply mentioning md5 AND surface the italic
+        // classification line per the prompt
+        // ("_↪️ treating as steer on the prior task_" or similar).
+        // We match either explicit-steer narration OR the steer emoji
+        // (`↪️`) to allow for natural-language variation while still
+        // failing if no narration appears (the previous version of
+        // this UAT was too loose — bare `/md5/i` passed by coincidence
+        // on the queued path).
+        const reply = await sc.expectMessage(
+          (m) => {
+            const txt = m.text;
+            const mentionsMd5 = /\bmd5\b/i.test(txt);
+            const narratesSteer =
+              /↪️|\bsteer(ing)?\b|continuing the (prior|original|in-flight) task|amendment|course[- ]correct/i.test(
+                txt,
+              );
+            return mentionsMd5 && narratesSteer;
+          },
+          { from: "bot", timeout: 120_000 },
+        );
         expect(reply.text.toLowerCase()).toContain("md5");
       } finally {
         await sc.tearDown();
       }
     },
-    150_000,
+    180_000,
   );
 
   it(
-    "follow-up WITH /queue → agent treats as new task",
+    "follow-up with no prefix mid-turn → agent treats as queued (new task)",
     async () => {
       const sc = await spinUp({ agent: "test-harness" });
       try {
@@ -71,9 +81,10 @@ describe.skip("uat: rapid follow-ups — steering vs queued", () => {
           + "Use bash.",
         );
         await new Promise((r) => setTimeout(r, 3_000));
-        // Queued: completely independent task. The agent should NOT
-        // reference the counting task.
-        await sc.sendDM("/queue what is 2+2?");
+        // No prefix — the default-flipped contract says this is a
+        // QUEUED new task. The agent should NOT reference the
+        // counting work.
+        await sc.sendDM("what is 2+2?");
 
         // First reply should be from the counting task (still
         // in-flight). Then a second reply for the queued task.
@@ -81,16 +92,32 @@ describe.skip("uat: rapid follow-ups — steering vs queued", () => {
           from: "bot",
           timeout: 60_000,
         });
-        // Then we expect another reply (the queued task's answer).
-        // /queue is treated as a new task per the prompt — answer
-        // should be "4" or mention 2+2.
+
+        // Second reply: the queued task's answer. We want to see
+        // EITHER the italic queued-narration line OR a fresh "4"
+        // answer that doesn't reference the counting work.
         const secondReply = await sc.expectMessage(
-          (m) =>
-            m.messageId > firstReply.messageId
-            && /\b4\b|two\s+plus\s+two|2\s*\+\s*2/i.test(m.text),
+          (m) => {
+            if (m.messageId <= firstReply.messageId) return false;
+            const txt = m.text;
+            const answersTheQuestion =
+              /\b4\b|\bfour\b|two\s+plus\s+two|2\s*\+\s*2/i.test(txt);
+            const narratesQueued =
+              /📥|\bqueued\b|new\s+(?:independent\s+)?task|fresh\s+task/i.test(
+                txt,
+              );
+            // Pass if either: the explicit narration is present, OR the
+            // reply answers cleanly without referencing the counting
+            // task. The latter is the substantive behavioural check —
+            // the queued task is isolated from the in-flight context.
+            const isolatedFromCounting = !/\bcount(ing)?\b|\bsleep\b/i.test(
+              txt,
+            );
+            return answersTheQuestion && (narratesQueued || isolatedFromCounting);
+          },
           { from: "bot", timeout: 120_000 },
         );
-        expect(secondReply.text).toMatch(/4|two|2\s*\+\s*2/i);
+        expect(secondReply.text).toMatch(/4|four|2\s*\+\s*2/i);
       } finally {
         await sc.tearDown();
       }

package/vendor/hindsight-memory/scripts/recall.py

@@ -556,7 +556,15 @@ def main():
             max_tokens=config.get("recallMaxTokens", 1024),
             budget=config.get("recallBudget", "mid"),
             types=config.get("recallTypes"),
-            timeout=10,
+            # 8s in-script timeout leaves 4s headroom inside the 12s
+            # UserPromptSubmit hook ceiling (see hooks.json:20) for cache
+            # write + block formatting. Tightened from 10s in switchroom
+            # v0.13.22: the 2026-05-24 audit showed 17-26% of turns
+            # breaching the 12s hook timeout on heavy agents (finn /
+            # gymbro / klanker), which dropped the recall entirely; an
+            # earlier-hard-timeout failure returns cleanly with no
+            # memories instead of blowing past the hook ceiling.
+            timeout=8,
         )
         results = response.get("results", [])
     except Exception as e:
@@ -577,7 +585,15 @@ def main():
                 max_tokens=config.get("recallMaxTokens", 1024),
                 budget=config.get("recallBudget", "mid"),
                 types=config.get("recallTypes"),
-                timeout=10,
+                # 8s in-script timeout leaves 4s headroom inside the 12s
+                # UserPromptSubmit hook ceiling (see hooks.json:20) for cache
+                # write + block formatting. Tightened from 10s in switchroom
+                # v0.13.22: the 2026-05-24 audit showed 17-26% of turns
+                # breaching the 12s hook timeout on heavy agents (finn /
+                # gymbro / klanker), which dropped the recall entirely; an
+                # earlier-hard-timeout failure returns cleanly with no
+                # memories instead of blowing past the hook ceiling.
+                timeout=8,
             )
             extra_results = extra_response.get("results", [])
             if extra_results: