switchroom 0.5.0

package/bin/handoff-briefing.sh

@@ -0,0 +1,206 @@
+#!/bin/bash
+# handoff-briefing.sh — Assemble a context briefing for fresh-session handoff.
+#
+# Invoked by start.sh in 'handoff' mode instead of writing a .handoff-briefing.md
+# from the previous session (which relies on the Stop hook summarizer). This
+# script assembles a lighter-weight briefing from three sources:
+#
+#   1. Last 20 Telegram messages from the plugin SQLite history DB
+#      ($TELEGRAM_STATE_DIR/history.db). Requires python3 + sqlite3 stdlib.
+#
+#   2. Hindsight recall results for "what was happening recently?"
+#      via $HINDSIGHT_API_URL/v1/default/banks/$HINDSIGHT_BANK_ID/memories/recall
+#      Requires curl + jq. Skipped gracefully if Hindsight is unreachable.
+#
+#   3. Today's daily memory from $WORKSPACE_DIR/memory/YYYY-MM-DD.md
+#      Skipped if missing.
+#
+# Output is written to $AGENT_DIR/.handoff-briefing.md (or stdout if
+# HANDOFF_BRIEFING_STDOUT=1 is set). start.sh injects this into
+# --append-system-prompt.
+#
+# Graceful degradation: each source is attempted independently. Failure of
+# any single source produces empty output for that section rather than
+# crashing the whole briefing. A completely empty briefing (all sources
+# missing) writes nothing so start.sh skips the --append-system-prompt arg.
+#
+# Prerequisites:
+#   - python3 (stdlib sqlite3) — for Telegram history DB
+#   - curl, jq                — for Hindsight recall (optional)
+#   - TELEGRAM_STATE_DIR      — points to the plugin state dir containing history.db
+#   - HINDSIGHT_API_URL       — base URL for Hindsight (optional)
+#   - HINDSIGHT_BANK_ID       — bank/collection name (optional)
+#   - WORKSPACE_DIR or AGENT_DIR — to locate memory/YYYY-MM-DD.md
+#   - AGENT_DIR               — output destination (if HANDOFF_BRIEFING_STDOUT!=1)
+#
+# Usage:
+#   handoff-briefing.sh [--stdout]
+#
+# The --stdout flag overrides HANDOFF_BRIEFING_STDOUT=1.
+
+set -u
+
+# ── Configuration ──────────────────────────────────────────────────────────────
+TELEGRAM_STATE="${TELEGRAM_STATE_DIR:-}"
+HINDSIGHT_URL="${HINDSIGHT_API_URL:-}"
+HINDSIGHT_BANK="${HINDSIGHT_BANK_ID:-}"
+AGENT_DIR="${AGENT_DIR:-}"
+WORKSPACE_DIR="${WORKSPACE_DIR:-$AGENT_DIR}"
+MAX_MESSAGES="${HANDOFF_BRIEFING_MAX_MESSAGES:-20}"
+HINDSIGHT_TIMEOUT="${HANDOFF_BRIEFING_HINDSIGHT_TIMEOUT:-4}"
+
+# Determine output mode
+STDOUT_MODE=0
+if [ "${HANDOFF_BRIEFING_STDOUT:-}" = "1" ] || [ "${1:-}" = "--stdout" ]; then
+  STDOUT_MODE=1
+fi
+
+# ── Source 1: Recent Telegram messages ─────────────────────────────────────────
+TELEGRAM_SECTION=""
+if [ -n "$TELEGRAM_STATE" ] && [ -d "$TELEGRAM_STATE" ]; then
+  HISTORY_DB="$TELEGRAM_STATE/history.db"
+  if [ -f "$HISTORY_DB" ] && command -v python3 >/dev/null 2>&1; then
+    # Use python3's stdlib sqlite3 — no bun:sqlite, no extra deps.
+    # Query the most recent $MAX_MESSAGES rows ordered by ts DESC, then
+    # reverse for chronological display. We skip system messages (role NULL).
+    TELEGRAM_ROWS=$(python3 - "$HISTORY_DB" "$MAX_MESSAGES" 2>/dev/null <<'PYEOF'
+import sys, sqlite3, datetime
+
+db_path = sys.argv[1]
+limit = int(sys.argv[2])
+
+try:
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+    # Fetch most recent rows; reverse for chronological output.
+    cur.execute(
+        """
+        SELECT role, user, ts, text
+        FROM messages
+        WHERE role IN ('user', 'assistant')
+        ORDER BY ts DESC
+        LIMIT ?
+        """,
+        (limit,),
+    )
+    rows = list(reversed(cur.fetchall()))
+    conn.close()
+    for row in rows:
+        ts_str = datetime.datetime.fromtimestamp(row["ts"]).strftime("%Y-%m-%d %H:%M")
+        role = row["role"]
+        label = row["user"] if role == "user" and row["user"] else role
+        # Truncate long messages to keep the briefing concise
+        text = row["text"] or ""
+        if len(text) > 600:
+            text = text[:600] + "… [truncated]"
+        # Escape any literal backslash to keep the shell echo safe
+        text = text.replace("\\", "\\\\")
+        print(f"[{ts_str}] {label}: {text}")
+except Exception as e:
+    sys.stderr.write(f"handoff-briefing: sqlite query failed: {e}\n")
+    sys.exit(0)
+PYEOF
+)
+    if [ -n "$TELEGRAM_ROWS" ]; then
+      TELEGRAM_SECTION="## Recent conversation (last $MAX_MESSAGES messages)
+
+$TELEGRAM_ROWS"
+    fi
+  fi
+fi
+
+# ── Source 2: Hindsight recall ──────────────────────────────────────────────────
+HINDSIGHT_SECTION=""
+if [ -n "$HINDSIGHT_URL" ] && [ -n "$HINDSIGHT_BANK" ] && command -v curl >/dev/null 2>&1 && command -v jq >/dev/null 2>&1; then
+  RECALL_QUERY="what was happening recently in our conversation?"
+  RECALL_RESPONSE=$(curl -sf -m "$HINDSIGHT_TIMEOUT" -X POST \
+    -H "Content-Type: application/json" \
+    -d "$(jq -n --arg q "$RECALL_QUERY" --argjson m 800 '{query: $q, max_tokens: $m}')" \
+    "${HINDSIGHT_URL%/}/v1/default/banks/${HINDSIGHT_BANK}/memories/recall" 2>/dev/null)
+  if [ -n "$RECALL_RESPONSE" ]; then
+    RECALL_TEXT=$(printf '%s' "$RECALL_RESPONSE" | jq -r '
+      if .results == null or (.results | length) == 0 then
+        empty
+      else
+        (.results | map("- " + (.text // "(no text)") + (if .timestamp then " (" + .timestamp + ")" else "" end)) | join("\n"))
+      end
+    ' 2>/dev/null)
+    if [ -n "$RECALL_TEXT" ]; then
+      HINDSIGHT_SECTION="## Hindsight recall (recent context)
+
+$RECALL_TEXT"
+    fi
+  fi
+fi
+
+# ── Source 3: Today's daily memory ─────────────────────────────────────────────
+DAILY_SECTION=""
+TODAY=$(date +%Y-%m-%d 2>/dev/null || true)
+if [ -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")
+    if [ -n "$DAILY_CONTENT" ]; then
+      DAILY_SECTION="## Today's memory (${TODAY})
+
+$DAILY_CONTENT"
+    fi
+  fi
+fi
+
+# ── Assemble briefing ───────────────────────────────────────────────────────────
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null || date +"%Y-%m-%d %H:%M:%S UTC")
+
+# Determine restart reason if available
+RESTART_REASON="unknown"
+if [ -n "$AGENT_DIR" ] && [ -f "$AGENT_DIR/.restart-reason" ]; then
+  RESTART_REASON=$(cat "$AGENT_DIR/.restart-reason" 2>/dev/null | head -1 | tr -d '\r\n')
+fi
+# Also check SWITCHROOM_PENDING_ENDED_VIA if set by start.sh
+if [ -n "${SWITCHROOM_PENDING_ENDED_VIA:-}" ]; then
+  RESTART_REASON="$SWITCHROOM_PENDING_ENDED_VIA"
+fi
+
+# Build the briefing body
+SECTIONS=""
+for section in "$TELEGRAM_SECTION" "$HINDSIGHT_SECTION" "$DAILY_SECTION"; do
+  if [ -n "$section" ]; then
+    if [ -n "$SECTIONS" ]; then
+      SECTIONS="$SECTIONS
+
+---
+
+$section"
+    else
+      SECTIONS="$section"
+    fi
+  fi
+done
+
+# Empty briefing — nothing to inject
+if [ -z "$SECTIONS" ]; then
+  exit 0
+fi
+
+BRIEFING="You just restarted at ${TIMESTAMP}. Previous session ended via: ${RESTART_REASON}. Consult this briefing before responding.
+
+---
+
+${SECTIONS}"
+
+# ── Output ──────────────────────────────────────────────────────────────────────
+if [ "$STDOUT_MODE" = "1" ]; then
+  printf '%s\n' "$BRIEFING"
+else
+  if [ -z "$AGENT_DIR" ]; then
+    # Fallback: write to stdout if AGENT_DIR is not set
+    printf '%s\n' "$BRIEFING"
+    exit 0
+  fi
+  OUTPUT_FILE="$AGENT_DIR/.handoff-briefing.md"
+  OUTPUT_TMP="${OUTPUT_FILE}.tmp.$$"
+  printf '%s\n' "$BRIEFING" > "$OUTPUT_TMP" && mv -f "$OUTPUT_TMP" "$OUTPUT_FILE"
+fi
+
+exit 0

package/bin/run-hook.sh

@@ -0,0 +1,228 @@
+#!/usr/bin/env bash
+# run-hook.sh — wrap a hook command and surface failures to the issue
+# sink (#425). Phase 0.2 of #424.
+#
+# Usage:
+#   run-hook.sh <source> <command> [args...]
+#
+#   <source>  Stable identifier for this hook, e.g. "hook:handoff" or
+#             "hook:secret-scrub-stop". Becomes the issue source field;
+#             coalesces all failures of this hook into one entry.
+#   <command> The actual hook command (binary or script path).
+#   [args...] Forwarded verbatim to <command>.
+#
+# Behaviour:
+#   - Stdin/stdout pass through unchanged. Hooks that emit JSON to
+#     claude on stdout still work.
+#   - Stderr is teed: visible in journald as before AND captured to a
+#     buffer so we can attach the tail to the issue detail.
+#   - On exit 0: auto-resolve any prior unresolved issue with the same
+#     fingerprint. So a transient flake clears itself on next success.
+#   - On non-zero exit: record an issue with severity=error, code = the
+#     command basename, summary = "<source>: <basename> exited <code>",
+#     detail = last ~60 lines of stderr.
+#   - The wrapper itself never blocks the hook. If `switchroom issues`
+#     fails (CLI missing, state dir not writable), we just emit a one-line
+#     warning to stderr and exit with the original status.
+#
+# The wrapper exits with the original command's exit code, so claude
+# code's hook contract (block / allow / non-zero behaviour) is preserved.
+
+set -u
+
+if [ "$#" -lt 2 ]; then
+  echo "run-hook.sh: usage: run-hook.sh <source> <command> [args...]" >&2
+  exit 2
+fi
+
+SOURCE="$1"; shift
+COMMAND="$1"
+shift
+
+# Derive a code that discriminates between, e.g., `bash foo.sh` and
+# `bash bar.sh`. When COMMAND is a known interpreter (bash, node, etc.)
+# and the first arg looks like a script path, use its basename. So
+# fingerprints stay distinct across hooks that share an interpreter.
+case "$(basename -- "$COMMAND")" in
+  bash|sh|node|npx|bun|python|python3|deno)
+    if [ "$#" -gt 0 ]; then
+      CODE="$(basename -- "$1")"
+    else
+      CODE="$(basename -- "$COMMAND")"
+    fi
+    ;;
+  *)
+    CODE="$(basename -- "$COMMAND")"
+    ;;
+esac
+
+# Best-effort: locate the switchroom CLI. Prefer SWITCHROOM_CLI_PATH
+# (set in the agent's MCP env), then PATH. If not found, the wrapper
+# degrades to a passthrough — no issue recording, but the hook still
+# runs.
+if [ -n "${SWITCHROOM_CLI_PATH:-}" ] && [ -x "$SWITCHROOM_CLI_PATH" ]; then
+  SWITCHROOM_CLI="$SWITCHROOM_CLI_PATH"
+elif command -v switchroom >/dev/null 2>&1; then
+  SWITCHROOM_CLI="$(command -v switchroom)"
+else
+  SWITCHROOM_CLI=""
+fi
+
+# We need a writable state dir to record issues. The CLI also accepts
+# this via env; we just check up-front so the degraded path is obvious.
+STATE_DIR="${TELEGRAM_STATE_DIR:-}"
+
+# Run the wrapped command, capturing stderr to a temp file. After the
+# command exits, replay the buffer to our own stderr so journald sees
+# everything as before. This is intentionally NOT a process substitution
+# with tee — bash does not wait for process substitutions to drain
+# before the next command runs, which previously meant tail-reading
+# the buffer could miss the final lines (the most informative ones).
+# See review on #434/#435.
+STDERR_TMP="$(mktemp -t run-hook-stderr.XXXXXX 2>/dev/null || mktemp)"
+trap 'rm -f "$STDERR_TMP" 2>/dev/null || true' EXIT
+
+"$COMMAND" "$@" 2>"$STDERR_TMP"
+STATUS=$?
+
+# Replay captured stderr to our own stderr now that the command has
+# fully exited — preserves journald visibility without the streaming
+# property (which hooks don't need; they're short-lived).
+if [ -s "$STDERR_TMP" ]; then
+  cat "$STDERR_TMP" >&2
+fi
+
+emit_warn() {
+  echo "run-hook.sh: $1" >&2
+}
+
+# When RUN_HOOK_DEBUG=1 is set, drop the stderr redirect on the
+# issues-CLI invocations so an operator debugging a broken record-path
+# sees the actual cause in journald instead of just the generic
+# "failed to record issue (non-fatal)" line. See #445.
+debug_mode() {
+  [ "${RUN_HOOK_DEBUG:-}" = "1" ]
+}
+
+record_failure() {
+  local detail summary
+  # Last ~60 lines of stderr; CLI will further cap to DETAIL_MAX_BYTES.
+  if [ -s "$STDERR_TMP" ]; then
+    detail="$(tail -n 60 "$STDERR_TMP")"
+  else
+    detail=""
+  fi
+  summary="${SOURCE}: ${CODE} exited ${STATUS}"
+
+  # Pipe detail via stdin so we don't have to shell-quote arbitrary
+  # error text. CLI reads it when --detail-stdin is set.
+  if debug_mode; then
+    if [ -n "$detail" ]; then
+      printf '%s' "$detail" | "$SWITCHROOM_CLI" issues record \
+        --severity error \
+        --source "$SOURCE" \
+        --code "$CODE" \
+        --summary "$summary" \
+        --detail-stdin \
+        --quiet \
+        ${STATE_DIR:+--state-dir "$STATE_DIR"} \
+        || emit_warn "failed to record issue (non-fatal)"
+    else
+      "$SWITCHROOM_CLI" issues record \
+        --severity error \
+        --source "$SOURCE" \
+        --code "$CODE" \
+        --summary "$summary" \
+        --quiet \
+        ${STATE_DIR:+--state-dir "$STATE_DIR"} \
+        || emit_warn "failed to record issue (non-fatal)"
+    fi
+  else
+    if [ -n "$detail" ]; then
+      printf '%s' "$detail" | "$SWITCHROOM_CLI" issues record \
+        --severity error \
+        --source "$SOURCE" \
+        --code "$CODE" \
+        --summary "$summary" \
+        --detail-stdin \
+        --quiet \
+        ${STATE_DIR:+--state-dir "$STATE_DIR"} \
+        >/dev/null 2>&1 || emit_warn "failed to record issue (non-fatal)"
+    else
+      "$SWITCHROOM_CLI" issues record \
+        --severity error \
+        --source "$SOURCE" \
+        --code "$CODE" \
+        --summary "$summary" \
+        --quiet \
+        ${STATE_DIR:+--state-dir "$STATE_DIR"} \
+        >/dev/null 2>&1 || emit_warn "failed to record issue (non-fatal)"
+    fi
+  fi
+}
+
+resolve_success() {
+  # Fast-skip the CLI fork when there is nothing to resolve.
+  #
+  # Cold-starting the switchroom CLI to call `issues resolve` costs
+  # ~785ms on a typical box (measured 2026-05-01 across three runs).
+  # With 3-5 successful hooks per turn this is 2.4-4 s of pure wrapper
+  # overhead per turn — bigger than the model's first-token latency.
+  #
+  # Most hooks succeed and most successful hooks have nothing to clear
+  # (a fleet check on 2026-05-01 found 0 unresolved entries across 5
+  # production agents). In that case `issues resolve` walks the file,
+  # finds no matching unresolved entry, and returns 0 — pure waste.
+  #
+  # Bash-side prefilter mirrors the CLI's match condition exactly:
+  #   - fingerprint == "<source>::<code>"  (per src/issues/fingerprint.ts)
+  #   - resolved_at is null/missing        (per IssueEvent.resolved_at?)
+  # Since IssueEvent.resolved_at is optional and JSON.stringify omits
+  # undefined fields, an unresolved entry's JSONL line will NOT contain
+  # the substring `"resolved_at":` at all. So the prefilter is:
+  #
+  #   any line containing the fingerprint AND lacking `"resolved_at":`
+  #
+  # If no such line exists, the CLI's resolve op is a guaranteed no-op
+  # and we skip the fork. False positives (forking when we don't need
+  # to) match today's behaviour and are harmless. False negatives
+  # (skipping when we should fork) require a fingerprint substring
+  # collision with `"resolved_at":` somewhere on the same line, which
+  # the JSON ordering and key set make impossible.
+  local fingerprint="${SOURCE}::${CODE}"
+  local issues_file="${STATE_DIR}/issues.jsonl"
+
+  if [ -z "$STATE_DIR" ] || [ ! -s "$issues_file" ]; then
+    return 0
+  fi
+  if ! grep -F "\"fingerprint\":\"${fingerprint}\"" "$issues_file" 2>/dev/null \
+    | grep -vqF '"resolved_at":'; then
+    return 0
+  fi
+
+  # Real work — fork the CLI to do the actual flip.
+  if debug_mode; then
+    "$SWITCHROOM_CLI" issues resolve --source "$SOURCE" --code "$CODE" \
+      ${STATE_DIR:+--state-dir "$STATE_DIR"} \
+      || true
+  else
+    "$SWITCHROOM_CLI" issues resolve --source "$SOURCE" --code "$CODE" \
+      ${STATE_DIR:+--state-dir "$STATE_DIR"} \
+      >/dev/null 2>&1 || true
+  fi
+}
+
+if [ -z "$SWITCHROOM_CLI" ]; then
+  # Degraded path. Emit a single warning so the operator knows visibility
+  # is off, but don't change the hook's exit semantics.
+  emit_warn "switchroom CLI not found on PATH; hook ran without issue tracking"
+  exit "$STATUS"
+fi
+
+if [ "$STATUS" -eq 0 ]; then
+  resolve_success
+else
+  record_failure
+fi
+
+exit "$STATUS"

package/bin/switchroom.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env bun
+import { program } from "../src/cli/index.js";
+
+program.parse();

package/bin/timezone-hook.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+# UserPromptSubmit hook that emits the agent's current local time.
+#
+# Switchroom agents run as long-lived Claude Code processes. Inbound Telegram
+# messages arrive with UTC timestamps (e.g. ts="2026-04-23T00:37:12Z"), and
+# the LLM — having no other clock — infers that UTC is "now." On a host whose
+# operator lives in Australia/Melbourne that's 10–11 hours off, and the
+# agent will cheerfully tell the user "good morning" at 10pm local time.
+#
+# This hook fires on every UserPromptSubmit and prints a one-line hint that
+# Claude Code prepends to the prompt as additionalContext, so the LLM sees
+# fresh local time each turn. The resolved zone is passed in via
+# SWITCHROOM_TIMEZONE (baked into the agent's systemd unit at scaffold/
+# reconcile time). If unset we fall back to UTC — same default as the
+# resolver — so the hook never fails loudly.
+#
+# Stale-install detection: when SWITCHROOM_TIMEZONE is unset we also annotate
+# the hint with an in-band WARNING. This makes the failure visible to the
+# agent (and thus to the user), rather than silently emitting "UTC" while the
+# operator's real zone is Australia/Melbourne. Typical cause: an install
+# upgraded past the timezone-awareness PR without re-running
+# `switchroom systemd install` to refresh the unit files.
+#
+# Failure modes are silent: hooks that error block the turn in Claude Code,
+# and a missing timezone hint is never worse than no hint at all.
+
+set -eu
+
+if [ -z "${SWITCHROOM_TIMEZONE:-}" ]; then
+  TZ_VAL="UTC"
+  TZ_UNSET=1
+else
+  TZ_VAL="$SWITCHROOM_TIMEZONE"
+  TZ_UNSET=0
+fi
+
+# Round the emitted timestamp down to the nearest 15-minute bucket. This
+# matters for prompt caching: the timestamp lands in additionalContext on
+# every UserPromptSubmit, and Anthropic's cache is content-addressed, so
+# a fresh per-second value would invalidate the cache key on every turn.
+# 15 minutes is short enough that "current local time" stays useful and
+# long enough to coalesce ~15× more cache hits than per-minute. GNU date's
+# `-d "@<unix>"` is required (Linux-only, fine for switchroom production).
+NOW_UNIX=$(date +%s)
+ROUNDED=$(( NOW_UNIX - (NOW_UNIX % 900) ))
+NOW=$(TZ="$TZ_VAL" date -d "@$ROUNDED" '+%Y-%m-%d %H:%M %Z (UTC%:z)')
+
+if [ "$TZ_UNSET" = "1" ]; then
+  MSG="Current local time: $NOW ($TZ_VAL — WARNING: SWITCHROOM_TIMEZONE unset; systemd unit may be stale, run \`switchroom systemd install\` to refresh)"
+else
+  MSG="Current local time: $NOW ($TZ_VAL)"
+fi
+
+# Emit as additionalContext so Claude Code prepends to the prompt.
+# Prefer jq for JSON escaping when available (handles backticks, quotes,
+# newlines); fall back to a manual escape of the few chars we might embed.
+if command -v jq >/dev/null 2>&1; then
+  jq -cn --arg msg "$MSG" \
+    '{hookSpecificOutput:{hookEventName:"UserPromptSubmit",additionalContext:$msg}}'
+else
+  # Manual escape: backslash, then double-quote. The message only ever
+  # contains the above fixed template + TZ value + date output, none of
+  # which legally contain control chars, so this is sufficient.
+  ESCAPED=${MSG//\\/\\\\}
+  ESCAPED=${ESCAPED//\"/\\\"}
+  printf '{"hookSpecificOutput":{"hookEventName":"UserPromptSubmit","additionalContext":"%s"}}\n' "$ESCAPED"
+fi

package/bin/user-profile-refresh-hook.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# Refresh the user-profile Mental Model on Stop, so the next session
+# wakes up with a current snapshot of who the user is.
+# Debounced to 30 min via a marker file so rapid-fire turns don't
+# hammer Hindsight.
+set -u
+AGENT_DIR="$(dirname "$TELEGRAM_STATE_DIR")"
+BANK_ID="${HINDSIGHT_BANK_ID:-}"
+API_URL="${HINDSIGHT_API_URL:-http://127.0.0.1:18888}"
+[ -z "$BANK_ID" ] && exit 0
+MARKER="$AGENT_DIR/.mm-refresh-last"
+if [ -f "$MARKER" ]; then
+  _LAST=$(cat "$MARKER" 2>/dev/null || echo 0)
+  _NOW=$(date +%s)
+  if [ $((_NOW - _LAST)) -lt 1800 ]; then
+    exit 0   # < 30 min since last refresh, skip
+  fi
+fi
+# Fire-and-forget refresh via MCP. Timeout bounded by Claude Code hook.
+# Output nothing on success or failure; errors are surfaced via doctor.
+{
+  # JSON-RPC flow: initialize → tools/call refresh_mental_model
+  SESSION=$(curl -sS -X POST "$API_URL/mcp/" \
+    -H "Content-Type: application/json" -H "Accept: application/json, text/event-stream" \
+    -H "X-Bank-Id: $BANK_ID" -D /tmp/mm-refresh-$$.headers \
+    -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"mm-refresh","version":"0.1"}}}' \
+    -m 3 -o /dev/null 2>/dev/null && grep -i mcp-session-id /tmp/mm-refresh-$$.headers | cut -d' ' -f2 | tr -d '\r\n')
+  if [ -n "$SESSION" ]; then
+    curl -sS -X POST "$API_URL/mcp/" \
+      -H "Content-Type: application/json" -H "Accept: application/json, text/event-stream" \
+      -H "X-Bank-Id: $BANK_ID" -H "mcp-session-id: $SESSION" \
+      -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"refresh_mental_model","arguments":{"name":"user-profile"}}}' \
+      -m 5 -o /dev/null 2>/dev/null || true
+  fi
+  rm -f /tmp/mm-refresh-$$.headers 2>/dev/null || true
+  date +%s > "$MARKER"
+} &
+exit 0