switchroom 0.13.19 → 0.13.21

package/telegram-plugin/tests/handoff-continuity.test.ts

@@ -219,7 +219,7 @@ describe("shouldShowHandoffLine", () => {
 describe("formatHandoffLine", () => {
   it("wraps the topic in italic HTML with the return emoji", () => {
     const line = formatHandoffLine("fixing the bug", "html");
-    expect(line).toBe("<i>↩️ Picked up where we left off — fixing the bug</i>\n\n");
+    expect(line).toBe("<i>↩️ Picked up where we left off, fixing the bug</i>\n\n");
   });
 
   it("escapes HTML-unsafe chars in the topic", () => {
@@ -238,7 +238,7 @@ describe("formatHandoffLine", () => {
 
   it("produces plain text for 'text' format", () => {
     const line = formatHandoffLine("simple", "text");
-    expect(line).toBe("↩️ Picked up where we left off — simple\n\n");
+    expect(line).toBe("↩️ Picked up where we left off, simple\n\n");
   });
 
   it("always ends with a blank-line separator", () => {
@@ -246,4 +246,17 @@ describe("formatHandoffLine", () => {
       expect(formatHandoffLine("t", fmt).endsWith("\n\n")).toBe(true);
     }
   });
+
+  // Regression guard: the handoff prefix was an em-dash bypass for the
+  // v0.13.20 voice scrubber (the framework prefix is concatenated AFTER
+  // scrubVoice runs in executeReply). Replacing the em-dash with a
+  // comma at the template source closes that leak. Pin it so a future
+  // operator who "fixes typography" doesn't re-introduce the dash.
+  it("does NOT contain an em-dash or en-dash in any format (voice-scrub guard)", () => {
+    for (const fmt of ["html", "markdownv2", "text"] as const) {
+      const line = formatHandoffLine("anything goes here", fmt);
+      expect(line).not.toContain("—");
+      expect(line).not.toContain("–");
+    }
+  });
 });

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/tests/text-voice-scrub.test.ts

@@ -0,0 +1,174 @@
+/**
+ * Unit suite for #1683 text-voice-scrub.
+ *
+ * The fleet sample on 2026-05-23 showed 73% of outbound replies
+ * shipped at least one em-dash despite the SOUL.md.hbs soft rule.
+ * These tests pin the deterministic transform that the framework
+ * enforces, including the code/inline/HTML/URL preservation that
+ * keeps the scrub from mangling legitimate non-prose contexts.
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import { scrubVoice } from '../text-voice-scrub.js'
+
+describe('scrubVoice — em / en dash replacement', () => {
+  beforeEach(() => {
+    delete process.env.SWITCHROOM_DISABLE_VOICE_SCRUB
+  })
+  afterEach(() => {
+    delete process.env.SWITCHROOM_DISABLE_VOICE_SCRUB
+  })
+
+  describe('mechanical rewrite of spaced dashes', () => {
+    it('replaces a spaced em-dash before lowercase with a comma', () => {
+      const r = scrubVoice('on it — checking the calendar')
+      expect(r.scrubbed).toBe('on it, checking the calendar')
+      expect(r.replaced).toBe(1)
+    })
+
+    it('replaces a spaced em-dash before an uppercase letter with a period', () => {
+      // The model often writes "Here's the result — Done." style.
+      const r = scrubVoice("Here's the result — Done.")
+      expect(r.scrubbed).toBe("Here's the result. Done.")
+      expect(r.replaced).toBe(1)
+    })
+
+    it('handles multiple em-dashes in one sentence', () => {
+      const r = scrubVoice('one — two — three — done')
+      expect(r.scrubbed).toBe('one, two, three, done')
+      expect(r.replaced).toBe(3)
+    })
+
+    it('treats en-dash (–) identically to em-dash', () => {
+      const r = scrubVoice('on it – checking the calendar')
+      expect(r.scrubbed).toBe('on it, checking the calendar')
+      expect(r.replaced).toBe(1)
+    })
+
+    it('replaces unspaced word-dash-word as a comma', () => {
+      // Less common but seen in tightly-typed prose.
+      const r = scrubVoice('flag—on or flag—off')
+      expect(r.scrubbed).toBe('flag, on or flag, off')
+      expect(r.replaced).toBe(2)
+    })
+
+    it('replaces end-of-line dashes with a period', () => {
+      const r = scrubVoice('thinking out loud —\nnext line here')
+      expect(r.scrubbed).toBe('thinking out loud.\nnext line here')
+      expect(r.replaced).toBe(1)
+    })
+
+    it('converts a leading-dash sentence-start to ASCII hyphen', () => {
+      // Quoted-style or list-bullet em-dash at message start; falls
+      // through to the catch-all rule.
+      const r = scrubVoice('— note: ship it')
+      expect(r.scrubbed).toBe('- note: ship it')
+      expect(r.replaced).toBe(1)
+    })
+  })
+
+  describe('protected regions are left alone', () => {
+    it('preserves dashes inside fenced code blocks', () => {
+      const input = 'here is code:\n```bash\nfoo --bar — baz\n```\nand prose — done'
+      const r = scrubVoice(input)
+      expect(r.scrubbed).toBe(
+        'here is code:\n```bash\nfoo --bar — baz\n```\nand prose, done',
+      )
+      expect(r.replaced).toBe(1)
+    })
+
+    it('preserves dashes inside inline code', () => {
+      const r = scrubVoice('the flag `--really — keep` matters — yes')
+      expect(r.scrubbed).toBe('the flag `--really — keep` matters, yes')
+      expect(r.replaced).toBe(1)
+    })
+
+    it('preserves dashes inside <code> HTML tags', () => {
+      const r = scrubVoice('see <code>x — y</code> and note — ok')
+      expect(r.scrubbed).toBe('see <code>x — y</code> and note, ok')
+      expect(r.replaced).toBe(1)
+    })
+
+    it('preserves dashes inside <pre> HTML tags', () => {
+      const r = scrubVoice('block:\n<pre>x — y\nz — w</pre>\nend — ok')
+      expect(r.scrubbed).toBe('block:\n<pre>x — y\nz — w</pre>\nend, ok')
+      expect(r.replaced).toBe(1)
+    })
+
+    it('preserves dashes inside URLs', () => {
+      const r = scrubVoice('see https://example.com/a—b for context — ok')
+      expect(r.scrubbed).toBe(
+        'see https://example.com/a—b for context, ok',
+      )
+      expect(r.replaced).toBe(1)
+    })
+
+    it('preserves a code block containing markdown that could otherwise match', () => {
+      // The placeholder restore must put the original raw fence back,
+      // not a transformed copy.
+      const fence =
+        '```\n# heading — title\nfunction f() {}\n```'
+      const r = scrubVoice(fence + '\ntrailing — yes')
+      expect(r.scrubbed).toBe(fence + '\ntrailing, yes')
+      expect(r.replaced).toBe(1)
+    })
+  })
+
+  describe('no-op cases', () => {
+    it('returns identity (same string, replaced=0) when input has no dashes', () => {
+      const input = 'no dashes anywhere, just commas and periods.'
+      const r = scrubVoice(input)
+      expect(r.scrubbed).toBe(input)
+      expect(r.replaced).toBe(0)
+    })
+
+    it('returns identity when input is empty', () => {
+      const r = scrubVoice('')
+      expect(r.scrubbed).toBe('')
+      expect(r.replaced).toBe(0)
+    })
+
+    it('kill switch (SWITCHROOM_DISABLE_VOICE_SCRUB=1) returns input unchanged', () => {
+      process.env.SWITCHROOM_DISABLE_VOICE_SCRUB = '1'
+      const r = scrubVoice('on it — checking')
+      expect(r.scrubbed).toBe('on it — checking')
+      expect(r.replaced).toBe(0)
+    })
+
+    it('kill switch accepts "true" as well as "1"', () => {
+      process.env.SWITCHROOM_DISABLE_VOICE_SCRUB = 'true'
+      const r = scrubVoice('on it — checking')
+      expect(r.scrubbed).toBe('on it — checking')
+      expect(r.replaced).toBe(0)
+    })
+  })
+
+  describe('realistic fleet samples', () => {
+    it('scrubs a multi-step status message', () => {
+      const input =
+        "I'll check the calendar — should take a few seconds. " +
+        'Result: empty for Saturday — nothing scheduled. Anything else?'
+      const r = scrubVoice(input)
+      expect(r.scrubbed).toBe(
+        "I'll check the calendar, should take a few seconds. " +
+        'Result: empty for Saturday, nothing scheduled. Anything else?',
+      )
+      expect(r.replaced).toBe(2)
+    })
+
+    it('mixed prose and code keeps the code untouched', () => {
+      const input =
+        'Running `git status --short` — looks clean. ' +
+        '```\nM file.ts — modified\n```\n' +
+        'Ready to commit — go?'
+      const r = scrubVoice(input)
+      expect(r.scrubbed).toBe(
+        'Running `git status --short`, looks clean. ' +
+        '```\nM file.ts — modified\n```\n' +
+        'Ready to commit, go?',
+      )
+      expect(r.replaced).toBe(2)
+    })
+  })
+})