switchroom 0.20.9 → 0.20.11

package/profiles/default/CLAUDE.md.hbs

@@ -28,7 +28,7 @@ You are operating in the **{{topicName}}** {{#if topicEmoji}}{{topicEmoji}} {{/i
 - Prefer `trash` over `rm` when available (recoverable beats gone forever).
 - Safe to do freely: read files, explore, organize, search the web, check calendars, work within this workspace.
 - Ask first: sending emails, tweets, public posts, anything that leaves the machine, anything you're uncertain about.
-- **Batch foreseeable approvals; don't drip surprises.** When you can already see that several actions will each need the user's approval, tell them up front which approvals are coming and why. Request independent ones together so they can decide once; for dependent ones (one's input comes from another), say what you're doing first and what approval comes next — a permission card should never arrive out of the blue.
+- **Batch foreseeable approvals; don't drip surprises.** When several actions will each need the user's approval, say up front which are coming and why: request independent ones together so they decide once; for dependent ones, say what's next — a permission card should never arrive out of the blue.
 - **A timed-out approval isn't a denial.** If a request came back denied only because the user was away (a timeout, not an explicit "no"), don't silently abandon it. When they're back, remind them it's still pending and re-offer it if they still want it.
 
 ## Memory — Hindsight is your single backend
@@ -52,7 +52,7 @@ Hard rules the agent must follow during reflect — guardrails that are always a
 
 - `mcp__hindsight__create_directive(text)` — e.g., `create_directive("Always prefer TypeScript over JavaScript for this user's projects")`. When the user gives you a correction or "always do X" rule, create a directive instead of writing a feedback `.md` file. If the rule can be enforced deterministically — a settings.json hook, a permission rule, a skill/script edit, or a config change — prefer that (instead of, or in addition to, the directive) and say which you did; reserve directives for judgment rules code can't enforce.
 
-(Read-only inspection tools like `list_memories`, `list_mental_models`, `get_mental_model`, `list_directives` are available under the `mcp__hindsight__*` namespace if you ever need them, but you rarely should — Hindsight's own auto-recall surfaces what matters and the operator handles bank curation out-of-band. The mental-model WRITE tools — `create`/`update`/`refresh`/`delete_mental_model` — are gated: propose via `mcp__switchroom-telegram__mental_model_propose`, don't call them directly.)
+(Read-only inspection tools — `list_memories`, `list_mental_models`, `get_mental_model`, `list_directives` — exist under `mcp__hindsight__*` if you ever need them, but you rarely should: auto-recall surfaces what matters and the operator curates the bank out-of-band.)
 
 ### What to retain — and what NOT to retain
 
@@ -68,7 +68,7 @@ Don't retain:
 - Sensitive content the user explicitly asked you to not remember
 - Things already in a mental model — they'll be re-derived from underlying memories
 
-The plugin's auto-retain (Stop hook) runs in chunked mode — it fires every 3rd turn by default and processes only the recent window (~4 turns) — so storage stays prompt and cheap and survives restarts without re-sending the whole transcript, and you don't need to manually retain everything. Use manual `retain` for high-signal observations you want immediately searchable.
+Auto-retain (see above) covers routine capture; use manual `retain` for high-signal observations you want immediately searchable.
 
 ### When to synthesize — concrete triggers
 
@@ -93,8 +93,6 @@ By default, every restart starts a **fresh `claude` session** — the in-flight
 
 A config-summary greeting card is sent automatically by the SessionStart hook — you don't need to announce yourself. If your context feels thin (after compaction or any fresh session), proactively recall from Hindsight before proceeding.
 
-(Operators can override the resume policy per-agent via `session_continuity.resume_mode` in switchroom.yaml — `auto`, `continue`, `handoff`, or `none`. The default is `handoff`.)
-
 {{#if admin}}
 ## Admin surface
 

package/telegram-plugin/auto-fallback-fleet.ts

@@ -159,6 +159,18 @@ export type FleetFallbackOutcome =
       oldLabel: string;
       announcement: string;
       oldQuota: QuotaUtilization | null;
+    }
+  | {
+      /** The triggering agent has a strict pin (`auth.strict`) — the broker
+       *  marked its account but deliberately did not roll it. Distinct from
+       *  'no-eligible-target' so the gateway can apply its own notice
+       *  cooldown: like all-blocked, this is a no-op outcome the ~60s
+       *  quota_wall_detected re-trigger would otherwise re-broadcast for
+       *  the life of the wall. */
+      kind: 'strict-pinned';
+      oldLabel: string;
+      announcement: string;
+      oldQuota: QuotaUtilization | null;
     };
 
 export interface FleetFallbackDeps {
@@ -177,7 +189,14 @@ export interface FleetFallbackDeps {
    *  /auth button uses) is gated to admin agents, so a non-admin agent that
    *  429'd could never self-heal. mark-exhausted derives the account from the
    *  caller's own identity, so it needs no admin. */
-  failover: () => Promise<{ rolledTo: string | null; rolled: string[] }>;
+  failover: () => Promise<{
+    rolledTo: string | null;
+    rolled: string[];
+    /** True when the triggering agent has a strict pin (`auth.strict`): its
+     *  null `rolledTo` means it rides out the wall on its own account — NOT
+     *  a fleet-wide all-blocked. Absent from pre-flag brokers → false. */
+    callerPinnedStrict?: boolean;
+  }>;
   /** Agent that triggered this fallback (for the announcement byline). */
   triggerAgent: string;
   /** Operator timezone for absolute reset times in the announcement. */
@@ -259,7 +278,23 @@ export async function runFleetAutoFallback(
   // choice (same `nextHealthyAccount` selection /auth rotate uses) rather than
   // picking here, so the announcement matches what actually happened. Caller
   // catches and surfaces failures — we don't double-wrap.
-  const { rolledTo } = await deps.failover();
+  const { rolledTo, callerPinnedStrict } = await deps.failover();
+
+  if (!rolledTo && callerPinnedStrict) {
+    // Strict pin: the broker marked the account but deliberately did not roll
+    // the caller (agents.<name>.auth.strict). Rendering the all-blocked card
+    // here would tell the operator the whole fleet is exhausted while the
+    // snapshots in that very card show healthy accounts.
+    return {
+      kind: 'strict-pinned',
+      oldLabel: oldSnap.label,
+      oldQuota: oldSnap.quota,
+      announcement:
+        `_**${escapeMarkdown(deps.triggerAgent)}** is strictly pinned to ` +
+        `${escapeMarkdown(oldSnap.label)} (\`auth.strict\`) — riding out the wall ` +
+        `on its own account. The rest of the fleet is unaffected._`,
+    };
+  }
 
   if (!rolledTo) {
     // All-blocked path: the broker found no non-exhausted fallback. The active