switchroom 0.15.11 → 0.15.12

package/telegram-plugin/gateway/model-command.ts

@@ -33,12 +33,20 @@ import {
 } from '../../src/agents/model-picker.js'
 
 /**
- * Aliases the claude CLI resolves natively. Listed in help text only —
- * the handler does NOT restrict to these (a full model id like
- * `claude-opus-4-8` passes through and claude itself validates it, so
- * new aliases/models work without a switchroom release).
+ * Aliases the claude CLI resolves natively (`claude --help`: "an alias for
+ * the latest model (e.g. 'fable', 'opus', or 'sonnet')"). Listed in help
+ * text only — the handler does NOT restrict to these (a full model id like
+ * `claude-opus-4-8` passes through and claude itself validates it, so new
+ * aliases/models work without a switchroom release).
+ *
+ * `fable` is the latest flagship (Fable 5) — kept selectable here on
+ * purpose. NB the alias is NOT the full codename: `claude-fable-5` (a
+ * pinned pre-launch id) was retired server-side and 4xx'd the whole fleet
+ * on 2026-06-13, while the `fable` alias keeps resolving to the current
+ * model. Aliases are the durable way to pick a model — see the model
+ * regression tests.
  */
-export const MODEL_ALIASES = ['opus', 'sonnet', 'haiku', 'default'] as const
+export const MODEL_ALIASES = ['opus', 'sonnet', 'haiku', 'fable', 'default'] as const
 
 /**
  * Shape gate for the model argument. This string is typed literally

package/telegram-plugin/tests/gateway-request-secret.test.ts

@@ -29,7 +29,7 @@ describe('request_secret — gateway wiring', () => {
   })
 
   it('is allow-listed and dispatched', () => {
-    expect(gw).toMatch(/'request_secret',\n\]\)/)
+    expect(gw).toMatch(/'request_secret',\n/)
     expect(gw).toMatch(/case 'request_secret':\s*\n\s*return executeRequestSecret\(args\)/)
   })
 

package/telegram-plugin/tests/linear-agent-activity.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import {
+  emitLinearAgentActivity,
+  type LinearTokenResult,
+} from '../gateway/linear-activity.js'
+
+/**
+ * Tests for the `linear_agent_activity` MCP tool (#2298).
+ *
+ * Structural part: assert the tool is declared in bridge/bridge.ts and
+ * allow-listed + dispatched in gateway/gateway.ts (the gateway IIFE can't be
+ * imported in a test, so wiring is verified by reading the source — same
+ * constraint as gateway-request-secret.test.ts).
+ *
+ * Behavioural part: the activity-emit logic lives in gateway/linear-activity.ts
+ * with injectable token-resolver + fetch, so the happy path and the
+ * vault-denied path are exercised without a broker or the network.
+ */
+
+const okToken = (token: string) => async (): Promise<LinearTokenResult> => ({ ok: true, token })
+
+function fakeFetch(status: number, jsonBody: unknown): {
+  fetchImpl: typeof fetch
+  calls: Array<{ url: string; init?: RequestInit }>
+} {
+  const calls: Array<{ url: string; init?: RequestInit }> = []
+  const fetchImpl = (async (url: string, init?: RequestInit) => {
+    calls.push({ url, init })
+    return {
+      ok: status >= 200 && status < 300,
+      status,
+      json: async () => jsonBody,
+      text: async () => JSON.stringify(jsonBody),
+    } as unknown as Response
+  }) as unknown as typeof fetch
+  return { fetchImpl, calls }
+}
+
+describe('linear_agent_activity — gateway wiring (#2298)', () => {
+  const gw = readFileSync(new URL('../gateway/gateway.ts', import.meta.url), 'utf8')
+  const bridge = readFileSync(new URL('../bridge/bridge.ts', import.meta.url), 'utf8')
+
+  it('declares the MCP tool with required {agent_session_id,type}', () => {
+    const idx = bridge.indexOf(`name: 'linear_agent_activity'`)
+    expect(idx).toBeGreaterThan(0)
+    const schema = bridge.slice(idx, idx + 2000)
+    expect(schema).toMatch(/required: \['agent_session_id', 'type'\]/)
+    expect(schema).toMatch(/thought/)
+    expect(schema).toMatch(/complete/)
+  })
+
+  it('is allow-listed and dispatched', () => {
+    expect(gw).toMatch(/'linear_agent_activity',\n\]\)/)
+    expect(gw).toMatch(/case 'linear_agent_activity':\s*\n\s*return executeLinearAgentActivity\(args\)/)
+  })
+})
+
+describe('emitLinearAgentActivity — behaviour (#2298)', () => {
+  it('POSTs an agentActivityCreate mutation on the happy path', async () => {
+    const { fetchImpl, calls } = fakeFetch(200, { data: { agentActivityCreate: { success: true } } })
+    const r = await emitLinearAgentActivity(
+      { agent_session_id: 'sess_1', type: 'thought', body: 'On it.' },
+      { agent: 'carrie', resolveToken: okToken('lin_tok'), fetchImpl, log: () => {} },
+    )
+    expect(r.content[0].text).toMatch(/emitted on session sess_1/)
+    expect(calls).toHaveLength(1)
+    expect(calls[0].url).toBe('https://api.linear.app/graphql')
+    const sent = JSON.parse(calls[0].init!.body as string)
+    expect(sent.query).toMatch(/agentActivityCreate/)
+    expect(sent.variables.input.agentSessionId).toBe('sess_1')
+    expect(sent.variables.input.content).toEqual({ type: 'thought', body: 'On it.' })
+    expect((calls[0].init!.headers as Record<string, string>).Authorization).toBe('lin_tok')
+  })
+
+  it('allows complete with no body', async () => {
+    const { fetchImpl } = fakeFetch(200, { data: { agentActivityCreate: { success: true } } })
+    const r = await emitLinearAgentActivity(
+      { agent_session_id: 'sess_2', type: 'complete' },
+      { agent: 'carrie', resolveToken: okToken('lin_tok'), fetchImpl, log: () => {} },
+    )
+    expect(r.content[0].text).toMatch(/complete emitted/)
+  })
+
+  it('requires body for thought/message/error', async () => {
+    await expect(
+      emitLinearAgentActivity(
+        { agent_session_id: 'sess_3', type: 'message' },
+        { resolveToken: okToken('t'), log: () => {} },
+      ),
+    ).rejects.toThrow(/body is required/)
+  })
+
+  it('rejects an unknown type', async () => {
+    await expect(
+      emitLinearAgentActivity(
+        { agent_session_id: 'sess_4', type: 'banana', body: 'x' },
+        { resolveToken: okToken('t'), log: () => {} },
+      ),
+    ).rejects.toThrow(/type must be one of/)
+  })
+
+  it('returns vault_request_access guidance when the token is denied', async () => {
+    const r = await emitLinearAgentActivity(
+      { agent_session_id: 'sess_5', type: 'thought', body: 'hi' },
+      {
+        agent: 'carrie',
+        resolveToken: async () => ({ ok: false, reason: 'denied' }),
+        log: () => {},
+      },
+    )
+    expect(r.content[0].text).toMatch(/vault_request_access/)
+    expect(r.content[0].text).toMatch(/linear\/carrie\/token/)
+  })
+
+  it('surfaces a Linear API error status', async () => {
+    const { fetchImpl } = fakeFetch(401, { error: 'bad token' })
+    const r = await emitLinearAgentActivity(
+      { agent_session_id: 'sess_6', type: 'thought', body: 'hi' },
+      { agent: 'carrie', resolveToken: okToken('lin_tok'), fetchImpl, log: () => {} },
+    )
+    expect(r.content[0].text).toMatch(/Linear API 401/)
+  })
+})

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

