switchroom 0.21.18 → 0.21.20

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.21.18", COMMIT_SHA = "ae063418", COMMIT_DATE = "2026-08-18T03:14:53Z";
+var VERSION = "0.21.20", COMMIT_SHA = "fa05da22", COMMIT_DATE = "2026-08-18T20:00:16Z";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -21340,6 +21340,60 @@ function renderHindsightHooksOverrides(raw, tunables) {
   return JSON.stringify(root, null, 2) + `
 `;
 }
+function readHooksPrefetchAsyncTimeout(raw) {
+  const absent = { present: false, async: false, timeout: null };
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return absent;
+  }
+  const hooks = parsed?.hooks;
+  if (hooks == null || typeof hooks !== "object")
+    return absent;
+  const matchers = hooks.Stop;
+  if (!Array.isArray(matchers))
+    return absent;
+  for (const matcher of matchers) {
+    const inner = matcher?.hooks;
+    if (!Array.isArray(inner))
+      continue;
+    for (const hook of inner) {
+      const h = hook;
+      if (h == null || typeof h.command !== "string")
+        continue;
+      if (!h.command.includes(PREFETCH_HOOK_COMMAND_MARKER))
+        continue;
+      return {
+        present: true,
+        async: h.async === true,
+        timeout: typeof h.timeout === "number" ? h.timeout : null
+      };
+    }
+  }
+  return absent;
+}
+function validatePrefetchAsyncTimeout(shape, prefetchRecallTimeoutSeconds) {
+  const problems = [];
+  if (!shape.present) {
+    problems.push("hooks/hooks.json registers no Stop hook for prefetch.py (the async " + "recall-prefetch producer)");
+    return problems;
+  }
+  if (!shape.async) {
+    problems.push('the prefetch.py Stop hook is not marked `"async": true` \u2014 a synchronous ' + "prefetch blocks every turn's completion for up to its timeout");
+  }
+  if (shape.timeout === null || shape.timeout <= 0) {
+    problems.push("the prefetch.py Stop hook has no positive `timeout` (async ceiling) \u2014 a " + "wedged producer would never be reaped");
+    return problems;
+  }
+  if (shape.timeout > MAX_PREFETCH_ASYNC_TIMEOUT_SECONDS) {
+    problems.push(`the prefetch.py async ceiling is ${shape.timeout}s, above the ` + `${MAX_PREFETCH_ASYNC_TIMEOUT_SECONDS}s maximum \u2014 a wedged producer holds a ` + `background slot for that long`);
+  }
+  if (prefetchRecallTimeoutSeconds >= shape.timeout) {
+    problems.push(`memoryPrefetchTimeoutSeconds ${prefetchRecallTimeoutSeconds}s is >= the ` + `${shape.timeout}s async hook ceiling \u2014 the producer's own recall can outlive ` + `its hook and be SIGKILLed mid buffer-write, leaving a torn buffer`);
+  }
+  return problems;
+}
 function readHooksRecallTimeout(raw) {
   let parsed;
   try {
@@ -21368,7 +21422,7 @@ function readHooksRecallTimeout(raw) {
   }
   return null;
 }
-var DEFAULT_RECALL_HOOK_TIMEOUT_SECONDS = 12, DEFAULT_RECALL_MAX_MEMORIES = 8, RECALL_DEADLINE_HEADROOM_SECONDS = 2, MIN_RECALL_HOOK_TIMEOUT_SECONDS, DEFAULT_RECALL_REQUEST_TIMEOUT_SECONDS = 12, MANAGED_HOOK_EVENT = "UserPromptSubmit", RECALL_HOOK_COMMAND_MARKER = "recall.py";
+var DEFAULT_RECALL_HOOK_TIMEOUT_SECONDS = 12, DEFAULT_RECALL_MAX_MEMORIES = 8, RECALL_DEADLINE_HEADROOM_SECONDS = 2, MIN_RECALL_HOOK_TIMEOUT_SECONDS, DEFAULT_RECALL_REQUEST_TIMEOUT_SECONDS = 12, MANAGED_HOOK_EVENT = "UserPromptSubmit", RECALL_HOOK_COMMAND_MARKER = "recall.py", PREFETCH_HOOK_COMMAND_MARKER = "prefetch.py", MAX_PREFETCH_ASYNC_TIMEOUT_SECONDS = 30;
 var init_hindsight_recall_tunables = __esm(() => {
   init_hindsight_recall_passthrough();
   MIN_RECALL_HOOK_TIMEOUT_SECONDS = RECALL_DEADLINE_HEADROOM_SECONDS + 1;
@@ -28559,6 +28613,25 @@ class DirectiveAdmin {
     });
     return `Deactivated directive '${target.name}' (id ${target.id}) in bank ` + `'${this.opts.bankId}', tagged ${args.tag}.`;
   }
+  async deactivateAllActiveByName(args) {
+    const all = await this.list();
+    const named = all.filter((d) => d.name === args.name);
+    if (named.length === 0) {
+      const known = all.map((d) => d.name).sort().join(", ");
+      throw new Error(`no directive named '${args.name}' in bank '${this.opts.bankId}' ` + `(the directive to deactivate). Known directives: ${known || "(none)"}`);
+    }
+    const active = named.filter((d) => d.is_active !== false);
+    const alreadyInactive = named.filter((d) => d.is_active === false).map((d) => ({ id: d.id, name: d.name, priority: d.priority }));
+    for (const d of active)
+      this.refuseIfRulesBlock(d);
+    const deactivated = [];
+    for (const d of active) {
+      if (!args.dryRun)
+        await this.deactivateResolved(all, d);
+      deactivated.push({ id: d.id, name: d.name, priority: d.priority });
+    }
+    return { deactivated, alreadyInactive, dryRun: args.dryRun ?? false };
+  }
   async reactivate(args) {
     const all = await this.list();
     const target = this.resolve(all, args.name, "the directive to reactivate");
@@ -30482,16 +30555,25 @@ function resolveHindsightVendorResolution() {
     execPath: process.execPath
   });
 }
