switchroom 0.19.2 → 0.19.4

package/dist/host-control/main.js

@@ -26663,7 +26663,7 @@ import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:f
 import { dirname as dirname4, join as join7 } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.19.2";
+var VERSION = "0.19.4";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "switchroom",
   "//version": "NOT the release version — source of truth is the git tag, resolved by scripts/build.mjs:resolveVersion() (see CLAUDE.md > Standard release process). This field is stale by design and only the Layer-4 dev/non-tag fallback for build.mjs + src/cli/resolve-version.ts; do NOT bump it expecting a release to pick it up. npm-pack tarball naming needs a real version — do that as an UNCOMMITTED pack-time bump (see release step 6), never a committed one.",
-  "version": "0.19.2",
+  "version": "0.19.4",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/profiles/default/CLAUDE.md.hbs

@@ -70,6 +70,14 @@ Don't retain:
 
 The plugin's auto-retain (Stop hook) fires every turn, but in chunked mode each retain only processes a small recent window (~3 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.
 
+### When to synthesize — concrete triggers
+
+Auto-recall and auto-retain keep the bank fed, but they never *synthesize* — that's on you, and it only happens if you act on these triggers. Each is paired with a deterministic backstop so nothing depends on you remembering:
+
+- **Reflect instead of hand-assembling.** When a question needs an answer *across many past memories* — "what did we decide about X", "summarize where Y stands", "have I seen this before" — call `mcp__hindsight__reflect` rather than firing several `recall`s and stitching the fragments yourself. Rule of thumb: if you're about to make 2+ manual `recall` calls to reconstruct one answer, that's a `reflect`. (Backstop: auto-recall already injects the top hits every turn — reflect is the escalation when those aren't enough, not a replacement.)
+- **Propose a model when you keep re-deriving.** When you notice you've rebuilt the *same standing answer* two or three sessions running — the recurring state of your specialty a user keeps asking around — stop re-deriving and propose a mental model via `mcp__switchroom-telegram__mental_model_propose(name, source_query)` (or run the `mental-model-curator` skill to survey the bank and propose the earned few). One organic proposal beats ten reflexive recalls. Don't propose for a one-off fact — that's a `retain`; don't propose identity/"who is the user" — profile banks own that.
+- **Merge or retire directives when they pile up.** Directives are capped at `MAX_DIRECTIVES=15` active per bank — past that, the lowest-priority ones are silently truncated from the `<active_directives>` recall block and never reach you. When directives start overlapping or reading stale, run the `mental-model-curator` skill's directive merge/retire pass (it proposes; deletes stay operator-approved). (Backstop: `switchroom doctor` WARNs at >12 and FAILs at >15 active directives, so the pile-up surfaces on the issues card even if you don't notice it in-session.)
+
 ## Sub-Agent Delegation
 
 The main session is for conversation. Execution belongs in sub-agents. Before making tool calls, classify the request:

package/skills/mental-model-curator/SKILL.md

@@ -9,7 +9,11 @@ description: >
   "review my memory bank", "what standing models should I have", "bootstrap
   mental models", "suggest mental models from my bank", "audit my mental models",
   "what recurring questions do I keep re-deriving", and typos like "propose
