switchroom 0.20.9 → 0.20.11

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

package/telegram-plugin/gateway/gateway.ts

@@ -433,7 +433,8 @@ import {
 import { createThrottleTierRunner } from './throttle-tier-wiring.js'
 import { parseLitellmNoticeWindowMs } from '../litellm-local-notice.js'
 import { createLitellmLocalNoticeRunner, decideRateLimitedSurface } from './litellm-local-notice-wiring.js'
-import { runFleetAutoFallback, renderFallbackFailureNotice, evaluateFallbackFailureNotice, evaluateAllBlockedNotice, type FallbackFailureNoticeState, type FallbackAllBlockedNoticeState } from '../auto-fallback-fleet.js'
+import { runFleetAutoFallback, renderFallbackFailureNotice, evaluateFallbackFailureNotice, type FallbackFailureNoticeState } from '../auto-fallback-fleet.js'
+import { resetFleetFallbackNoticeCooldowns, shouldSendAllBlockedNotice, shouldSendStrictPinnedNotice } from './fleet-fallback-notice-cooldown.js'
 import { startRestartWatchdog } from './restart-watchdog.js'
 import { createAccessStore } from './access-store.js'
 
@@ -626,6 +627,13 @@ import { readTurnUsages } from '../../src/agents/perf.js'
 import { buildContextOccupancy, writeContextOccupancySnapshot } from './context-occupancy.js'
 import { decideProactiveCompact, initialCompactState, type CompactState } from './proactive-compact.js'
 import { IdleTracker, idleDurationToMs, DEFAULT_IDLE_CLEAR_MS } from './idle-clear.js'
+import {
+  openPrivateInterval,
+  closePrivateInterval,
+  PRIVATE_ON_REPLY,
+  PUBLIC_REPLY,
+} from './privacy-state.js'
+import { makePrivacyResetForNewSession, isContinueRestoreBoot } from './privacy-reset.js'
 import { nextCompactNotify, idleCompactNotifyState, type CompactNotifyState } from './compact-notify.js'
 import {
   tryHostdDispatch,
@@ -769,13 +777,9 @@ import type { ChatKey as _ChatKey } from './inbound-delivery-machine.js'
 import { dispatchEffects } from './inbound-delivery-machine-dispatch.js'
 import { maybeFireWarmup } from './prefix-warmup.js'
 import {
-  renderSkillProposalCard,
-  skillProposalKeyboard,
-} from './skill-proposal-card.js'
-import {
-  enqueueProposal as enqueueSkillProposal,
-  isSuppressed as isSkillProposalSuppressed,
-} from '../../src/self-improve/skill-proposals.js'
+  handlePostSkillProposal,
+  handlePostEvalCaseProposal,
+} from './self-improve-proposal-wiring.js'
 import { decideSubagentHandback } from './subagent-handback-inbound-builder.js'
 import {
   decideSubagentProgress,
@@ -803,6 +807,7 @@ import type {
   QueryPendingPermissionMessage,
   CheckPreApprovedMessage,
   PostSkillProposalMessage,
+  PostEvalCaseProposalMessage,
   PermissionEvent,
   RolloutStatusPostMessage,
   RolloutStatusEditMessage,
@@ -5097,6 +5102,10 @@ function maybeIdleClear(): void {
           `telegram gateway: idle /clear suppressed for ${agentName} ` +
             `(activity in check-to-send gap)\n`,
         );
+      } else {
+        // The idle /clear fired → new logical session; reset privacy to public.
+        const idleChat = loadAccess().allowFrom[0];
+        if (idleChat) resetPrivacyForNewSession(String(idleChat), undefined);
       }
     })
     .catch((err: unknown) => {
@@ -5600,6 +5609,11 @@ const swallowingApiCall = createSwallowingRetryApiCall(
   robustApiCall,
   (line) => process.stderr.write(line),
 )
+// Privacy (#private-mode): reset to public on a genuine new session (boot / /clear); loud only on a private→public transition. See privacy-reset.ts.
+const resetPrivacyForNewSession = makePrivacyResetForNewSession((chatId, threadId, text) =>
+  void swallowingApiCall(
+    () => lockedBot.api.sendMessage(chatId, text, threadId != null ? { message_thread_id: threadId, disable_notification: false } : { disable_notification: false }),
+    { chat_id: chatId, verb: 'privacy-reset-alert', priorityClass: 'critical' }))
 
 /**
  * The ONE seam every `setMessageReaction` in this gateway goes through (#3155).
@@ -9058,6 +9072,11 @@ const stalePinSweeper: StalePinSweeper = createGatewayStalePinSweeper({
       ? loadStatusPins(STATUS_PIN_STORE_PATH, statusPinStoreFs)
       : [],
   eligible: () => stalePinSweepEligible,
+  // Share the live path's per-process pin-rights negative cache so the sweep
+  // and executePinLeg agree on rights-less chats (D3): the sweep skips a chat
+  // the live path already proved rights-less, and feeds its own reactive
+  // discoveries back so the live path skips too.
+  rightsCache: statusPinRightsCache,
   store: { path: STALE_PIN_SWEEP_STORE_PATH, fs: sweepStoreFs },
   // Per-deployment override only. UNSET (the normal case) means "take the
   // standing policy" — UNPIN_ALL_FORUM_TOPIC_ENABLED in stale-pin-sweep.ts,
@@ -11592,69 +11611,19 @@ if (isGatewayMain) ipcServer = createIpcServer({
   // onQuotaWallDetected so it doesn't fall inside the source slice that
   // send-outbound-wiring.test.ts takes between onSendOutbound and
   // onQuotaWallDetected.
+  // Thin delegate — body lives in self-improve-proposal-wiring.ts to keep the
+  // gateway line ratchet flat. Placed AFTER onQuotaWallDetected so it doesn't
+  // fall inside the source slice send-outbound-wiring.test.ts takes between
+  // onSendOutbound and onQuotaWallDetected.
   onPostSkillProposal(_client: IpcClient, msg: PostSkillProposalMessage) {
-    const self = process.env.SWITCHROOM_AGENT_NAME
-    if (self && msg.agentName !== self) {
-      process.stderr.write(
-        `telegram gateway: post_skill_proposal rejected — agent mismatch (${msg.agentName} != ${self})\n`,
-      )
-      return
-    }
-    try {
-      assertAllowedChat(msg.chatId)
-    } catch (err) {
-      process.stderr.write(
-        `telegram gateway: post_skill_proposal rejected — ${(err as Error).message}\n`,
-      )
-      return
-    }
-    const stateDir = process.env.TELEGRAM_STATE_DIR
-    if (stateDir == null || stateDir.length === 0) {
-      process.stderr.write(`telegram gateway: post_skill_proposal: TELEGRAM_STATE_DIR unset, skipping\n`)
-      return
-    }
-    // Dedup against still-live rejection fingerprints — never re-surface a
-    // proposal the operator already dismissed.
-    if (isSkillProposalSuppressed(stateDir, {
-      lesson: msg.lesson,
-      draft: msg.draft,
-      skill_slug: msg.skillSlug,
-    })) {
-      process.stderr.write(
-        `telegram gateway: post_skill_proposal suppressed (rejected before) slug=${msg.skillSlug}\n`,
-      )
-      return
-    }
-    const proposal = enqueueSkillProposal(stateDir, {
-      skill_slug: msg.skillSlug,
-      is_new: msg.isNew,
-      lesson: msg.lesson,
-      draft: msg.draft,
-      evidence: msg.evidence,
-      chat_id: Number(msg.chatId),
-    })
-    const cardText = renderSkillProposalCard({
-      id: proposal.id,
-      skill_slug: proposal.skill_slug,
-      is_new: proposal.is_new,
-      lesson: proposal.lesson,
-      evidence: proposal.evidence,
-      skill_md: proposal.draft['SKILL.md'],
-    })
-    const threadId = msg.threadId
-    void swallowingApiCall(
-      () =>
-        bot.api.sendMessage(msg.chatId, cardText, {
-          parse_mode: 'HTML',
-          reply_markup: skillProposalKeyboard(proposal.id),
-          ...(threadId != null && threadId !== 1 ? { message_thread_id: threadId } : {}),
-        }),
-      { chat_id: msg.chatId, verb: 'skill-proposal-card', ...(threadId != null ? { threadId } : {}) },
-    )
-    process.stderr.write(
-      `telegram gateway: post_skill_proposal agent=${msg.agentName} chat=${msg.chatId} ` +
-      `proposal=${proposal.id} slug=${proposal.skill_slug} new=${proposal.is_new}\n`,
-    )
+    handlePostSkillProposal(msg, { bot, assertAllowedChat, swallowingApiCall })
+  },
+
+  // RFC amendment §"corrections as eval cases" — thin delegate; the
+  // DETERMINISTIC applier runs on Approve in handleEvalCaseProposalCallback,
+  // NOT a model turn. Body in self-improve-proposal-wiring.ts.
+  onPostEvalCaseProposal(_client: IpcClient, msg: PostEvalCaseProposalMessage) {
+    handlePostEvalCaseProposal(msg, { bot, assertAllowedChat, swallowingApiCall })
   },
 
   // Buzz Phase 2b: the duplex peer's advisory publish outcome — no-op unless the hub mirror booted.
@@ -17683,6 +17652,10 @@ async function refreshPinnedBanner(reason: string): Promise<void> {
       onError: (phase, err) => {
         process.stderr.write(`telegram gateway: banner ${phase} failed (${reason}): ${err}\n`)
       },
+      // Share the one per-process pin-rights negative cache with the status-pin
+      // path and the stale-pin sweep (D5): the banner skips a chat already known
+      // rights-less and records/clears its own pin-verb discoveries there.
+      rightsCache: statusPinRightsCache,
       // Durable pin persistence into the SHARED status-pin store (distinct
       // `banner:` pinKey). persist-BEFORE-pin ordering: pending() lands before
       // the pinChatMessage call so a crash in that window is recoverable by the
@@ -17908,16 +17881,10 @@ const litellmLocalNoticeRunner = createLitellmLocalNoticeRunner({
  */
 let fallbackFailureNoticeState: FallbackFailureNoticeState = { lastSentAtMs: 0 }
 
-/**
- * Bug 2 — per-gateway cooldown for the "All accounts blocked" card. The
- * all-blocked outcome is a no-op swap (doFireFleetAutoFallback returns false),
- * so the fleetFallbackGate dedup window never arms for it, and the ~60s
- * quota_wall_detected re-trigger would otherwise re-broadcast the identical card
- * every minute for the life of the wall. This bounds it to one card per window.
- * Reset on a successful swap so a fresh all-blocked after a recovery (a real new
- * transition) is not stale-suppressed.
- */
-let fallbackAllBlockedNoticeState: FallbackAllBlockedNoticeState = { lastSentAtMs: 0 }
+// Per-gateway cooldown gates for the two NO-OP fleet-fallback outcomes
+// (all-blocked and strict-pinned) live in ./fleet-fallback-notice-cooldown.ts,
+// which owns their state and stderr suppress-logs (switchroom#4442, extracted to
+// keep the inline notice logic out of the line-ratchet-guarded gateway.ts).
 
 function broadcastFleetFallbackFailure(triggerAgent: string, reason: string): void {
   if (process.env.SWITCHROOM_FLEET_FALLBACK_FAILURE_NOTICE === '0') return
@@ -18167,7 +18134,11 @@ async function doFireFleetAutoFallback(
         // weekly-capped account is never re-probed (and re-wedged) within the
         // broker's ~5h default.
         const r = await client.markExhausted(untilMs)
-        return { rolledTo: r.rolledTo ?? null, rolled: r.rolled }
+        return {
+          rolledTo: r.rolledTo ?? null,
+          rolled: r.rolled,
+          callerPinnedStrict: r.caller_pinned_strict ?? false,
+        }
       },
       triggerAgent,
       tz,
@@ -18193,7 +18164,11 @@ async function doFireFleetAutoFallback(
     // cooldown; a successful swap resets the window so a later (genuinely new)
     // all-blocked still emits promptly.
     if (outcome.kind === 'switched') {
-      fallbackAllBlockedNoticeState = { lastSentAtMs: 0 }
+      resetFleetFallbackNoticeCooldowns()
+    } else if (outcome.kind === 'strict-pinned') {
+      // Same cooldown pattern as all-blocked (below): a no-op outcome the
+      // ~60s wall re-trigger would otherwise re-broadcast every minute.
+      if (!shouldSendStrictPinnedNotice(triggerAgent)) return false
     } else if (outcome.kind === 'all-blocked') {
       // ── Second recovery tier: MODEL-TIER downgrade (precedence A) ──────────
       // Account-swap just came back all-blocked (no account still serves the
@@ -18210,14 +18185,7 @@ async function doFireFleetAutoFallback(
         // card — a restart is coming that replays the interrupted turn.
         return false
       }
-      const verdict = evaluateAllBlockedNotice(fallbackAllBlockedNoticeState, Date.now())
-      if (!verdict.send) {
-        process.stderr.write(
-          `telegram gateway: [fleet-fallback] all-blocked card suppressed (cooldown) agent=${triggerAgent}\n`,
-        )
-        return false
-      }
-      fallbackAllBlockedNoticeState = verdict.next
+      if (!shouldSendAllBlockedNotice(triggerAgent)) return false
     }
     // Post the announcement to every authorized chat. Mirrors the
     // operator-event broadcast pattern (line ~2290) — DM-only opts
@@ -19849,6 +19817,22 @@ bot.command('compact', async ctx => {
 })
 bot.command('clear', async ctx => {
   await handleInjectCommand(ctx, buildInjectDeps({ open: true, fixedVerb: '/clear' }))
+  // A /clear starts a new logical session → reset privacy to public.
+  const clearChatId = String(ctx.chat!.id)
+  resetPrivacyForNewSession(clearChatId, resolveThreadId(clearChatId, ctx.message?.message_thread_id))
+})
+// Per-operator session privacy controls. NOT admin verbs (deliberately kept
+// out of ADMIN_COMMAND_NAMES) — they gate memory writing for THIS session, so
+// they share the plain per-command isAuthorizedSender gate like inject/clear.
+bot.command('private', async ctx => {
+  if (!isAuthorizedSender(ctx)) return
+  openPrivateInterval()
+  await switchroomReply(ctx, PRIVATE_ON_REPLY)
+})
+bot.command('public', async ctx => {
+  if (!isAuthorizedSender(ctx)) return
+  closePrivateInterval()
+  await switchroomReply(ctx, PUBLIC_REPLY)
 })
 // /model and /effort extracted to bot-commands-model-effort.ts
 // (switchroom#2996 P6 bot.command drain). Helper registration keeps grammy
@@ -21749,6 +21733,15 @@ bot.on('callback_query:data', async ctx => {
     return
   }
 
+  // RFC amendment §"corrections as eval cases": one-tap eval-case card.
+  //   evcase:approve:<id> — run the DETERMINISTIC apply-eval-case applier
+  //                         (byte-exact write; NOT a model turn)
+  //   evcase:deny:<id>    — dismiss + mark the proposal rejected
+  if (data.startsWith('evcase:')) {
+    await callbackQueryHandlers.handleEvalCaseProposalCallback(ctx, data)
+    return
+  }
+
   // #2862: missed-approvals re-offer digest.
   //   missre:retry:<id>   — inject a synthetic inbound asking the agent to
   //                         re-attempt (re-raises a fresh approval card)
@@ -23527,6 +23520,8 @@ async function startGateway(): Promise<void> {  // #2996 P0c: the boot IIFE, now
             // Only when we KNOW it was a /model switch (reason) AND we will send the
             // confirmation (marker chat captured); otherwise the boot card fires
             // normally. Version/quota remain available via /status.
+            // Privacy: genuine FRESH boot (cold/crash/planned/model-switch) → reset to public, reusing boot-card's chat. Suppressed on a --continue/auto transcript-restore (state must persist) and never wired to bridge-reconnect.
+            if (target && !isContinueRestoreBoot(resolveAgentDirFromEnv())) resetPrivacyForNewSession(target.chatId, target.threadId)
             const suppressBootCardForModelSwitch =
               modelSwitchReason != null && modelSwitchMarkerChat != null
             if (target && suppressBootCardForModelSwitch) {