+function removeVendoredHindsightPlugin(agentDir) {
+  const destPath = join15(agentDir, ".claude", "plugins", "hindsight-memory");
+  if (existsSync20(destPath)) {
+    rmSync7(destPath, { recursive: true, force: true });
+  }
+}
 function installHindsightPlugin(agentName, agentDir, switchroomConfig, resolvedAgentConfig) {
   if (!switchroomConfig)
     return null;
   const memory = switchroomConfig.memory;
-  if (!isHindsightEnabled(switchroomConfig))
+  if (!isHindsightEnabled(switchroomConfig)) {
+    removeVendoredHindsightPlugin(agentDir);
     return null;
+  }
   if (!memory)
     return null;
   const agentMemory = switchroomConfig.agents[agentName]?.memory;
   if (resolveHindsightAutoRecall(switchroomConfig, agentName, resolvedAgentConfig) === false) {
+    removeVendoredHindsightPlugin(agentDir);
     return null;
   }
   const vendorResolution = resolveHindsightVendorResolution();
@@ -63701,6 +63783,135 @@ function detectHindsightRecallTunableDrift(name, agentConfig, agentDir, config)
   }
   return findings;
 }
+function detectPrefetchAsyncTimeoutDrift(name, agentConfig, agentDir, config) {
+  if (!isHindsightEnabled(config))
+    return [];
+  const resolved = resolveAgentConfig(config.defaults, config.profiles, agentConfig);
+  if (resolved.memory?.auto_recall === false)
+    return [];
+  const pluginDir = join66(agentDir, ".claude", "plugins", "hindsight-memory");
+  if (!existsSync69(pluginDir))
+    return [];
+  const settingsPath = join66(pluginDir, "settings.json");
+  if (!existsSync69(settingsPath))
+    return [];
+  let settings = null;
+  try {
+    settings = JSON.parse(readFileSync62(settingsPath, "utf-8"));
+  } catch {
+    return [];
+  }
+  if (settings?.memoryPrefetchEnabled !== true)
+    return [];
+  const hooksPath = join66(pluginDir, "hooks", "hooks.json");
+  if (!existsSync69(hooksPath))
+    return [];
+  let shape;
+  try {
+    shape = readHooksPrefetchAsyncTimeout(readFileSync62(hooksPath, "utf-8"));
+  } catch {
+    return [];
+  }
+  const rawPrefetchTimeout = settings.memoryPrefetchTimeoutSeconds;
+  const prefetchRecallTimeout = typeof rawPrefetchTimeout === "number" && Number.isFinite(rawPrefetchTimeout) && rawPrefetchTimeout > 0 ? rawPrefetchTimeout : 5;
+  const problems = validatePrefetchAsyncTimeout(shape, prefetchRecallTimeout);
+  if (problems.length === 0)
+    return [];
+  return [
+    {
+      surface: "memory-prefetch",
+      agent: name,
+      detail: `async recall-prefetch (memoryPrefetchEnabled) is ON but its async-timeout ` + `config is unsafe: ${problems.join("; ")}`,
+      fix: "Re-stamp the plugin (`switchroom apply`) so hooks.json carries the " + '`prefetch.py` Stop hook with `"async": true` and a timeout above ' + "memoryPrefetchTimeoutSeconds, or set memoryPrefetchEnabled off until the " + "async ceiling is corrected \u2014 a wedged prefetch either blocks the turn or " + "is killed mid buffer-write."
+    }
+  ];
+}
+function hashPluginScriptsTree(scriptsRoot) {
+  if (!existsSync69(scriptsRoot))
+    return null;
+  const out = new Map;
+  const skipDir = (n) => n === "__pycache__";
+  const skipFile = (n) => n.endsWith(".pyc") || n.includes(".bak");
+  const walk = (dir, rel) => {
+    let entries;
+    try {
+      entries = readdirSync27(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const childRel = rel === "" ? ent.name : `${rel}/${ent.name}`;
+      const childAbs = join66(dir, ent.name);
+      if (ent.isDirectory()) {
+        if (skipDir(ent.name))
+          continue;
+        walk(childAbs, childRel);
+      } else if (ent.isFile()) {
+        if (skipFile(ent.name))
+          continue;
+        try {
+          out.set(childRel, createHash13("sha256").update(readFileSync62(childAbs)).digest("hex"));
+        } catch {
+          out.set(childRel, "unreadable");
+        }
+      }
+    }
+  };
+  walk(scriptsRoot, "");
+  return out;
+}
+function detectHindsightPluginTreeDrift(name, agentDir) {
+  const pluginDir = join66(agentDir, ".claude", "plugins", "hindsight-memory");
+  if (!existsSync69(pluginDir))
+    return [];
+  const releaseResolution = resolveHindsightVendorResolution();
+  if (releaseResolution.path === null) {
+    return [];
+  }
+  const releaseScripts = join66(releaseResolution.path, "scripts");
+  const deployedScripts = join66(pluginDir, "scripts");
+  const releaseHashes = hashPluginScriptsTree(releaseScripts);
+  if (releaseHashes === null || releaseHashes.size === 0) {
+    return [];
+  }
+  const deployedHashes = hashPluginScriptsTree(deployedScripts) ?? new Map;
+  const missing = [];
+  const changed = [];
+  const extra = [];
+  for (const [rel, hash2] of releaseHashes) {
+    const got = deployedHashes.get(rel);
+    if (got === undefined)
+      missing.push(rel);
+    else if (got !== hash2)
+      changed.push(rel);
+  }
+  for (const rel of deployedHashes.keys()) {
+    if (!releaseHashes.has(rel))
+      extra.push(rel);
+  }
+  if (missing.length === 0 && changed.length === 0 && extra.length === 0) {
+    return [];
+  }
+  const parts = [];
+  const summarise = (label, items) => {
+    if (items.length === 0)
+      return;
+    const shown = items.slice(0, 6).sort();
+    const more = items.length > shown.length ? ` (+${items.length - shown.length} more)` : "";
+    parts.push(`${label}: ${shown.join(", ")}${more}`);
+  };
+  summarise("missing", missing);
+  summarise("changed", changed);
+  summarise("stale-extra", extra);
+  return [
+    {
+      surface: "memory-plugin-build",
+      agent: name,
+      detail: `vendored hindsight-memory plugin scripts/ tree does NOT match the ` + `release build (manifest version is not a reliable signal \u2014 it can ` + `sit unchanged across builds): ${parts.join("; ")}`,
+      fix: "Re-vendor the plugin: `switchroom apply` re-copies the release " + "`scripts/` tree into this agent (or removes it entirely when the " + "agent has memory turned off), then restart the agent " + "(`switchroom agent restart " + name + "`). A tree that keeps drifting after apply means the agent's memory " + "config and its on-disk plugin disagree \u2014 check memory.backend / " + "memory.auto_recall for this agent."
+    }
+  ];
+}
 function writeDriftReport(agentDir, findings) {
   try {
     const report = {
@@ -63724,6 +63935,8 @@ function detectAgentDrift(name, agentConfigRaw, agentsDir, config, configPath, o
   }));
   findings.push(...detectSkillsDrift(name, agentDir));
   findings.push(...detectHindsightRecallTunableDrift(name, agentConfig, agentDir, config));
+  findings.push(...detectPrefetchAsyncTimeoutDrift(name, agentConfig, agentDir, config));
+  findings.push(...detectHindsightPluginTreeDrift(name, agentDir));
   if (!opts.skipContainerProbes) {
     findings.push(...detectHookScriptDrift(name, {
       binDir: opts.binDir,
@@ -110495,6 +110708,37 @@ function registerMemoryDirectiveCommand(memory, program3) {
       process.exit(1);
     }
   }));
+  directive.command("deactivate <agent> <name>").description("Deactivate every ACTIVE directive named <name> in <agent>'s bank by " + "flipping is_active=false \u2014 the M3 directive-placement campaign entry " + "point for retiring a guardrail's in-bank copy once it has been " + "relocated to the agent's always-loaded CLAUDE.md. Matches by NAME " + "(mirrors reconcile's 'every ACTIVE directive named <name>' selection); " + "if multiple active copies share the name, all are deactivated. " + "REVERSIBLE \u2014 only is_active is touched, never a delete or a " + "content/priority rewrite, so it can be reactivated. Idempotent: a " + "re-run over already-inactive copies is a clean no-op, not an error. " + "REFUSES any directive carrying the rules-block marker tag (that stays " + "active until an M3-flip removes the marker) \u2014 the whole call is " + "refused if even one active copy carries it, mutating nothing.").option("--dry-run", "Print what WOULD deactivate without mutating anything").option("--json", "Machine-readable output").action(withConfigError(async (agent, name, opts) => {
+    const admin = resolveDirectiveAdmin(program3, agent);
+    try {
+      const result = await admin.deactivateAllActiveByName({
+        name,
+        ...opts.dryRun ? { dryRun: true } : {}
+      });
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: true, agent, name, ...result }));
+        return;
+      }
+      const verb = result.dryRun ? "would deactivate" : "deactivated";
+      if (result.deactivated.length === 0) {
+        console.log(source_default.yellow(`\u2022 no-op: no ACTIVE directive named "${name}" in ${agent}'s bank ` + `(${result.alreadyInactive.length} already-inactive ` + `cop${result.alreadyInactive.length === 1 ? "y" : "ies"} left ` + `untouched). Nothing to do.`));
+        return;
+      }
+      for (const d of result.deactivated) {
+        console.log(source_default.green(`  ${result.dryRun ? "[dry-run] " : "\u2713 "}${verb} "${d.name}" ` + `(id ${d.id}, prior priority ${d.priority ?? "unset"})`));
+      }
+      const n = result.deactivated.length;
+      console.log(source_default.green(`${result.dryRun ? "[dry-run] " : "\u2713 "}${verb} ${n} directive` + `${n === 1 ? "" : "s"} named "${name}" in ${agent}'s bank` + (result.alreadyInactive.length > 0 ? ` (${result.alreadyInactive.length} already-inactive ` + `cop${result.alreadyInactive.length === 1 ? "y" : "ies"} skipped)` : "") + (result.dryRun ? " \u2014 nothing was mutated" : ". Reverse with reactivate.")));
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: msg }));
+      } else {
+        console.error(source_default.red(`\u2717 ${msg}`));
+      }
+      process.exit(1);
+    }
+  }));
   directive.command("mark-rules-block <agent> <id>").description("Stamp the persisted rules-block marker tag on directive <id> in " + "<agent>'s bank \u2014 the SAME DirectiveAdmin.markRulesBlock write path " + "the batch triage executor uses. Once stamped, deactivate_directive " + "(and every other DirectiveAdmin deactivation path) refuses this " + "directive unconditionally until an M3-flip action removes the " + "marker. This is the real entry point the mental-model-curator " + "skill's interactive triage pass calls for every directive it " + "classifies rules-block, BEFORE presenting the card \u2014 that skill " + "has no other write path to this marker (no MCP tool exposes it), " + "so without this call the code-level refusal never actually " + "arms itself on the interactive path (PR #4760 review follow-up).").option("--json", "Machine-readable output").action(withConfigError(async (agent, id, opts) => {
     const selfAgent = process.env.SWITCHROOM_AGENT_NAME;
     if (selfAgent && selfAgent !== agent) {

package/dist/host-control/main.js

@@ -21598,7 +21598,7 @@ function allocateAgentUid(name) {
 }
 
 // src/build-info.ts
-var VERSION = "0.21.18";
+var VERSION = "0.21.20";
 
 // src/setup/hindsight-recall-passthrough.ts
 var HINDSIGHT_RECALL_TAG_WEIGHT_SEED = Object.freeze({ sidechain: 0.8 });

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.21.18",
+  "version": "0.21.20",
   "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/skills/switchroom-release/SKILL.md

@@ -63,7 +63,12 @@ gh release create "vX.Y.Z" -R switchroom/switchroom \
 ```
 
 - **`--draft` is mandatory.** A published release with no assets immediately becomes `/releases/latest` and 404s every `curl | sh` install for the entire ~25-minute build window. `release.yml` will forcibly re-draft an incomplete published release within about a minute, but do not rely on the safety net — it exists for the case where this step was done wrong.
-- Creating the release object *before* the tag is what removes the race: `release.yml`'s `guard` job polls ~150s for it. **If you skip this step entirely, `guard` auto-creates the draft release from `CHANGELOG.md` (#4331)** — so a skipped `gh release create` is recoverable, not fatal, as long as the CHANGELOG section exists. Still create it here when you can: it is one fewer thing depending on the auto-heal, and it lets you author a title/notes that differ from the raw CHANGELOG section.
+- **Creating the release object *before* the tag is effectively REQUIRED, not belt-and-suspenders.** `release.yml`'s `guard` job polls ~150s for the release to appear, and if it never does it auto-creates the draft from `CHANGELOG.md` (#4331). But that auto-create routinely lands **too late for the same `release` run's completeness check**: the draft is created at the tail of the poll window, the check re-reads the release list in the *same* job, still cannot see it, exits 4, and **fails the run** — `npm`/`publish`/`finalize` all `needs:` this job, so they SKIP and nothing ships. This is not hypothetical: on **v0.21.18** (`release` run `32095648269`, attempt 1) the tag was pushed with no draft, `guard` retried 10× over ~150s, logged `auto-created draft release v0.21.18 from CHANGELOG.md`, then still exited 4 (`auto-created v0.21.18 but the completeness check still cannot see it`) and the job failed at `03:33:23Z` — npm/publish/latest all SKIPPED. So do not read #4331 as "skipping this step is fine": create the draft here, on the pinned SHA, before the tag push. It also lets you author a title/notes that differ from the raw CHANGELOG section.
+- **If the tag is already pushed without a draft and `guard` has failed, the fix-forward is a re-run, not a re-cut.** The auto-create has by then left a real draft object behind, so re-run the failed jobs — the guard's completeness check now sees the draft and passes:
+  ```bash
+  gh run rerun <release-run-id> --failed -R switchroom/switchroom
+  ```
+  On the second attempt `guard` passes → binaries attach → npm publishes → the GitHub Release un-drafts → `:vX.Y.Z` promotes to `:latest`. This is exactly how v0.21.18 recovered (attempt 2 published `03:37:03Z`). Do NOT cut a new patch version to route around a failed guard — the release for this tag already exists as a draft.
 - **Notes extraction gotcha (historical):** the naive `awk '/^## vX/,/^## v/' CHANGELOG` range collapses to a single line. Use a start-flag awk: `awk 'f{print} /^## vX\.Y\.Z/{print; f=1} f && /^## v/ && !/^## vX\.Y\.Z/{exit}'` — or extract the section to a temp file by line range.
 - **`gh release create` has been silently dropped in past runs.** Verify it exists and is a draft:
   ```bash

package/telegram-plugin/connection-drop.ts

@@ -0,0 +1,83 @@
+/**
+ * connection-drop.ts — the ONE canonical "was this a mid-stream connection /
+ * SSE drop?" wording matcher.
+ *
+ * THE PROBLEM this closes
+ * -----------------------
+ * Two independent classifiers historically disagreed about what a mid-stream
+ * "connection lost" / SSE-drop is, and they are consulted on different code
+ * paths:
+ *
+ *   - Path A — `parseLlmError` (llm-error-present.ts) → `detectModelUnavailable`
+ *     (model-unavailable.ts): a network-drop wording maps to
+ *     `{kind:'transient', source:'network'}`.
+ *   - Path B — the sub-agent transcript path → `detectErrorInTranscriptLine`
+ *     (session-tail.ts) → `classifyClaudeError` (operator-events.ts): a
+ *     connection-drop-worded line that is NOT the exact `server_error` /
+ *     `api_error` type falls through to `unknown-5xx`/`unknown-4xx` (a generic
+ *     terminal), because that path never consulted the network-drop wording
+ *     list.
+ *
+ * So the SAME dropped-stream line was a "transient network" event on one path
+ * and a "generic terminal" event on the other. This module gives both paths a
+ * single predicate to consult so a connection-drop is identifiable as such on
+ * BOTH.
+ *
+ * SCOPE: this is a WORDING matcher only. It answers "does this text look like a
+ * transport connection drop?" — it deliberately does NOT decide the final
+ * error kind. Callers gate the raw predicate on their own classification (only
+ * flagging a drop on the transient/unknown/transport families, never on a
+ * positively-identified auth/quota/credit wall) so a wrapped auth/quota error
+ * whose OUTER text happens to say "fetch failed" is never mislabelled a drop.
+ *
+ * Pure module: no IPC, no bot, no FS. Trivially unit-testable.
+ */
+
+/**
+ * Canonical connection-drop / SSE-drop wordings (lowercase substrings, matched
+ * case-insensitively). Provenance for each entry is in the PR description; the
+ * list is deliberately CONSERVATIVE — it covers transport-layer connection
+ * drops only and must NOT match auth / quota / overload / provider-credit
+ * wording (verified by the negative tests). Bare `stream` / `terminated` are
+ * intentionally EXCLUDED: `upstream`/`downstream` contain `stream`, and
+ * `terminated` appears in unrelated contexts — both would over-match and risk a
+ * false auto-resume in the later PRs that gate on this predicate.
+ *
+ * DNS-resolution failures (`enotfound`, `eai_again`, `getaddrinfo`, "request
+ * timed out") are also excluded: a name-resolution failure is a network fault
+ * but NOT a connection drop (no connection was ever established). Path A still
+ * classifies those as its broader `network` kind, unchanged — they simply do
+ * not set the connection-drop discriminator.
+ */
+export const CONNECTION_DROP_SIGNALS: readonly string[] = [
+  // ── Node/undici transport error codes (worded + code forms) ──────────────
+  'socket hang up', // model-unavailable.ts networkSignals; mcp-credential-failure.ts
+  'econnreset', // model-unavailable.ts networkSignals; retry-api-call.ts; ubiquitous fixtures
+  'econnrefused', // model-unavailable.ts networkSignals
+  'etimedout', // model-unavailable.ts networkSignals; retry-api-call.ts
+  'epipe', // broken pipe on a half-dead socket (tests: pending-card-expiry, boot-sweep-gate)
+  'fetch failed', // model-unavailable.ts networkSignals; retry-api-call.ts
+  'network error', // model-unavailable.ts networkSignals
+  // ── Worded connection-lost forms ─────────────────────────────────────────
+  'connection refused', // model-unavailable.ts networkSignals
+  'connection reset', // worded ECONNRESET (retry-api-call.ts comment)
+  'connection closed', // model-unavailable.ts networkSignals; canonical "Connection closed mid-response"
+  'connection lost', // plausible SSE-drop wording (precise phrase, no over-match risk)
+  // ── Mid-response / SSE-drop markers ──────────────────────────────────────
+  'mid-response', // model-unavailable.ts networkSignals; "Connection closed mid-response"
+  'premature close', // Node/undici stream "Premature close" — a response body that ended early
+  'stream disconnected', // plausible SSE-drop wording (precise two-word phrase)
+  'stream closed', // plausible SSE-drop wording (precise two-word phrase)
+]
+
+/**
+ * True when `text` carries a canonical connection-drop / SSE-drop wording.
+ *
+ * WORDING ONLY — see the module header. Never throws; a non-string collapses to
+ * `false`.
+ */
+export function isConnectionDropText(text: string): boolean {
+  if (typeof text !== 'string' || text.length === 0) return false
+  const lower = text.toLowerCase()
+  return CONNECTION_DROP_SIGNALS.some(s => lower.includes(s))
+}

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

@@ -23205,6 +23205,31 @@ var OPERATOR_ACTIONABLE_KINDS = new Set([
   "proxy-misconfig"
 ]);
 
+// connection-drop.ts
+var CONNECTION_DROP_SIGNALS = [
+  "socket hang up",
+  "econnreset",
+  "econnrefused",
+  "etimedout",
+  "epipe",
+  "fetch failed",
+  "network error",
+  "connection refused",
+  "connection reset",
+  "connection closed",
+  "connection lost",
+  "mid-response",
+  "premature close",
+  "stream disconnected",
+  "stream closed"
+];
+function isConnectionDropText(text) {
+  if (typeof text !== "string" || text.length === 0)
+    return false;
+  const lower = text.toLowerCase();
+  return CONNECTION_DROP_SIGNALS.some((s) => lower.includes(s));
+}
+
 // tool-label-sidecar.ts
 import { existsSync as existsSync2, readFileSync, statSync as statSync2 } from "node:fs";
 import { join as join2 } from "node:path";
@@ -23677,6 +23702,10 @@ function extractRetryState(obj) {
     maxRetries: typeof obj.maxRetries === "number" ? obj.maxRetries : null
   };
 }
+var CONNECTION_DROP_ELIGIBLE_KINDS = new Set(["transport-transient", "unknown-5xx", "unknown-4xx"]);
+function isConnectionDrop(kind, scanText) {
+  return CONNECTION_DROP_ELIGIBLE_KINDS.has(kind) && isConnectionDropText(scanText);
+}
 function detectErrorInTranscriptLine(line) {
   if (!line || line.length > 2 * 1024 * 1024)
     return null;
@@ -23701,7 +23730,9 @@ ${errStr}`) ? "rate-limited" : "quota-exhausted" : classifyClaudeError({ type: e
       raw: obj,
       detail: text || errStr || "api error",
       transient: kind2 === "rate-limited",
-      terminal: true
+      terminal: true,
+      connectionDrop: isConnectionDrop(kind2, `${text}
+${errStr}`)
     };
   }
   const isErrorLine = type === "api_error" || type === "error";
@@ -23714,7 +23745,15 @@ ${errStr}`) ? "rate-limited" : "quota-exhausted" : classifyClaudeError({ type: e
   const transient = kind === "rate-limited" || kind === "transport-transient";
   const retry = extractRetryState(obj);
   const terminal = !transient ? true : retry.retryAttempt != null && retry.maxRetries != null ? retry.retryAttempt >= retry.maxRetries : isErrorLine;
-  return { kind, raw, detail, transient, terminal };
+  return {
+    kind,
+    raw,
+    detail,
+    transient,
+    terminal,
+    connectionDrop: isConnectionDrop(kind, `${detail}
+${String(type ?? "")}`)
+  };
 }
 function extractDetailMessage(obj) {
   if (!obj)

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

@@ -74529,6 +74529,31 @@ var OPERATOR_ACTIONABLE_KINDS = new Set([
   "proxy-misconfig"
 ]);
 
+// connection-drop.ts
+var CONNECTION_DROP_SIGNALS = [
+  "socket hang up",
+  "econnreset",
+  "econnrefused",
+  "etimedout",
+  "epipe",
+  "fetch failed",
+  "network error",
+  "connection refused",
+  "connection reset",
+  "connection closed",
+  "connection lost",
+  "mid-response",
+  "premature close",
+  "stream disconnected",
+  "stream closed"
+];
+function isConnectionDropText(text4) {
+  if (typeof text4 !== "string" || text4.length === 0)
+    return false;
+  const lower = text4.toLowerCase();
+  return CONNECTION_DROP_SIGNALS.some((s) => lower.includes(s));
+}
+
 // session-tail.ts
 function sanitizeCwdToProjectName(cwd) {
   return cwd.replace(/[^a-zA-Z0-9]/g, "-");
@@ -74783,6 +74808,7 @@ function projectTranscriptLine(line) {
   }
   return [];
 }
+var CONNECTION_DROP_ELIGIBLE_KINDS = new Set(["transport-transient", "unknown-5xx", "unknown-4xx"]);
 
 // pty-tail.ts
 var import_headless = __toESM(require_xterm_headless(), 1);
@@ -78601,6 +78627,7 @@ function parseLlmError(raw, retryState) {
       terminal = true;
     }
   }
+  const connectionDrop = (kind === "transient" || kind === "unknown") && isConnectionDropText(text4);
   return {
     kind,
     coreText: buildCoreText(kind, source),
@@ -78610,6 +78637,7 @@ function parseLlmError(raw, retryState) {
     ...requestId != null ? { requestId } : {},
     ...providerId != null ? { providerId } : {},
     source,
+    connectionDrop,
     autoRetrying,
     terminal
   };
@@ -101454,6 +101482,10 @@ function extractRetryState(obj) {
     maxRetries: typeof obj.maxRetries === "number" ? obj.maxRetries : null
   };
 }
+var CONNECTION_DROP_ELIGIBLE_KINDS2 = new Set(["transport-transient", "unknown-5xx", "unknown-4xx"]);
+function isConnectionDrop(kind, scanText) {
+  return CONNECTION_DROP_ELIGIBLE_KINDS2.has(kind) && isConnectionDropText(scanText);
+}
 function detectErrorInTranscriptLine(line) {
   if (!line || line.length > 2 * 1024 * 1024)
     return null;
@@ -101478,7 +101510,9 @@ ${errStr}`) ? "rate-limited" : "quota-exhausted" : classifyClaudeError({ type: e
       raw: obj,
       detail: text4 || errStr || "api error",
       transient: kind2 === "rate-limited",
-      terminal: true
+      terminal: true,
+      connectionDrop: isConnectionDrop(kind2, `${text4}
+${errStr}`)
     };
   }
   const isErrorLine = type === "api_error" || type === "error";
@@ -101491,7 +101525,15 @@ ${errStr}`) ? "rate-limited" : "quota-exhausted" : classifyClaudeError({ type: e
   const transient = kind === "rate-limited" || kind === "transport-transient";
   const retry = extractRetryState(obj);
   const terminal = !transient ? true : retry.retryAttempt != null && retry.maxRetries != null ? retry.retryAttempt >= retry.maxRetries : isErrorLine;
-  return { kind, raw, detail, transient, terminal };
+  return {
+    kind,
+    raw,
+    detail,
+    transient,
+    terminal,
+    connectionDrop: isConnectionDrop(kind, `${detail}
+${String(type ?? "")}`)
+  };
 }
 function extractDetailMessage(obj) {
   if (!obj)
@@ -105876,10 +105918,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.21.18";
-var COMMIT_SHA = "ae063418";
-var COMMIT_DATE = "2026-08-18T03:14:53Z";
-var LATEST_PR = 4772;
+var VERSION2 = "0.21.20";
+var COMMIT_SHA = "fa05da22";
+var COMMIT_DATE = "2026-08-18T20:00:16Z";
+var LATEST_PR = 4782;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts