switchroom 0.20.9 → 0.20.10

package/bin/handoff-briefing.sh

@@ -34,9 +34,32 @@
 #   - AGENT_DIR               — output destination (if HANDOFF_BRIEFING_STDOUT!=1)
 #
 # Usage:
-#   handoff-briefing.sh [--stdout]
+#   handoff-briefing.sh [--stdout] [--lean]
 #
 # The --stdout flag overrides HANDOFF_BRIEFING_STDOUT=1.
+#
+# LEAN MODE (--lean, alias --mode=compaction)
+# -------------------------------------------
+# The compaction re-seat path (bin/working-state-reload-hook.sh, wired as the
+# SessionStart(compact) hook) invokes this script with --lean so BOTH legacy-
+# and gateway-briefing agents share ONE assembler at the compaction boundary —
+# no copy of the sqlite/recall logic lives in the hook. Lean mode differs from
+# the boot briefing in three deliberate ways:
+#
+#   1. It emits ONLY the recent-Telegram-tail + Hindsight-recall sections.
+#      Daily-memory (Source 3) and the "You just restarted at …" header are
+#      SKIPPED. Rationale is token duplication, not latency: Claude Code's
+#      native compaction summary already preserves the recent turns, so
+#      re-injecting the full boot briefing on every compaction of a long
+#      session partially triples coverage.
+#   2. It IGNORES the SWITCHROOM_PENDING_* env (boot-time pending-turn scope).
+#      Those name the surface that was mid-turn at the PREVIOUS boot; at a
+#      compaction hours into a live session they are stale and would brief the
+#      WRONG chat surface. Lean mode zeroes them so the python scoper derives
+#      the single most-recently-active (chat_id, thread_id) straight from the
+#      DB (scope_source=db-latest).
+#   3. It forces stdout and never touches AGENT_DIR (no output file), so it is
+#      safe to call from the hook regardless of whether AGENT_DIR is exported.
 
 set -u
 
@@ -71,12 +94,32 @@ HINDSIGHT_TIMEOUT="${HANDOFF_BRIEFING_HINDSIGHT_TIMEOUT:-3}"
 TARGET_CHAT_ID="${SWITCHROOM_PENDING_CHAT_ID:-}"
 TARGET_THREAD_ID="${SWITCHROOM_PENDING_THREAD_ID:-}"
 
-# Determine output mode
+# Determine output + lean mode. Parse every arg (order-independent) so
+# `--lean`, `--stdout`, or both, work regardless of position.
 STDOUT_MODE=0
-if [ "${HANDOFF_BRIEFING_STDOUT:-}" = "1" ] || [ "${1:-}" = "--stdout" ]; then
+LEAN_MODE=0
+for _arg in "$@"; do
+  case "$_arg" in
+    --stdout) STDOUT_MODE=1 ;;
+    --lean|--mode=compaction) LEAN_MODE=1 ;;
+    *) : ;;
+  esac
+done
+if [ "${HANDOFF_BRIEFING_STDOUT:-}" = "1" ]; then
   STDOUT_MODE=1
 fi
 
+# Lean (compaction) mode: force stdout, and ZERO the pending-turn env scope so
+# the python scoper falls through to db-latest (see LEAN MODE note in header).
+# This is the load-bearing correctness fix for a mid-session compaction: the
+# SWITCHROOM_PENDING_* surface is the previous boot's, not the currently-active
+# chat. Clearing them here (not in the hook) keeps the single scoping code path.
+if [ "$LEAN_MODE" = "1" ]; then
+  STDOUT_MODE=1
+  TARGET_CHAT_ID=""
+  TARGET_THREAD_ID=""
+fi
+
 # ── Source 1: Recent Telegram messages ─────────────────────────────────────────
 TELEGRAM_SECTION=""
 if [ -n "$TELEGRAM_STATE" ] && [ -d "$TELEGRAM_STATE" ]; then
@@ -362,7 +405,9 @@ fi
 # dropping today's memory.
 DAILY_SECTION=""
 TODAY=$(TZ="$_TZ_VAL" date +%Y-%m-%d 2>/dev/null || date +%Y-%m-%d 2>/dev/null || true)
-if [ -n "$TODAY" ] && [ -n "$WORKSPACE_DIR" ]; then
+# Lean/compaction mode SKIPS daily memory (token duplication — the native
+# summary already carries recent context; see LEAN MODE note in header).
+if [ "$LEAN_MODE" != "1" ] && [ -n "$TODAY" ] && [ -n "$WORKSPACE_DIR" ]; then
   DAILY_FILE="$WORKSPACE_DIR/memory/${TODAY}.md"
   if [ -f "$DAILY_FILE" ] && [ -s "$DAILY_FILE" ]; then
     DAILY_CONTENT=$(cat "$DAILY_FILE")
@@ -391,7 +436,14 @@ if [ -n "$OUTPUT_FILE" ]; then
 else
   # stdout / no-AGENT_DIR mode — buffered; print the whole briefing once.
   if [ -n "$STDOUT_BUFFER" ]; then
-    printf '%s\n\n---\n\n%s\n' "$BRIEFING_HEADER" "$STDOUT_BUFFER"
+    if [ "$LEAN_MODE" = "1" ]; then
+      # Lean/compaction: no "You just restarted at …" boot header — this is a
+      # mid-conversation compaction, not a restart, and the hook emits its own
+      # <compact-recovery> framing. Print only the assembled sections.
+      printf '%s\n' "$STDOUT_BUFFER"
+    else
+      printf '%s\n\n---\n\n%s\n' "$BRIEFING_HEADER" "$STDOUT_BUFFER"
+    fi
   fi
 fi
 

package/bin/working-state-reload-hook.sh

