@coreplane/switchboard 1.233.0 → 1.235.0

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

@@ -43,6 +43,7 @@ import {
   recycledMidCommandMessage,
 } from "../../src/execution/sandboxLifecycle.js";
 import { envFromRequest } from "../../src/execution/sandboxEnv.js";
+import { IdleGuard, type IdleGuardHost } from "../../src/execution/sandboxIdle.js";
 import { RUNTIME_REPLACEMENT_WORDING, isRuntimeUnreachableSignal } from "../../src/execution/residentRefresh.js";
 import {
   fleetBusyAnswer,
@@ -166,16 +167,66 @@ interface FileRefusal {
   reason?: string;
 }
 
+/** Durable Object storage key of the idle ledger's served-time. */
+const IDLE_LEDGER_KEY = "switchboard.idle.lastServedAt";
+/** The scheduled-callback name of the idle sweep (a method below). */
+const IDLE_SWEEP_CALLBACK = "idleSweep";
+
 export class SwitchboardSandbox extends Sandbox<Env> {
-  // Idle lifetime of a thread's container (the SDK's own default is 10 min).
-  // Idle means idle: the SDK renews the activity timeout every second while a
-  // command's stream is open (its control connection's busy poll), so a
-  // running command never counts toward it and the shell-level `timeout` is
-  // the one deadline a command can hit (docs/reference/specs/execution.md item 2).
-  // 5 minutes frees the slot sooner while a prompt follow-up still reuses the
-  // warm workspace.
+  // The SDK's idle setting (its own default is 10 min), kept so its alarm
+  // loop calls `onActivityExpired` on this cadence — but on the 0.13 line that
+  // hook is a question to the runtime ("anything still running?"), not a
+  // deadline, and the answer kept twenty-five containers awake for 16 hours.
+  // The deadline itself is the guard's (docs/reference/specs/execution.md
+  // item 22): 5 minutes after the last request this object served, the
+  // container is destroyed, whatever runs inside; the shell-level `timeout`
+  // stays the one deadline a command can hit (item 2), since a request in
+  // flight is service.
   sleepAfter = SANDBOX_SLEEP_AFTER;
 
+  private readonly idle: IdleGuard;
+
+  constructor(...args: ConstructorParameters<typeof Sandbox<Env>>) {
+    super(...args);
+    this.idle = new IdleGuard(this.idleHost());
+    // Every wake, including the one the SDK's own alarm causes on a leaked
+    // container: the baseline is read and a sweep armed before any request.
+    this.ctx.blockConcurrencyWhile(() => this.idle.wake());
+  }
+
+  /** The guard's view of this object: the platform's running flag, the SDK's
+   *  schedule table and clean destroy, the platform's kill, and storage. */
+  private idleHost(): IdleGuardHost {
+    return {
+      now: systemClock,
+      containerRunning: () => this.ctx.container?.running,
+      sweepScheduled: async () => (await this.listSchedules(IDLE_SWEEP_CALLBACK)).length > 0,
+      scheduleSweep: async (delayMs) => {
+        await this.schedule(Math.ceil(delayMs / 1000), IDLE_SWEEP_CALLBACK);
+      },
+      destroySandbox: () => this.destroy(),
+      killContainer: async () => {
+        await this.ctx.container?.destroy();
+      },
+      loadLastServedAt: () => this.ctx.storage.get<number>(IDLE_LEDGER_KEY),
+      saveLastServedAt: (at) => this.ctx.storage.put(IDLE_LEDGER_KEY, at),
+      log: (event) => console.log(JSON.stringify({ ...event, thread: this.ctx.id.name ?? this.ctx.id.toString() })),
+      wait: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    };
+  }
+
+  /** The idle sweep, scheduled by the guard through the SDK's schedule table
+   *  and re-armed by it while a container is running. */
+  async idleSweep(): Promise<void> {
+    await this.idle.sweep();
+  }
+
+  /** The SDK's activity expiry, answered by the guard's verdict instead of the
+   *  runtime's process probes. */
+  override async onActivityExpired(): Promise<void> {
+    await this.idle.expired();
+  }
+
   /** One command as one supervised process (docs/reference/specs/execution.md
    *  item 4): `timeout -k 10 <secs> bash -c 'mkdir -p /workspace && cd
    *  /workspace && <command>'`, the caller's env on the process alone (item 5),
@@ -188,6 +239,16 @@ export class SwitchboardSandbox extends Sandbox<Env> {
     command: string,
     execTimeoutSecs: number,
     envVars: Record<string, string>,
+  ): Promise<ExecAnswer | ExecFailure> {
+    return this.idle.served(() => this.execute(command, execTimeoutSecs, envVars));
+  }
+
+  /** `runCommand` without the ledger entry: the body, and the internal caller
+   *  (`readBase64`'s stat) that is already inside a served request. */
+  private async execute(
+    command: string,
+    execTimeoutSecs: number,
+    envVars: Record<string, string>,
   ): Promise<ExecAnswer | ExecFailure> {
     const startedAt = systemClock();
     const full = `mkdir -p ${WORKDIR} && cd ${WORKDIR} && ${command}`;
@@ -277,7 +338,9 @@ export class SwitchboardSandbox extends Sandbox<Env> {
   }
 
   async readText(path: string): Promise<{ content: string } | FileRefusal> {
-    return this.fileOp(async () => ({ content: (await this.readFile(path, { encoding: "utf-8" })).content }));
+    return this.idle.served(() =>
+      this.fileOp(async () => ({ content: (await this.readFile(path, { encoding: "utf-8" })).content })),
+    );
   }
 
   /** `encoding: "base64"` (src/execution/binaryRead.ts): the size first, from
@@ -285,7 +348,11 @@ export class SwitchboardSandbox extends Sandbox<Env> {
    *  decoded bytes to it — an SDK read that came back short would otherwise
    *  pass as the file. A file over the cap is refused by name inside a 200. */
   async readBase64(path: string): Promise<Base64ReadAnswer | FileRefusal> {
-    const stat = await this.runCommand(statCommandFor(path), 60, {});
+    return this.idle.served(() => this.readBase64Now(path));
+  }
+
+  private async readBase64Now(path: string): Promise<Base64ReadAnswer | FileRefusal> {
+    const stat = await this.execute(statCommandFor(path), 60, {});
     if ("error" in stat) {
       // The stat's own named failure — a full fleet, a silent control port —
       // is the read's, token included, so the executor waits as it would
@@ -309,10 +376,12 @@ export class SwitchboardSandbox extends Sandbox<Env> {
   }
 
   async write(path: string, content: string): Promise<{ ok: true } | FileRefusal> {
-    return this.fileOp(async () => {
-      await this.writeFile(path, content);
-      return { ok: true as const };
-    });
+    return this.idle.served(() =>
+      this.fileOp(async () => {
+        await this.writeFile(path, content);
+        return { ok: true as const };
+      }),
+    );
   }
 }
 

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.233.0",
+  "version": "1.235.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.233.0",
+      "version": "1.235.0",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -20032,7 +20032,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.233.0",
+      "version": "1.235.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@earendil-works/pi-ai": "0.85.1",

package/dist/assets/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard",
-  "version": "1.233.0",
+  "version": "1.235.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.233.0",
-  "commit": "4c96f69d476e76e2bc768a9eb6d505b683fddd36",
-  "builtAt": "2026-09-16T15:18:25.322Z"
+  "version": "1.235.0",
+  "commit": "091ab2f1f6d89290bde9c84e933d23525f9c8873",
+  "builtAt": "2026-09-16T17:37:07.278Z"
 }

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

@@ -96,9 +96,10 @@ export interface AgentDef {
    *  router's table is rendered from this registry. `false` keeps a preset
    *  out of the table — structurally: it is absent from the table the model
    *  is shown and refused as a single route even if the model names it.
-   *  `ship` (it holds the merge grant) opts out for good; `conductor` (it
-   *  starts other runs) opts out of the table and is reached through the
-   *  router's compound form alone, with its parts named. */
+   *  `coding` (a bare write ask deserves the review loop, so `ship` holds its
+   *  seat) opts out; `conductor` (it starts other runs) opts out of the table
+   *  and is reached through the router's compound form alone, with its parts
+   *  named. */
   routable?: false;
   /** System prompt variant for resident-repo runs (docs/reference/specs/resident-repos.md):
    *  the workspace is a ready worktree — no cloning, no installs, no repo
@@ -535,6 +536,11 @@ const WORK_PRESETS = {
     // `config set channel efforts.coding=…`, or `effort:` per request).
     machine: "repo-resident",
     identity: "write", // pushes branches and opens pull requests
+    // Never routed: a plain write ask deserves the coding → review loop, so
+    // the router's table offers `ship` in coding's seat — a routed ship runs
+    // a generated one-unit plan whose merge is a person's, never the runner's.
+    // A request that wants a bare coding run names it — `agent:coding`.
+    routable: false,
   },
   review: {
     name: "review",
@@ -568,10 +574,10 @@ const WORK_PRESETS = {
     toolset: "full",
     machine: "repo-resident",
     identity: "write",
-    // Never routed: ship is the plan runner and holds the merge grant, so a
-    // wrong route into it is code landing on main, not a stray pull request.
-    // A request that wants it names it — `agent:ship`.
-    routable: false,
+    // Routable: a routed ship runs a generated one-unit plan whose merge is a
+    // person's (`merge: person`) and never a seeded plan (the hand-off refuses
+    // a routed `plan <path>.md` naming `agent:ship`), so a wrong route costs a
+    // reviewed pull request, never code landing on main.
     maxTurns: 1,
     maxTokens: 16000,
     maxMinutes: 120,

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

@@ -38,12 +38,15 @@ export interface CompletionRequest {
   system?: string;
   messages: ChatMessage[];
   tools?: ToolDef[];
-  /** Force one of `tools`: the model must answer by calling the named tool,
-   *  so the call's input IS the answer and prose cannot occur (the request
-   *  router's shape, routing-and-config item 21). Anthropic: `tool_choice:
-   *  {type: "tool", name}`; Chat Completions: `tool_choice: {type: "function",
-   *  function: {name}}`. Absent → the model chooses. */
-  toolChoice?: { type: "tool"; name: string };
+  /** Force tool calling (the request router's shape, routing-and-config item
+   *  21). `{type: "tool", name}` forces the named tool — Anthropic:
+   *  `tool_choice: {type: "tool", name}`; Chat Completions: `tool_choice:
+   *  {type: "function", function: {name}}` — so the call's input IS the answer
+   *  and prose cannot occur. `{type: "any"}` forces one call to some tool of
+   *  `tools` — spelled `"any"` on Anthropic's Messages API and `"required"` on
+   *  Chat Completions, with parallel tool calls switched off on the wire so
+   *  the answer is exactly one call. Absent → the model chooses. */
+  toolChoice?: { type: "tool"; name: string } | { type: "any" };
   maxTokens: number;
   /** model effort hint; providers apply it only where the model supports it */
   effort?: Effort;

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

@@ -137,6 +137,14 @@ export type RunNoteKind =
    *  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"
+  /** The run ended with uncommitted changes or unpushed commits in its
+   *  workspace, and they do not outlive it: a run starts from a clean tree
+   *  (docs/reference/specs/resident-repos.md item 17), so the release that
+   *  follows the reply discards them. The summary names both counts and what
+   *  to do instead (commit and push). Read off the workspace by the run loop
+   *  after the model's last turn — the release itself runs after the record
+   *  is sealed — and set on the card's label too, so the loss is never silent. */
+  | "work_left_behind"
   /** 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) —
@@ -201,6 +209,7 @@ export const RUN_NOTE_KINDS = [
   "verdict_turn",
   "cold_sandbox",
   "rebind_refused",
+  "work_left_behind",
   "pr_not_opened",
   "review_not_posted",
   "compacted",
@@ -358,6 +367,11 @@ export type RunEvent =
    *  past the summary cap. The status card and friction analyzer keep reading
    *  `summary`. */
   /** `spanId` (docs/reference/specs/tracing.md): the `tool.*` span this call ran under, once the runner emits spans. */
+  /** `logIndex` (docs/reference/specs/run-history.md item 53): the row of the run's
+   *  session log holding the assistant turn this call rode in — on a `tool_result`,
+   *  the user turn its batch's results make. How a search hit's turn finds its
+   *  step on the page. Absent for a run without a session, a record from before
+   *  the field, and a call the mirror could not place. */
   | {
       type: "tool_call";
       tool: string;
@@ -365,6 +379,7 @@ export type RunEvent =
       command?: string;
       callId?: string;
       spanId?: string;
+      logIndex?: number;
       seq?: number;
       at?: number;
     }
@@ -384,6 +399,7 @@ export type RunEvent =
       output?: string;
       infra?: true;
       spanId?: string;
+      logIndex?: number;
       seq?: number;
       at?: number;
     }
@@ -483,11 +499,20 @@ export type RunEvent =
       model?: string;
       /** The request's trace id (docs/reference/specs/tracing.md), once the root exists. */
       traceId?: string;
+      /** The harness the run is driven by (`Harness.name`; docs/reference/specs/harness.md
+       *  item 8): `pi` today. Absent on a command run, which starts no process,
+       *  and on a record written before the seam existed. Additive. */
+      harness?: string;
       effort?: string;
       repo?: string;
       ref?: string;
       pr?: number;
       headSha?: string;
+      /** The plan runner instance whose story this record is (agent-ship item
+       *  17): written on the pipeline's own record alone, so its page can list
+       *  the instance's units. A child's instance rides the record's
+       *  `parentInstanceId`, never here. */
+      instanceId?: string;
       seq?: number;
       at?: number;
     }

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

@@ -5,7 +5,7 @@
  *  shipped code.
  *
  *  Background: the check used to be three sequential container spawns per
- *  binding (`test -d`, `su … git status --porcelain`, `su … git rev-list
+ *  binding (`test -d`, `su … git status --porcelain -uno`, `su … git rev-list
  *  --count HEAD --not --remotes`), and `isIdle()` ran it serially per live
  *  binding — every refresh cycle's idle gate paid 3×N process round-trips.
  *  The three probes fold into one `sh -c` script; the DECISION semantics are
@@ -42,7 +42,7 @@ export function worktreeCleanlinessScript(worktreePath: string, user: string): s
   const inner = [
     `t=$(mktemp) || { echo gitrc=1; echo 'giterr=mktemp failed'; exit 0; }`,
     `cd ${wt} 2>"$t" || { echo gitrc=1; printf 'giterr=%s\\n' "$(grep -m 1 . "$t" || echo 'cd failed')"; rm -f "$t"; exit 0; }`,
-    `s_out=$(git status --porcelain 2>"$t"); s_rc=$?; s_err=$(grep -m 1 . "$t" || true)`,
+    `s_out=$(git status --porcelain -uno 2>"$t"); s_rc=$?; s_err=$(grep -m 1 . "$t" || true)`,
     `a_out=$(git rev-list --count HEAD --not --remotes 2>"$t"); a_rc=$?; a_err=$(grep -m 1 . "$t" || true)`,
     `rm -f "$t"`,
     `if [ "$s_rc" -ne 0 ] || [ "$a_rc" -ne 0 ]; then`,
@@ -66,6 +66,64 @@ export function worktreeCleanlinessScript(worktreePath: string, user: string): s
 export interface WorktreeCleanliness {
   clean: boolean;
   reason?: string;
+  /** What the probes counted, when they ran: the tracked files `git status
+   *  --porcelain -uno` listed as changed — item 17's definition of dirt, the
+   *  same the run loop counts for its note, so the card and the release log
+   *  name one number; untracked scratch is the thread's own and not work —
+   *  and the commits on no remote branch. Absent when the tree is missing or
+   *  a probe failed. */
+  changes?: number;
+  unpushed?: number;
+}
+
+/** What a release discards (docs/reference/specs/resident-repos.md item 16a):
+ *  the counts a run left in its tree, named in the detach answer and the
+ *  bot's log so the loss is never silent. */
+export interface LeftBehind {
+  uncommittedChanges: number;
+  unpushedCommits: number;
+}
+
+/** The counts the probes measured, as what a release leaves behind: nothing
+ *  when the probes could not run (a tree that is gone or unreadable) and
+ *  nothing when both are zero — the answer names only a loss. */
+export function leftBehindOf(measured: WorktreeCleanliness): LeftBehind | undefined {
+  if (measured.changes === undefined || measured.unpushed === undefined) return undefined;
+  if (measured.changes === 0 && measured.unpushed === 0) return undefined;
+  return { uncommittedChanges: measured.changes, unpushedCommits: measured.unpushed };
+}
+
+/** What an eviction records about the tree it removed
+ *  (docs/reference/specs/resident-repos.md item 17: dirt never keeps a tree,
+ *  and nothing is discarded silently), written on the binding beside the
+ *  cause: the counts when the probes ran and found something, or the probe's
+ *  first error line when git could not read the tree — nothing readable was
+ *  kept, but the record must not read as clean. */
+export type EvictedTree = { leftBehind: LeftBehind } | { unmeasured: string };
+
+/** The measurement as the eviction's record: `undefined` for a clean tree or
+ *  one already gone with the disk (nothing was discarded). */
+export function evictedTreeOf(measured: WorktreeCleanliness): EvictedTree | undefined {
+  const leftBehind = leftBehindOf(measured);
+  if (leftBehind) return { leftBehind };
+  if (!measured.clean) return { unmeasured: measured.reason ?? "clean-check failed" };
+  return undefined;
+}
+
+/** The resident's log line for what an eviction discarded. */
+export function evictedTreeSentence(tree: EvictedTree): string {
+  if ("leftBehind" in tree)
+    return `left behind ${tree.leftBehind.uncommittedChanges} uncommitted change(s) and ${tree.leftBehind.unpushedCommits} unpushed commit(s), discarded with the tree`;
+  return `the tree could not be measured before its removal (${tree.unmeasured})`;
+}
+
+/** The bot's word for a discarded tree, in the release log and the run's
+ *  record: what was left, why it is gone, what to do instead. */
+export function leftBehindSentence(left: LeftBehind): string {
+  return (
+    `${left.uncommittedChanges} uncommitted change(s) and ${left.unpushedCommits} unpushed commit(s) were left in the worktree; ` +
+    "a run starts from a clean tree, so they were discarded — commit and push what must be kept"
+  );
 }
 
 /** Decide from the script's tagged output. Unknown (missing/failed tags,
@@ -89,7 +147,13 @@ export function parseWorktreeCleanliness(r: {
   }
   const changes = Number(tags.get("changes")) || 0;
   const unpushed = Number(tags.get("unpushed")) || 0;
-  if (changes > 0 || unpushed > 0)
-    return { clean: false, reason: `dirty: ${changes} uncommitted change(s), ${unpushed} unpushed commit(s)` };
-  return { clean: true };
+  if (changes > 0 || unpushed > 0) {
+    return {
+      clean: false,
+      reason: `dirty: ${changes} uncommitted change(s), ${unpushed} unpushed commit(s)`,
+      changes,
+      unpushed,
+    };
+  }
+  return { clean: true, changes, unpushed };
 }

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

@@ -311,17 +311,18 @@ export interface DiskEvictionCandidate {
 
 /** Why a tree was kept under disk pressure. `other` is the caller's fallback
  *  for a keep decided outside `orderEvictionCandidates` (a binding that moved
- *  during the check); free text never becomes a token. */
-export type DiskKeepWhy = "busy" | "default-ref" | "recent" | "dirty" | "requesting" | "other";
+ *  during the check); free text never becomes a token. No token names dirt:
+ *  a tree is never kept for what it holds (a run starts from a clean tree),
+ *  the Worker records what it removes instead. */
+export type DiskKeepWhy = "busy" | "default-ref" | "recent" | "requesting" | "other";
 
 /** Order the live trees for eviction under pressure and name every one that is
  *  kept: the requesting thread itself, a busy tree, the default branch (the
  *  one most likely re-attached — the same rule as `reclaimDecision`), and a
  *  tree attached within `DISK_EVICT_MIN_IDLE_MS` are never candidates; the
- *  rest are ordered coldest first (oldest `lastAttachAt`, ties on key).
- *  Cleanliness is NOT decided here — it needs the container (as the thread
- *  user), so the Worker checks each candidate in this order and keeps a dirty
- *  or unreadable one (`dirty`), exactly like the sweep. */
+ *  rest are ordered coldest first (oldest `lastAttachAt`, ties on key). What
+ *  each tree holds is not asked — the Worker measures it as the thread user
+ *  right before the eviction, for the record only. */
 export function orderEvictionCandidates(input: {
   candidates: readonly DiskEvictionCandidate[];
   now: number;