@@ -113,6 +113,46 @@ describe("isValidModelArg", () => {
   });
 });
 
+// Regression for the 2026-06-13 fleet outage: defaults.model was pinned to
+// the full codename `claude-fable-5`, which Anthropic retired server-side →
+// every agent 4xx'd. The fix is to select models by ALIAS (durable) instead
+// of pinned ids. This locks in that `fable` (and the other aliases) stay
+// selectable, and documents the alias-vs-codename distinction.
+describe("model selection: aliases stay selectable (incl. fable)", () => {
+  it("lists fable as a first-class alias", () => {
+    // `fable` is the latest flagship (Fable 5) and must remain pickable.
+    expect(MODEL_ALIASES).toContain("fable");
+    // The standard set is intact alongside it.
+    for (const a of ["opus", "sonnet", "haiku", "default"]) {
+      expect(MODEL_ALIASES, a).toContain(a);
+    }
+  });
+
+  it("each alias is a valid model arg and parses as a set", () => {
+    for (const alias of MODEL_ALIASES) {
+      expect(isValidModelArg(alias), alias).toBe(true);
+      expect(parseModelCommand(`/model ${alias}`)).toEqual({ kind: "set", model: alias });
+    }
+  });
+
+  it("the help text surfaces the fable alias", async () => {
+    const reply = await handleModelCommand({ kind: "help" }, makeDeps());
+    expect(reply.text).toContain("fable");
+  });
+
+  it("passthrough: a full id (incl. the retired claude-fable-5 codename) is shape-accepted, not allowlisted", () => {
+    // switchroom does NOT allowlist models — the SHAPE gate passes any
+    // well-formed id through to claude, which is the sole validator. So the
+    // retired `claude-fable-5` codename still parses here (it just 4xx's at
+    // claude); selection flexibility (any current/future model) is preserved.
+    expect(parseModelCommand("/model claude-fable-5")).toEqual({
+      kind: "set",
+      model: "claude-fable-5",
+    });
+    expect(isValidModelArg("claude-fable-5")).toBe(true);
+  });
+});
+
 describe("handleModelCommand — show / help never inject (picker-wedge guard)", () => {
   it("show renders configured model + switch options without injecting", async () => {
     const { deps, calls } = makeDeps();