@@ -0,0 +1,262 @@
+#!/bin/bash
+# working-state-reload-hook.sh — deliver post-compaction continuation into
+# context immediately after context compaction.
+#
+# WHY THIS EXISTS
+# ---------------
+# Claude Code auto-compacts late in the context window. The native
+# auto-summarizer produces a structured summary of intent/changes/pending
+# work, but it is lossy: fast-moving detail an agent is actively juggling
+# mid-task (a checklist, the current plan, in-flight IDs, the exact "where
+# was I" scratch, recent phrasing) is exactly what a summary flattens or
+# drops. Worse, the model resuming from a summary can read it as a FRESH
+# start and re-greet the user, breaking a conversation the user experiences
+# as unbroken.
+#
+# This hook closes that gap deterministically, in three layers:
+#   1. It ALWAYS emits a short, static recovery/orientation block — for
+#      EVERY agent, whether or not it maintains a working-state file. This
+#      is the load-bearing default: it tells the model its context was just
+#      compacted mid-conversation, that the native summary is lossy, and
+#      which concrete recovery tools exist in this environment.
+#   2. If the agent maintains a working-state file AND it is non-empty, the
+#      hook additionally appends that file verbatim (with its last-modified
+#      time, so a stale/forgotten file is visibly stale rather than silently
+#      steering).
+#   3. It emits a LEAN briefing (P1) — a scoped recent Telegram tail + a
+#      Hindsight recall — so the compacted session gets fresh-boot PARITY:
+#      it picks up the actual conversation, not just the fact it was
+#      compacted. This is delegated to handoff-briefing.sh --lean (the SINGLE
+#      briefing assembler; no copy of the sqlite/recall logic here), so BOTH
+#      legacy- and gateway-briefing agents share one compaction re-seat path.
+#      Lean by design: it skips daily-memory/workspace re-render (token
+#      duplication — the native summary already keeps recent turns) and
+#      ignores SWITCHROOM_PENDING_* to brief the db-latest chat surface rather
+#      than a stale pending-turn one. Graceful: if history.db or Hindsight is
+#      unavailable it emits what it can (or nothing) and never fails the hook.
+#
+# It is wired as a SessionStart hook with matcher "compact" (see
+# src/agents/scaffold.ts buildSettingsHooksBlock). Per Claude Code's hook
+# contract:
+#   - SessionStart fires with source="compact" on auto OR manual compaction,
+#     mid-turn, right after the compaction boundary.
+#   - Text a SessionStart hook prints to stdout IS added to the model's
+#     context (unlike PreCompact stdout, which is NOT injected).
+# So printing here re-seats orientation (and any working state) into context
+# the instant the summary replaces the transcript — no marker file, no
+# gateway round-trip, no waiting for the next user message.
+#
+# The matcher "compact" is load-bearing: it scopes this hook to compaction
+# ONLY. A bare (matcher-less) SessionStart also fires on "startup", "resume",
+# "clear", and "fork", which would inject the recovery block on every boot —
+# noise, and prompt-cache churn. We rely on the matcher AND, belt-and-braces,
+# re-check the `source` field from stdin below so a future Claude Code matcher
+# regression can never turn this into an every-boot inject.
+#
+# THE WORKING-STATE FILE CONVENTION
+# ---------------------------------
+#   $TELEGRAM_STATE_DIR/.working-state.md
+# i.e. <agentDir>/telegram/.working-state.md (TELEGRAM_STATE_DIR is exported
+# by start.sh as "<agentDir>/telegram"). An agent maintains this file itself
+# as its durable scratch of "what I'm mid-way through". If the file is absent
+# or empty — the common case for agents that don't use it — the hook simply
+# skips the append; the static recovery block is still emitted. No file is
+# ever created here.
+#
+# PERFORMANCE
+# -----------
+# The static recovery block and working-state append are local-only (a heredoc
+# plus at most one `stat`/`cat` of a small file) — sub-second. The lean
+# briefing (layer 3) adds one local SQLite read and ONE network hop to
+# Hindsight, which handoff-briefing.sh caps (HANDOFF_BRIEFING_HINDSIGHT_TIMEOUT,
+# default 3s). Worst-case runtime is therefore a few seconds, dominated by that
+# cap; the SessionStart(compact) hook's Claude Code timeout is set accordingly
+# in src/agents/scaffold.ts. Latency here is a non-issue by design: compaction
+# itself takes far longer, and the prompt cache is already invalidated by the
+# summary replacing the transcript. (Contrast the hindsight session_start.py
+# SessionStart hook, which times out at its 5s budget on every firing — a
+# separate, independent context-loss cause tracked against the hindsight-memory
+# plugin, NOT fixed here.)
+#
+# Failure modes are all silent: a hook that errors would surface on the issues
+# card via run-hook.sh, but a missing/absent working-state file, an unreadable
+# mtime, a missing history.db, or an unreachable Hindsight is never an error —
+# the recovery block still emits and the hook exits 0.
+
+set -u
+
+# ---------------------------------------------------------------------------
+# Defensive source guard. The matcher "compact" in settings.json already
+# scopes Claude Code to fire this hook only on compaction, but we re-verify
+# the source from the hook's stdin JSON so a matcher regression (or a manual
+# mis-wire) can never cause this to inject on a normal startup/resume/clear/
+# fork boot. If stdin carries a `source` and it is not "compact", exit
+# silently. If there is no stdin (e.g. a unit test invoking the script
+# directly), fall through and trust the matcher.
+# ---------------------------------------------------------------------------
+if ! [ -t 0 ]; then
+  STDIN_JSON=$(cat 2>/dev/null || true)
+  if [ -n "${STDIN_JSON:-}" ]; then
+    SOURCE=""
+    if command -v jq >/dev/null 2>&1; then
+      SOURCE=$(printf '%s' "$STDIN_JSON" | jq -r '.source // empty' 2>/dev/null || true)
+    else
+      SOURCE=$(printf '%s' "$STDIN_JSON" \
+        | grep -o '"source"[[:space:]]*:[[:space:]]*"[^"]*"' \
+        | head -1 \
+        | sed 's/.*"source"[[:space:]]*:[[:space:]]*"//;s/"$//' 2>/dev/null || true)
+    fi
+    if [ -n "$SOURCE" ] && [ "$SOURCE" != "compact" ]; then
+      exit 0
+    fi
+  fi
+fi
+
+# ---------------------------------------------------------------------------
+# Static recovery/orientation block. ALWAYS emitted on a compaction start,
+# for EVERY agent — this is the load-bearing default. Plain stdout from a
+# SessionStart hook IS added to the model's context by Claude Code, so this
+# re-orients the model the instant the native summary replaces the transcript.
+# Deterministic heredoc string: no network, no CLI fork.
+# ---------------------------------------------------------------------------
+cat <<'EOF'
+<compact-recovery source="switchroom working-state-reload hook">
+Your context was just COMPACTED mid-conversation. This is NOT a fresh start:
+you are CONTINUING a conversation the user experiences as unbroken. The native
+summary above is lossy — it flattens or drops fast-moving detail (in-flight
+IDs, the exact "where was I", recent phrasing). Do not greet the user or act
+as if starting over; pick up where the conversation left off.
+
+Re-orient using the recovery tools in THIS environment before continuing:
+  - Telegram chat history: the get_recent_messages MCP tool
+    (mcp__switchroom-telegram__get_recent_messages) to re-read what was just
+    being discussed.
+  - Hindsight memory: recall / reflect (mcp__hindsight__recall,
+    mcp__hindsight__reflect) for facts and decisions from earlier sessions.
+  - Workspace files for durable task state.
+</compact-recovery>
+EOF
+
+# ---------------------------------------------------------------------------
+# Resolve the working-state file. Primary: $TELEGRAM_STATE_DIR (exported by
+# start.sh for telegram-plugin agents). Fallback: derive the conventional
+# telegram state dir from the agent name, so the hook still works if invoked
+# in a context where TELEGRAM_STATE_DIR is not exported. If neither resolves,
+# skip the working-state append — the recovery block above already emitted,
+# and the lean briefing below still runs.
+#
+# NOTE: this is a GUARDED block (not an early `exit`), because the lean
+# post-compaction briefing further down must run for EVERY compaction,
+# including the common case of an agent that keeps no working-state file.
+# ---------------------------------------------------------------------------
+STATE_DIR="${TELEGRAM_STATE_DIR:-}"
+if [ -z "$STATE_DIR" ]; then
+  AGENT_NAME="${SWITCHROOM_AGENT_NAME:-}"
+  if [ -n "$AGENT_NAME" ] && [ -n "${HOME:-}" ]; then
+    STATE_DIR="$HOME/.switchroom/agents/$AGENT_NAME/telegram"
+  fi
+fi
+
+WORKING_STATE_FILE=""
+if [ -n "$STATE_DIR" ]; then
+  WORKING_STATE_FILE="$STATE_DIR/.working-state.md"
+fi
+
+# Append the working state only when the file resolves AND is non-empty.
+if [ -n "$WORKING_STATE_FILE" ] && [ -s "$WORKING_STATE_FILE" ]; then
+  # -------------------------------------------------------------------------
+  # Resolve the working-state file's last-modified time so a stale, forgotten
+  # file is VISIBLY stale to the model rather than silently steering it. Try a
+  # portable sequence: GNU/busybox `stat -c %y`, then BSD/macOS `stat -f %Sm`,
+  # then GNU `date -r <file>`. If none work, omit the mtime — never fail the
+  # hook over it.
+  # -------------------------------------------------------------------------
+  MTIME=""
+  if MTIME=$(stat -c %y "$WORKING_STATE_FILE" 2>/dev/null) && [ -n "$MTIME" ]; then
+    :
+  elif MTIME=$(stat -f '%Sm' "$WORKING_STATE_FILE" 2>/dev/null) && [ -n "$MTIME" ]; then
+    :
+  elif MTIME=$(date -r "$WORKING_STATE_FILE" 2>/dev/null) && [ -n "$MTIME" ]; then
+    :
+  else
+    MTIME=""
+  fi
+
+  # -------------------------------------------------------------------------
+  # Append the working state verbatim, wrapped in its own delimiter block. The
+  # header line carries the mtime (when resolvable) so a stale file reads as
+  # stale.
+  # -------------------------------------------------------------------------
+  printf '%s\n' '<working-state source="switchroom working-state-reload hook">'
+  if [ -n "$MTIME" ]; then
+    printf '%s\n' 'The following is your working-state file ('"$WORKING_STATE_FILE"', last updated '"$MTIME"'),'
+  else
+    printf '%s\n' 'The following is your working-state file ('"$WORKING_STATE_FILE"'),'
+  fi
+  printf '%s\n' 'reloaded verbatim so in-flight task state survives the summarizer. It may'
+  printf '%s\n' 'be stale — reconcile it against the summary and the recovery tools above'
+  printf '%s\n' 'before trusting it, then continue.'
+  printf '%s\n' '---'
+  cat "$WORKING_STATE_FILE"
+  printf '\n%s\n' '</working-state>'
+fi
+
+# ---------------------------------------------------------------------------
+# Lean post-compaction briefing (P1). ADDITIVE on source=compact, after the
+# static recovery block and the optional working-state append. It re-seats the
+# compacted session to fresh-boot PARITY: a scoped recent Telegram tail + a
+# Hindsight recall, so the agent picks up the actual conversation rather than
+# only being TOLD it was compacted.
+#
+# DRY: the assembly is delegated to handoff-briefing.sh --lean — the SINGLE
+# briefing assembler. No copy of the sqlite/recall logic lives here. Lean mode
+# emits ONLY the Telegram-tail + recall (daily-memory and the boot header are
+# skipped — token duplication, the native summary already keeps recent turns),
+# and IGNORES SWITCHROOM_PENDING_* to derive the db-latest surface (a stale
+# pending-turn scope would brief the wrong chat at a mid-session compaction).
+#
+# SHARED PATH: this hook fires on SessionStart(compact) for EVERY agent,
+# regardless of session_continuity.briefing mode (legacy vs gateway), so both
+# modes get identical compaction re-seat through this one path.
+#
+# GRACEFUL: if the assembler script is not found, or emits nothing (no
+# history.db, Hindsight unreachable), the block is simply omitted. The lean
+# briefing NEVER fails the hook — the recovery block above already stands on
+# its own. handoff-briefing.sh caps its only network hop (Hindsight) at a few
+# seconds, so runtime is bounded.
+# ---------------------------------------------------------------------------
+BRIEFING_SCRIPT=""
+_HOOK_DIR=$(dirname -- "$0" 2>/dev/null || true)
+if [ -n "$_HOOK_DIR" ] && [ -r "$_HOOK_DIR/handoff-briefing.sh" ]; then
+  BRIEFING_SCRIPT="$_HOOK_DIR/handoff-briefing.sh"
+elif command -v handoff-briefing.sh >/dev/null 2>&1; then
+  BRIEFING_SCRIPT="handoff-briefing.sh"
+fi
+
+if [ -n "$BRIEFING_SCRIPT" ]; then
+  # Inner timeout, SHORTER than the 8s Claude Code hook budget, so a slow
+  # assembler degrades to "recovery block only" instead of losing everything.
+  # Without it, if the assembler runs long (e.g. an operator raises
+  # HANDOFF_BRIEFING_HINDSIGHT_TIMEOUT past the hook budget) Claude Code kills
+  # the WHOLE hook at 8s and discards ALL stdout — including the near-unkillable
+  # <compact-recovery> orientation block already printed above. Capping the
+  # assembler at 5s keeps the #4390 recovery floor intact. `timeout` is
+  # coreutils (present in the agent image); fall back to an un-timed call if it
+  # is somehow unavailable, so the lean briefing still works.
+  if command -v timeout >/dev/null 2>&1; then
+    LEAN_BRIEFING=$(timeout 5 bash "$BRIEFING_SCRIPT" --lean 2>/dev/null || true)
+  else
+    LEAN_BRIEFING=$(bash "$BRIEFING_SCRIPT" --lean 2>/dev/null || true)
+  fi
+  if [ -n "$LEAN_BRIEFING" ]; then
+    printf '%s\n' '<compact-briefing source="switchroom working-state-reload hook">'
+    printf '%s\n' 'The recent conversation and recalled memory below are re-seated so this'
+    printf '%s\n' 'compacted session has the same footing as a fresh boot. Use them to pick up'
+    printf '%s\n' 'the thread; reconcile against the native summary above before trusting either.'
+    printf '%s\n' '---'
+    printf '%s\n' "$LEAN_BRIEFING"
+    printf '%s\n' '</compact-briefing>'
+  fi
+fi
+
+exit 0

