@coreplane/switchboard 1.260.3 → 1.260.5

package/dist/assets/src/core/ship/renewal.ts

@@ -160,7 +160,9 @@ export function renderRenewal(
   grant: Grant,
   options: { idle?: boolean; senders?: readonly string[] } = {},
 ): string {
-  const recourse = options.idle ? "reply in this thread to continue" : "re-issue the request to try again";
+  const recourse = options.idle
+    ? "the next reply in this thread continues the unit"
+    : "the next reply in this thread continues the original task";
   const senders = options.senders?.length
     ? `, with ${options.senders.length} message${options.senders.length === 1 ? "" : "s"} from ${options.senders.join(", ")}`
     : "";

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

@@ -321,6 +321,12 @@ export interface ChannelIO {
    * can name the run it caused. Optional: Slack/CLI need nothing from it.
    */
   runFinished?(receipt: RunReceipt): void;
+  /**
+   * Called when a typed request fails before it can create a run. One-shot
+   * channels use this to return a failing process/transport status while the
+   * requester-facing reply remains the channel's safe sentence.
+   */
+  requestFailed?(): void;
   /**
    * Called once by the core the moment a run has been CREATED in the registry
    * (before it executes), with the run id. The async HTTP ingress path uses it

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

@@ -59,7 +59,7 @@ export function bashBudgetWithinRun(wantedMs: number, remainingMs: number): RunB
     return {
       kind: "exhausted",
       note:
-        `run budget exhausted — ${secs(remainingMs)}s of wall clock left, inside the ` +
+        `the run budget is exhausted — ${secs(remainingMs)}s of wall clock left, inside the ` +
         `${secs(RUN_DEADLINE_RESERVE_MS)}s write-up reserve, so the command was not run; write up what you have now`,
     };
   }

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

@@ -170,6 +170,21 @@ export function boundByOf(binding: { ref: string; boundBy?: BoundBy }, defaultRe
   return binding.boundBy ?? (binding.ref === defaultRef ? "default" : "name");
 }
 
+/** Disk admission runs after an evicted binding's replacement reserves its
+ * pool user in storage. Restore the prior binding before an admission throw
+ * escapes, so a failed attach never publishes its provisional replacement. */
+export async function admitThreadDiskWithRollback<T>(
+  admitThreadDisk: () => Promise<T>,
+  rollback: () => Promise<void>,
+): Promise<T> {
+  try {
+    return await admitThreadDisk();
+  } catch (err) {
+    await rollback();
+    throw err;
+  }
+}
+
 /** The record a rebind leaves on the binding and in the attach answer: from
  *  which ref, onto which branch, for which pull request, when. `returnedAt`:
  *  that branch was gone from the mirror at a later attach and the binding

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

@@ -55,21 +55,37 @@ export type WorktreeDecision =
   /** Keep the tree exactly as it stands. */
   | { kind: "reuse" }
   /** Wipe it and clone afresh (a provisioning attach only). */
-  | { kind: "recreate"; why: "mode-switch" | "missing" | "unreadable" | "dirty" | "stale" }
+  | { kind: "recreate"; why: "mode-switch" | "ref-changed" | "missing" | "unreadable" | "dirty" | "stale" }
   /** A reusing attach cannot keep this tree, and must not replace it. */
   | { kind: "refuse"; why: string };
 
+/** A named-ref replacement is built beside the checkout its sticky binding
+ * still names. Once the attach settles, discard the superseded checkout on
+ * success or the provisional checkout on failure; either outcome leaves the
+ * persisted binding and the one surviving checkout saying the same ref. */
+export function replacementWorktreeCleanup(input: {
+  priorPath: string;
+  replacementPath: string;
+  succeeded: boolean;
+}): string | null {
+  if (input.priorPath === input.replacementPath) return null;
+  return input.succeeded ? input.priorPath : input.replacementPath;
+}
+
 export function decideWorktree(input: {
   /** True for a resumed run's attach: keep the tree, never wipe it. */
   reuse: boolean;
   /** The tree was built for the other mode (read-only against writable). */
   modeSwitch: boolean;
+  /** The binding moved to another ref. Even equal tips need a fresh clone so
+   *  the checked-out branch is the ref the caller named. */
+  refChanged?: boolean;
   /** The commit a provisioning attach checks out: the ref's tip, or the expected head. */
   sha: string;
   worktreePath: string;
   facts: WorktreeFacts;
 }): WorktreeDecision {
-  const { reuse, modeSwitch, sha, worktreePath, facts } = input;
+  const { reuse, modeSwitch, refChanged = false, sha, worktreePath, facts } = input;
   if (modeSwitch) {
     return reuse
       ? {
@@ -78,6 +94,11 @@ export function decideWorktree(input: {
         }
       : { kind: "recreate", why: "mode-switch" };
   }
+  if (refChanged) {
+    return reuse
+      ? { kind: "refuse", why: `the worktree at ${worktreePath} is attached to another ref` }
+      : { kind: "recreate", why: "ref-changed" };
+  }
   if (!facts.exists) {
     return reuse
       ? {

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

@@ -194,11 +194,11 @@ export function fleetBusyRunEndedLine(run: string | undefined, thread: string, e
 }
 
 /** The message `ExecCapacityError` carries once the wait is spent: names the
- *  wait and the knob, and tells the reader this is a retry-later condition. */
+ *  wait and the missing automatic queue as a bug, never delegates a retry. */
 export function fleetBusyExhaustedMessage(waitedMs: number): string {
   return (
-    `sandbox fleet busy — no free per-thread sandbox after waiting ${Math.round(waitedMs / 1000)}s ` +
-    "(the fleet's max_instances is reached); try again in a few minutes"
+    `this is a bug: the sandbox fleet had no free per-thread sandbox after waiting ${Math.round(waitedMs / 1000)}s ` +
+    "(the fleet's max_instances is reached), and no automatic queue remained"
   );
 }
 
@@ -273,11 +273,11 @@ export function sandboxStartingExecAnswer(cause: string): {
 }
 
 /** The message `ExecCapacityError` carries when a container did not start
- *  inside the start budget: the wait, and what to do. */
+ *  inside the start budget: the wait and the missing automatic recovery. */
 export function startWaitExhaustedMessage(waitedMs: number): string {
   return (
-    `sandbox not ready — the thread's container did not finish starting within ${Math.round(waitedMs / 1000)}s; ` +
-    "try again in a few minutes"
+    `this is a bug: the thread's sandbox did not finish starting within ${Math.round(waitedMs / 1000)}s, ` +
+    "and no automatic start wait remained"
   );
 }