-  knowlege models". Do NOT use for storing a single fact/preference/decision —
+  knowlege models". ALSO owns the directive merge/retire pass — triggers like
+  "audit my directives", "merge my directives", "retire stale directives", "my
+  directives are overlapping", "too many active directives", "clean up my
+  guardrails", and when switchroom doctor FLAGs a bank over the directive WARN/FAIL
+  threshold. Do NOT use for storing a single fact/preference/decision —
   that is retain, not a mental model. Do NOT use for identity or "who is the
   user" — that lives in profile banks, so never propose an identity model here
   (the operator's review of the card, not any code guard, is the only gate — so
@@ -18,7 +22,7 @@ description: >
   whose shape you know, PROPOSE it through the approve/deny card — never call
   create_mental_model directly (it is not pre-approved; the propose card is the
   only sanctioned write path, Fix 1.2 / #2903).
-allowed-tools: mcp__hindsight__list_banks mcp__hindsight__get_bank_stats mcp__hindsight__list_mental_models mcp__hindsight__get_mental_model mcp__hindsight__reflect mcp__hindsight__recall mcp__switchroom-telegram__mental_model_propose
+allowed-tools: mcp__hindsight__list_banks mcp__hindsight__get_bank_stats mcp__hindsight__list_mental_models mcp__hindsight__get_mental_model mcp__hindsight__list_directives mcp__hindsight__reflect mcp__hindsight__recall mcp__switchroom-telegram__mental_model_propose
 ---
 
 # mental-model-curator — Propose standing knowledge models from your own bank
@@ -54,6 +58,9 @@ models. Propose the few that are earned; let the operator ratify.
   (name + source_query + one-line reason) and STOP. Do NOT call
   `mental_model_propose` in this mode. This is the safe way to run against any
   bank.
+- **Directive merge/retire pass:** a separate job — see "Directive merge/retire
+  pass" below. It is always proposal-only (text out; the operator taps to enact),
+  and runs independently of the mental-model modes above.
 
 ## Workflow
 
@@ -145,6 +152,65 @@ empty topic at 3am is useless and noisy. If invoked from a scheduled sweep,
 the next interactive turn instead of firing cards unattended. Treat live-turn,
 operator-present proposing as the only supported path for now.
 
+## Directive merge/retire pass
+
+A second, independent job of this skill: keep the bank's **active directives**
+lean. Directives are hard rules applied on every `reflect` — but the bank caps
+active directives at **`MAX_DIRECTIVES=15`**. Past the cap, the lowest-priority
+directives are **silently truncated** from the `<active_directives>` recall block
+and never reach the agent — so an overloaded, overlapping, or stale directive set
+doesn't just add noise, it silently drops your real guardrails. Fleet doctor
+WARNs at >12 active and FAILs at >15 (workstream C2), and its fix text points
+here — this pass is the durable path it names.
+
+**You PROPOSE; you never delete.** `delete_directive` is deliberately NOT
+pre-approved (#2911) — it falls through to a per-call operator approval card, and
+that human tap is the only gate that retires a standing guardrail. So this pass
+outputs a plan; it does not enact retirements itself.
+
+### When to run it
+
+- The operator asks (see the directive triggers in the description), OR
+- switchroom doctor flags a bank at/over the directive WARN/FAIL threshold, OR
+- you're already curating the bank and notice the directive set is bloated.
+
+### Workflow
+
+1. **List the active set.** `mcp__hindsight__list_directives` (active only). If
+   the count is comfortably under the WARN threshold (≤12) AND nothing reads
+   stale/overlapping, STOP and report "directive set is healthy (N active) —
+   nothing to merge or retire." Don't manufacture churn.
+2. **Cluster for overlap.** Group directives that encode substantially the same
+   rule (even reworded) or that are strict specializations of a broader one. Each
+   cluster of 2+ is a **merge candidate**: one crisp consolidated directive that
+   subsumes the group, with the retirements it replaces named.
+3. **Flag the stale.** A directive is a **retire candidate** when it's obsoleted
+   by a newer rule, references a decision/tool/project that no longer exists, or
+   contradicts a directive you're keeping. Contradictions are the priority — a
+   live contradictory pair makes `reflect` nondeterministic.
+4. **Present the plan as text — do NOT enact.** Output, ranked by how much it
+   reduces the active count and risk:
+   - **Merges:** the proposed consolidated directive text + the exact directives
+     (by name/id) it would retire.
+   - **Retirements:** each stale directive (name/id) + one-line reason.
+   - The resulting active count vs `MAX_DIRECTIVES`, so the operator sees whether
+     the plan clears the cap.
+   Then STOP. The operator decides. Enacting a merge is a follow-up: the
+   consolidated `create_directive` is autonomous, but **each** retirement fires
+   its own `delete_directive` approval card — that per-card human tap is the
+   deterministic backstop, not something this skill routes around.
+
+### Directive-pass anti-patterns
+
+- ❌ Calling `delete_directive` from this skill — it proposes; the operator's tap
+  on the per-call card is the only sanctioned retire path.
+- ❌ Merging directives that only look similar — a merge that drops a real
+  distinction silently weakens a guardrail. When unsure, propose retire-nothing.
+- ❌ Manufacturing merges on a healthy small set just to "tidy" — run the pass
+  when it's earned (bloat, overlap, staleness, or a doctor flag), not reflexively.
+- ❌ Leaving a live contradictory pair in place — surface it as the top retire
+  candidate; it's what makes `reflect` nondeterministic.
+
 ## Anti-patterns
 
 - ❌ Proposing against an empty or thin bank — synthesizes to noise.

package/telegram-plugin/auth-snapshot-format.ts

@@ -26,8 +26,24 @@ import { escapeMarkdown, codeSpanSafe } from './card-format.js';
 
 // ── shared types ─────────────────────────────────────────────────────
 
-/** Tri-state health verdict per account, derived from live quota. */
-export type AccountHealth = 'healthy' | 'throttling' | 'blocked' | 'unknown';
+/**
+ * Health verdict per account. The first three are derived from live quota;
+ * `retired` and `org-blocked` are config/entitlement classifications that
+ * OUTRANK quota (an out-of-service account has no meaningful "health"):
+ *   - `org-blocked` — Anthropic disabled the account at the org level
+ *     (entitlement_blocked); renders "DISABLED (org)". Populated by PR2.
+ *   - `retired` — the config no longer routes to the account (`in_service`
+ *     false: removed from fallback_order + every agent/consumer pin). It must
+ *     never read as available/healthy, is sorted LAST, and is excluded from
+ *     the switch keyboard + the recommendation.
+ */
+export type AccountHealth =
+  | 'healthy'
+  | 'throttling'
+  | 'blocked'
+  | 'unknown'
+  | 'retired'
+  | 'org-blocked';
 
 /**
  * Combined per-account view used by every formatter in this module.
@@ -51,6 +67,19 @@ export interface AccountSnapshot {
    *  stale data as current; undefined for live-probe snapshots (fresh
    *  by construction). */
   capturedAtMs?: number;
+  /**
+   * Fleet in-service classification (broker `in_service`). TRUE when the config
+   * still routes to this account; `false` → RETIRED. Absent → treated as
+   * in-service (only an explicit `false` retires, so a pre-field broker never
+   * falsely retires the fleet). Drives the `retired` health verdict.
+   */
+  inService?: boolean;
+  /**
+   * Org / entitlement-level block (broker `entitlement_blocked`, populated by
+   * PR2). TRUE → `org-blocked` health verdict ("DISABLED (org)"), which OUTRANKS
+   * retirement. Absent / false on a pre-PR2 broker.
+   */
+  entitlementBlocked?: boolean;
 }
 
 // ── health classification ────────────────────────────────────────────
@@ -98,6 +127,18 @@ const OVERAGE_EXHAUSTED_REASONS = new Set<string>(['out_of_credits']);
  * Failover safety against a real 429 is preserved via the mark-exhausted path.
  */
 export function classifyHealth(snap: AccountSnapshot, now: Date = new Date()): AccountHealth {
+  // Precedence (config/entitlement outranks quota): active > DISABLED (org) >
+  // RETIRED > quota-derived health. The active account always keeps its
+  // quota-derived verdict (it is by definition in-service and never org-blocked
+  // in the view). For every non-active account, an org-level entitlement block
+  // wins over retirement, and either wins over the quota windows — an
+  // out-of-service account has no meaningful quota "health". Only an explicit
+  // `inService === false` retires (absent → in-service), so a pre-field broker
+  // never falsely retires the fleet.
+  if (!snap.isActive) {
+    if (snap.entitlementBlocked === true) return 'org-blocked';
+    if (snap.inService === false) return 'retired';
+  }
   if (!snap.quota) return 'unknown';
   const q = snap.quota;
   // #2494 Bug C — a thin/headerless probe (no real utilization signal on
@@ -308,6 +349,8 @@ const HEALTH_EMOJI: Record<AccountHealth, string> = {
   throttling: '🟡',
   blocked: '🔴',
   unknown: '⚪',
+  'org-blocked': '⛔',
+  retired: '⚫',
 };
 
 /**
@@ -332,6 +375,19 @@ function renderAccountRow(
   const marker = snap.isActive ? '● ' : '';
   const label = displayLabel(snap.label, opts);
 
+  // Out-of-service accounts (org-disabled / retired) outrank quota: their live
+  // windows are irrelevant and misleading (a retired account at 0%/0% reads as
+  // "available"), so render a single status note instead of a quota bar.
+  const health = classifyHealth(snap, now);
+  if (health === 'org-blocked' || health === 'retired') {
+    const note =
+      health === 'org-blocked'
+        ? 'DISABLED (org) — no fleet routing'
+        : 'retired — removed from fleet rotation';
+    lines.push(`${marker}\`${codeSpanSafe(label)}\`  _${note}_`);
+    return lines;
+  }
+
   if (!snap.quota) {
     lines.push(
       `${marker}\`${codeSpanSafe(label)}\`  _quota probe failed_`,
@@ -360,7 +416,6 @@ function renderAccountRow(
     `${marker}\`${codeSpanSafe(label)}\`  ${fiveStr} / ${sevenStr}`,
   );
 
-  const health = classifyHealth(snap, now);
   if (health === 'blocked') {
     // quota-exhausted (recoverable): surface only the recovery countdown — the
     // binding window's reset is the only thing that matters until then.
@@ -432,10 +487,14 @@ function formatAgeStamp(atMs: number, now: Date = new Date()): string {
  * blocked → throttling → unknown → healthy.
  */
 const TABLE_HEALTH_RANK: Record<AccountHealth, number> = {
-  blocked: 0,
-  throttling: 1,
-  unknown: 2,
-  healthy: 3,
+  // org-disabled is a hard, actionable problem → first. RETIRED is out of
+  // service (informational, not actionable) → LAST, after healthy.
+  'org-blocked': 0,
+  blocked: 1,
+  throttling: 2,
+  unknown: 3,
+  healthy: 4,
+  retired: 5,
 };
 
 /** Escape a cell value for a GFM table cell: pipes break the column grid, and
@@ -565,7 +624,15 @@ export function recommendation(
   const active = snapshots.find((s) => s.isActive);
   if (!active) return 'No active account set.';
   const activeHealth = classifyHealth(active, now);
-  const others = snapshots.filter((s) => !s.isActive);
+  // EXCLUDE out-of-service accounts (retired / org-disabled) from the
+  // recommendation entirely: a retired account is not a switch target and must
+  // not inflate an "all accounts blocked" verdict. Only in-service accounts are
+  // candidate alternatives or count toward the fleet-blocked summary.
+  const inServiceFleet = snapshots.filter((s) => {
+    const h = classifyHealth(s, now);
+    return h !== 'retired' && h !== 'org-blocked';
+  });
+  const others = inServiceFleet.filter((s) => !s.isActive);
   const healthyAlt = others.find((s) => classifyHealth(s, now) === 'healthy');
   // Demo mode masks the email labels that appear in the recommendation
   // sentence, in lockstep with the per-account rows above.
@@ -590,7 +657,8 @@ export function recommendation(
     // #2494 Bug B — no healthy alternative. Do NOT collapse to "All accounts
     // blocked": that's only honest when EVERY account is truly walled with no
     // usable or imminently-refilling slot. Distinguish the buckets first.
-    return summarizeNoHealthyAlt(snapshots, now, demo);
+    // Only in-service accounts count — a retired account is not "blocked".
+    return summarizeNoHealthyAlt(inServiceFleet, now, demo);
   }
 
   // unknown
@@ -770,7 +838,15 @@ export function renderFallbackAnnouncement(input: FallbackAnnouncementInput): st
       // Blocked-first ordering mirrors renderAuthSnapshotFormat2 — the user
       // scans the walled accounts (and their recovery times) at the top, with
       // the active account floating first within its group.
-      const healthOrder: AccountHealth[] = ['blocked', 'throttling', 'healthy', 'unknown'];
+      const healthOrder: AccountHealth[] = [
+        'org-blocked',
+        'blocked',
+        'throttling',
+        'healthy',
+        'unknown',
+        // RETIRED last — out of service, informational only.
+        'retired',
+      ];
       const rank = (s: AccountSnapshot): number => healthOrder.indexOf(classifyHealth(s, now));
       const ordered = [...fleet].sort(
         (a, b) => rank(a) - rank(b) || Number(b.isActive) - Number(a.isActive),
@@ -937,7 +1013,18 @@ export function buildSnapshotKeyboard(
   const switchTargets = snapshots
     .filter((s) => !s.isActive)
     .sort((a, b) => switchPriority(a, now) - switchPriority(b, now))
-    .filter((s) => classifyHealth(s, now) !== 'blocked' && classifyHealth(s, now) !== 'unknown')
+    .filter((s) => {
+      const h = classifyHealth(s, now);
+      // Never offer a switch into a target we can't (or shouldn't) serve on:
+      // blocked / unknown (existing), and now RETIRED / org-disabled — an
+      // out-of-service account is not a valid fleet target.
+      return (
+        h !== 'blocked' &&
+        h !== 'unknown' &&
+        h !== 'retired' &&
+        h !== 'org-blocked'
+      );
+    })
     .slice(0, max);
 
   for (const t of switchTargets) {
@@ -964,7 +1051,8 @@ function switchPriority(s: AccountSnapshot, now: Date = new Date()): number {
   if (h === 'healthy') return 0;
   if (h === 'throttling') return 1;
   if (h === 'unknown') return 2;
-  return 3; // blocked
+  if (h === 'blocked') return 3;
+  return 4; // retired / org-blocked — out of service, always last (and filtered)
 }
 
 // ── shared HTML escape ───────────────────────────────────────────────
@@ -1073,6 +1161,8 @@ export function buildSnapshotsFromState(
       quota: q && q.ok ? q.data : null,
       quotaError: q && !q.ok ? q.reason : undefined,
       expiresAtMs: acc.expiresAt,
+      inService: acc.in_service,
+      entitlementBlocked: acc.entitlement_blocked,
     });
   }
   return out;
@@ -1128,6 +1218,8 @@ export function buildSnapshotsFromCachedState(
       // stale data (the 2026-06-09 incident: a recovery latched days
       // earlier only surfaced — and notified — at the next fleet bounce).
       capturedAtMs: lq?.capturedAt,
+      inService: acc.in_service,
+      entitlementBlocked: acc.entitlement_blocked,
     };
   });
 }

package/telegram-plugin/dist/bridge/bridge.js

@@ -23711,6 +23711,7 @@ function startSessionTail(config2) {
   let stopped = false;
   let pendingPartial = "";
   const fileCursors = new Map;
+  const replayUntilByFile = new Map;
   function readNew() {
     if (stopped || !currentFile)
       return;
@@ -23719,11 +23720,15 @@ function startSessionTail(config2) {
       if (stat.size < cursor) {
         cursor = 0;
         pendingPartial = "";
-        if (currentFile != null)
+        if (currentFile != null) {
           fileCursors.delete(currentFile);
+          replayUntilByFile.delete(currentFile);
+        }
       }
       if (stat.size === cursor)
         return;
+      const chunkStart = cursor;
+      const isReplayChunk = chunkStart < (replayUntilByFile.get(currentFile) ?? 0);
       const buf = Buffer.alloc(stat.size - cursor);
       const fd = openSync(currentFile, "r");
       try {
@@ -23743,7 +23748,7 @@ function startSessionTail(config2) {
         const sid = sessionIdForFile(currentFile);
         for (const ev of events) {
           try {
-            onEvent(decorate(ev, sid));
+            onEvent(decorate(isReplayChunk && ev.kind === "model" ? { ...ev, replayed: true } : ev, sid));
           } catch (err) {
             log?.(`session-tail: onEvent threw: ${err.message}`);
           }
@@ -23796,6 +23801,7 @@ function startSessionTail(config2) {
         const size = statSync3(file).size;
         cursor = computeFirstAttachCursor(file, size);
         if (cursor < size) {
+          replayUntilByFile.set(file, size);
           log?.(`session-tail: attached to ${file} (cursor=${cursor}, replaying in-flight turn from offset; size=${size})`);
         } else {
           log?.(`session-tail: attached to ${file} (cursor=${cursor})`);