switchroom 0.20.10 → 0.20.12

package/telegram-plugin/dist/server.js

@@ -24962,18 +24962,6 @@ var init_bridge = __esm(async () => {
         required: ["chat_id"]
       }
     },
-    {
-      name: "pin_message",
-      description: "Pin a message in a Telegram chat. Useful for important outputs the user wants to find later. Requires admin rights in groups.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          chat_id: { type: "string" },
-          message_id: { type: "string" }
-        },
-        required: ["chat_id", "message_id"]
-      }
-    },
     {
       name: "delete_message",
       description: "Delete a message the bot previously sent. Prefer edit_message if you just want to update text \u2014 delete_message is for true removal.",

package/telegram-plugin/fallback-card-collapse.ts

@@ -103,6 +103,7 @@ export type FallbackDeliveryOutcomeKind =
   | 'all-blocked'
   | 'no-old-active'
   | 'no-eligible-target'
+  | 'strict-pinned'
   | 'error';
 
 /**

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

@@ -328,7 +328,15 @@ export interface AuthBrokerClient {
    * `setActive` this needs no admin — the account is derived from the caller's
    * identity — so auto-fallback works from any agent.
    */
-  markExhausted(until?: number): Promise<{ account: string; rolled: string[]; rolledTo?: string | null }>
+  markExhausted(until?: number): Promise<{
+    account: string
+    rolled: string[]
+    rolledTo?: string | null
+    /** True when the caller is a strict-pinned agent (`auth.strict`): its
+     *  null `rolledTo` means "riding out the wall", not fleet all-blocked.
+     *  Absent on pre-flag brokers. */
+    caller_pinned_strict?: boolean
+  }>
   /**
    * 429 throttle tier (broker `mark-throttled`). Records a transient
    * per-account rate limit on the CALLER's own account — `throttled_until`
@@ -344,6 +352,8 @@ export interface AuthBrokerClient {
     throttled_until: number
     escalated: boolean
     rolledTo?: string | null
+    /** See markExhausted.caller_pinned_strict. */
+    caller_pinned_strict?: boolean
   }>
   rmAccount(label: string): Promise<{ label: string }>
   refreshAccount(label: string): Promise<{ account: string; expiresAt?: number }>

package/telegram-plugin/gateway/callback-query-handlers.ts

@@ -70,6 +70,11 @@ import {
   getProposal as getSkillProposal,
   setProposalStatus as setSkillProposalStatus,
 } from '../../src/self-improve/skill-proposals.js'
+import { parseEvalCaseProposalCallback } from './eval-case-proposal-card.js'
+import {
+  getEvalCaseProposal,
+  setEvalCaseProposalStatus,
+} from '../../src/self-improve/eval-case-proposals.js'
 import { maskToken } from '../secret-detect/mask.js'
 import {
   defaultVaultWrite,
@@ -1328,6 +1333,100 @@ async function handleSkillProposalCallback(ctx: Context, data: string): Promise<
   )
 }
 
