switchroom 0.21.17 → 0.21.19

package/dist/host-control/main.js

@@ -21598,7 +21598,7 @@ function allocateAgentUid(name) {
 }
 
 // src/build-info.ts
-var VERSION = "0.21.17";
+var VERSION = "0.21.19";
 
 // 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.17",
+  "version": "0.21.19",
   "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.17";
-var COMMIT_SHA = "ac61272c";
-var COMMIT_DATE = "2026-08-17T16:42:58Z";
-var LATEST_PR = 4768;
+var VERSION2 = "0.21.19";
+var COMMIT_SHA = "7e7061ba";
+var COMMIT_DATE = "2026-08-18T15:36:04Z";
+var LATEST_PR = 4777;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts

package/telegram-plugin/dist/server.js

@@ -17278,6 +17278,34 @@ var init_operator_events = __esm(() => {
   ]);
 });
 
+// connection-drop.ts
+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));
+}
+var CONNECTION_DROP_SIGNALS;
+var init_connection_drop = __esm(() => {
+  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"
+  ];
+});
+
 // tool-label-sidecar.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2, statSync as statSync3 } from "node:fs";
 import { join as join3 } from "node:path";
@@ -17761,6 +17789,9 @@ function extractRetryState(obj) {
     maxRetries: typeof obj.maxRetries === "number" ? obj.maxRetries : null
   };
 }
+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;
@@ -17785,7 +17816,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";
@@ -17798,7 +17831,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)
@@ -18234,13 +18275,15 @@ function startSessionTail(config2) {
     }
   };
 }
-var MAX_JSONL_LINE_BYTES, MAX_ERROR_TEXT_CHARS = 500;
+var MAX_JSONL_LINE_BYTES, MAX_ERROR_TEXT_CHARS = 500, CONNECTION_DROP_ELIGIBLE_KINDS;
 var init_session_tail = __esm(() => {
   init_operator_events();
   init_model_unavailable();
+  init_connection_drop();
   init_tool_label_sidecar();
   init_model_label();
   MAX_JSONL_LINE_BYTES = 2 * 1024 * 1024;
+  CONNECTION_DROP_ELIGIBLE_KINDS = new Set(["transport-transient", "unknown-5xx", "unknown-4xx"]);
 });
 
 // ../node_modules/.bun/@xterm+headless@6.0.0/node_modules/@xterm/headless/lib-headless/xterm-headless.js

package/telegram-plugin/llm-error-present.ts

@@ -41,6 +41,7 @@ import {
   type ProviderCreditEntry,
 } from './provider-credit.js'
 import { classifyClaudeError } from './operator-events.js'
+import { isConnectionDropText } from './connection-drop.js'
 import { stripRawErrorBytes, extractRequestId } from './raw-error-scrub.js'
 import { fmtLocalClock, tzAbbrev } from './shared/local-time.js'
 
@@ -94,6 +95,18 @@ export interface ParsedLlmError {
    */
   providerId?: string
   source: LlmErrorSource
+  /**
+   * True when this error is a mid-stream connection / SSE drop (a transport
+   * connection loss), per the canonical {@link isConnectionDropText} matcher.
+   * Set consistently on BOTH classification paths (here and
+   * `detectErrorInTranscriptLine`) so a later PR can gate auto-resume on ONE
+   * reliable discriminator. Only ever true for the `transient`/`unknown`
+   * families — never for a positively-identified auth/quota/overload/credit
+   * wall (guarded below), so it can never trigger a wrong auto-resume of a
+   * genuinely terminal error. Classification only in this PR; no consumer acts
+   * on it yet.
+   */
+  connectionDrop: boolean
   /** True when the harness is still retrying this error internally (mid-retry). */
   autoRetrying: boolean
   /** True when the failure is final (NOT an in-flight retry). */
@@ -169,6 +182,17 @@ export function parseLlmError(
     }
   }
 
