@coreplane/switchboard 1.243.0 → 1.245.0

package/dist/assets/src/execution/residentRefresh.ts

@@ -186,6 +186,22 @@ export function killStaleBuildProcessesCommand(user: string, dir: string): strin
  *  failure however it died. */
 const INTERRUPTION_SIGNATURE = /\bexit 143\b|Session terminated|SIGTERM|^restore-interrupted:/;
 
+/** The wordings git gives when the MIRROR itself is broken: its `origin`
+ *  remote gone from `config`, the repository not a repository, an object store
+ *  with bad, corrupt or unreadable objects, a local file it cannot open. None
+ *  of these is GitHub's doing, and none is cured by waiting for GitHub. */
+const MIRROR_FAILURE_WORDING =
+  /'origin' does not appear to be a git repository|not a git repository|\bbad object\b|\bcorrupt\b|unable to read (?:tree|object|commit|blob)|object file .* is empty|cannot open \.git\/|unable to open object|missing object/i;
+
+/** Whether a failed mirror fetch failed on the mirror (the resident's own
+ *  disk — item 67 counts it) rather than on GitHub (`github-unreachable`, a
+ *  serviceable reason that parks on repeat, item 16b). GitHub is the default:
+ *  a message names the mirror only through the wordings above, so an unknown
+ *  failure keeps the reading it always had. */
+export function fetchFailureIsMirrors(message: string): boolean {
+  return MIRROR_FAILURE_WORDING.test(message);
+}
+
 /** Message wording of the Sandbox SDK's runtime-replacement error family — the
  *  container went away UNDER a live SDK call, so the failure never reaches the
  *  shell-kill signature above: a step that dies this way surfaces as
@@ -225,14 +241,17 @@ const INTERRUPTION_SIGNATURE = /\bexit 143\b|Session terminated|SIGTERM|^restore
 export const RUNTIME_MOVED_WORDING =
   /previous runtime incarnation|interrupted because the runtime changed|runtime identity is no longer active|sandbox lifetime is no longer current|platform was updating the sandbox runtime|no longer identifies pid/i;
 /** The platform's words for a container that is down under a command (see
- *  `RUNTIME_MOVED_WORDING`): the spawn refusal of a stopped container and the
- *  binding's not-running refusal, anchored to the full phrase so a genuine
+ *  `RUNTIME_MOVED_WORDING`): the spawn refusal of a stopped container, the
+ *  binding's not-running refusal, and the SDK's "The container just exited"
+ *  for a container that died under a live exec (a roll landing mid-step; the
+ *  bot side reads the same words as a roll, residentWake's
+ *  CONTAINER_GONE_WORDING), each anchored to the full phrase so a genuine
  *  crash ("container exited with unexpected exit code") and the readiness
  *  probe ("the container is not listening") never match. The harness's
  *  container seam reads the same two as a container down under its one more
  *  command — a wait, never a judgement (harness.md item 6). */
 export const STOPPED_CONTAINER_WORDING =