+/**
+ * Eval-case proposal callback (RFC amendment §"corrections as eval cases").
+ *
+ * On Approve this runs the DETERMINISTIC `apply-eval-case` applier via
+ * execFileSync — NOT a model turn — so the case lands byte-exact as approved
+ * (precedent: the `switchroom vault set` on-tap execFileSync in this file).
+ * The operator's tap IS the authorization; the gateway sets the proposal
+ * `approved` BEFORE invoking the applier (whose own status check is
+ * defense-in-depth, MJ2, since the store is agent-writable).
+ */
+async function handleEvalCaseProposalCallback(ctx: Context, data: string): Promise<void> {
+  const senderId = String(ctx.from?.id ?? '')
+  const access = loadAccess()
+  if (!access.allowFrom.includes(senderId)) {
+    await ctx.answerCallbackQuery({ text: 'Not authorized.' }).catch(() => {})
+    return
+  }
+  const parsed = parseEvalCaseProposalCallback(data)
+  if (parsed == null) {
+    await ctx.answerCallbackQuery({ text: 'Bad request' }).catch(() => {})
+    return
+  }
+  const stateDir = process.env.TELEGRAM_STATE_DIR
+  const agent = process.env.SWITCHROOM_AGENT_NAME ?? ''
+  if (stateDir == null || stateDir.length === 0) {
+    await ctx.answerCallbackQuery({ text: 'State dir unset — cannot apply.' }).catch(() => {})
+    return
+  }
+  const proposal = getEvalCaseProposal(stateDir, parsed.id)
+  if (proposal == null) {
+    await ctx.answerCallbackQuery({ text: 'Proposal expired or already actioned.' }).catch(() => {})
+    if (ctx.callbackQuery?.message) {
+      await ctx.editMessageReplyMarkup({ reply_markup: { inline_keyboard: [] } }).catch(() => {})
+    }
+    return
+  }
+  if (proposal.status !== 'pending') {
+    await ctx.answerCallbackQuery({ text: `Already ${proposal.status}.` }).catch(() => {})
+    if (ctx.callbackQuery?.message) {
+      await ctx.editMessageReplyMarkup({ reply_markup: { inline_keyboard: [] } }).catch(() => {})
+    }
+    return
+  }
+
+  if (parsed.action === 'deny') {
+    setEvalCaseProposalStatus(stateDir, parsed.id, 'rejected')
+    await ctx.answerCallbackQuery({ text: '🚫 Dismissed.' }).catch(() => {})
+    if (ctx.callbackQuery?.message && 'text' in ctx.callbackQuery.message) {
+      await ctx
+        .editMessageText(
+          `${escapeHtmlForTg(ctx.callbackQuery.message.text ?? '')}\n\n🚫 <i>Dismissed.</i>`,
+          { parse_mode: 'HTML', reply_markup: { inline_keyboard: [] } },
+        )
+        .catch(() => {})
+    }
+    return
+  }
+
+  // Approve — authorize, then run the deterministic applier.
+  setEvalCaseProposalStatus(stateDir, parsed.id, 'approved')
+  await ctx.answerCallbackQuery({ text: '✅ Adding the eval case…' }).catch(() => {})
+
+  const cli = process.env.SWITCHROOM_CLI_PATH ?? 'switchroom'
+  let applyOk = true
+  let applyOut = ''
+  try {
+    applyOut = execFileSync(
+      cli,
+      ['self-improve', 'apply-eval-case', '--id', parsed.id],
+      { encoding: 'utf8', timeout: 15000, env: process.env },
+    ).trim()
+  } catch (err) {
+    applyOk = false
+    const e = err as { stdout?: string; stderr?: string; message?: string }
+    applyOut = [e.stdout, e.stderr, e.message].filter(Boolean).join('\n').trim()
+  }
+
+  const footer = applyOk
+    ? '✅ <i>Added as a regression test.</i>'
+    : `⚠️ <i>Apply failed:</i> ${escapeHtmlForTg(applyOut.slice(0, 200))}`
+  if (ctx.callbackQuery?.message && 'text' in ctx.callbackQuery.message) {
+    await ctx
+      .editMessageText(
+        `${escapeHtmlForTg(ctx.callbackQuery.message.text ?? '')}\n\n${footer}`,
+        { parse_mode: 'HTML', reply_markup: { inline_keyboard: [] } },
+      )
+      .catch(() => {})
+  }
+  process.stderr.write(
+    `telegram gateway: eval_case_apply agent=${agent} proposal=${proposal.id} ` +
+    `slug=${proposal.skill_slug} ok=${applyOk}\n`,
+  )
+}
+
 /**
  * hindsight Phase 5 — handle a tap on the mental-model PROPOSAL card.
  *   mmp:approve:<stageId> — declare the model: append it to the agent's
@@ -3233,6 +3332,7 @@ async function handleAuthDashboardCallback(ctx: Context): Promise<void> {
     performVaultAccessApproval,
     resolveAccessApprovalPassphraseMismatch,
     handleSkillProposalCallback,
+    handleEvalCaseProposalCallback,
     handleMentalModelProposeCallback,
     handleVaultRequestAccessCallback,
     handleVaultRequestSaveCallback,

package/telegram-plugin/gateway/eval-case-proposal-card.ts

@@ -0,0 +1,86 @@
+/**
+ * One-tap eval-case proposal card (RFC amendment §"corrections as eval
+ * cases").
+ *
+ * `switchroom self-improve add-eval-case` sends a `post_eval_case_proposal`
+ * IPC; the gateway persists it (eval-case-proposals store) and renders THIS
+ * card. Unlike the skill-proposal card, tapping Approve does NOT inject a
+ * model turn — the gateway callback runs the DETERMINISTIC `apply-eval-case`
+ * applier via execFileSync, so the case lands byte-exact as approved.
+ *
+ * Pure builders, kept out of gateway.ts so the card text + callback shape are
+ * pinned by tests independent of the bot plumbing.
+ *
+ * callback_data shape (must fit Telegram's 64-byte limit):
+ *   evcase:approve:<id>
+ *   evcase:deny:<id>
+ */
+
+export const EVAL_CASE_PROPOSAL_CALLBACK_PREFIX = 'evcase:'
+
+/** Narrow view of a stored eval-case proposal the card needs. */
+export interface EvalCaseProposalView {
+  id: string
+  skill_slug: string
+  held_out: boolean
+  case: { prompt: string; expectations?: string[] }
+}
+
+function escapeHtml(s: string): string {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+}
+
+/** Truncate a single-line preview of the prompt for the card. */
+function previewPrompt(prompt: string, max = 240): string {
+  const oneLine = prompt.replace(/\s+/g, ' ').trim()
+  return oneLine.length > max ? oneLine.slice(0, max - 1) + '…' : oneLine
+}
+
+/** Render the eval-case proposal card text (HTML parse mode). */
+export function renderEvalCaseProposalCard(p: EvalCaseProposalView): string {
+  const lines: string[] = []
+  lines.push(`🧪 <b>Eval case proposed</b>`)
+  lines.push('')
+  lines.push(`<b>Skill:</b> <code>${escapeHtml(p.skill_slug)}</code>`)
+  if (p.held_out) lines.push(`<i>held-out (won't be added to evals.json)</i>`)
+  lines.push(`<b>Test prompt:</b> ${escapeHtml(previewPrompt(p.case.prompt))}`)
+  const exps = p.case.expectations ?? []
+  if (exps.length > 0) {
+    lines.push('<b>Checks:</b>')
+    for (const e of exps.slice(0, 5)) lines.push(`• ${escapeHtml(e.slice(0, 120))}`)
+  }
+  lines.push('')
+  lines.push(
+    '<i>Tap Add to append it as a regression test (re-scanned for ' +
+      'secrets/PII, written byte-exact — no model turn). Tap Dismiss to drop it.</i>',
+  )
+  return lines.join('\n')
+}
+
+/** Inline keyboard for the card. */
+export function evalCaseProposalKeyboard(id: string): {
+  inline_keyboard: Array<Array<{ text: string; callback_data: string }>>
+} {
+  return {
+    inline_keyboard: [
+      [
+        { text: '✅ Add case', callback_data: `${EVAL_CASE_PROPOSAL_CALLBACK_PREFIX}approve:${id}` },
+        { text: '🚫 Dismiss', callback_data: `${EVAL_CASE_PROPOSAL_CALLBACK_PREFIX}deny:${id}` },
+      ],
+    ],
+  }
+}
+
+/** Parse an `evcase:` callback into { action, id }, or null if not ours. */
+export function parseEvalCaseProposalCallback(
+  data: string,
+): { action: 'approve' | 'deny'; id: string } | null {
+  if (!data.startsWith(EVAL_CASE_PROPOSAL_CALLBACK_PREFIX)) return null
+  const rest = data.slice(EVAL_CASE_PROPOSAL_CALLBACK_PREFIX.length)
+  const idx = rest.indexOf(':')
+  if (idx < 0) return null
+  const action = rest.slice(0, idx)
+  const id = rest.slice(idx + 1)
+  if ((action !== 'approve' && action !== 'deny') || id.length === 0) return null
+  return { action, id }
+}

