switchroom 0.17.10 → 0.18.6

package/telegram-plugin/tests/liveness-tracker.test.ts

@@ -0,0 +1,228 @@
+/**
+ * liveness-tracker.test.ts — drives the REAL LivenessTracker (the testability
+ * seam of the orphaned-reply thinking-pause fix).
+ *
+ * Root cause being fixed: the orphaned-reply fuse (ORPHANED_REPLY_TIMEOUT_MS =
+ * 30 s) was reset ONLY by `tool_label` / `text` events. During a long model
+ * reasoning pause the gateway sees NO such events (thinking carries no text),
+ * so the fuse ran down and force-ended a genuinely-live turn mid-work.
+ *
+ * The fix stamps `lastStreamEventAt` on ANY genuine stream event; if a genuine
+ * event landed within `windowMs` (default 120 s) the turn is "recently
+ * streaming" and the fuse re-arms instead of firing. A genuine multi-minute
+ * hang (no events at all) still fires.
+ *
+ * These tests use the REAL class — no replica helpers.
+ *
+ * NOTE on onStreamEvent's signature: it is `(kind, durationMs, now)`. The
+ * tracker is time-only — it never reads text content (the "Prompt is too long"
+ * marker matters to the gateway's context-exhaustion detection, not to the
+ * tracker). Where the fix spec wrote `onStreamEvent('text','Prompt is too
+ * long',0)` we pass `undefined` as durationMs (it is not a turn_end).
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  LivenessTracker,
+  ORPHANED_REPLY_STREAM_WINDOW_MS,
+  ORPHANED_REPLY_TIMEOUT_MS,
+  ORPHANED_REPLY_MAX_REARMS,
+} from '../context-exhaustion.js'
+
+const W = ORPHANED_REPLY_STREAM_WINDOW_MS // 120_000
+const MAX = ORPHANED_REPLY_MAX_REARMS // 20
+const FUSE = ORPHANED_REPLY_TIMEOUT_MS // 30_000
+
+function expiry(
+  t: LivenessTracker,
+  now: number,
+  opts?: { working?: boolean; humanWaiting?: boolean },
+) {
+  return t.decideOnExpiry({
+    working: opts?.working ?? false,
+    humanWaiting: opts?.humanWaiting ?? false,
+    now,
+    windowMs: W,
+    maxRearms: MAX,
+  })
+}
+
+describe('LivenessTracker — pinned constants', () => {
+  it('window is 120 s and fuse tick is 30 s', () => {
+    expect(W).toBe(120_000)
+    expect(FUSE).toBe(30_000)
+    expect(MAX).toBe(20)
+  })
+})
+
+describe('T1 — thinking-pause survival', () => {
+  it('text→tool_use→tool_result then a 45s stream gap keeps re-arming (gap < window)', () => {
+    const t = new LivenessTracker(0)
+    t.onStreamEvent('text', undefined, 0)
+    t.onStreamEvent('tool_use', undefined, 1_000)
+    t.onStreamEvent('tool_result', undefined, 2_000)
+
+    // +30s past the last event (t=32s): recently streaming → re-arm.
+    const d1 = expiry(t, 32_000)
+    expect(d1).toEqual({ rearm: true, countsAgainstCap: true })
+    expect(t.orphanedReplyRearmCount).toBe(1)
+
+    // +45s past the last event (t=47s): still within the 120s window → re-arm.
+    const d2 = expiry(t, 47_000)
+    expect(d2).toEqual({ rearm: true, countsAgainstCap: true })
+    expect(t.orphanedReplyRearmCount).toBe(2)
+  })
+
+  it('the next genuine stream event ZEROES the rearm counter and re-stamps liveness', () => {
+    const t = new LivenessTracker(0)
+    t.onStreamEvent('tool_result', undefined, 2_000)
+    expiry(t, 32_000)
+    expiry(t, 47_000)
+    expect(t.orphanedReplyRearmCount).toBe(2)
+
+    t.onStreamEvent('tool_label', undefined, 48_000)
+    expect(t.orphanedReplyRearmCount).toBe(0)
+    expect(t.lastStreamEventAt).toBe(48_000)
+  })
+
+  it('a synthetic turn_end (durationMs === -1) does NOT stamp or reset (F4 boundary)', () => {
+    const t = new LivenessTracker(0)
+    t.onStreamEvent('tool_label', undefined, 48_000)
+    expiry(t, 60_000) // counter → 1
+    expect(t.orphanedReplyRearmCount).toBe(1)
+
+    t.onStreamEvent('turn_end', -1, 70_000)
+    expect(t.lastStreamEventAt).toBe(48_000) // unchanged — synthetic excluded
+    expect(t.orphanedReplyRearmCount).toBe(1) // not reset
+
+    // A REAL turn_end (durationMs >= 0) DOES stamp — harmless, the turn is
+    // ending anyway (spec #3).
+    t.onStreamEvent('turn_end', 0, 71_000)
+    expect(t.lastStreamEventAt).toBe(71_000)
+    expect(t.orphanedReplyRearmCount).toBe(0)
+  })
+})
+
+describe('T2 — production repro (48s tool_result, 78s expiry)', () => {
+  it('text@0, tool_use@1s, tool_result@48s → expiry@78s re-arms (78-48=30 < 120)', () => {
+    const t = new LivenessTracker(0)
+    t.onStreamEvent('text', undefined, 0)
+    t.onStreamEvent('tool_use', undefined, 1_000)
+    t.onStreamEvent('tool_result', undefined, 48_000)
+
+    const d = expiry(t, 78_000)
+    expect(d.rearm).toBe(true)
+    expect(t.orphanedReplyRearmCount).toBe(1)
+
+    // tool_label@80s zeroes the counter (progress observed).
+    t.onStreamEvent('tool_label', undefined, 80_000)
+    expect(t.orphanedReplyRearmCount).toBe(0)
+  })
+})
+
+describe('T3 — long active turn (A2: counter reset is load-bearing)', () => {
+  it('tool_label every 60s + expiry every 60s+30s NEVER fires across 15 min; counter never exceeds 1', () => {
+    const t = new LivenessTracker(0)
+    for (let k = 0; k < 15; k++) {
+      t.onStreamEvent('tool_label', undefined, k * 60_000) // progress → reset
+      const d = expiry(t, k * 60_000 + 30_000, { working: true })
+      expect(d.rearm).toBe(true) // never fires
+      expect(t.orphanedReplyRearmCount).toBeLessThanOrEqual(1)
+    }
+  })
+
+  it('WITHOUT the progress reset the SAME cadence hits cap=20 near t=600s (proves reset load-bearing)', () => {
+    const t = new LivenessTracker(0)
+    let firedAt = -1
+    for (let k = 1; k <= 25; k++) {
+      const now = k * 30_000
+      // working:true so it would re-arm indefinitely IF the counter didn't
+      // accumulate — but with no onStreamEvent reset it climbs to the cap.
+      const d = expiry(t, now, { working: true })
+      if (!d.rearm) {
+        firedAt = now
+        break
+      }
+    }
+    // 20th re-arm lands at t=600s; the 21st expiry (t=630s) fires at the cap.
+    expect(t.orphanedReplyRearmCount).toBe(MAX)
+    expect(firedAt).toBeGreaterThanOrEqual(600_000)
+  })
+})
+
+describe('T4 — genuine hang caught (no events at all)', () => {
+  it('tool_result@0 then silence: re-arms via recentlyStreaming @30/60/90s, FIRES @120s (window lapsed)', () => {
+    const t = new LivenessTracker(0)
+    t.onStreamEvent('tool_result', undefined, 0)
+
+    for (const now of [30_000, 60_000, 90_000]) {
+      const d = expiry(t, now) // working:false — kept alive only by recentlyStreaming
+      expect(d.rearm).toBe(true)
+    }
+
+    // t=120s: now - lastStreamEventAt = 120_000 >= window → not recently
+    // streaming, working false → fail-safe FIRE.
+    const d = expiry(t, 120_000)
+    expect(d).toEqual({ rearm: false, countsAgainstCap: false })
+  })
+})
+
+describe('T5 — context-exhaustion recovery COMPLETES (not suppressed forever)', () => {
+  it('a "Prompt is too long" text event stamps liveness; defensive-guard predicate is true@30s, false@>=120s', () => {
+    const t = new LivenessTracker(0)
+    // The marker is a genuine `text` event (content is not a tracker concern).
+    t.onStreamEvent('text', undefined, 0)
+
+    // Context exhaustion means no tool is in flight: working === false. The
+    // defensive-guard suppression predicate is `working || recentlyStreaming`.
+    const working = false
+
+    // @30s: recentlyStreaming true → synthetic turn_end is suppressed. This
+    // DOCUMENTS the accepted ~30s→~120s recovery-latency growth (F3).
+    expect(working || t.recentlyStreaming(30_000, W)).toBe(true)
+
+    // @120s: window lapsed → NOT suppressed → teardown COMPLETES.
+    expect(working || t.recentlyStreaming(120_000, W)).toBe(false)
+
+    // @150s: still not suppressed — recovery is delayed, never forever.
+    expect(working || t.recentlyStreaming(150_000, W)).toBe(false)
+  })
+})
+
+describe('T7 — cap semantics', () => {
+  it('interleaved expiry/genuine-event: count 1 → 0 → 1 → 2', () => {
+    const t = new LivenessTracker(0)
+
+    expect(expiry(t, 10_000).rearm).toBe(true)
+    expect(t.orphanedReplyRearmCount).toBe(1)
+
+    t.onStreamEvent('tool_label', undefined, 11_000) // genuine event resets
+    expect(t.orphanedReplyRearmCount).toBe(0)
+
+    expiry(t, 20_000)
+    expect(t.orphanedReplyRearmCount).toBe(1)
+
+    expiry(t, 30_000) // consecutive silence (last event 11_000, gap 19s < 120s)
+    expect(t.orphanedReplyRearmCount).toBe(2)
+  })
+
+  it('21 consecutive recently-streaming expiries (no reset): 21st fires at the cap', () => {
+    const t = new LivenessTracker(0)
+    let last: { rearm: boolean; countsAgainstCap: boolean } | undefined
+    for (let k = 1; k <= 21; k++) {
+      // now = k*1000 keeps the gap from the seed (0) under the 120s window,
+      // so recentlyStreaming stays true throughout — the ONLY bound is the cap.
+      last = expiry(t, k * 1_000)
+    }
+    expect(last).toEqual({ rearm: false, countsAgainstCap: true })
+    expect(t.orphanedReplyRearmCount).toBe(MAX)
+
+    // humanWaiting past the cap → uncapped re-arm.
+    const dHuman = expiry(t, 22_000, { humanWaiting: true })
+    expect(dHuman).toEqual({ rearm: true, countsAgainstCap: false })
+
+    // recentlyStreaming false + working false + humanWaiting false → fail-safe FIRE.
+    const dFire = expiry(t, 200_000)
+    expect(dFire).toEqual({ rearm: false, countsAgainstCap: false })
+  })
+})

package/telegram-plugin/tests/model-command.test.ts

@@ -38,6 +38,7 @@ function okResult(output: string): InjectResult {
 function makeDeps(overrides: Partial<ModelCommandDeps> = {}) {
   const calls: Array<{ agent: string; command: string }> = [];
   const restartCalls: string[] = [];
+  const relaunchCalls: Array<{ model: string; reason: string }> = [];
   const deps: ModelCommandDeps = {
     inject: async (agent, command) => {
       calls.push({ agent, command });
@@ -50,9 +51,10 @@ function makeDeps(overrides: Partial<ModelCommandDeps> = {}) {
     preBlock: (s) => `<pre>${s}</pre>`,
     getActiveSessionModel: () => null,
     scheduleRestart: async (reason) => { restartCalls.push(reason); },
+    scheduleModelRelaunch: async (model, reason) => { relaunchCalls.push({ model, reason }); },
     ...overrides,
   };
-  return { deps, calls, restartCalls };
+  return { deps, calls, restartCalls, relaunchCalls };
 }
 
 describe("parseModelCommand", () => {
@@ -111,8 +113,17 @@ describe("isValidModelArg", () => {
       expect(isValidModelArg(good), good).toBe(true);
     }
   });
+  it("accepts OpenRouter-style sr-vendor/model ids (embedded slash)", () => {
+    // `/` is a legal char in a model id — needed for OpenRouter-style
+    // `sr-vendor/model` routing. It is NOT a shell metachar inside the
+    // double-quoted `claude --model "$_EFFECTIVE_MODEL"` launch, so it is
+    // safe. Kept aligned with the shell shape gate in profiles/_base/start.sh.hbs.
+    for (const good of ["sr-openrouter/gpt-5", "sr-vendor/model", "sr-mistralai/mixtral-8x7b"]) {
+      expect(isValidModelArg(good), good).toBe(true);
+    }
+  });
   it("rejects whitespace, metacharacters, and over-long strings", () => {
-    for (const bad of ["", " ", "a b", "a;b", "a/b", "-x", "a".repeat(120), "a\tb", "a\nb"]) {
+    for (const bad of ["", " ", "a b", "a;b", "-x", "a".repeat(120), "a\tb", "a\nb", "/leading"]) {
       expect(isValidModelArg(bad), JSON.stringify(bad)).toBe(false);
     }
   });
@@ -355,16 +366,6 @@ describe("handleModelCommand — sr-* → Claude graceful restart", () => {
     expect(reply.text).toContain("Set model to sonnet");
   });
 
-  it("does NOT restart when switching from Claude to sr-* (no session override)", async () => {
-    const { deps, calls, restartCalls } = makeDeps({
-      getActiveSessionModel: () => null,
-    });
-    await handleModelCommand({ kind: "set", model: "sr-gemini-2.5-pro" }, deps);
-    // sr-* is not a Claude model — no restart
-    expect(restartCalls).toHaveLength(0);
-    expect(calls).toHaveLength(1);
-  });
-
   it("surfaces scheduleRestart failures without propagating the error", async () => {
     const { deps, calls } = makeDeps({
       getActiveSessionModel: () => "sr-deepseek-r1",
@@ -386,6 +387,128 @@ describe("handleModelCommand — sr-* → Claude graceful restart", () => {
   });
 });
 
+describe("handleModelCommand — Claude → sr-* session relaunch", () => {
+  it("schedules a model relaunch (carrier) instead of injecting for an sr-* target", async () => {
+    const { deps, calls, restartCalls, relaunchCalls } = makeDeps({
+      getActiveSessionModel: () => null,
+    });
+    const reply = await handleModelCommand({ kind: "set", model: "sr-glm-5" }, deps);
+    // Must NOT inject (claude's picker rejects sr-* ids)
+    expect(calls).toHaveLength(0);
+    // Must NOT use the sr→claude scheduleRestart path
+    expect(restartCalls).toHaveLength(0);
+    // Must schedule the carrier-based relaunch with the full sr-* id
+    expect(relaunchCalls).toHaveLength(1);
+    expect(relaunchCalls[0].model).toBe("sr-glm-5");
+    expect(reply.text).toContain("sr-glm-5");
+    expect(reply.text).toContain("30s");
+    expect(reply.html).toBe(true);
+  });
+
+  it("expands a short sr alias then relaunches on the full id", async () => {
+    const { deps, calls, relaunchCalls } = makeDeps({ getActiveSessionModel: () => null });
+    await handleModelCommand({ kind: "set", model: "glm" }, deps);
+    expect(calls).toHaveLength(0);
+    expect(relaunchCalls).toHaveLength(1);
+    expect(relaunchCalls[0].model).toBe("sr-glm-5");
+  });
+
+  it("Claude target still uses the instant inject path (no relaunch)", async () => {
+    const { deps, calls, relaunchCalls, restartCalls } = makeDeps({
+      getActiveSessionModel: () => null,
+    });
+    await handleModelCommand({ kind: "set", model: "sonnet" }, deps);
+    expect(calls).toHaveLength(1);
+    expect(relaunchCalls).toHaveLength(0);
+    expect(restartCalls).toHaveLength(0);
+  });
+
+  it("sr-* → Claude still takes the scheduleRestart path (not scheduleModelRelaunch)", async () => {
+    const { deps, calls, restartCalls, relaunchCalls } = makeDeps({
+      getActiveSessionModel: () => "sr-glm-5",
+    });
+    await handleModelCommand({ kind: "set", model: "opus" }, deps);
+    expect(calls).toHaveLength(0);
+    expect(relaunchCalls).toHaveLength(0);
+    expect(restartCalls).toHaveLength(1);
+  });
+
+  it("surfaces scheduleModelRelaunch failures without propagating the error", async () => {
+    const { deps, calls } = makeDeps({
+      getActiveSessionModel: () => null,
+      scheduleModelRelaunch: async () => { throw new Error("carrier write failed"); },
+    });
+    const reply = await handleModelCommand({ kind: "set", model: "sr-glm-5" }, deps);
+    expect(calls).toHaveLength(0);
+    expect(reply.text).toContain("Could not schedule model switch");
+    expect(reply.text).toContain("carrier write failed");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Manual full-sr-* passthrough (Ken 2026-07-08): the /model MENU stays curated
+// to the main SR_MODEL_ALIASES set, but typing `/model <any registered sr-*>`
+// must switch to that exact model — the set path is a SHAPE gate only, with NO
+// whitelist against SR_MODEL_LABELS / SR_MODEL_ALIASES. These guard that any
+// arbitrary sr-* id passes through verbatim and schedules the relaunch on the
+// exact id (not rejected, not remapped, not injected).
+// ---------------------------------------------------------------------------
+describe("handleModelCommand — arbitrary sr-* passthrough (no whitelist)", () => {
+  // sr-* names that are NOT in SR_MODEL_ALIASES (so not menu-reachable) but ARE
+  // registered in the live litellm config — must still switch when typed.
+  const ARBITRARY_SR = [
+    "sr-gpt-oss-120b",
+    "sr-gpt-oss-20b",
+    "sr-minimax-m3",
+    "sr-gemini-flash-lite",
+    "sr-gpt-5.5",
+    "sr-gpt-5-codex",
+    "sr-gpt-5.2-codex",
+    "sr-deepseek-v4-flash",
+  ];
+
+  it("each arbitrary sr-* passes the shape gate and isSrModel", () => {
+    for (const name of ARBITRARY_SR) {
+      expect(isValidModelArg(name), `${name} must pass MODEL_ARG_RE`).toBe(true);
+      expect(isSrModel(name), `${name} must be recognised as sr-*`).toBe(true);
+      expect(isClaudeModel(name)).toBe(false);
+    }
+  });
+
+  it("relaunches on the exact typed id — not rejected, not remapped", async () => {
+    for (const name of ARBITRARY_SR) {
+      const { deps, calls, restartCalls, relaunchCalls } = makeDeps({
+        getActiveSessionModel: () => null,
+      });
+      const reply = await handleModelCommand({ kind: "set", model: name }, deps);
+      // Never injected (claude's picker rejects sr-* ids).
+      expect(calls, `${name} must not inject`).toHaveLength(0);
+      // Never the sr→claude restart path (source session is Claude here).
+      expect(restartCalls, `${name} must not scheduleRestart`).toHaveLength(0);
+      // Scheduled the carrier relaunch on the EXACT id (no alias remap).
+      expect(relaunchCalls).toHaveLength(1);
+      expect(relaunchCalls[0].model, `${name} must relaunch verbatim`).toBe(name);
+      expect(reply.text).toContain(name);
+    }
+  });
+
+  it("parseModelCommand accepts arbitrary sr-* ids as a set command", () => {
+    for (const name of ARBITRARY_SR) {
+      expect(parseModelCommand(`/model ${name}`)).toEqual({ kind: "set", model: name });
+    }
+  });
+
+  it("switching FROM an arbitrary sr-* back to Claude takes the restart path", async () => {
+    const { deps, calls, restartCalls, relaunchCalls } = makeDeps({
+      getActiveSessionModel: () => "sr-gpt-oss-120b",
+    });
+    await handleModelCommand({ kind: "set", model: "opus" }, deps);
+    expect(calls).toHaveLength(0);
+    expect(relaunchCalls).toHaveLength(0);
+    expect(restartCalls).toHaveLength(1);
+  });
+});
+
 describe("inject allowlist contract", () => {
   it("/model stays on the inject allowlist (the set path depends on it)", async () => {
     const { INJECT_COMMANDS } = await import("../../src/agents/inject.js");
@@ -433,11 +556,13 @@ describe("SR_MODEL_ALIASES / expandSrAlias", () => {
     }
   });
 
-  it("handleModelCommand injects expanded sr-* id, not the short alias", async () => {
-    const { deps, calls } = makeDeps({ getActiveSessionModel: () => null });
+  it("handleModelCommand relaunches on the expanded sr-* id, not the short alias", async () => {
+    const { deps, calls, relaunchCalls } = makeDeps({ getActiveSessionModel: () => null });
     await handleModelCommand({ kind: "set", model: "flash" }, deps);
-    expect(calls).toHaveLength(1);
-    expect(calls[0].command).toBe("/model sr-gemini-2.5-flash");
+    // sr-* targets no longer inject — they carrier-relaunch on the full id.
+    expect(calls).toHaveLength(0);
+    expect(relaunchCalls).toHaveLength(1);
+    expect(relaunchCalls[0].model).toBe("sr-gemini-2.5-flash");
   });
 
   it("handleModelCommand with alias schedules restart when session is on sr-*", async () => {
@@ -688,6 +813,58 @@ describe("SR_MODEL_LABELS", () => {
     expect(SR_MODEL_LABELS["sr-gemini-2.5-pro"]).toBe("Gemini 2.5 Pro");
     expect(SR_MODEL_LABELS["sr-deepseek-r1"]).toBe("DeepSeek R1");
   });
+
+  it("bumps sr-glm-5 label to GLM-5.2 (now targets glm-5.2 in litellm)", () => {
+    expect(SR_MODEL_LABELS["sr-glm-5"]).toBe("GLM-5.2");
+  });
+
+  it("has friendly names for the new OpenRouter sr-* models (display-only)", () => {
+    expect(SR_MODEL_LABELS["sr-gpt-oss-20b"]).toBe("GPT-OSS 20B");
+    expect(SR_MODEL_LABELS["sr-gpt-oss-120b"]).toBe("GPT-OSS 120B");
+    expect(SR_MODEL_LABELS["sr-gpt-5.5"]).toBe("GPT-5.5");
+    expect(SR_MODEL_LABELS["sr-gpt-5-codex"]).toBe("GPT-5 Codex");
+    expect(SR_MODEL_LABELS["sr-gpt-5.2-codex"]).toBe("GPT-5.2 Codex");
+    expect(SR_MODEL_LABELS["sr-gemini-flash-lite"]).toBe("Gemini 3.1 Flash Lite");
+    expect(SR_MODEL_LABELS["sr-minimax-m3"]).toBe("MiniMax M3");
+    expect(SR_MODEL_LABELS["sr-deepseek-v4-flash"]).toBe("DeepSeek V4 Flash");
+  });
+});
+
+describe("menu stays curated — new OpenRouter models are display-only, not in the picker", () => {
+  // The 8 new models are typeable (manual passthrough) but must NOT bloat the
+  // /model keyboard. externalModelNames() seeds the picker from SR_MODEL_ALIASES
+  // values, so these ids must be ABSENT from both the alias table and the picker
+  // list. This locks in Ken's "menu = main models only" decision.
+  const NEW_SR = [
+    "sr-gpt-oss-20b",
+    "sr-gpt-oss-120b",
+    "sr-gpt-5.5",
+    "sr-gpt-5-codex",
+    "sr-gpt-5.2-codex",
+    "sr-gemini-flash-lite",
+    "sr-minimax-m3",
+    "sr-deepseek-v4-flash",
+  ];
+
+  it("SR_MODEL_ALIASES stays the curated 6-entry main set (no new short aliases)", () => {
+    expect(Object.keys(SR_MODEL_ALIASES).sort()).toEqual(
+      ["codex", "deepseek", "flash", "gemini", "glm", "r1"],
+    );
+    // None of the new sr-* ids are an alias target.
+    const targets = new Set(Object.values(SR_MODEL_ALIASES));
+    for (const name of NEW_SR) {
+      expect(targets.has(name), `${name} must NOT be an alias target`).toBe(false);
+    }
+  });
+
+  it("externalModelNames (picker seed) excludes the new models", () => {
+    const picker = externalModelNames([]);
+    for (const name of NEW_SR) {
+      expect(picker.includes(name), `${name} must NOT appear in the picker`).toBe(false);
+    }
+    // The curated main set is still exactly the alias targets.
+    expect(picker.sort()).toEqual([...new Set(Object.values(SR_MODEL_ALIASES))].sort());
+  });
 });
 
 describe("buildModelMenu — with sr-* models", () => {

package/telegram-plugin/tests/narrative-render.test.ts

@@ -0,0 +1,125 @@
+/**
+ * narrative-render.test.ts — T6: end-to-end narration through the REAL pure
+ * render helpers, tied to the REAL LivenessTracker (thinking-pause fix).
+ *
+ * Proves the narration surface still behaves after the orphaned-reply fix:
+ *   (a) a long narration is clipped and rendered as ONE feed line;
+ *   (b) a narration that is a draft of the delivered reply is SUPPRESSED,
+ *       while a differing narration is SHOWN;
+ *   (c) a narration after a >30s stream gap keeps the turn alive (the tracker
+ *       stamps liveness) AND renders; thinking / tool_result carry no narration
+ *       text so they add NO feed line (thinking only drives the 🤔 reaction).
+ *
+ * All assertions drive the REAL helpers — no replicas.
+ *
+ * DEVIATION NOTE: the fix spec's T6(a) wrote "≤120-char line". The real clip
+ * bound is `STATUS_LINE_MAX` (200) in status-no-truncate.ts, so this test pins
+ * the real constant instead of the stale 120.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  clipNarrative,
+  appendActivityLabel,
+  renderActivityFeedWithNested,
+} from '../tool-activity-summary.js'
+import { isDraftOfReply, REPLY_TOOLS } from '../narrative-dedup.js'
+import { STATUS_LINE_MAX } from '../status-no-truncate.js'
+import { LivenessTracker, ORPHANED_REPLY_STREAM_WINDOW_MS } from '../context-exhaustion.js'
+
+const W = ORPHANED_REPLY_STREAM_WINDOW_MS
+
+describe('T6(a) — long narration is clipped to one feed line', () => {
+  it('clipNarrative → appendActivityLabel → renderActivityFeedWithNested yields one clipped line', () => {
+    const long = 'x'.repeat(STATUS_LINE_MAX + 50) // 250 chars, no newlines
+    const clipped = clipNarrative(long)
+    expect(clipped.length).toBe(STATUS_LINE_MAX)
+
+    const lines: string[] = []
+    appendActivityLabel(lines, clipped)
+    expect(lines).toHaveLength(1)
+
+    const rendered = renderActivityFeedWithNested(lines, [])
+    expect(rendered).not.toBeNull()
+    expect(rendered).toContain(clipped)
+  })
+
+  it('clipNarrative keeps only the first line, trimmed', () => {
+    const multi = '  first line of narration  \nsecond line should be dropped'
+    expect(clipNarrative(multi)).toBe('first line of narration')
+  })
+})
+
+describe('T6(b) — a narration that drafts the reply is suppressed', () => {
+  // Model the reducer decision: only render narration that is NOT a draft of
+  // the delivered reply (narrative-dedup gate).
+  function renderNarrationUnlessDraft(narration: string, replyText: string): string | null {
+    if (isDraftOfReply(narration, replyText)) return null // suppressed
+    const lines: string[] = []
+    appendActivityLabel(lines, clipNarrative(narration))
+    return renderActivityFeedWithNested(lines, [])
+  }
+
+  it('REPLY_TOOLS is the reply set (sanity — draft dedup only runs for reply tools)', () => {
+    expect(REPLY_TOOLS.has('reply')).toBe(true)
+    expect(REPLY_TOOLS.has('stream_reply')).toBe(true)
+  })
+
+  it('suppresses a trailing narration that is a draft of the delivered reply', () => {
+    const reply = 'The build passed and I deployed the fix to staging.'
+    const draft = 'The build passed and I deployed the fix to staging' // ~identical
+    expect(isDraftOfReply(draft, reply)).toBe(true)
+    expect(renderNarrationUnlessDraft(draft, reply)).toBeNull()
+  })
+
+  it('shows a genuinely different narration line', () => {
+    const reply = 'The build passed and I deployed the fix to staging.'
+    const working = 'Running the integration test suite'
+    expect(isDraftOfReply(working, reply)).toBe(false)
+    const rendered = renderNarrationUnlessDraft(working, reply)
+    expect(rendered).not.toBeNull()
+    expect(rendered).toContain('Running the integration test suite')
+  })
+})
+
+describe('T6(c) — narration after a stream gap: alive + rendered; thinking/tool_result add no line', () => {
+  it('a narration text event after a >30s gap stamps liveness (turn alive) and renders', () => {
+    const t = new LivenessTracker(0)
+    t.onStreamEvent('text', undefined, 0)
+    // >30s gap with no events — turn would previously have been at risk.
+    const gapNow = 35_000
+    // Narration lands: stamps liveness, keeping the turn alive.
+    t.onStreamEvent('text', undefined, gapNow)
+    expect(t.lastStreamEventAt).toBe(gapNow)
+    expect(t.recentlyStreaming(gapNow, W)).toBe(true)
+
+    const lines: string[] = []
+    appendActivityLabel(lines, clipNarrative('Compiling the gateway bundle'))
+    const rendered = renderActivityFeedWithNested(lines, [])
+    expect(rendered).toContain('Compiling the gateway bundle')
+  })
+
+  it('thinking and tool_result stamp liveness but carry NO narration text → no feed line', () => {
+    const t = new LivenessTracker(0)
+    const lines: string[] = []
+    // A rendered narration line already present.
+    appendActivityLabel(lines, clipNarrative('Editing gateway.ts'))
+    expect(lines).toHaveLength(1)
+
+    // thinking: keeps the turn alive (liveness stamp) but produces no text.
+    t.onStreamEvent('thinking', undefined, 5_000)
+    expect(t.lastStreamEventAt).toBe(5_000)
+    // A thinking/tool_result event has no label → appendActivityLabel adds nothing.
+    expect(appendActivityLabel(lines, undefined)).toBeNull()
+    expect(lines).toHaveLength(1)
+
+    // tool_result: same — stamps liveness, no narration line.
+    t.onStreamEvent('tool_result', undefined, 6_000)
+    expect(t.lastStreamEventAt).toBe(6_000)
+    expect(appendActivityLabel(lines, '')).toBeNull()
+    expect(lines).toHaveLength(1)
+
+    const rendered = renderActivityFeedWithNested(lines, [])
+    expect(rendered).toContain('Editing gateway.ts')
+  })
+})

package/telegram-plugin/tests/operator-events.test.ts

@@ -253,6 +253,21 @@ describe('renderOperatorEvent — unknown-5xx', () => {
   })
 })
 
+describe('renderOperatorEvent — config-warning', () => {
+  it('is framed as non-urgent (dismiss-only, no restart/reauth/logs actions)', () => {
+    const { text, keyboard } = renderOperatorEvent(
+      makeEvent('config-warning', { detail: 'person_id: dropped 1 malformed users: entry at boot — lisa (empty person_id)' }),
+    )
+    expect(text).toContain('Config warning')
+    expect(text).toContain('Non-urgent')
+    const buttons = keyboard.inline_keyboard.flat()
+    expect(buttons.every(b => b.callback_data?.includes('dismiss'))).toBe(true)
+    expect(buttons.some(b => b.callback_data?.includes('restart'))).toBe(false)
+    expect(buttons.some(b => b.callback_data?.includes('reauth'))).toBe(false)
+    expect(buttons.some(b => b.callback_data?.includes('logs'))).toBe(false)
+  })
+})
+
 describe('renderOperatorEvent — markdown escaping (#2669)', () => {
   it('passes < > literally in agent name (markdown, #2669)', () => {
     const { text } = renderOperatorEvent(makeEvent('unknown-4xx', { agent: '<evil>' }))
@@ -276,6 +291,7 @@ describe('renderOperatorEvent — all kinds produce valid keyboard structure', (
     'agent-restarted-unexpectedly',
     'unknown-4xx',
     'unknown-5xx',
+    'config-warning',
   ]
 
   for (const kind of allKinds) {