+  // Connection-drop discriminator. Gated to the transient/unknown families so a
+  // positively-classified auth/quota/overload/credit wall is NEVER flagged as a
+  // drop, even if its raw text coincidentally carries a drop wording (e.g. a
+  // LiteLLM-wrapped 401 whose outer text says "fetch failed"). The gate mirrors
+  // Path B's inclusion set (`transport-transient`/`unknown-*`), keeping the two
+  // classifiers in agreement. `source==='network'` is not required: a drop
+  // wording that `detectModelUnavailable` does not recognise (e.g. `EPIPE`)
+  // lands on `unknown` here, and must still be identifiable as a drop.
+  const connectionDrop =
+    (kind === 'transient' || kind === 'unknown') && isConnectionDropText(text)
+
   return {
     kind,
     coreText: buildCoreText(kind, source),
@@ -178,6 +202,7 @@ export function parseLlmError(
     ...(requestId != null ? { requestId } : {}),
     ...(providerId != null ? { providerId } : {}),
     source,
+    connectionDrop,
     autoRetrying,
     terminal,
   }

package/telegram-plugin/scripts/bun-test-ci.sh

@@ -82,6 +82,12 @@ else
     uat/load-env.test.ts
     uat/uat-driver.test.ts
     uat/runners/
+    # M3 directive-flip UAT — deterministic (no-model, no-network) gate half.
+    # Same rationale as uat/runners/: vitest excludes all of uat/**, and these
+    # import `vitest` (bun runs them via its vitest-compat shim) — so they run
+    # on the BUN side. Directory match (trailing slash) never widens into
+    # uat/scenarios/. Fenced by scripts/check-test-runner-coverage.mjs.
+    uat/flip/
   )
 fi
 

package/telegram-plugin/session-tail.ts

@@ -42,6 +42,7 @@ function isMultiAgentEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
 }
 import { classifyClaudeError, type OperatorEventKind } from './operator-events.js'
 import { isLitellmProxyLocal429, isTransientUpstreamSignal } from './model-unavailable.js'
+import { isConnectionDropText } from './connection-drop.js'
 import { createToolLabelSidecar, type ToolLabelSidecar, type SidecarOptions } from './tool-label-sidecar.js'
 import { isModelSentinel } from './model-label.js'
 
@@ -960,6 +961,25 @@ function extractRetryState(obj: Record<string, unknown>): {
   }
 }
 
+/**
+ * The OperatorEventKinds on which a connection-drop wording may be flagged as a
+ * genuine transport drop. INCLUSION (not exclusion) by design: a positively
+ * classified auth/quota/credit/rate-limit/overload wall is NEVER in this set,
+ * so a wrapped terminal error whose outer text coincidentally carries a drop
+ * wording is never mislabelled a drop. `transport-transient` is the natural
+ * mid-stream-abort kind; `unknown-4xx`/`unknown-5xx` is where a drop-worded
+ * line lands when `classifyClaudeError` does not recognise its wording (the
+ * exact Path-B bug this closes). Mirrors Path A's `transient`/`unknown` gate in
+ * `parseLlmError`, keeping the two classifiers in agreement.
+ */
+const CONNECTION_DROP_ELIGIBLE_KINDS: ReadonlySet<OperatorEventKind> =
+  new Set<OperatorEventKind>(['transport-transient', 'unknown-5xx', 'unknown-4xx'])
+
+/** True when `kind` may carry the connection-drop flag AND the text is a drop wording. */
+function isConnectionDrop(kind: OperatorEventKind, scanText: string): boolean {
+  return CONNECTION_DROP_ELIGIBLE_KINDS.has(kind) && isConnectionDropText(scanText)
+}
+
 export function detectErrorInTranscriptLine(
   line: string,
 ): {
@@ -972,6 +992,15 @@ export function detectErrorInTranscriptLine(
    *  error mid-retry is `transient:true, terminal:false`; the caller
    *  suppresses it (no operator card until the failure is terminal). */
   terminal: boolean
+  /**
+   * True when this line is a mid-stream connection / SSE drop (a transport
+   * connection loss), per the canonical `isConnectionDropText` matcher, gated
+   * to the transport/unknown kinds. Set consistently with `parseLlmError`'s
+   * `ParsedLlmError.connectionDrop` so a later PR can gate auto-resume on ONE
+   * reliable discriminator across both classification paths. Classification
+   * only in this PR; no caller acts on it yet.
+   */
+  connectionDrop: boolean
 } | null {
   if (!line || line.length > 2 * 1024 * 1024) return null
   let obj: Record<string, unknown>
@@ -1042,6 +1071,7 @@ export function detectErrorInTranscriptLine(
       detail: text || errStr || 'api error',
       transient: kind === 'rate-limited',
       terminal: true,
+      connectionDrop: isConnectionDrop(kind, `${text}\n${errStr}`),
     }
   }
 
@@ -1089,7 +1119,14 @@ export function detectErrorInTranscriptLine(
       ? retry.retryAttempt >= retry.maxRetries
       : isErrorLine
 
-  return { kind, raw, detail, transient, terminal }
+  return {
+    kind,
+    raw,
+    detail,
+    transient,
+    terminal,
+    connectionDrop: isConnectionDrop(kind, `${detail}\n${String(type ?? '')}`),
+  }
 }
 
 function extractDetailMessage(obj: Record<string, unknown> | null): string | null {