switchroom 0.15.36 → 0.15.38

package/telegram-plugin/tests/tool-filter.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Unit tests for the switchroom-telegram tool-surface right-sizing (P4):
+ * connection gating of linear_* (A) + per-tool alwaysLoad pins for the hot
+ * path (B). Pure function — no bridge.ts import (which has side effects).
+ */
+
+import { describe, it, expect } from 'bun:test'
+import {
+  buildEffectiveToolSchemas,
+  ALWAYS_LOAD_TOOLS,
+  LINEAR_TOOLS,
+  type NamedTool,
+} from '../bridge/tool-filter.js'
+
+// A representative slice mirroring the real TOOL_SCHEMAS names.
+const SAMPLE: NamedTool[] = [
+  { name: 'reply', description: 'r' },
+  { name: 'stream_reply', description: 's' },
+  { name: 'get_recent_messages', description: 'g' },
+  { name: 'react', description: 'k' },
+  { name: 'edit_message', description: 'e' },
+  { name: 'send_typing', description: 't' },
+  { name: 'download_attachment', description: 'd' },
+  { name: 'ask_user', description: 'a' }, // cold
+  { name: 'send_gif', description: 'gif' }, // cold
+  { name: 'vault_request_access', description: 'v' }, // cold
+  { name: 'linear_agent_activity', description: 'la' },
+  { name: 'linear_create_issue', description: 'lc' },
+  { name: 'linear_agent_setup', description: 'ls' },
+]
+
+const names = (tools: NamedTool[]) => tools.map((t) => t.name)
+const metaOf = (tools: Array<NamedTool & { _meta?: unknown }>, n: string) =>
+  tools.find((t) => t.name === n)?._meta
+
+describe('buildEffectiveToolSchemas — connection gating (A)', () => {
+  it('drops all linear_* tools when Linear is NOT enabled', () => {
+    const out = buildEffectiveToolSchemas(SAMPLE, { linearEnabled: false })
+    for (const t of LINEAR_TOOLS) expect(names(out)).not.toContain(t)
+    // non-linear tools all survive
+    expect(names(out)).toContain('reply')
+    expect(names(out)).toContain('ask_user')
+    expect(out.length).toBe(SAMPLE.length - LINEAR_TOOLS.size)
+  })
+
+  it('keeps linear_* tools when Linear IS enabled', () => {
+    const out = buildEffectiveToolSchemas(SAMPLE, { linearEnabled: true })
+    for (const t of LINEAR_TOOLS) expect(names(out)).toContain(t)
+    expect(out.length).toBe(SAMPLE.length)
+  })
+})
+
+describe('buildEffectiveToolSchemas — per-tool deferral pins (B)', () => {
+  it('pins exactly the hot tools with _meta anthropic/alwaysLoad', () => {
+    const out = buildEffectiveToolSchemas(SAMPLE, { linearEnabled: true })
+    for (const hot of ALWAYS_LOAD_TOOLS) {
+      expect(metaOf(out, hot)).toEqual({ 'anthropic/alwaysLoad': true })
+    }
+  })
+
+  it('the reply path (reply/stream_reply) is ALWAYS pinned — never defers', () => {
+    const out = buildEffectiveToolSchemas(SAMPLE, { linearEnabled: false })
+    expect(metaOf(out, 'reply')).toEqual({ 'anthropic/alwaysLoad': true })
+    expect(metaOf(out, 'stream_reply')).toEqual({ 'anthropic/alwaysLoad': true })
+  })
+
+  it('cold tools carry NO _meta (so they defer under tool-search)', () => {
+    const out = buildEffectiveToolSchemas(SAMPLE, { linearEnabled: true })
+    for (const cold of ['ask_user', 'send_gif', 'vault_request_access', 'linear_create_issue']) {
+      expect(metaOf(out, cold)).toBeUndefined()
+    }
+  })
+})
+
+describe('buildEffectiveToolSchemas — purity', () => {
+  it('does not mutate the input array or its objects', () => {
+    const input: NamedTool[] = [{ name: 'reply' }, { name: 'send_gif' }]
+    const snapshot = JSON.stringify(input)
+    buildEffectiveToolSchemas(input, { linearEnabled: true })
+    expect(JSON.stringify(input)).toBe(snapshot)
+  })
+
+  it('preserves order', () => {
+    const out = buildEffectiveToolSchemas(SAMPLE, { linearEnabled: true })
+    expect(names(out)).toEqual(names(SAMPLE))
+  })
+})