-  /process supervisor is closed|container is not running, consider calling start/i;
+  /process supervisor is closed|container is not running, consider calling start|the container just exited/i;
 export const RUNTIME_REPLACEMENT_WORDING = new RegExp(
   `${RUNTIME_MOVED_WORDING.source}|${STOPPED_CONTAINER_WORDING.source}`,
   "i",
@@ -339,10 +358,30 @@ export const WAKE_PORT_READY_MS = 3 * 60_000;
  *  SDK by a test. */
 export const SDK_RUNTIME_RECORD_KEY = "currentRuntimeIdentity";
 
-/** The DOMException the SDK's connect abort raises: `AbortError`, message
- *  `The operation was aborted`. Anchored on the whole sentence so a command's
- *  own `Aborted (core dumped)` never matches. */
-export const RUNTIME_UNREACHABLE_WORDING = /\bThe operation was aborted\b/;
+/** The DOMException the SDK's connect abort raises — `fetchUpgradeAttempt`
+ *  calls `controller.abort()` with no reason when `DEFAULT_CONNECT_TIMEOUT_MS`
+ *  passes, so the runtime's own `AbortError` with the message exactly `The
+ *  operation was aborted`. Anchored on the WHOLE message: a command's own
+ *  `Aborted (core dumped)` never matches, and neither does a `TimeoutError`'s
+ *  `The operation was aborted due to timeout` — the text `AbortSignal.timeout`
+ *  raises, a route's own bound on a slow GitHub, not a silent runtime. A
+ *  wrapper is read by its `cause`, where the DOMException rides whole; a
+ *  wrapper that only pasted the sentence into a longer message is not the
+ *  signal. */
+export const RUNTIME_UNREACHABLE_WORDING = /^The operation was aborted\.?$/;
+
+/** `err` and its `cause` chain, bounded like the SDK's own `selfAndCauses`
+ *  walker: the SDK wraps platform errors, so the telling message can sit one or
+ *  two links down. The one walker for every reader of a throw's chain — the
+ *  resident Worker's classifiers and its thread-error builders, the sandbox
+ *  Worker's — so the depth bound and the shape are decided once. */
+export function* selfAndCauses(err: unknown): Generator<unknown> {
+  let current = err;
+  for (let depth = 0; depth < 8 && current != null; depth++) {
+    yield current;
+    current = typeof current === "object" ? (current as { cause?: unknown }).cause : undefined;
+  }
+}
 
 /** Is this one link of an error's cause chain the SDK's connect abort? By
  *  name first (the DOMException's `AbortError`), by the DOMException's message

package/dist/assets/src/execution/residentText.ts

@@ -38,7 +38,12 @@ export function residentErrorText(text: string): string {
   return redactAndCap(stripAnsi(text), RESIDENT_ERROR_CAP);
 }
 
-const SANITIZED_FIELDS = ["error", "reason", "summary"] as const;
+/** The free-text fields a resident body carries: `error` (the reply), `reason`
+ *  (the answer's own word or a lifecycle reason), `stateReason` (the lifecycle
+ *  reason beside `state` on a thread route's 503 — the same remote text
+ *  `reason` used to carry there, item 62), `summary`. A field added to a
+ *  resident answer that carries remote output is added HERE first. */
+const SANITIZED_FIELDS = ["error", "reason", "stateReason", "summary"] as const;
 
 /** How deep the sanitizer descends. The deepest resident shape today is
  *  `/residents` → `residents[]` → `live` → `reason` (depth 3); the bound exists
@@ -48,8 +53,8 @@ const SANITIZE_DEPTH = 4;
 /** A parsed resident body with its free-text fields made safe, at every level:
  *  `/residents` nests each resident's `state`/`reason` (or an `error`) under
  *  `residents[].live`, and `repo list` renders those. In each plain object only
- *  `error`, `reason` and `summary` are touched (when strings) — `error` at the
- *  reply-sized cap, the other two at the card-sized one; `stderr` is
+ *  `error`, `reason`, `stateReason` and `summary` are touched (when strings) —
+ *  `error` at the reply-sized cap, the others at the card-sized one; `stderr` is
  *  rewritten only when it mirrors `error` (the thread routes' failure shape
  *  copies the error into stderr). Every other field — `needs`, `state`,
  *  `stdout`, `status`, bindings, numbers — passes through untouched. Arrays are

package/dist/assets/src/mcp/registry.ts

@@ -238,6 +238,9 @@ export interface McpServerView {
   promotedFromName?: string;
   /** A user row's owner (the id after `user:` in `scopeKey`) as a display name, when the lookup answered. */
   ownerName?: string;
+  /** A channel row's channel (the id after `channel:` in `scopeKey`) as its name without the hash,
+   *  when the lookup answered. */
+  channelName?: string;
   /** A higher tier holds this name, so runs use that entry and this one is idle (`mcpServersFor`'s
    *  `shadowedBy`, the winning scope key — `org`, or `channel:<id>`); absent when this entry serves. */
   shadowedBy?: string;