package/dist/auth-broker/index.js

@@ -19820,6 +19820,23 @@ function extractApiErrorMessage(bodyText) {
   } catch {}
   return bodyText.trim().slice(0, 500);
 }
+function extractApiErrorCode(bodyText) {
+  if (!bodyText || bodyText.trim().length === 0)
+    return null;
+  try {
+    const parsed = JSON.parse(bodyText);
+    const code = parsed?.error?.details?.error_code;
+    if (typeof code === "string" && code.trim().length > 0)
+      return code.trim();
+  } catch {}
+  return null;
+}
+var ENTITLEMENT_BLOCKED_ERROR_CODES = new Set([
+  "oauth_not_allowed_for_organization"
+]);
+function isEntitlementBlockedErrorCode(code) {
+  return code != null && ENTITLEMENT_BLOCKED_ERROR_CODES.has(code);
+}
 function isEntitlementDisabledMessage(message) {
   if (!message)
     return false;
@@ -19877,7 +19894,8 @@ async function fetchQuota(opts) {
     } catch {}
     clearTimeout(timeout);
     const apiErrorMessage = extractApiErrorMessage(bodyText);
-    const entitlement = resp.status === 403 && isEntitlementDisabledMessage(apiErrorMessage);
+    const apiErrorCode = extractApiErrorCode(bodyText);
+    const entitlement = resp.status === 403 && (isEntitlementBlockedErrorCode(apiErrorCode) || isEntitlementDisabledMessage(apiErrorMessage));
     return {
       ok: false,
       reason: `HTTP ${resp.status} from Anthropic (${parsed.reason})`,

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.20.9", COMMIT_SHA = "63c4c44b";
+var VERSION = "0.20.10", COMMIT_SHA = "ebb54738";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -18815,7 +18815,9 @@ function hindsightContainerEnvPairs(opts) {
     ...hindsightLlmBudgetEnv(llm),
     ["HINDSIGHT_API_WORKER_ID", HINDSIGHT_DEFAULT_WORKER_ID],
     ...hindsightPerfEnvPairs(llm, litellm, gpu, perf),
-    ...hindsightPgEnvPairs(perf)
+    ...hindsightPgEnvPairs(perf),
+    ["SWITCHROOM_HINDSIGHT_REQUEUE_DEAD_LETTERS", HINDSIGHT_DEFAULT_REQUEUE_DEAD_LETTERS],
+    ["SWITCHROOM_HINDSIGHT_REQUEUE_MAX", HINDSIGHT_DEFAULT_REQUEUE_MAX]
   ];
   if (llmProvider === "claude-code") {
     pairs.push(["ANTHROPIC_MODEL", llmModel]);
@@ -19086,6 +19088,8 @@ function generateHindsightComposeSnippet(llm, mirrorDir, litellm, gpu, perf, cpA
     `      - HINDSIGHT_API_WORKER_ID=${HINDSIGHT_DEFAULT_WORKER_ID}`,
     ...hindsightPerfEnvPairs(llm, litellm, gpu, perf).map(([k, v]) => `      - ${k}=${v}`),
     ...hindsightPgEnvPairs(perf).map(([k, v]) => `      - ${k}=${v}`),
+    `      - SWITCHROOM_HINDSIGHT_REQUEUE_DEAD_LETTERS=${HINDSIGHT_DEFAULT_REQUEUE_DEAD_LETTERS}`,
+    `      - SWITCHROOM_HINDSIGHT_REQUEUE_MAX=${HINDSIGHT_DEFAULT_REQUEUE_MAX}`,
     `    mem_limit: ${HINDSIGHT_DEFAULT_MEM_LIMIT}`,
     `    mem_reservation: ${HINDSIGHT_DEFAULT_MEM_RESERVATION}`,
     `    pids_limit: ${HINDSIGHT_DEFAULT_PIDS_LIMIT}`,
@@ -19184,7 +19188,7 @@ async function ensureHindsightConsumer(configPath, account, uid = HINDSIGHT_DEFA
   atomicWriteFileSync3(configPath, tail, mode);
   return { added: true, reason: "added" };
 }
-var HINDSIGHT_DEFAULT_API_PORT = 18888, HINDSIGHT_DEFAULT_UI_PORT = 9999, HINDSIGHT_DEFAULT_MCP_URL, HINDSIGHT_DEFAULT_API_BASE_URL, HINDSIGHT_CONSUMER_NAME = "hindsight", HINDSIGHT_DEFAULT_WORKER_ID = "switchroom-hindsight", HINDSIGHT_DATA_VOLUME = "switchroom-hindsight-data", HINDSIGHT_DEFAULT_UID = 11000, HINDSIGHT_IMAGE_REPO = "ghcr.io/switchroom/switchroom-hindsight", HINDSIGHT_IMAGE, HINDSIGHT_DEFAULT_MODEL = "claude-sonnet-5", HINDSIGHT_DEFAULT_LITELLM_MODEL = "openrouter/google/gemini-3.1-flash-lite", HINDSIGHT_DEFAULT_MCP_STATELESS = true, HINDSIGHT_BROKER_SOCK_VOLUME, HINDSIGHT_CREDS_MIRROR_VOLUME, HINDSIGHT_CRED_DIR = "/run/claude-creds", HINDSIGHT_RETAIN_CHUNK_SIZE = 3000, HINDSIGHT_DEFAULT_RETAIN_MAX_COMPLETION_TOKENS = 16384, HINDSIGHT_RETAIN_MIN_TOKENS_PER_SECOND = 80.6, HINDSIGHT_RETAIN_CLIENT_DEADLINE_S, HINDSIGHT_DEFAULT_MEM_LIMIT = "16g", HINDSIGHT_DEFAULT_MEM_RESERVATION = "4g", HINDSIGHT_DEFAULT_PIDS_LIMIT = 1000, HINDSIGHT_DEFAULT_SHM_SIZE = "2g", HINDSIGHT_HEALTHCHECK_PY = 'import urllib.request,sys; sys.exit(0 if urllib.request.urlopen("http://localhost:8888/health",timeout=4).getcode()==200 else 1)', HINDSIGHT_HEALTHCHECK_CMD, DOCKER_PROBE_TIMEOUT_MS, defaultDockerProbe = (args) => {
+var HINDSIGHT_DEFAULT_API_PORT = 18888, HINDSIGHT_DEFAULT_UI_PORT = 9999, HINDSIGHT_DEFAULT_MCP_URL, HINDSIGHT_DEFAULT_API_BASE_URL, HINDSIGHT_CONSUMER_NAME = "hindsight", HINDSIGHT_DEFAULT_WORKER_ID = "switchroom-hindsight", HINDSIGHT_DATA_VOLUME = "switchroom-hindsight-data", HINDSIGHT_DEFAULT_UID = 11000, HINDSIGHT_IMAGE_REPO = "ghcr.io/switchroom/switchroom-hindsight", HINDSIGHT_IMAGE, HINDSIGHT_DEFAULT_MODEL = "claude-sonnet-5", HINDSIGHT_DEFAULT_LITELLM_MODEL = "openrouter/google/gemini-3.1-flash-lite", HINDSIGHT_DEFAULT_MCP_STATELESS = true, HINDSIGHT_DEFAULT_REQUEUE_DEAD_LETTERS = "1", HINDSIGHT_DEFAULT_REQUEUE_MAX = "25", HINDSIGHT_BROKER_SOCK_VOLUME, HINDSIGHT_CREDS_MIRROR_VOLUME, HINDSIGHT_CRED_DIR = "/run/claude-creds", HINDSIGHT_RETAIN_CHUNK_SIZE = 3000, HINDSIGHT_DEFAULT_RETAIN_MAX_COMPLETION_TOKENS = 16384, HINDSIGHT_RETAIN_MIN_TOKENS_PER_SECOND = 80.6, HINDSIGHT_RETAIN_CLIENT_DEADLINE_S, HINDSIGHT_DEFAULT_MEM_LIMIT = "16g", HINDSIGHT_DEFAULT_MEM_RESERVATION = "4g", HINDSIGHT_DEFAULT_PIDS_LIMIT = 1000, HINDSIGHT_DEFAULT_SHM_SIZE = "2g", HINDSIGHT_HEALTHCHECK_PY = 'import urllib.request,sys; sys.exit(0 if urllib.request.urlopen("http://localhost:8888/health",timeout=4).getcode()==200 else 1)', HINDSIGHT_HEALTHCHECK_CMD, DOCKER_PROBE_TIMEOUT_MS, defaultDockerProbe = (args) => {
   try {
     return execFileSync2("docker", args, {
       stdio: "pipe",
@@ -31105,6 +31109,18 @@ function buildSettingsHooksBlock(p) {
       ]
     }
   ];
+  const switchroomSessionStart = [
+    {
+      matcher: "compact",
+      hooks: [
+        {
+          type: "command",
+          command: wrap("hook:working-state-reload", `bash "${join12(DOCKER_BIN_PATH, "working-state-reload-hook.sh")}"`),
+          timeout: 8
+        }
+      ]
+    }
+  ];
   if (userHooks) {
     return {
       ...userHooks,
@@ -31112,6 +31128,10 @@ function buildSettingsHooksBlock(p) {
         ...userHooks.UserPromptSubmit ?? [],
         ...switchroomUserPromptSubmit
       ],
+      SessionStart: [
+        ...userHooks.SessionStart ?? [],
+        ...switchroomSessionStart
+      ],
       ...switchroomPreToolUse.length > 0 ? {
         PreToolUse: [
           ...userHooks.PreToolUse ?? [],
@@ -31134,6 +31154,7 @@ function buildSettingsHooksBlock(p) {
   }
   return {
     UserPromptSubmit: switchroomUserPromptSubmit,
+    SessionStart: switchroomSessionStart,
     ...switchroomPreToolUse.length > 0 ? { PreToolUse: switchroomPreToolUse } : {},
     ...switchroomPostToolUse.length > 0 ? { PostToolUse: switchroomPostToolUse } : {},
     ...switchroomStop.length > 0 ? { Stop: switchroomStop } : {}
@@ -63671,7 +63692,7 @@ function checkNodeVersion() {
   }
   return { name: "Node 18+", status: "ok", detail: label };
 }
-function findChromium(homeDir = process.env.HOME ?? "", envBrowsersPath = process.env.PLAYWRIGHT_BROWSERS_PATH) {
+function findChromium(homeDir = process.env.HOME ?? "", envBrowsersPath = process.env.PLAYWRIGHT_BROWSERS_PATH, bakedBrowsersPath = "/opt/playwright/browsers") {
   const candidates = [
     "chromium",
     "chromium-browser",
@@ -63688,6 +63709,9 @@ function findChromium(homeDir = process.env.HOME ?? "", envBrowsersPath = proces
     cacheLocations.push(envBrowsersPath);
   }
   cacheLocations.push(join74(homeDir, ".cache", "ms-playwright"));
+  if (bakedBrowsersPath && bakedBrowsersPath.length > 0) {
+    cacheLocations.push(bakedBrowsersPath);
+  }
   for (const cacheDir of cacheLocations) {
     if (!existsSync69(cacheDir))
       continue;
@@ -88255,6 +88279,9 @@ function refillNormalizedUtils(q, now) {
     sevenDayRefilled
   };
 }
+var ENTITLEMENT_BLOCKED_ERROR_CODES = new Set([
+  "oauth_not_allowed_for_organization"
+]);
 
 // src/cli/auth-schedule.ts
 function overageReasonBlocks(reason) {

package/dist/host-control/main.js

@@ -21493,7 +21493,7 @@ function allocateAgentUid(name) {
 }
 
 // src/build-info.ts
-var VERSION = "0.20.9";
+var VERSION = "0.20.10";
 
 // src/setup/hindsight-recall-tunables.ts
 var RECALL_DEADLINE_HEADROOM_SECONDS = 2;

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.20.9",
+  "version": "0.20.10",
   "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

@@ -1692,6 +1692,55 @@ if ! ls -d "$sr_cb_dir"/chromium-*/ >/dev/null 2>&1; then
 fi
 unset sr_cb_dir
 
+# Playwright browsers cache seeding. The agent image bakes the fleet-default
+# Playwright version's chromium at /opt/playwright/browsers (immutable:
+# root-owned inside a `read_only: true` root fs), but PLAYWRIGHT_BROWSERS_PATH
+# points at the persistent per-agent HOME cache (Dockerfile.agent ENV) so a
+# project pinning a DIFFERENT Playwright version can `playwright install` its
+# matching browser revision — revision-keyed dirs coexist side by side, and
+# the install survives container recreate via the HOME bind mount. Symlink
+# each baked revision into the cache so the fleet default (@playwright/mcp,
+# webapp-testing skill) still resolves with ZERO download; a real
+# agent-installed dir with the same name always wins over the link. Dangling
+# links into the bake (stale after an image bump changed the default
+# revision) are swept first. Dot-entries (.links) are untouched by the glob —
+# they must stay real + writable so project installs can register there.
+#
+# Zero-download depends on TWO things, not just this seeding. (1) Playwright
+# decides "already installed / skip download" purely by the INSTALLATION_COMPLETE
+# marker inside each revision dir (playwright-core browserFetcher.ts) — which
+# resolves fine through these symlinks, so the seed alone is enough at launch.
+# (2) BUT `playwright install` first GC-sweeps the browsers dir, deleting any
+# revision not referenced by a `.links/<sha1>` entry. The baked packages
+# registered their reference in /opt/.../.links at build time, not here, so a
+# skewed-version project install would otherwise GC these seed links and force a
+# re-download. Dockerfile.agent sets PLAYWRIGHT_SKIP_BROWSER_GC=1 in the runtime
+# env to disable that sweep — keep the two in lockstep. (`.links` is still
+# written by every install; we just never run the removal pass.)
+if [ -d /opt/playwright/browsers ]; then
+  sr_pw_cache="${PLAYWRIGHT_BROWSERS_PATH:-$HOME/.cache/ms-playwright}"
+  mkdir -p "$sr_pw_cache" 2>/dev/null || true
+  if [ -d "$sr_pw_cache" ] && [ -w "$sr_pw_cache" ]; then
+    for sr_pw_link in "$sr_pw_cache"/*; do
+      if [ -L "$sr_pw_link" ] && [ ! -e "$sr_pw_link" ]; then
+        case "$(readlink "$sr_pw_link")" in
+          /opt/playwright/browsers/*) rm -f "$sr_pw_link" ;;
+        esac
+      fi
+    done
+    for sr_pw_rev in /opt/playwright/browsers/*/; do
+      [ -d "$sr_pw_rev" ] || continue
+      sr_pw_name="$(basename "$sr_pw_rev")"
+      if [ ! -e "$sr_pw_cache/$sr_pw_name" ]; then
+        ln -s "${sr_pw_rev%/}" "$sr_pw_cache/$sr_pw_name" 2>/dev/null || true
+      fi
+    done
+  else
+    echo "WARNING (playwright cache): $sr_pw_cache missing or not writable — baked browsers not linked; playwright-based skills may attempt a fresh ~150MB download" >&2
+  fi
+  unset sr_pw_cache sr_pw_rev sr_pw_name sr_pw_link
+fi
+
 # LiteLLM routing (opt-in, #litellm). When SWITCHROOM_LITELLM is set (compose
 # env, gated on litellm.enabled && keyConfirmed), route the unmodified `claude`
 # CLI through the operator's LiteLLM proxy at ANTHROPIC_BASE_URL: fetch the

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

@@ -7308,6 +7308,12 @@ function refillNormalizedUtils(q, now) {
     sevenDayRefilled
   };
 }
+var ENTITLEMENT_BLOCKED_ERROR_CODES;
+var init_quota = __esm(() => {
+  ENTITLEMENT_BLOCKED_ERROR_CODES = new Set([
+    "oauth_not_allowed_for_organization"
+  ]);
+});
 
 // ../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType = (data) => {
@@ -12695,6 +12701,7 @@ function buildSnapshotsFromCachedState(state) {
 }
 var THROTTLING_THRESHOLD_PCT = 80, OVERAGE_EXHAUSTED_REASONS, HEALTH_EMOJI, TABLE_HEALTH_RANK;
 var init_auth_snapshot_format = __esm(() => {
+  init_quota();
   init_client();
   init_demo_mask();
   init_card_format();
@@ -38305,6 +38312,7 @@ function buildSnapshotsFromCachedState2(state7) {
 }
 var THROTTLING_THRESHOLD_PCT2 = 80, OVERAGE_EXHAUSTED_REASONS2, HEALTH_EMOJI2, TABLE_HEALTH_RANK2;
 var init_auth_snapshot_format2 = __esm(() => {
+  init_quota();
   init_client();
   init_demo_mask();
   init_card_format();
@@ -39033,6 +39041,7 @@ function renderUsageCard(snapshots, exhaustedByLabel, opts = {}) {
 }
 var FIVE_HOUR_MS, SEVEN_DAY_MS, BAR_WIDTH = 10, STATUS_LABEL;
 var init_quota_bar_format = __esm(() => {
+  init_quota();
   init_client();
   init_auth_snapshot_format();
   init_card_format();
@@ -102806,10 +102815,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.20.9";
-var COMMIT_SHA = "63c4c44b";
-var COMMIT_DATE = "2026-08-05T03:51:28Z";
-var LATEST_PR = 4388;
+var VERSION2 = "0.20.10";
+var COMMIT_SHA = "ebb54738";
+var COMMIT_DATE = "2026-08-05T10:11:19Z";
+var LATEST_PR = 4398;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts

package/vendor/hindsight-memory/CHANGELOG.md

@@ -54,6 +54,37 @@
 
 ### Changed (switchroom divergence)
 
+- **SessionStart hook runs async so its durability work stops being killed
+  mid-drain** (`hooks/hooks.json`, `scripts/session_start.py`). The hook does
+  the recovery a prior session's abrupt death skipped — drain the
+  SessionEnd-queued retains (#1071) and reconcile un-committed transcript turns
+  (#3244). Those two carry independent 4s wall-clock budgets
+  (`HINDSIGHT_DRAIN_BUDGET_S` / `HINDSIGHT_RECONCILE_BUDGET_S`), each sized in
+  isolation against the old synchronous 5s SessionStart timeout, plus a ~2s
+  Mode-1 external-server health probe. Summed, they routinely overran 5s, so
+  Claude Code SIGKILLed the hook part-way through — truncating exactly the
+  durability work it exists to do and letting the pending-retains backlog grow
+  (fleet transcripts carry 1000+ `hook_cancelled` attachments for
+  `session_start.py`, all `timedOut: true` with `durationMs > 5000`; a
+  successful firing injects no `additionalContext` and so leaves no record,
+  which made the failures look like ~100% of firings when the true rate is
+  unmeasurable from attachments). Setting `"async": true` on the hook (the same
+  non-blocking pattern the Stop-event `retain.py` already uses) detaches it from
+  the SessionStart critical path: it injects no context, so nothing depends on
+  it finishing first and async's dropped context costs nothing. The `timeout`
+  ceiling rises 5s → 30s purely as a background-lifetime bound above the ~10s
+  summed sub-budgets — it never re-introduces a startup block, because drain and
+  reconcile self-cap at their budgets regardless. The drain stays in the hook
+  (not deferred wholly to the `hindsight-drain` sidecar, which `start.sh` only
+  starts conditionally — when it is absent this hook is the sole backlog path)
+  and `reconcile_tail`, which has no sidecar equivalent, stays here and now runs
+  to completion; its over-budget remainder still resumes on the next boot.
+  Concurrent drain with the sidecar stays safe via `drain_pending`'s exclusive
+  `fcntl.flock`. Pinned by `scripts/tests/test_session_start_durability.py`
+  (drain + reconcile are still invoked, in order) and
+  `tests/hindsight-session-start-async.test.ts` (the async flag + budget-clearing
+  ceiling survive the scaffold's hooks-override round-trip).
+
 - **Recall/retain hygiene guard-rail batch** (`scripts/recall.py`,
   `scripts/subagent_retain.py`, `scripts/lib/content.py`, `scripts/tests/**`).
   Closes guard-rail debt in the fork's hook scripts before extending them:

package/vendor/hindsight-memory/hooks/hooks.json

@@ -6,7 +6,8 @@
           {
             "type": "command",
             "command": "python3 \"${CLAUDE_PLUGIN_ROOT}/scripts/session_start.py\"",
-            "timeout": 5
+            "async": true,
+            "timeout": 30
           }
         ]
       }

package/vendor/hindsight-memory/scripts/session_start.py

@@ -1,12 +1,39 @@
 #!/usr/bin/env python3
-"""SessionStart hook: health check + session logging.
-
-Fires once when a Claude Code session begins. Uses additionalContext
-(supported on SessionStart) to inject an initial system note if
-Hindsight is available.
-
-This is the Claude Code equivalent of Openclaw's service.start() —
-verify the server is reachable early, before the first prompt.
+"""SessionStart hook: health check + durability drain/reconcile.
+
+Fires once when a Claude Code session begins (startup / compact / clear).
+This is the Claude Code equivalent of Openclaw's service.start() — verify
+the server is reachable early, then do the durability work that a prior
+session's abrupt death may have skipped: drain SessionEnd-queued retains
+(#1071) and reconcile un-committed transcript turns (#3244).
+
+Runs ASYNC (``"async": true`` in hooks/hooks.json), for a reason specific
+to THIS hook: it injects NO additionalContext — every return path is a
+pure side effect — so nothing in the session depends on it finishing
+before the first prompt, and losing async's dropped context costs us
+nothing here (unlike recall.py, which must stay synchronous to inject).
+
+Why async matters: drain and reconcile each carry an independent
+wall-clock budget (``HINDSIGHT_DRAIN_BUDGET_S`` / ``HINDSIGHT_RECONCILE_BUDGET_S``,
+4s each) plus a Mode-1 health probe (~2s). Those budgets were each sized
+against the old synchronous 5s SessionStart timeout in ISOLATION, but they
+STACK on one hook: drain(4s) + reconcile(4s, added later in #3244) +
+probe(2s) routinely overran 5s, so the hook was SIGKILLed mid-drain on a
+large share of firings (see the fleet-wide ``hook_cancelled`` transcript
+attachments) — truncating exactly the durability work it exists to do,
+and growing the pending-retains backlog it was meant to clear. Async
+detaches it from the SessionStart critical path so the bounded, resumable
+drain/reconcile can run to completion instead of being cut off. Both are
+crash-safe under an eventual reap anyway: drain holds an ``fcntl.flock``
+the kernel releases on death and re-queues unsent entries, and reconcile
+is idempotent and resumes any over-budget remainder on the next boot.
+
+Keeping the drain here (rather than deferring wholly to the hindsight-drain
+sidecar) is deliberate: that sidecar is only CONDITIONALLY started — its
+own "NOT STARTED" branch in start.sh notes that when it is absent the
+memory queue is drained ONLY at session boot — so this hook stays the
+backlog path for agents without the sidecar. reconcile_tail has no sidecar
+equivalent at all and lives only here.
 """
 
 import json

package/vendor/hindsight-memory/scripts/tests/test_session_start_durability.py

@@ -0,0 +1,107 @@
+"""The SessionStart hook must still DO its durability work.
+
+The hook was made ``"async": true`` (hooks/hooks.json) so a stacked
+drain + reconcile + health-probe budget can no longer overrun the
+SessionStart timeout and get the process SIGKILLed mid-drain. Async only
+helps if the two durability calls are still MADE on the healthy path —
+if a refactor drops one, the queue silently stops draining and abrupt-kill
+turns stop being recovered, which is the exact outage the hook exists to
+prevent and which no attachment record would surface (a successful
+SessionStart hook that injects no context leaves no transcript trace).
+
+So this pins the OUTCOME, not the wiring: on a reachable server,
+``session_start.main()`` invokes ``drain_pending.drain`` and then
+``reconcile_tail.reconcile``, in that order (reconcile runs AFTER the
+drain by design — it recovers what SessionEnd never managed to enqueue).
+
+Lives under ``scripts/tests/`` because that is the only python test
+directory CI discovers (``ci-tests-python.yml`` runs ``unittest discover``
+from ``vendor/hindsight-memory/scripts``).
+"""
+
+import io
+import os
+import sys
+import unittest
+import unittest.mock
+
+SCRIPTS_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if SCRIPTS_DIR not in sys.path:
+    sys.path.insert(0, SCRIPTS_DIR)
+
+import drain_pending  # noqa: E402
+import reconcile_tail  # noqa: E402
+import session_start  # noqa: E402
+
+
+class _ReachableClient:
+    """Stand-in for HindsightClient — reachable, no network."""
+
+    def __init__(self, *_a, **_kw):
+        pass
+
+    def health_check(self, timeout=5, retries=3):
+        return True
+
+
+class DurabilityWorkStillRunsTest(unittest.TestCase):
+    CONFIG = {"autoRetain": True, "autoRecall": True}
+
+    def _run_main(self, config=None):
+        """Run ``session_start.main()`` against a reachable server with the
+        two durability calls stubbed, returning the ordered call log."""
+        calls = []
+
+        def fake_drain(cfg):
+            calls.append("drain")
+
+        def fake_reconcile(cfg, hook_input=None):
+            calls.append("reconcile")
+
+        cfg = dict(self.CONFIG if config is None else config)
+        with unittest.mock.patch.object(drain_pending, "drain", fake_drain), \
+            unittest.mock.patch.object(reconcile_tail, "reconcile", fake_reconcile), \
+            unittest.mock.patch.object(session_start, "load_config", lambda: cfg), \
+            unittest.mock.patch.object(
+                session_start,
+                "get_api_url",
+                lambda c, debug_fn=None, allow_daemon_start=True: (
+                    "http://127.0.0.1:9/none"
+                ),
+            ), \
+            unittest.mock.patch.object(
+                session_start, "HindsightClient", _ReachableClient
+            ), \
+            unittest.mock.patch.object(sys, "stdin", io.StringIO("{}")):
+            session_start.main()
+        return calls
+
+    def test_drain_and_reconcile_both_run_on_a_reachable_server(self):
+        calls = self._run_main()
+        self.assertIn("drain", calls, "queued retains must still be drained")
+        self.assertIn(
+            "reconcile",
+            calls,
+            "un-committed abrupt-kill turns must still be reconciled",
+        )
+
+    def test_reconcile_runs_after_the_drain(self):
+        calls = self._run_main()
+        self.assertEqual(
+            calls,
+            ["drain", "reconcile"],
+            "reconcile recovers what SessionEnd never enqueued, so it must "
+            "run AFTER the drain replays what it did",
+        )
+
+    def test_disabled_memory_skips_both(self):
+        """The control case: with both autoRecall and autoRetain off, the
+        hook returns before touching the durability path. Without this the
+        assertions above could be satisfied by calls that fire
+        unconditionally."""
+        calls = self._run_main(config={"autoRetain": False, "autoRecall": False})
+        self.assertEqual(calls, [])
+
+
+if __name__ == "__main__":
+    unittest.main()