package/telegram-plugin/tests/turn-flush-safety.test.ts

@@ -237,7 +237,7 @@ describe('decideTurnFlush', () => {
   // Regression guard for the redundant-follow-up-message fix: this reverts
   // the #1291 post-reply-tail flush, which posted a duplicate recap on
   // essentially every turn because the model habitually writes a closing
-  // summary after its final reply. See reference/conversational-pacing.md
+  // summary after its final reply. See reference/rfcs/conversational-pacing.md
   // — "the framework owns the beat; the model authors the words".
   describe('reply-called turns never flush trailing terminal text', () => {
     it('skips even when a long substantive tail follows the reply', () => {

package/telegram-plugin/turn-flush-safety.ts

@@ -172,7 +172,7 @@ export interface FlushDecisionInput {
  * message second-guesses an explicit reply and posts a redundant duplicate
  * on essentially every turn, because the model habitually writes a closing
  * summary. The framework owns the *beat*; the model authors the *words*
- * and emits them via reply (`reference/conversational-pacing.md`).
+ * and emits them via reply (`reference/rfcs/conversational-pacing.md`).
  *
  * (This reverts the #1291 post-reply-tail flush. Its intent — catch a
  * soft-commit reply followed by the real answer in terminal text only —

package/telegram-plugin/uat/assertions.ts

@@ -395,7 +395,7 @@ export async function waitForCardPhase(
  * The actual card render uses emoji markers in the header: `✅` for
  * done, `❌` for errors, `⚙️` while working (foreground), `🌀` for
  * Background (parent done but fleet still running, see #862 /
- * reference/conversational-pacing.md),
+ * reference/rfcs/conversational-pacing.md),
  * and `⏳` during the boot-card window. These markers are stable
  * enough to key on for UAT — finer parsing (checklist items,
  * sub-agent row content) is out of scope.

package/telegram-plugin/uat/scenarios/bg-sub-agent-dispatch-dm.test.ts

@@ -1,6 +1,6 @@
 /**
  * Background sub-agent visibility scenario — closes #709 / #776 / #782 / #788
- * (the four-issue family analysed in `reference/sub-agent-visibility-rfc.md`).
+ * (the four-issue family analysed in `reference/rfcs/sub-agent-visibility.md`).
  *
  * Verifies three acceptance criteria from the RFC in a single run because
  * they share setup:

package/telegram-plugin/uat/scenarios/fuzz-extended-dm.test.ts

@@ -149,7 +149,7 @@ const FUZZ_CASES: readonly FuzzCase[] = [
   // The conservative regex set in `telegram-plugin/inbound-classifier.ts`
   // captures 10 standalone "ping" patterns that count toward the
   // primary lagging KPI `inbound_status_query`. Each fire is a JTBD
-  // failure (`reference/know-what-my-agent-is-doing.md`), so we
+  // failure (`reference/jobs/know-what-my-agent-is-doing.md`), so we
   // want every variant to (a) reach the agent unchanged, (b)
   // produce a sensible reply (no crash, no loop, no ghosting).
   // Tracks cause class CC-7 from

package/telegram-plugin/uat/scenarios/jtbd-fast-ack-dm.test.ts

@@ -1,7 +1,7 @@
 /**
  * JTBD scenario — guaranteed fast acknowledgement (human-feel UX epic).
  *
- * Serves: `reference/conversational-pacing.md` and the JTBD
+ * Serves: `reference/rfcs/conversational-pacing.md` and the JTBD
  * "talking to my agent feels like talking to a capable person".
  *
  * A person you message answers in a beat — "got it", "on it, checking

package/telegram-plugin/uat/scenarios/jtbd-fast-trivial-dm.test.ts

@@ -1,7 +1,7 @@
 /**
  * JTBD scenario — short happy path: trivial questions reply FAST.
  *
- * Serves: `reference/know-what-my-agent-is-doing.md` — the short-path
+ * Serves: `reference/jobs/know-what-my-agent-is-doing.md` — the short-path
  * contract: a question with no real work should produce a plain reply
  * with no ceremony (no soft-commit, no progress chunks) within a tight
  * budget. Users judge agent speed on THIS path more than any other.
@@ -12,7 +12,7 @@
  *
  * ## Targets
  *
- * From `reference/conversational-pacing.md` and the post-v0.12.22
+ * From `reference/rfcs/conversational-pacing.md` and the post-v0.12.22
  * baseline measurements:
  *
  *   - **TTFO p95 (vision target):** < 30s — the published contract.

package/telegram-plugin/uat/scenarios/jtbd-forwarded-burst-dm.test.ts

@@ -1,7 +1,7 @@
 /**
  * JTBD scenario — forwarded burst / split paste coalesces into ONE turn.
  *
- * Serves: `reference/steer-or-queue-mid-flight.md` — the "Forwarded
+ * Serves: `reference/jobs/steer-or-queue-mid-flight.md` — the "Forwarded
  * burst / split paste" UAT prompt. When several messages land in quick
  * succession from the same sender (a forward of 3-4 messages, or a long
  * paste Telegram split into chunks), inbound coalescing must merge them

package/telegram-plugin/uat/scenarios/jtbd-memory-survives-restart-dm.test.ts

@@ -1,7 +1,7 @@
 /**
  * JTBD scenario — memory survives across restart (the "fleet differentiator").
  *
- * Serves: `reference/remember-across-sessions.md` — the JTBD says:
+ * Serves: `reference/jobs/remember-across-sessions.md` — the JTBD says:
  *
  *   *Outcome:* The agent brings back relevant facts, preferences,
  *   decisions, and open threads from past conversations, in the right

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

@@ -2,7 +2,7 @@
  * JTBD scenario — rapid follow-ups (steering vs queued classification).
  *
  * Live contract codified in `_shared/telegram-style.md.hbs` and
- * `reference/steer-or-queue-mid-flight.md` (default-flip commits
+ * `reference/jobs/steer-or-queue-mid-flight.md` (default-flip commits
  * `4fff90bf` + `597a58af`, 2026-04-17):
  *
  * - A mid-turn follow-up with NO prefix is `queued="true"` — new

package/telegram-plugin/uat/scenarios/jtbd-reflective-status-reaction-dm.test.ts

@@ -2,7 +2,7 @@
  * JTBD scenario — reflective status reaction (#1713).
  *
  * Serves the JTBD "know what my agent is actually doing" (see
- * `reference/know-what-my-agent-is-doing.md`). The status reaction on
+ * `reference/jobs/know-what-my-agent-is-doing.md`). The status reaction on
  * the user's inbound is the *primary* ambient liveness signal — the
  * user reads it as "what is the agent doing right now". When it
  * collapses straight to 👍 mid-turn, the signal evaporates and the

package/telegram-plugin/uat/scenarios/jtbd-wake-audit-content-dm.test.ts

@@ -1,7 +1,7 @@
 /**
  * JTBD scenario — wake-audit content visibility post-restart.
  *
- * Serves: `reference/restart-and-know-what-im-running.md` — the JTBD:
+ * Serves: `reference/jobs/restart-and-know-what-im-running.md` — the JTBD:
  *
  *   *Outcome:* After any restart, the user is told what config is live.
  *   Model, tools, skills, memory backend, auth state. **No need to ask.**