@coreplane/switchboard 1.226.1 → 1.227.0

package/dist/assets/deploy/cloudflare-resident/worker.ts

@@ -85,6 +85,19 @@ import { selectBindingsToPurge } from "../../src/execution/bindingPurge.js";
 import { busyAfterKillReason, planForceDetach } from "../../src/execution/residentDetach.js";
 import { parseReadonly, planReadonlyAttach } from "../../src/execution/residentReadonly.js";
 import { decideWorktree, parseReuse, type WorktreeFacts } from "../../src/execution/residentReuse.js";
+import {
+  boundByFor,
+  parseOwnPr,
+  parseRefByDefault,
+  rebindPlan,
+  rebindRefused,
+  rebindVerdict,
+  type BoundBy,
+  type OwnPr,
+  type Rebound,
+  type RebindRefused,
+  type RebindTreeFacts,
+} from "../../src/execution/residentRebind.js";
 import {
   depCacheScript,
   mutableCachePaths,
@@ -966,10 +979,21 @@ interface ResidentRecord {
 
 /** Per-thread binding: persisted in the resident DO keyed by
  *  threadKey; survives restarts and eviction. `user`/`evicted` describe the
- *  current allocation; `ref` is sticky for the thread's whole life. */
+ *  current allocation; `ref` is sticky for the thread's whole life, with one
+ *  exception — the branch the thread's own run opened a pull request on
+ *  (`rebound`, docs/reference/specs/resident-repos.md item 16). */
 interface ThreadBinding {
   threadKey: string;
   ref: string;
+  /** How `ref` was chosen when the binding was made: the repo default for want
+   *  of a named branch (item 30), or a branch someone named. Absent on a
+   *  binding made before the field: read as `default` iff `ref` is the default
+   *  branch. Only a `default` binding may ever move. */
+  boundBy?: BoundBy;
+  /** The one move a binding may make (item 16): from the default it was bound
+   *  to, onto the branch the thread's own run opened a pull request on. Set,
+   *  the binding never moves again. */
+  rebound?: Rebound;
   /** Allocated OS user (worker2..worker17); "" once evicted (pool released). */
   user: string;
   worktreePath: string;
@@ -1047,8 +1071,27 @@ interface AttachOk {
   /** Every command this attach ran, as offsets from its start (docs/reference/specs/
    *  tracing.md item 19): the bot grafts them under its attach span. */
   trace: ResidentStep[];
+  /** This attach moved the binding onto the branch the thread's own run opened
+   *  a pull request on (item 16): from where, to where, which PR. */
+  rebound?: Rebound;
+  /** The caller asked for that move and the binding stood: the branch, the PR
+   *  and why — so the bot can say where the follow-up runs and why. */
+  rebindRefused?: RebindRefused;
+}
+
+/** Why the caller's `refHint` is what it is (item 16), beside the hint itself:
+ *  `ownPr` — the pull request the thread's own run opened, whose head branch
+ *  the hint is (the one reason a binding may move; never a PR a person named);
+ *  `refByDefault` — the caller bound the resident's own default branch because
+ *  its message named none (item 30), recorded on a new binding as `boundBy`. */
+interface RefHintReason {
+  ownPr: OwnPr | null;
+  refByDefault: boolean;
 }
 
+/** The body every bot always sent: a hint with no reason attached. */
+const NO_REF_HINT_REASON: RefHintReason = { ownPr: null, refByDefault: false };
+
 /** Result of one /op test/build execution. `ok` is the command's
  *  verdict — a failing test run is a RESULT with ok:false, never an error. */
 interface OpRunOk {
@@ -4286,6 +4329,8 @@ export class ResidentDO extends Sandbox<Env> {
     threadKey: string,
     ref: string,
     worktreePath: string,
+    /** How a NEW binding's ref was chosen (item 16); an existing binding keeps its own record. */
+    boundBy: BoundBy,
   ): Promise<{ binding: ThreadBinding; wrote: boolean } | ThreadErr> {
     const key = threadBindingKey(threadKey);
     const existing = await this.ctx.storage.get<ThreadBinding>(key);
@@ -4306,6 +4351,15 @@ export class ResidentDO extends Sandbox<Env> {
       boundAt: existing?.boundAt ?? now,
       lastAttachAt: now,
       evicted: false,
+      // An evicted binding's own history: how its ref was chosen (absent on
+      // one made before the field — never overwritten by this attach's flag)
+      // and the one move it may have made.
+      ...(existing
+        ? {
+            ...(existing.boundBy !== undefined ? { boundBy: existing.boundBy } : {}),
+            ...(existing.rebound !== undefined ? { rebound: existing.rebound } : {}),
+          }
+        : { boundBy }),
     };
     await this.ctx.storage.put(key, binding);
     return { binding, wrote: true };
@@ -4326,13 +4380,14 @@ export class ResidentDO extends Sandbox<Env> {
     reuse = false,
     record?: ResidentRecord,
     traceparent?: string,
+    reason: RefHintReason = NO_REF_HINT_REASON,
   ): Promise<AttachOk | ThreadErr> {
     // One step trace per attach (docs/reference/specs/tracing.md item 19): every command
     // the attach runs lands on it, and the answer carries it.
     const t0 = systemClock();
     const trace = createStepTrace(t0);
     const res = await this.stepTrace.run(trace, () =>
-      this.attachThreadTraced(threadKey, refHint, readonly, wantSha, reuse, record, t0),
+      this.attachThreadTraced(threadKey, refHint, readonly, wantSha, reuse, record, t0, reason),
     );
     // The same steps as the resident's own `resident.attach` root (item 22).
     emitStepRoot("resident.attach", t0, trace.steps(), traceparent, "error" in res ? refusalOutcome(res) : "ok");
@@ -4348,6 +4403,7 @@ export class ResidentDO extends Sandbox<Env> {
     reuse: boolean,
     record: ResidentRecord | undefined,
     t0: number,
+    reason: RefHintReason,
   ): Promise<AttachOk | ThreadErr> {
     try {
       await this.ensureHydrated();
@@ -4365,7 +4421,17 @@ export class ResidentDO extends Sandbox<Env> {
       // container under it (and isIdle never parks the cycle mid-attach).
       this.attachesInFlight++;
       try {
-        return await this.attachThreadBody(threadKey, refHint, readonly, wantSha, reuse, resourceId, t0, record);
+        return await this.attachThreadBody(
+          threadKey,
+          refHint,
+          readonly,
+          wantSha,
+          reuse,
+          resourceId,
+          t0,
+          record,
+          reason,
+        );
       } finally {
         this.attachesInFlight--;
       }
@@ -4399,7 +4465,8 @@ export class ResidentDO extends Sandbox<Env> {
     reuse: boolean,
     resourceId: string,
     t0: number,
-    recordFromRoute?: ResidentRecord,
+    recordFromRoute: ResidentRecord | undefined,
+    reason: RefHintReason,
   ): Promise<AttachOk | ThreadErr> {
     try {
       await this.refreshIfStale(resourceId);
@@ -4419,8 +4486,21 @@ export class ResidentDO extends Sandbox<Env> {
     const record = recordFromRoute ?? (await this.registry().getRecord(resource));
     if (!record || !facts) return { error: "not-serviceable: registry record or repo facts missing", status: 503 };
 
-    const prior = stored.get(threadBindingKey(threadKey)) as ThreadBinding | undefined;
-    const ref = prior?.ref ?? refHint; // the binding's ref wins for the thread's whole life
+    // The binding's ref wins for the thread's whole life, with one exception
+    // (item 16): a thread bound to the repo default for want of a named branch
+    // moves, once and in place, onto the branch its own run opened a pull
+    // request on — when that branch is a local branch of this thread's tree and
+    // the tree is clean. Decided here, before the ref is chosen, so the rest of
+    // the attach (fetch, stale check, deps, credentials) runs on the moved ref.
+    const rebind = await this.rebindToOwnPr(
+      stored.get(threadBindingKey(threadKey)) as ThreadBinding | undefined,
+      reason.ownPr,
+      reuse,
+      facts.defaultRef,
+    );
+    if ("error" in rebind) return rebind;
+    const prior = rebind.binding;
+    const ref = prior?.ref ?? refHint;
     if (!ref) {
       // Name the default branch so the bot can bind to it (loudly) instead of
       // asking the user when the message named no branch; the binding is still
@@ -4437,7 +4517,12 @@ export class ResidentDO extends Sandbox<Env> {
     // and the prior binding's mode — the tested pure helper is the shipped code.
     const mode = planReadonlyAttach({ readonly, prior, slug, mirrorDir: MIRROR_DIR });
 
-    const alloc = await this.allocateThreadUser(threadKey, ref, worktreePath);
+    const alloc = await this.allocateThreadUser(
+      threadKey,
+      ref,
+      worktreePath,
+      boundByFor({ refByDefault: reason.refByDefault, ref, defaultRef: facts.defaultRef }),
+    );
     if ("error" in alloc) return alloc;
     const binding = alloc.binding;
     // "Nothing created" on failure: a FRESH allocation (new binding or a
@@ -4468,12 +4553,130 @@ export class ResidentDO extends Sandbox<Env> {
         binding,
         mode,
         rollback,
+        ...(rebind.rebound !== undefined ? { rebound: rebind.rebound } : {}),
+        ...(rebind.rebindRefused !== undefined ? { rebindRefused: rebind.rebindRefused } : {}),
       });
     } finally {
       this.diskCommittedKiB -= admission.committedKiB;
     }
   }
 
+  /** Item 16's one exception to the sticky binding: a thread bound to the repo
+   *  default for want of a named branch moves onto the branch its own run
+   *  opened a pull request on (`ownPr`), once, in place. The decision is the
+   *  pure `rebindPlan` / `rebindVerdict` of src/execution/residentRebind.ts;
+   *  this method measures the tree as the thread user and runs the verdict: a
+   *  `git checkout` inside the existing worktree — same path, same pool user,
+   *  no clone, no `rm -rf`, deps and snapshot lineage untouched — under the
+   *  mirror mutex so no other attach of the thread touches the tree meanwhile.
+   *  The rest of the attach then runs on the moved ref: the mirror fetch for
+   *  the PR head (item 51) and item 17's stale check, which keeps a tree whose
+   *  HEAD is the ref's tip or a descendant of it. The binding records the move
+   *  (`rebound`); the answer carries it, or the named refusal, so the bot can
+   *  say where the follow-up runs and why. A refusal never fails the attach. */
+  private async rebindToOwnPr(
+    prior: ThreadBinding | undefined,
+    ownPr: OwnPr | null,
+    reuse: boolean,
+    defaultRef: string,
+  ): Promise<{ binding: ThreadBinding | undefined; rebound?: Rebound; rebindRefused?: RebindRefused } | ThreadErr> {
+    const plan = rebindPlan({ ownPr, reuse, binding: prior, defaultRef });
+    if (plan.kind === "none" || prior === undefined) return { binding: prior };
+    if (plan.kind === "refuse") return { binding: prior, rebindRefused: plan.refused };
+    const key = threadBindingKey(prior.threadKey);
+    type Outcome =
+      | { kind: "none"; binding: ThreadBinding }
+      | { kind: "refuse"; refused: RebindRefused }
+      | { kind: "rebound"; moved: ThreadBinding; rebound: Rebound };
+    let outcome: Outcome;
+    try {
+      outcome = (
+        await this.withMirrorLock(async (): Promise<Outcome> => {
+          // The binding as it stands NOW, under the mutex — not the snapshot
+          // the plan read before the wait: the move is judged on, and written
+          // over, the row's current fields (its last attach time, its
+          // credential stamp), and a premise that changed while waiting —
+          // another attach already moved the ref — is re-judged, never
+          // overwritten.
+          const current = (await this.ctx.storage.get<ThreadBinding>(key)) ?? prior;
+          const again = rebindPlan({ ownPr, reuse, binding: current, defaultRef });
+          if (again.kind === "none") return { kind: "none", binding: current };
+          if (again.kind === "refuse") return again;
+          const wt = current.worktreePath;
+          // The facts, as the thread user in the thread's own tree: is the
+          // branch a local branch here (the physical trace of this thread's
+          // run having made it), and are the tracked files clean — judged
+          // only off a status git could read.
+          const tree: RebindTreeFacts = { exists: (await this.run(["test", "-d", `${wt}/.git`])).exitCode === 0 };
+          if (tree.exists) {
+            const branch = await this.threadRun(
+              current.user,
+              wt,
+              `git rev-parse --verify --quiet ${shellQuote(`refs/heads/${plan.to}`)}`,
+              DEFAULT_EXEC_TIMEOUT_MS,
+            );
+            tree.branchExists = branch.exitCode === 0;
+            const status = await this.threadRun(
+              current.user,
+              wt,
+              "git status --porcelain -uno",
+              DEFAULT_EXEC_TIMEOUT_MS,
+            );
+            tree.readable = status.exitCode === 0;
+            if (tree.readable) tree.dirty = status.stdout.trim() !== "";
+          }
+          const verdict = rebindVerdict(plan, tree);
+          if (verdict.kind !== "rebind") return verdict;
+          const startedAt = systemClock();
+          const checkout = await this.threadRun(
+            current.user,
+            wt,
+            `git checkout --quiet ${shellQuote(plan.to)}`,
+            DEFAULT_EXEC_TIMEOUT_MS,
+          );
+          this.stepTrace.getStore()?.record("rebind-checkout", {
+            startedAt,
+            endedAt: systemClock(),
+            exitCode: checkout.exitCode,
+            timedOut: checkout.timedOut,
+          });
+          if (checkout.exitCode !== 0) {
+            const detail =
+              checkout.stderr.trim().split("\n")[0]?.slice(0, 200) || `git checkout exited ${checkout.exitCode}`;
+            return { kind: "refuse", refused: rebindRefused(plan, "checkout-failed", detail) };
+          }
+          const rebound: Rebound = {
+            from: current.ref,
+            to: plan.to,
+            pr: plan.pr,
+            at: new Date(systemClock()).toISOString(),
+          };
+          const moved: ThreadBinding = { ...current, ref: plan.to, rebound };
+          await this.ctx.storage.put(key, moved);
+          return { kind: "rebound", moved, rebound };
+        }, ATTACH_MUTEX_WAIT_MS)
+      ).value;
+    } catch (err) {
+      if (err instanceof MirrorBusyError) {
+        const s = await this.getStatus();
+        return { error: errMsg(err), status: 503, state: s.state, reason: "mirror-busy" };
+      }
+      return { error: `attach-failed: ${errMsg(err)}`, status: 500 };
+    }
+    if (outcome.kind === "none") return { binding: outcome.binding };
+    if (outcome.kind === "refuse") {
+      console.log(
+        `attach ${prior.threadKey}: kept on ${prior.ref} — rebind to ${plan.to} refused (${outcome.refused.reason}: ${outcome.refused.why})`,
+      );
+      return { binding: prior, rebindRefused: outcome.refused };
+    }
+    const { moved, rebound } = outcome;
+    console.log(
+      `attach ${prior.threadKey}: rebound ${rebound.from} → ${rebound.to} (the thread's own pull request #${rebound.pr})`,
+    );
+    return { binding: moved, rebound };
+  }
+
   /** The second half of an attach, past disk admission: mint, fetch + clone
    *  under the mirror lock, deps, credentials, the binding write. Split from
    *  `attachThreadBody` only so the admission's commitment is released on every
@@ -4490,8 +4693,12 @@ export class ResidentDO extends Sandbox<Env> {
     binding: ThreadBinding;
     mode: ReturnType<typeof planReadonlyAttach>;
     rollback: () => Promise<void>;
+    /** What `rebindToOwnPr` decided (item 16), for the answer. */
+    rebound?: Rebound;
+    rebindRefused?: RebindRefused;
   }): Promise<AttachOk | ThreadErr> {
     const { threadKey, refHint, wantSha, reuse, slug, t0, facts, record, binding, mode, rollback } = input;
+    const { rebound, rebindRefused } = input;
 
     // Command-level token mint — before the lock so mint latency
     // never holds the mutex, and failure never blocks the attach.
@@ -4664,6 +4871,8 @@ export class ResidentDO extends Sandbox<Env> {
       mutexWaitMs: locked.waitedMs,
       attachMs: systemClock() - t0,
       trace: this.currentSteps(),
+      ...(rebound !== undefined ? { rebound } : {}),
+      ...(rebindRefused !== undefined ? { rebindRefused } : {}),
     };
   }
 
@@ -7540,13 +7749,34 @@ async function handleAttach(env: Env, body: Record<string, unknown>, traceparent
   if ("error" in want) return json({ error: want.error }, 400);
   const reuse = parseReuse(body.reuse);
   if ("error" in reuse) return json({ error: reuse.error }, 400);
+  // Why the hint is what it is (item 16): the thread's own pull request and
+  // its head branch — the branch checked against the one ref pattern like
+  // every ref, before it can become a git argument — and the bound-by-default flag.
+  const parsedOwnPr = parseOwnPr(body.ownPr);
+  if ("error" in parsedOwnPr) return json({ error: parsedOwnPr.error }, 400);
+  if (parsedOwnPr.ownPr !== null) {
+    const ownRef = parseRef(parsedOwnPr.ownPr.ref, "ownPr.ref");
+    if ("error" in ownRef) return json({ error: ownRef.error }, 400);
+  }
+  const refByDefault = parseRefByDefault(body.refByDefault);
+  if ("error" in refByDefault) return json({ error: refByDefault.error }, 400);
+  const reason: RefHintReason = { ownPr: parsedOwnPr.ownPr, refByDefault: refByDefault.refByDefault };
   // Post-validation, the answer streams like /exec (item 59): heartbeat
   // whitespace then ONE JSON document over HTTP 200, so an attach that waits
   // on a deps install (minutes) cannot lose the connection the way a plain
   // response does (`fetch failed` a few minutes in). A refusal
   // carries its `status` in the body; `ResidentExecutor.attach` reads it there.
   return streamHeartbeatJson(
-    ctx.stub.attachThread(ctx.threadKey, refHint, readonly.readonly, want.sha, reuse.reuse, ctx.record, traceparent),
+    ctx.stub.attachThread(
+      ctx.threadKey,
+      refHint,
+      readonly.readonly,
+      want.sha,
+      reuse.reuse,
+      ctx.record,
+      traceparent,
+      reason,
+    ),
     (result) => result,
     (err) => ({ error: errMsg(err), status: 500 }),
   );

package/dist/assets/deploy/cloudflare-sandbox/Dockerfile

@@ -173,3 +173,10 @@ RUN npm install -g @earendil-works/pi-coding-agent@0.85.1 \
   && npm cache clean --force \
   && pi --version | grep -qx '0.85.1' \
   && pi --help | grep -q -- '--mode <mode>'
+
+# PID 1 keeps the container alive across a crash of the SDK's container
+# server (the supervisor's header says why); the base image's ENTRYPOINT is
+# the server itself, so one uncaught exception there ended the container.
+# src/deploy/sandboxRuntimeSupervisor.test.ts holds this pair of lines.
+COPY --chmod=0755 runtime-supervisor.sh /usr/local/bin/sandbox-runtime-supervisor
+ENTRYPOINT ["/usr/local/bin/sandbox-runtime-supervisor"]

package/dist/assets/deploy/cloudflare-sandbox/runtime-supervisor.sh

@@ -0,0 +1,67 @@
+#!/bin/sh
+# PID 1 of the cold sandbox: keeps the container alive across a crash of the
+# SDK's container server (/container-server/sandbox). That server calls
+# process.exit(1) on any uncaught exception, and as the base image's
+# ENTRYPOINT it was PID 1 — so one uncaught error ended the whole container:
+# /workspace gone, a detached pi with it, every later /exec a 500 until the
+# platform noticed. Started here as a child instead, the server's exit is a
+# restart a second later; the disk, the detached processes and the Durable
+# Object's view of a running container all survive, and the SDK recreates its
+# session on the next command (docs/reference/specs/execution.md item 21).
+#
+# A stop from the platform is SIGTERM to PID 1: forwarded to the server, and
+# nothing starts again — a stop that lands during the pause between two
+# starts, or before the new pid is known, still ends here — and the server's
+# own exit status becomes this script's. A terminal's INT is forwarded as
+# TERM too: a child started with `&` by a non-interactive shell ignores INT
+# (POSIX), so INT itself would stop nothing. A server that cannot stay up —
+# QUICK_EXIT_LIMIT exits in a row, each within QUICK_EXIT_SECS of starting —
+# ends the container with the last status instead of looping forever.
+# src/deploy/sandboxRuntimeSupervisor.test.ts holds the shape and drives it.
+set -u
+RUNTIME=${SANDBOX_RUNTIME:-/container-server/sandbox}
+QUICK_EXIT_SECS=10
+QUICK_EXIT_LIMIT=5
+pid=
+stopping=
+quick=0
+code=0
+
+on_signal() {
+  stopping=1
+  if [ -n "$pid" ]; then kill -TERM "$pid" 2>/dev/null; fi
+}
+trap on_signal TERM INT
+
+while :; do
+  started=$(date +%s)
+  "$RUNTIME" "$@" &
+  pid=$!
+  # A stop that landed between the start and this line found no pid to
+  # forward to; the server it missed gets it here.
+  if [ -n "$stopping" ]; then kill -TERM "$pid" 2>/dev/null; fi
+  wait "$pid"
+  code=$?
+  # A trapped signal ends `wait` early (status > 128) while the server still
+  # runs; wait again until it is really gone, so the status is its own.
+  while kill -0 "$pid" 2>/dev/null; do
+    wait "$pid"
+    code=$?
+  done
+  pid=
+  if [ -n "$stopping" ]; then exit "$code"; fi
+  if [ $(( $(date +%s) - started )) -lt "$QUICK_EXIT_SECS" ]; then
+    quick=$((quick + 1))
+  else
+    quick=0
+  fi
+  if [ "$quick" -ge "$QUICK_EXIT_LIMIT" ]; then
+    echo "sandbox-runtime-supervisor: the runtime exited with status $code, $quick times in a row within ${QUICK_EXIT_SECS}s of starting; giving up" >&2
+    exit "$code"
+  fi
+  echo "sandbox-runtime-supervisor: the runtime exited with status $code; starting it again" >&2
+  sleep 1
+  # A stop that landed during the pause: the last status is the answer, and
+  # nothing starts again.
+  if [ -n "$stopping" ]; then exit "$code"; fi
+done

package/dist/assets/deploy/cloudflare-sandbox/worker.ts

@@ -40,6 +40,11 @@ import {
   fleetBusyExecAnswer,
   isContainerStarting,
   isFleetBusyError,
+  isRuntimeProxyFailure,
+  isRuntimeUnreachableError,
+  runtimeUnreachableAnswer,
+  runtimeUnreachableExecAnswer,
+  SandboxRuntimeUnreachableError,
   thrownShape,
   thrownText,
 } from "../../src/execution/sandboxErrors.js";
@@ -96,6 +101,38 @@ export class SwitchboardSandbox extends Sandbox {
     }
   }
 
+  // A proxied fetch that nothing answered (docs/reference/specs/execution.md
+  // item 9): the `@cloudflare/containers` base class turns a failed fetch to
+  // the container's port into a plain-text HTTP 500 — `Error proxying request
+  // to container: …` when nothing listens (the SDK's server exited, or the
+  // image's PID 1 has not started it again yet), `Container suddenly
+  // disconnected` when the connection dropped mid-request — and the SDK's
+  // client, expecting JSON, throws the bare `HTTP error! status: 500`. Read
+  // the body here, before the client does, and throw the named error with the
+  // facts a card and a log search need: this container's id (the Durable
+  // Object's id is the container id in the `containers` dataset), the SDK
+  // pin, and whether the platform still calls the container running. Every
+  // other answer passes through untouched — a 500 body that is not the proxy's
+  // is re-wrapped unread by the client.
+  override async containerFetch(
+    requestOrUrl: Request | string | URL,
+    portOrInit?: number | RequestInit,
+    portParam?: number,
+  ): Promise<Response> {
+    const res = await super.containerFetch(requestOrUrl, portOrInit, portParam);
+    if (res.status !== 500) return res;
+    const body = await res.text();
+    if (isRuntimeProxyFailure(res.status, body)) {
+      throw new SandboxRuntimeUnreachableError({
+        containerId: this.ctx.id.toString(),
+        running: this.ctx.container?.running,
+        sdkVersion: SDK_PIN,
+        cause: body,
+      });
+    }
+    return new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
+  }
+
   override async exec(command: string, options?: ExecOptions): Promise<ExecResult> {
     return withActivityKeepalive(
       () => this.renewActivityTimeout(),
@@ -316,6 +353,11 @@ export default {
       // Never an empty text (item 3): a message-less SDK error is named as
       // such, with the rollout hint.
       const msg = thrownText(thrownShape(err));
+      // Nothing answered at the container's port (item 9): the file op never
+      // reached a server, so a 503 the executor's transport retry re-sends —
+      // by then the image's PID 1 has the server back — with the named reason
+      // and the container in the text.
+      if (isRuntimeUnreachableError(err)) return json(runtimeUnreachableAnswer(msg), 503);
       // A full fleet (docs/reference/specs/execution.md item 14): the SDK could not get a
       // container instance for this thread's Durable Object, so no session
       // exists and the file op never started — re-sending is safe by
@@ -406,6 +448,13 @@ function streamExec(
           // message-less SDK error is named, with the rollout hint. The
           // classifiers below still read the raw `shape`.
           const raw = thrownText(shape);
+          // Nothing answered at the container's port (item 9): named, with the
+          // container, in the dual shape — and never re-sent by anyone, since a
+          // command in flight when the server died may have run.
+          if (isRuntimeUnreachableError(err)) {
+            finish(runtimeUnreachableExecAnswer(raw));
+            return;
+          }
           // A full fleet (docs/reference/specs/execution.md item 14): session creation
           // failed because no container instance was free, so the command
           // never started — re-sending it is safe by construction. The named

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.226.1",
+  "version": "1.227.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.226.1",
+      "version": "1.227.0",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -17685,7 +17685,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.226.1",
+      "version": "1.227.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.124.0",

package/dist/assets/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard",
-  "version": "1.226.1",
+  "version": "1.227.0",
   "private": true,
   "description": "Mention it in Slack and an agent reviews the PR, ships the fix, or answers the question — on the model you choose, with its tools running where you decide.",
   "license": "Apache-2.0",

package/dist/assets/source.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.226.1",
-  "commit": "d69b1bb7040d07e4934a41d4fa8d94949236e175",
-  "builtAt": "2026-09-15T19:02:34.971Z"
+  "version": "1.227.0",
+  "commit": "ddc2b12dbf8da3149e5128cac35fb34b8b43755e",
+  "builtAt": "2026-09-15T19:54:11.830Z"
 }

package/dist/assets/src/core/authz/policy.ts

@@ -58,6 +58,14 @@ export const POLICY: readonly Rule[] = [
   { action: "runs:read", resource: "command", when: [grant("runs:read")] },
   { action: "runs:write", resource: "command", when: [grant("runs:write")] },
 
+  // ── conversations ────────────────────────────────────────────────────────
+  // Who may point the bot at another thread (record 0037). Asked for a
+  // pointing actor (`pointingActor`: one membership, the origin channel, no
+  // grants), so `member-of` reads: a public channel from anywhere, a private
+  // channel only from inside it, an admin's `all` not consulted. The row has
+  // no caller until the references dispatch step lands behind its flag.
+  { action: "conversation:read", resource: "channel", when: [MEMBER_OF] },
+
   // ── review ───────────────────────────────────────────────────────────────
   // `review abridge` spends one Opus-class call and rewrites a stored record:
   // the grant admits the command (admins through `all`, operators by name;

package/dist/assets/src/core/runEvents.ts

@@ -116,6 +116,14 @@ export type RunNoteKind =
    *  after the attach, before the first turn, so the run page explains a
    *  sandbox run that shows resident steps. */
   | "cold_sandbox"
+  /** The resident kept this thread's binding where it was instead of moving
+   *  it onto the branch the thread's own run opened a pull request on
+   *  (docs/reference/specs/resident-repos.md item 16): the summary names the
+   *  branch the run stays on, the PR, the reason and the resident's sentence.
+   *  The same word the card carries; published by the dispatcher after the
+   *  attach, before the first turn, so the run page explains a follow-up that
+   *  runs on the default instead of on its thread's PR. */
+  | "rebind_refused"
   /** A coding run submitted a PR description but the post-step opened no
    *  pull request because the branch it observed IS the base the pull
    *  request would target (docs/reference/specs/pr-description.md item 5) —
@@ -170,6 +178,7 @@ export const RUN_NOTE_KINDS = [
   "seed",
   "description_turn",
   "cold_sandbox",
+  "rebind_refused",
   "pr_not_opened",
   "review_not_posted",
   "compacted",
@@ -249,7 +258,7 @@ export function isSpanRecord(e: { type: string }): e is SpanStartEvent | SpanEnd
 
 /** The protected head (docs/reference/specs/tracing.md; live-view item 2) — is this event head material? The root's start, `slack.receive` and the
  *  `dispatch.*` span pairs, `input`, `context`, `run_meta`, `route`, and the
- *  `mcp_unavailable` / `spans_dropped` notes. */
+ *  `mcp_unavailable` / `spans_dropped` / `cold_sandbox` / `rebind_refused` notes. */
 export function isHeadMaterial(event: RunEvent): boolean {
   switch (event.type) {
     case "input":
@@ -258,7 +267,12 @@ export function isHeadMaterial(event: RunEvent): boolean {
     case "route":
       return true;
     case "run_note":
-      return event.kind === "mcp_unavailable" || event.kind === "spans_dropped" || event.kind === "cold_sandbox";
+      return (
+        event.kind === "mcp_unavailable" ||
+        event.kind === "spans_dropped" ||
+        event.kind === "cold_sandbox" ||
+        event.kind === "rebind_refused"
+      );
     case "span_start":
       return event.name === "request" || event.name === "slack.receive" || event.name.startsWith("dispatch.");
     case "span_end":