switchroom 0.19.3 → 0.19.5

package/dist/auth-broker/index.js

@@ -18839,6 +18839,27 @@ function parseQuotaHeaders(headers, now = new Date) {
     }
   };
 }
+function extractApiErrorMessage(bodyText) {
+  if (!bodyText || bodyText.trim().length === 0)
+    return null;
+  try {
+    const parsed = JSON.parse(bodyText);
+    const msg = parsed?.error?.message;
+    if (typeof msg === "string" && msg.trim().length > 0)
+      return msg.trim();
+  } catch {}
+  return bodyText.trim().slice(0, 500);
+}
+function isEntitlementDisabledMessage(message) {
+  if (!message)
+    return false;
+  const m = message.toLowerCase();
+  if (!m.includes("disabled"))
+    return false;
+  const mentionsCode = m.includes("claude code") || m.includes("claude subscription");
+  const mentionsOrgOrSub = m.includes("organization") || m.includes("subscription") || m.includes(" org ");
+  return mentionsCode && mentionsOrgOrSub;
+}
 async function fetchQuota(opts) {
   const token = opts.accessToken?.trim();
   if (!token || token.length === 0) {
@@ -18874,13 +18895,28 @@ async function fetchQuota(opts) {
     }
     return { ok: false, reason: `quota probe network error: ${msg}` };
   }
-  clearTimeout(timeout);
   const parsed = parseQuotaHeaders(resp.headers);
-  if (parsed.ok)
+  if (parsed.ok) {
+    clearTimeout(timeout);
     return parsed;
+  }
   if (!resp.ok) {
-    return { ok: false, reason: `HTTP ${resp.status} from Anthropic (${parsed.reason})` };
+    let bodyText = "";
+    try {
+      bodyText = await resp.text();
+    } catch {}
+    clearTimeout(timeout);
+    const apiErrorMessage = extractApiErrorMessage(bodyText);
+    const entitlement = resp.status === 403 && isEntitlementDisabledMessage(apiErrorMessage);
+    return {
+      ok: false,
+      reason: `HTTP ${resp.status} from Anthropic (${parsed.reason})`,
+      httpStatus: resp.status,
+      ...apiErrorMessage ? { apiErrorMessage } : {},
+      failureKind: entitlement ? "entitlement_blocked" : "other"
+    };
   }
+  clearTimeout(timeout);
   return parsed;
 }
 
@@ -18912,7 +18948,9 @@ function snapshotClearlyHealthy(s) {
   return s.fiveHourUtilizationPct < HEALTHY_CLEAR_PCT && s.sevenDayUtilizationPct < HEALTHY_CLEAR_PCT;
 }
 function accountEligibility(opts) {
-  const { mark, snapshot, now, allowOverage = false } = opts;
+  const { mark, snapshot, now, allowOverage = false, entitlementBlocked = false } = opts;
+  if (entitlementBlocked)
+    return "blocked";
   if (snapshotFresh(snapshot, now) && snapshotWalled(snapshot) && !overageLiftsWall(snapshot, allowOverage)) {
     return "blocked";
   }
@@ -19343,16 +19381,20 @@ async function fetchAndSummarizeExternalSpend(opts) {
       },
       signal: ac.signal
     });
-    if (!res.ok)
+    if (!res.ok) {
+      console.warn(`external-spend: LiteLLM /spend/logs returned HTTP ${res.status} — ` + `External /usage row will be blank (check master key / proxy)`);
       return null;
+    }
     let body;
     try {
       body = await res.json();
-    } catch {
+    } catch (err) {
+      console.warn(`external-spend: failed to parse /spend/logs JSON: ${err?.message ?? err}`);
       return null;
     }
     return summarizeExternalSpend(normalizeSpendLogRows(body), now);
-  } catch {
+  } catch (err) {
+    console.warn(`external-spend: LiteLLM /spend/logs fetch failed: ${err?.message ?? err}`);
     return null;
   } finally {
     clearTimeout(timer);
@@ -21170,9 +21212,51 @@ class AuthBroker {
       mark: this.exhaustionMarkOf(account),
       snapshot: this.lastQuotaCache[account],
       now: this.now(),
-      allowOverage: this.isOverageAllowed(account)
+      allowOverage: this.isOverageAllowed(account),
+      entitlementBlocked: this.isAccountEntitlementBlocked(account)
     });
   }
