switchroom 0.17.6 → 0.18.3

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')
+  })
+})