package/telegram-plugin/gateway/fleet-fallback-notice-cooldown.test.ts

@@ -0,0 +1,74 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import {
+  resetFleetFallbackNoticeCooldowns,
+  shouldSendAllBlockedNotice,
+  shouldSendStrictPinnedNotice,
+} from './fleet-fallback-notice-cooldown.js'
+
+const COOLDOWN_MS = 30 * 60_000
+// Realistic wall-clock base: the initial state is { lastSentAtMs: 0 }, so the
+// first call only "sends" when `now` is at least COOLDOWN_MS past the epoch —
+// always true for a real Date.now(), so anchor the fakes there too.
+const BASE = 1_700_000_000_000
+
+function captureStderr(): { lines: string[]; restore: () => void } {
+  const lines: string[] = []
+  const spy = vi
+    .spyOn(process.stderr, 'write')
+    .mockImplementation((chunk: string | Uint8Array): boolean => {
+      lines.push(typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8'))
+      return true
+    })
+  return { lines, restore: () => spy.mockRestore() }
+}
+
+afterEach(() => {
+  // Reset the module-scope windows so each test starts from a clean gate.
+  resetFleetFallbackNoticeCooldowns()
+  vi.restoreAllMocks()
+})
+
+describe('fleet-fallback notice cooldown gates', () => {
+  it('sends the first all-blocked card and suppresses a repeat inside the window', () => {
+    const { lines, restore } = captureStderr()
+    const t0 = BASE
+    expect(shouldSendAllBlockedNotice('agentA', t0)).toBe(true)
+    // Re-fire well inside the 30-min window: suppressed, with the exact log text.
+    expect(shouldSendAllBlockedNotice('agentA', t0 + 60_000)).toBe(false)
+    expect(lines).toEqual([
+      'telegram gateway: [fleet-fallback] all-blocked card suppressed (cooldown) agent=agentA\n',
+    ])
+    // After the window elapses, it sends again.
+    expect(shouldSendAllBlockedNotice('agentA', t0 + COOLDOWN_MS)).toBe(true)
+    restore()
+  })
+
+  it('sends the first strict-pinned card and suppresses a repeat inside the window', () => {
+    const { lines, restore } = captureStderr()
+    const t0 = BASE + 100_000_000
+    expect(shouldSendStrictPinnedNotice('agentB', t0)).toBe(true)
+    expect(shouldSendStrictPinnedNotice('agentB', t0 + 60_000)).toBe(false)
+    expect(lines).toEqual([
+      'telegram gateway: [fleet-fallback] strict-pinned card suppressed (cooldown) agent=agentB\n',
+    ])
+    restore()
+  })
+
+  it('keeps the two windows independent — a strict card never suppresses an all-blocked', () => {
+    const t0 = BASE + 200_000_000
+    expect(shouldSendStrictPinnedNotice('agentC', t0)).toBe(true)
+    // All-blocked has its own window and is unaffected by the strict send above.
+    expect(shouldSendAllBlockedNotice('agentC', t0 + 1000)).toBe(true)
+  })
+
+  it('reset re-arms both windows so a post-recovery transition emits promptly', () => {
+    const t0 = BASE + 300_000_000
+    expect(shouldSendAllBlockedNotice('agentD', t0)).toBe(true)
+    expect(shouldSendStrictPinnedNotice('agentD', t0)).toBe(true)
+    // A successful swap resets both windows.
+    resetFleetFallbackNoticeCooldowns()
+    // Immediately after reset, both send again despite being inside the window.
+    expect(shouldSendAllBlockedNotice('agentD', t0 + 1000)).toBe(true)
+    expect(shouldSendStrictPinnedNotice('agentD', t0 + 1000)).toBe(true)
+  })
+})

package/telegram-plugin/gateway/fleet-fallback-notice-cooldown.ts

@@ -0,0 +1,71 @@
+/**
+ * fleet-fallback-notice-cooldown.ts — per-gateway cooldown gates for the two
+ * NO-OP fleet-fallback outcomes: "all accounts blocked" and "strict-pinned".
+ *
+ * Both outcomes make `doFireFleetAutoFallback` return false WITHOUT swapping the
+ * active account, so the `fleetFallbackGate` dedup window never arms for them and
+ * the ~60s `quota_wall_detected` re-trigger would otherwise re-broadcast the
+ * identical card every minute for the life of the wall. Each outcome gets its own
+ * per-gateway cooldown window (separate state so a strict-pinned card never
+ * suppresses a genuine later all-blocked, or vice versa). A successful swap resets
+ * both windows so a fresh transition after recovery is not stale-suppressed.
+ *
+ * Extracted verbatim from gateway.ts (switchroom#4442) to keep the inline notice
+ * logic out of the file the line-ratchet guards. Behaviour is byte-identical to
+ * the previous inline gates: same 30-min cooldown window (via
+ * `evaluateAllBlockedNotice`), same stderr suppress-log text, same
+ * return-false-on-suppress contract.
+ */
+
+import {
+  evaluateAllBlockedNotice,
+  type FallbackAllBlockedNoticeState,
+} from '../auto-fallback-fleet.js'
+
+let allBlockedState: FallbackAllBlockedNoticeState = { lastSentAtMs: 0 }
+let strictPinnedState: FallbackAllBlockedNoticeState = { lastSentAtMs: 0 }
+
+/** Reset both cooldown windows — called on a successful account swap. */
+export function resetFleetFallbackNoticeCooldowns(): void {
+  allBlockedState = { lastSentAtMs: 0 }
+  strictPinnedState = { lastSentAtMs: 0 }
+}
+
+/**
+ * Gate the "all accounts blocked" card. Returns true if it should be sent now
+ * (advancing the cooldown window); false if suppressed by the window, writing the
+ * same stderr suppress log the gateway used inline.
+ */
+export function shouldSendAllBlockedNotice(
+  triggerAgent: string,
+  now: number = Date.now(),
+): boolean {
+  const verdict = evaluateAllBlockedNotice(allBlockedState, now)
+  if (!verdict.send) {
+    process.stderr.write(
+      `telegram gateway: [fleet-fallback] all-blocked card suppressed (cooldown) agent=${triggerAgent}\n`,
+    )
+    return false
+  }
+  allBlockedState = verdict.next
+  return true
+}
+
+/**
+ * Gate the "strict-pinned" card. Same contract as `shouldSendAllBlockedNotice`,
+ * against the separate strict-pinned cooldown window.
+ */
+export function shouldSendStrictPinnedNotice(
+  triggerAgent: string,
+  now: number = Date.now(),
+): boolean {
+  const verdict = evaluateAllBlockedNotice(strictPinnedState, now)
+  if (!verdict.send) {
+    process.stderr.write(
+      `telegram gateway: [fleet-fallback] strict-pinned card suppressed (cooldown) agent=${triggerAgent}\n`,
+    )
+    return false
+  }
+  strictPinnedState = verdict.next
+  return true
+}