+  isAccountEntitlementBlocked(account) {
+    return this.quota[account]?.entitlement_blocked === true;
+  }
+  markEntitlementBlocked(label, result) {
+    if (result.ok || result.failureKind !== "entitlement_blocked")
+      return;
+    if (this.quota[label]?.entitlement_blocked === true)
+      return;
+    this.quota[label] = {
+      ...this.quota[label],
+      entitlement_blocked: true,
+      entitlement_blocked_at: this.now(),
+      ...result.apiErrorMessage ? { entitlement_blocked_reason: result.apiErrorMessage } : {}
+    };
+    this.persistQuota();
+    this.audit({
+      op: "mark-exhausted",
+      identity: { kind: "operator" },
+      account: label,
+      accountKind: "claude",
+      ok: true,
+      reason: "entitlement-403"
+    });
+    process.stdout.write(`auth-broker: ${label} returned entitlement-403 (Claude Code access disabled) — marked entitlement_blocked${result.apiErrorMessage ? ` (${result.apiErrorMessage})` : ""}
+`);
+  }
+  clearEntitlementBlocked(label) {
+    const entry = this.quota[label];
+    if (!entry?.entitlement_blocked)
+      return;
+    const {
+      entitlement_blocked,
+      entitlement_blocked_at,
+      entitlement_blocked_reason,
+      ...rest
+    } = entry;
+    this.quota[label] = rest;
+    this.persistQuota();
+    process.stdout.write(`auth-broker: live probe of ${label} succeeded — cleared entitlement_blocked mark
+`);
+  }
   premiumWallMarkOf(account) {
     const q = this.quota[account];
     if (!q || q.premium_walled_until === undefined)
@@ -21329,7 +21413,8 @@ class AuthBroker {
       mark: this.exhaustionMarkOf(account),
       snapshot,
       now,
-      allowOverage: true
+      allowOverage: true,
+      entitlementBlocked: this.isAccountEntitlementBlocked(account)
     }) === "eligible";
   }
   accountEligibilityOf(account) {
@@ -21339,7 +21424,8 @@ class AuthBroker {
       mark: this.exhaustionMarkOf(account),
       snapshot,
       now: this.now(),
-      allowOverage
+      allowOverage,
+      entitlementBlocked: this.isAccountEntitlementBlocked(account)
     });
     if (verdict === "eligible" && allowOverage && snapshot && (snapshot.fiveHourUtilizationPct >= WALL_PCT || snapshot.sevenDayUtilizationPct >= WALL_PCT)) {
       process.stdout.write(`auth-broker: ${account} is past the utilization wall but eligible via allow_overage — Anthropic overage billing active (5h=${snapshot.fiveHourUtilizationPct.toFixed(1)}%, 7d=${snapshot.sevenDayUtilizationPct.toFixed(1)}%)
@@ -21356,6 +21442,8 @@ class AuthBroker {
       const result = await this.probeQuotaSingleFlight(account, token);
       if (result.ok)
         this.cacheQuotaSnapshot(account, result);
+      else
+        this.markEntitlementBlocked(account, result);
     } catch {}
   }
   async nextHealthyAccountLive(current, order) {
@@ -21455,7 +21543,6 @@ class AuthBroker {
         expiresAt: creds?.claudeAiOauth?.expiresAt,
         exhausted,
         in_service: inService.has(label),
-        entitlement_blocked: false,
         exhausted_until: q?.exhausted_until,
         throttled_until: q?.throttled_until,
         threshold_violations: this.thresholdViolations[label] ?? 0,
@@ -21465,6 +21552,7 @@ class AuthBroker {
         premium_walled_until: q?.premium_walled_until,
         premium_wall_bucket: q?.premium_wall_bucket,
         last_tier_quota: this.lastTierQuotaCache[label] ?? null,
+        entitlement_blocked: q?.entitlement_blocked ?? false,
         usage_ledger: summarizeAccountUsage(this.usageLedger, label, this.now())
       };
     });
@@ -21539,6 +21627,7 @@ class AuthBroker {
         this.cacheQuotaSnapshot(label, result);
         return { label, result, served: "live" };
       }
+      this.markEntitlementBlocked(label, result);
       if (cached) {
         return { label, result: cachedSnapshotToResult(cached), served: "cache", capturedAt: cached.capturedAt };
       }
@@ -21560,6 +21649,7 @@ class AuthBroker {
   cacheQuotaSnapshot(label, result) {
     if (!result.ok)
       return;
+    this.clearEntitlementBlocked(label);
     const snapshot = {
       fiveHourUtilizationPct: result.data.fiveHourUtilizationPct,
       sevenDayUtilizationPct: result.data.sevenDayUtilizationPct,
@@ -21589,6 +21679,8 @@ class AuthBroker {
     const canarySet = this.premiumCanarySet();
     const canaryEnabled = process.env.SWITCHROOM_DISABLE_MODEL_TIER_PROBE !== "1";
     for (const label of listAccounts(this.home)) {
+      if (this.isAccountEntitlementBlocked(label))
+        continue;
       const creds = readAccountCredentials(label, this.home);
       const token = creds?.claudeAiOauth?.accessToken;
       if (!token)
@@ -21601,6 +21693,7 @@ class AuthBroker {
         continue;
       }
       this.cacheQuotaSnapshot(label, result);
+      this.markEntitlementBlocked(label, result);
       probed.push({ label, result });
       if (canaryEnabled && canarySet.has(label)) {
         let tierResult;

package/dist/cli/autoaccept-poll.js

@@ -490,6 +490,7 @@ async function runWedgeWatchdog(opts) {
   let confirmModalPresent = 0;
   let permissionPromptPresent = 0;
   let manifestStallPresent = 0;
+  let lastManifestKey = null;
   let confirmCooldownUntil = 0;
   let permissionCooldownUntil = 0;
   while (polls < maxPolls) {
@@ -505,11 +506,16 @@ async function runWedgeWatchdog(opts) {
     const isPermissionPrompt = !isRateLimitMenu && !!text && permissionPromptSignature !== null && permissionPromptSignature.test(text);
     const isConfirmModal = !isRateLimitMenu && !isPermissionPrompt && !!text && confirmModalSignature !== null && confirmModalSignature.test(text);
     const isBlockingModal = !isRateLimitMenu && !isPermissionPrompt && !isConfirmModal && !!text && signature.test(text) && !deferToPrompts.some((p) => p.match.test(text));
-    const isManifestStall = !!text && manifestStallSignature !== null && manifestStallSignature.test(text) && STOP_HOOK_ERROR_SIGNATURE.test(text);
+    const manifestSignatureHit = !!text && manifestStallSignature !== null && manifestStallSignature.test(text);
+    const manifestKey = manifestSignatureHit ? stabilityKey(text) : null;
+    const stopHookPresent = !!text && STOP_HOOK_ERROR_SIGNATURE.test(text);
+    const manifestNoProgress = manifestSignatureHit && (stopHookPresent || manifestKey === lastManifestKey);
+    lastManifestKey = manifestKey;
+    const isManifestStall = manifestNoProgress;
     if (isManifestStall) {
       manifestStallPresent++;
       if (manifestStallPresent >= manifestStallPolls) {
-        const detail = `Manifesting + stop-hook-error present ${manifestStallPresent} polls ` + `(~${Math.round(manifestStallPresent * pollIntervalMs / 1000)}s) with no progress`;
+        const detail = `Manifesting ${stopHookPresent ? "+ stop-hook-error " : "pane byte-stable "}` + `present ${manifestStallPresent} polls ` + `(~${Math.round(manifestStallPresent * pollIntervalMs / 1000)}s) with no progress`;
         console.error(`[wedge-watchdog] ${opts.agentName}: manifest-stall wedge \u2014 ${detail}; ` + (requestRestart ? "escalating to kill + handoff restart" : "no requestRestart wired \u2014 logging only"));
         if (requestRestart) {
           try {

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.19.3", COMMIT_SHA = "41896be4";
+var VERSION = "0.19.5", COMMIT_SHA = "c5feaef8";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -29899,6 +29899,15 @@ function normalizeBindMountPath(p) {
     out = out.slice(0, -1);
   return out;
 }
+function isLoopbackHttpBase(url) {
+  try {
+    const u = new URL(url.includes("://") ? url : `http://${url}`);
+    const h = (u.hostname || "").toLowerCase();
+    return h === "localhost" || h === "127.0.0.1" || h === "::1";
+  } catch {
+    return false;
+  }
+}
 function resolveConfigMountSource(switchroomConfigPath, homePrefix) {
   if (!switchroomConfigPath)
     return;
@@ -30154,13 +30163,17 @@ function generateCompose(opts) {
   }
   lines.push(`      SWITCHROOM_AUTH_BROKER_STATE_DIR: /state/auth-broker`);
   let authBrokerNeedsHostGateway = false;
+  let authBrokerNeedsHostNetwork = false;
   {
     const llBase = config.litellm?.base_url;
     if (typeof llBase === "string" && llBase.trim()) {
       const raw = llBase.trim().replace(/\/+$/, "");
-      const bridged = raw.replace(/^http:\/\/127\.0\.0\.1(?=[:/]|$)/i, "http://host.docker.internal").replace(/^http:\/\/localhost(?=[:/]|$)/i, "http://host.docker.internal").replace(/^https:\/\/127\.0\.0\.1(?=[:/]|$)/i, "https://host.docker.internal").replace(/^https:\/\/localhost(?=[:/]|$)/i, "https://host.docker.internal");
-      lines.push(`      SWITCHROOM_LITELLM_BASE: ${JSON.stringify(bridged)}`);
-      authBrokerNeedsHostGateway = true;
+      lines.push(`      SWITCHROOM_LITELLM_BASE: ${JSON.stringify(raw)}`);
+      if (isLoopbackHttpBase(raw)) {
+        authBrokerNeedsHostNetwork = true;
+      } else {
+        authBrokerNeedsHostGateway = true;
+      }
     }
   }
   lines.push(`      SWITCHROOM_ACCOUNTS_DIR: /state/accounts`);
@@ -30168,7 +30181,9 @@ function generateCompose(opts) {
   if (opts.operatorUid !== undefined) {
     lines.push(`      SWITCHROOM_AUTH_BROKER_OPERATOR_UID: "${opts.operatorUid}"`);
   }
-  if (authBrokerNeedsHostGateway) {
+  if (authBrokerNeedsHostNetwork) {
+    lines.push(`    network_mode: host`);
+  } else if (authBrokerNeedsHostGateway) {
     lines.push(`    extra_hosts:`);
     lines.push(`      - "host.docker.internal:host-gateway"`);
   }

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.3";
+var VERSION = "0.19.5";
 
 // 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.3",
+  "version": "0.19.5",
   "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/_base/start.sh.hbs

@@ -325,6 +325,32 @@ x-litellm-tags: agent:$SWITCHROOM_AGENT_NAME,profile:${SWITCHROOM_AGENT_PROFILE:
   #    retrying — it recovers on its own the moment the broker
   #    unlocks (no human, no container recreate); bot token invalid
   #    → 401 → gateway exits 78 → quarantined (operator action).
+  # --- Session-model carrier PRE-FORK SNAPSHOT (gateway-consume boot race) ---
+  # The gateway forked just below consumes `.session-model` (+ the bounded-retry
+  # attempt counter) the moment it acquires the boot lock (#3284 healthy-boot
+  # consume, gateway.ts). But the session-model RESOLUTION block runs much later
+  # in the INNER pass — behind the LiteLLM probe's up-to-120s wait — so the
+  # gateway reliably won the race and the carrier vanished before resolution
+  # ever read it: a `/model <target>` differing from the configured default was
+  # silently dropped and the boot reverted (the overlord `/model fable`
+  # NOT-APPLIED incident, 2026-07). Snapshot the carrier + counter HERE, before
+  # the fork, into `.boot-snapshot` siblings the gateway never touches; the
+  # resolution block prefers the snapshot and deletes it after use (per-boot
+  # ephemeral). Refresh-or-remove every boot so a stale snapshot can never
+  # re-apply a consumed override on a later restart.
+  rm -f "{{agentDir}}/.session-model.boot-snapshot" "{{agentDir}}/.session-model-boot-attempts.boot-snapshot"
+  if [ -f "{{agentDir}}/.session-model" ]; then
+    # A failed copy (ENOSPC, perms) must not be a SILENT drop — the resolution
+    # block still falls back to the live carrier, but the gateway may consume
+    # that first, so warn loudly enough to diagnose a reverted override.
+    cp -f "{{agentDir}}/.session-model" "{{agentDir}}/.session-model.boot-snapshot" 2>/dev/null \
+      || echo "session-model: WARNING — failed to snapshot .session-model before the gateway fork; if the gateway consumes the carrier first, this boot's /model override may silently revert to the configured default" >&2
+    if [ -f "{{agentDir}}/.session-model-boot-attempts" ]; then
+      cp -f "{{agentDir}}/.session-model-boot-attempts" "{{agentDir}}/.session-model-boot-attempts.boot-snapshot" 2>/dev/null \
+        || echo "session-model: WARNING — failed to snapshot .session-model-boot-attempts before the gateway fork (retry-budget count may be lost this boot)" >&2
+    fi
+  fi
+
   _gateway_bundle=/opt/switchroom/telegram-plugin/dist/gateway/gateway.js
   _telegram_enabled={{#if telegramEnabledFlag}}{{telegramEnabledFlag}}{{else}}true{{/if}}
   if [ "$_telegram_enabled" = "true" ] && [ -f "$_gateway_bundle" ] && command -v bun >/dev/null 2>&1; then
@@ -1333,7 +1359,11 @@ rm -f "{{agentDir}}/.relaunch-model-intent" "{{agentDir}}/.session-model-kept-no
 # meaningless without a carrier to belong to, so sweep it as stale ONLY when no
 # `.session-model` carrier is present (rollout leftover / completed apply / a
 # prior giveup that didn't get to delete it).
-[ -f "{{agentDir}}/.session-model" ] || rm -f "{{agentDir}}/.session-model-boot-attempts"
+# (Gateway-consume race fix: the outer pass snapshotted the carrier BEFORE the
+# gateway fork — the gateway may already have consumed the live carrier by now
+# on a healthy boot, so the snapshot is an equally valid "a carrier existed
+# this boot" signal.)
+{ [ -f "{{agentDir}}/.session-model" ] || [ -f "{{agentDir}}/.session-model.boot-snapshot" ]; } || rm -f "{{agentDir}}/.session-model-boot-attempts"
 
 # Migration shim (one release): a leftover one-shot `.session-model-override`
 # carrier from a pre-consume-once gateway means an OLD gateway wrote it
@@ -1344,6 +1374,18 @@ if [ -f "{{agentDir}}/.session-model-override" ]; then
   rm -f "{{agentDir}}/.session-model-override"
   if printf '%s' "$_mig" | grep -Eq '^[A-Za-z0-9][]A-Za-z0-9._[/-]{0,99}$'; then
     printf '{"model":"%s","configuredDefaultAtWrite":"%s","ts":%s}\n' "$_mig" "$_EFFECTIVE_MODEL" "$(( $(date +%s) * 1000 ))" > "{{agentDir}}/.session-model" 2>/dev/null || true
+    # Also refresh the pre-fork snapshot: this write happened AFTER the outer
+    # pass's snapshot point, and the resolution below prefers the snapshot. A
+    # newer legacy intent must win over any stale pre-fork copy (and survive
+    # an early gateway consume of the live file).
+    #
+    # KNOWN one-release quirk (accepted): this live write also lands AFTER the
+    # gateway's boot-lock consume already fired, so on a healthy boot nothing
+    # deletes it until the NEXT boot's gateway consume — the migrated legacy
+    # override therefore applies for up to TWO boots instead of one. Shim-only
+    # (the mainline gateway writes `.session-model` directly, pre-restart, so
+    # it is snapshotted and consumed normally); the shim dies next release.
+    cp -f "{{agentDir}}/.session-model" "{{agentDir}}/.session-model.boot-snapshot" 2>/dev/null || true
     echo "session-model: migrated legacy one-shot carrier '$_mig' to .session-model (applying + consuming this boot)" >&2
   else
     echo "session-model: ignoring malformed legacy .session-model-override (failed shape gate)" >&2
@@ -1351,8 +1393,19 @@ if [ -f "{{agentDir}}/.session-model-override" ]; then
   unset _mig
 fi
 
-if [ -f "{{agentDir}}/.session-model" ]; then
-  _smf="$(cat "{{agentDir}}/.session-model" 2>/dev/null || true)"
+# Prefer the PRE-FORK SNAPSHOT over the live carrier: on a healthy boot the
+# gateway (forked long before this block runs) has typically ALREADY consumed
+# the live `.session-model` by now — reading only the live file silently
+# reverted every `/model <target>` that differed from the configured default
+# (the overlord `/model fable` NOT-APPLIED incident). The snapshot was taken
+# before the gateway fork so it is race-free; fall back to the live file when
+# no snapshot exists (non-docker runtimes / block run standalone in tests).
+if [ -f "{{agentDir}}/.session-model.boot-snapshot" ] || [ -f "{{agentDir}}/.session-model" ]; then
+  if [ -f "{{agentDir}}/.session-model.boot-snapshot" ]; then
+    _smf="$(cat "{{agentDir}}/.session-model.boot-snapshot" 2>/dev/null || true)"
+  else
+    _smf="$(cat "{{agentDir}}/.session-model" 2>/dev/null || true)"
+  fi
   _sm_model="$(printf '%s' "$_smf" | sed -n 's/.*"model"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p')"
   _sm_cfg="$(printf '%s' "$_smf" | sed -n 's/.*"configuredDefaultAtWrite"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p')"
   # BOUNDED-RETRY CONSUME (#3284) — the carrier is NO LONGER deleted here before
@@ -1380,7 +1433,13 @@ if [ -f "{{agentDir}}/.session-model" ]; then
   # and persists the incremented counter. The delete-before-apply that used to
   # sit here is GONE by design.
   _SM_MAX_ATTEMPTS=3
-  _sm_attempts="$(cat "{{agentDir}}/.session-model-boot-attempts" 2>/dev/null | tr -dc '0-9' || true)"
+  # Counter read prefers the pre-fork snapshot for the same race reason (the
+  # gateway deletes the live counter alongside the carrier on healthy consume).
+  if [ -f "{{agentDir}}/.session-model-boot-attempts.boot-snapshot" ]; then
+    _sm_attempts="$(cat "{{agentDir}}/.session-model-boot-attempts.boot-snapshot" 2>/dev/null | tr -dc '0-9' || true)"
+  else
+    _sm_attempts="$(cat "{{agentDir}}/.session-model-boot-attempts" 2>/dev/null | tr -dc '0-9' || true)"
+  fi
   [ -z "$_sm_attempts" ] && _sm_attempts=0
   _sm_attempts=$(( _sm_attempts + 1 ))
   # Shape gate — kept BYTE-IDENTICAL with MODEL_ARG_RE in
@@ -1444,6 +1503,10 @@ if [ -f "{{agentDir}}/.session-model" ]; then
   fi
   unset _smf _sm_model _sm_cfg _sm_attempts _SM_MAX_ATTEMPTS
 fi
+# The snapshot is strictly per-boot: consumed here regardless of which branch
+# fired, so it can never re-apply an already-consumed override on a later boot
+# (the outer pass also refresh-or-removes it, belt and braces).
+rm -f "{{agentDir}}/.session-model.boot-snapshot" "{{agentDir}}/.session-model-boot-attempts.boot-snapshot"
 
 # Configured-default LiteLLM guard, SPLIT BY CAUSE (2026-07-17 boot-race
 # incident: a slow LiteLLM co-boot demoted a configured-fable agent to opus on