@coreplane/switchboard 1.249.1 → 1.250.0

package/dist/assets/config/config.example.yaml

@@ -14,10 +14,9 @@ providers:
   # OpenAI itself runs on its Responses API (record 0052): every first-party
   # OpenAI card in pi's registry is `openai-responses`, OpenAI recommends the
   # wire for new projects, and its chat route loses tool calling with any
-  # effort above `none` from GPT-5.4. The wire is a declaration here; the proxy
-  # serves the Responses route in a later unit, and until then a run on this
-  # block meets the provider's own answer. `type: openai-compatible` keeps
-  # loading as `wire: openai-chat` for one release.
+  # effort above `none` from GPT-5.4. The proxy serves the wire at
+  # `/v1/responses` — a run on this block is pinned and metered like any other.
+  # `type: openai-compatible` keeps loading as `wire: openai-chat` for one release.
   openai:
     wire: openai-responses
     baseUrl: https://api.openai.com/v1
@@ -57,6 +56,10 @@ providers:
     #     inputs:
     #       image: true
     #     cache: automatic
+    #     # The answer shapes the card takes — a forced tool call, the one-JSON-
+    #     # object text contract, or both (absent assumes both). The intake gate
+    #     # refuses at load a card declaring neither under its classify default.
+    #     answers: ["tool", "text"]
     # A passthrough is merged into the request body on the wires whose adapter
     # takes one — a vendor-only feature such as OpenRouter's routing, never a
     # control: it is not decided, not noted and not in the matrix, and a wrong
@@ -445,6 +448,26 @@ workspaceDir: ./workspaces
 #   model: anthropic/claude-haiku-4-5
 #   answer: text
 
+# The thread-reply intake gate (docs/decisions/0058-a-thread-reply-is-read-before-it-is-answered-intake-decides-whether-the-bot-was-addressed.md;
+# docs/reference/specs/routing-and-config.md item 27). How an unmentioned reply
+# in a channel thread the bot is part of is treated — NOTHING CALLS THE GATE
+# YET; the Slack wiring lands in a later release, and until then behavior is
+# unchanged whatever this block says. `threadReplies`: `classify` (the code's
+# default — one cheap model turn decides whether the bot was addressed; a
+# silent reply then gets no reaction, no card and no run), `mention` (only a
+# mention is answered; an unmentioned reply is silent with a receipt and no
+# model call) or `always` (today's answer-every-reply path, byte for byte).
+# Also settable per channel and per user: `intake: { threadReplies: <mode> }`
+# on a `channels.<id>` or `users.<id>` scope, user over channel over here.
+# `model` is the verdict's model; default `routing.model`, else
+# `defaults.models.general`. A mention, a DM and a top-level post never pass
+# through the gate in any mode. A model whose operator card (`providers.<p>.
+# models.<id>.answers`) declares it answers neither a forced tool call nor the
+# text contract is refused at load when the default mode is `classify`.
+# intake:
+#   threadReplies: classify
+#   model: anthropic/claude-haiku-4-5
+
 # Linked threads (docs/decisions/0037-a-linked-thread-is-quoted-not-joined.md;
 # docs/reference/specs/routing-and-config.md item 22). Off by default. On, a
 # permalink in a request to a thread in another PUBLIC channel the bot is a
@@ -535,6 +558,16 @@ workspaceDir: ./workspaces
 #   catchUp:
 #     enabled: true
 #     windowMinutes: 30
+#   # The apps whose relay footer — `Sent by Claude in <#C…> on behalf of <@U…> ·
+#   # <permalink>`, appended by the Claude Slack app to a post it makes from a
+#   # Claude Code session — names the person the run is for and billed to
+#   # (docs/reference/specs/slack-channel.md item 13). By Slack bot id: the
+#   # `bot_id` on the app's messages, the `B…` a run record's `postedBy:
+#   # slack:bot:B…` carries. The footer is message text any app can write, so
+#   # it is read only from an app listed here; from any other app the app itself
+#   # is the requester, footer or not. Absent or empty: no footer is honoured.
+#   relayApps:
+#     - B0123ABCDE
 
 # Where chat-set runtime overrides (`config set`, `config instructions`, `config clear`)
 # persist (docs/reference/specs/routing-and-config.md item 12). Without this block they go to

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

@@ -71,25 +71,35 @@ import {
   checkFence,
   decideClaim,
   decideClaimWrite,
+  decideIntakeInsert,
   phaseTransition,
   reclaimPhase,
   selectReclaim,
 } from "../../src/core/runLedger/decisions.ts";
+import { intakeReceiptRetentionMs } from "../../src/core/budgets.ts";
 import {
   IDEMPOTENCY_KEY_PATTERN,
+  capThreadEvent,
   INSTANCE_ID_PATTERN,
   isCoordinatorInstance,
   isCoordinatorUnit,
+  isThreadEvent,
   sendRunFinished,
+  UNIT_PATTERN,
   type CoordinatorInstance,
   type CoordinatorUnit,
   type RunFinishedSend,
+  type ThreadEvent,
 } from "../../src/core/coordinator/contract.ts";
 import {
   GEN_PATTERN,
+  isIntakeReceipt,
   type ClaimRequest,
   type ClaimResult,
   type FenceResult,
+  type IntakeQuery,
+  type IntakeReceipt,
+  type IntakeWriteResult,
   type LivePhase,
   type LiveRunRow,
   type ReclaimedRun,
@@ -1515,6 +1525,22 @@ export class RunHistoryDO extends DurableObject<Env> {
         PRIMARY KEY (run_id, kind)
       );
     `);
+    // The intake receipts (run-history item 59): one verdict per message key,
+    // first writer wins, beside the live rows because the reconnect catch-up
+    // reads them through the same store key. `prune_after` is stamped at the
+    // insert (the bound is the writer's window through
+    // `intakeReceiptRetentionMs`) and the alarm sweeps by it.
+    this.sql.exec(`
+      CREATE TABLE IF NOT EXISTS intake_receipts (
+        key TEXT PRIMARY KEY,
+        thread_key TEXT NOT NULL,
+        decided_at INTEGER NOT NULL,
+        prune_after INTEGER NOT NULL,
+        json TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS intake_thread ON intake_receipts(thread_key, decided_at);
+      CREATE INDEX IF NOT EXISTS intake_prune ON intake_receipts(prune_after);
+    `);
     // The coordinator's parent records (run-history item 49): one row per
     // instance, written by the bot at the instance's creation and read by the
     // spawn route for the requester, channel and thread every child acts as.
@@ -1537,6 +1563,20 @@ export class RunHistoryDO extends DurableObject<Env> {
         PRIMARY KEY (instance_id, unit)
       );
     `);
+    // The thread events of a unit-owned thread (record 0051's reply-as-event rule): a
+    // sibling table of the unit rows, never a field on them — `putUnits`
+    // replaces a row whole, so an append landing between a route's read and
+    // its put would be lost. Consumption is a column of its own, set once.
+    this.sql.exec(`
+      CREATE TABLE IF NOT EXISTS coordinator_unit_events (
+        instance_id TEXT NOT NULL,
+        unit TEXT NOT NULL,
+        seq INTEGER NOT NULL,
+        json TEXT NOT NULL,
+        consumed_by TEXT,
+        PRIMARY KEY (instance_id, unit, seq)
+      );
+    `);
   }
 
   // ---- the coordinator's parent records (run-history item 49) -----------------
@@ -1613,6 +1653,68 @@ export class RunHistoryDO extends DurableObject<Env> {
       .map((r) => JSON.parse(r.json) as CoordinatorUnit);
   }
 
+  // ---- the thread events of a unit-owned thread (record 0051's reply-as-event rule) --------------
+
+  /** The next sequence assigned in one transaction, the per-event cap applied
+   *  (attachments dropped whole, the row saying how many). */
+  async appendUnitEvent(
+    instanceId: string,
+    unit: string,
+    event: Omit<ThreadEvent, "seq">,
+  ): Promise<{ ok: true; seq: number }> {
+    let seq = 1;
+    this.ctx.storage.transactionSync(() => {
+      const max = this.sql
+        .exec<{
+          m: number | null;
+        }>(`SELECT MAX(seq) AS m FROM coordinator_unit_events WHERE instance_id = ? AND unit = ?`, instanceId, unit)
+        .toArray()[0];
+      seq = (max?.m ?? 0) + 1;
+      const capped = capThreadEvent({ ...event, seq });
+      this.sql.exec(
+        `INSERT INTO coordinator_unit_events (instance_id, unit, seq, json) VALUES (?, ?, ?, ?)`,
+        instanceId,
+        unit,
+        seq,
+        JSON.stringify(capped),
+      );
+    });
+    return { ok: true, seq };
+  }
+
+  /** The unit's events in sequence order; `unconsumedOnly` filters to the rows nothing has consumed. */
+  async listUnitEvents(instanceId: string, unit: string, unconsumedOnly: boolean): Promise<ThreadEvent[]> {
+    return this.sql
+      .exec<{ json: string; consumed_by: string | null }>(
+        `SELECT json, consumed_by FROM coordinator_unit_events WHERE instance_id = ? AND unit = ?${
+          unconsumedOnly ? " AND consumed_by IS NULL" : ""
+        } ORDER BY seq ASC`,
+        instanceId,
+        unit,
+      )
+      .toArray()
+      .map((r) => {
+        const e = JSON.parse(r.json) as ThreadEvent;
+        return r.consumed_by !== null ? { ...e, consumedBy: r.consumed_by } : e;
+      });
+  }
+
+  /** Consumption set once — idempotent: a row already consumed keeps its first consumer. */
+  async markUnitEventsConsumed(instanceId: string, unit: string, seqs: number[], by: string): Promise<{ ok: true }> {
+    this.ctx.storage.transactionSync(() => {
+      for (const seq of seqs) {
+        this.sql.exec(
+          `UPDATE coordinator_unit_events SET consumed_by = ? WHERE instance_id = ? AND unit = ? AND seq = ? AND consumed_by IS NULL`,
+          by,
+          instanceId,
+          unit,
+          seq,
+        );
+      }
+    });
+    return { ok: true };
+  }
+
   // ---- the live-run ledger (run-history items 28–34) --------------------------
 
   private liveRow(runId: string): LiveRunRow | undefined {
@@ -1993,6 +2095,59 @@ export class RunHistoryDO extends DurableObject<Env> {
     return parseEventRows(this.eventRows(runId, 0, Number.MAX_SAFE_INTEGER));
   }
 
+  // ---- the intake receipts (run-history item 59) -------------------------------
+
+  private intakeRow(key: string): IntakeReceipt | undefined {
+    const r = this.sql.exec<{ json: string }>(`SELECT json FROM intake_receipts WHERE key = ?`, key).toArray()[0];
+    return r ? (JSON.parse(r.json) as IntakeReceipt) : undefined;
+  }
+
+  /** Insert-if-absent inside one transaction: the first writer's row stands
+   *  and every caller acts on `stored` (`decideIntakeInsert`). `windowMs` is
+   *  the writer's reconnect catch-up window; the retention bound is stamped on
+   *  the row so the alarm's sweep is one indexed delete. */
+  async recordIntake(key: string, receipt: IntakeReceipt, windowMs: number): Promise<IntakeWriteResult> {
+    let out: IntakeWriteResult = { inserted: false, stored: receipt };
+    this.ctx.storage.transactionSync(() => {
+      out = decideIntakeInsert(this.intakeRow(key), receipt);
+      if (!out.inserted) return;
+      this.sql.exec(
+        `INSERT INTO intake_receipts (key, thread_key, decided_at, prune_after, json) VALUES (?, ?, ?, ?, ?)`,
+        key,
+        receipt.threadKey,
+        receipt.decidedAt,
+        receipt.decidedAt + intakeReceiptRetentionMs(windowMs),
+        JSON.stringify(receipt),
+      );
+    });
+    if ((await this.ctx.storage.getAlarm()) === null)
+      await this.ctx.storage.setAlarm(systemClock() + RUN_SWEEP_INTERVAL_MS);
+    return out;
+  }
+
+  async readIntake(key: string): Promise<IntakeReceipt | null> {
+    return this.intakeRow(key) ?? null;
+  }
+
+  /** A thread's receipts, or the receipts since an instant, oldest first. */
+  async listIntake(query: IntakeQuery): Promise<IntakeReceipt[]> {
+    const clauses: string[] = [];
+    const params: (string | number)[] = [];
+    if (query.threadKey !== undefined) {
+      clauses.push("thread_key = ?");
+      params.push(query.threadKey);
+    }
+    if (query.since !== undefined) {
+      clauses.push("decided_at >= ?");
+      params.push(query.since);
+    }
+    const where = clauses.length ? ` WHERE ${clauses.join(" AND ")}` : "";
+    return this.sql
+      .exec<{ json: string }>(`SELECT json FROM intake_receipts${where} ORDER BY decided_at ASC`, ...params)
+      .toArray()
+      .map((r) => JSON.parse(r.json) as IntakeReceipt);
+  }
+
   // ---- policy ---------------------------------------------------------------
 
   /** The persisted policy (defaults until the first proposal lands). */
@@ -2274,12 +2429,19 @@ export class RunHistoryDO extends DurableObject<Env> {
       const now = systemClock();
       const { policy } = this.policyState();
       let deleted = 0;
+      let receipts = 0;
       let candidates: { key: string; threadKey: string }[] = [];
       this.ctx.storage.transactionSync(() => {
         deleted = this.trim(policy, now, undefined).deleted;
         // Orphan sweep: events whose run is gone (defensive — `deleteRuns` pairs
         // the two deletes, so this is a periodic check, not a per-put cost).
         this.sql.exec(`DELETE FROM run_events WHERE run_id NOT IN (SELECT run_id FROM runs)`);
+        // Intake receipts past their bound (item 59): each row carries its own
+        // `prune_after`, stamped at the insert from the writer's window.
+        receipts = this.sql
+          .exec<{ n: number }>(`SELECT COUNT(*) AS n FROM intake_receipts WHERE prune_after <= ?`, now)
+          .one().n;
+        this.sql.exec(`DELETE FROM intake_receipts WHERE prune_after <= ?`, now);
         // The sessions no kept run names any more (session-log item 7): decided
         // here, on the rows this transaction leaves; dropped after it.
         candidates = this.sql
@@ -2291,7 +2453,9 @@ export class RunHistoryDO extends DurableObject<Env> {
           .map((r) => ({ key: r.key, threadKey: r.thread_key }));
       });
       const dropped = await this.sweepSessions(candidates);
-      console.log(`[runs/alarm] swept ${deleted} rows outside policy, dropped ${dropped} session log(s)`);
+      console.log(
+        `[runs/alarm] swept ${deleted} rows outside policy, pruned ${receipts} intake receipt(s), dropped ${dropped} session log(s)`,
+      );
       await this.ctx.storage.setAlarm(now + RUN_SWEEP_INTERVAL_MS);
       root.end("ok", { swept: deleted });
     } catch (err) {
@@ -3538,6 +3702,9 @@ const LEDGER_ROUTES = new Set([
   "/runs/coordinator/get",
   "/runs/coordinator/units/put",
   "/runs/coordinator/units/list",
+  "/runs/coordinator/events/append",
+  "/runs/coordinator/events/list",
+  "/runs/coordinator/events/mark-consumed",
   "/runs/claim",
   "/runs/heartbeat",
   "/runs/append",
@@ -3553,6 +3720,9 @@ const LEDGER_ROUTES = new Set([
   "/runs/reclaim",
   "/runs/live",
   "/runs/live-events",
+  "/runs/intake",
+  "/runs/intake/read",
+  "/runs/intake/list",
   "/runs/transcript/owner",
   "/runs/transcript/write",
   "/runs/transcript/read",
@@ -3926,6 +4096,64 @@ async function handleLedger(pathname: string, body: unknown, env: Env): Promise<
       return json({ error: "instanceId must be a Workflow instance id" }, 400);
     return json({ units: await stub.listUnits(b.instanceId) });
   }
+  // The thread events of a unit-owned thread (record 0051's reply-as-event rule): append assigns
+  // the sequence, list filters unconsumed, mark-consumed is idempotent.
+  if (pathname.startsWith("/runs/coordinator/events/")) {
+    if (typeof b.instanceId !== "string" || !INSTANCE_ID_PATTERN.test(b.instanceId))
+      return json({ error: "instanceId must be a Workflow instance id" }, 400);
+    if (typeof b.unit !== "string" || !UNIT_PATTERN.test(b.unit)) return json({ error: "unit must be a unit id" }, 400);
+    if (pathname === "/runs/coordinator/events/append") {
+      if (!isThreadEvent({ ...(b.event as Record<string, unknown>), seq: 1 }))
+        return json({ error: "event must be a thread event (without its seq)" }, 400);
+      // The store assigns the sequence and the consumer: a caller's `seq` or
+      // `consumedBy` is dropped, so no row is born consumed in its JSON while
+      // its column still lists it unconsumed.
+      const { seq: _ignored, consumedBy: _fresh, ...event } = b.event as ThreadEvent;
+      const r = await stub.appendUnitEvent(b.instanceId, b.unit, event as Omit<ThreadEvent, "seq" | "consumedBy">);
+      console.log(`[runs/coordinator/events/append] ${key.value} ${b.instanceId}:${b.unit} seq ${r.seq}`);
+      return json(r);
+    }
+    if (pathname === "/runs/coordinator/events/list") {
+      return json({ events: await stub.listUnitEvents(b.instanceId, b.unit, b.unconsumedOnly === true) });
+    }
+    if (pathname === "/runs/coordinator/events/mark-consumed") {
+      if (!Array.isArray(b.seqs) || !b.seqs.every((s) => typeof s === "number" && Number.isInteger(s) && s >= 1))
+        return json({ error: "seqs must be an array of sequence numbers" }, 400);
+      if (typeof b.by !== "string" || b.by.length === 0 || b.by.length > 200)
+        return json({ error: "by must name the consumer" }, 400);
+      const r = await stub.markUnitEventsConsumed(b.instanceId, b.unit, b.seqs as number[], b.by);
+      console.log(
+        `[runs/coordinator/events/mark-consumed] ${key.value} ${b.instanceId}:${b.unit} ${b.seqs.length} row(s) by ${b.by}`,
+      );
+      return json(r);
+    }
+  }
+
+  // The intake receipts (run-history item 59): keyed by the message, not a run.
+  if (pathname === "/runs/intake" || pathname === "/runs/intake/read") {
+    const receiptKey = b.key;
+    if (typeof receiptKey !== "string" || receiptKey.length === 0 || receiptKey.length > 256)
+      return json({ error: "key must be a non-empty string of at most 256 characters" }, 400);
+    if (pathname === "/runs/intake/read") return json({ receipt: await stub.readIntake(receiptKey) });
+    if (!isIntakeReceipt(b.receipt)) return json({ error: "receipt must be an intake receipt" }, 400);
+    if (b.windowMs !== undefined && (typeof b.windowMs !== "number" || !Number.isFinite(b.windowMs) || b.windowMs < 0))
+      return json({ error: "windowMs must be a non-negative number" }, 400);
+    const r = await stub.recordIntake(receiptKey, b.receipt, typeof b.windowMs === "number" ? b.windowMs : 0);
+    console.log(`[runs/intake] ${key.value} ${receiptKey} → ${r.inserted ? "inserted" : "existing"}`);
+    return json(r);
+  }
+  if (pathname === "/runs/intake/list") {
+    if (b.threadKey !== undefined && (typeof b.threadKey !== "string" || b.threadKey.length === 0))
+      return json({ error: "threadKey must be a non-empty string" }, 400);
+    if (b.since !== undefined && (typeof b.since !== "number" || !Number.isFinite(b.since)))
+      return json({ error: "since must be a number" }, 400);
+    return json({
+      receipts: await stub.listIntake({
+        ...(b.threadKey !== undefined ? { threadKey: b.threadKey } : {}),
+        ...(b.since !== undefined ? { since: b.since } : {}),
+      }),
+    });
+  }
 
   const runId = parseRunId(b.runId);
   if (!runId.ok) return json({ error: runId.error }, 400);

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

@@ -36,12 +36,21 @@ RUN git config --system user.name "switchboard-resident" \
 # cores once several threads run). These defaults inherit into every thread's
 # `su … -c` shell (su without `-` keeps the environment). CI=1 makes runners
 # non-interactive (no watch mode, no TTY progress spinners in captured
-# output). The heap cap keeps one runaway process to an eighth of the 12 GiB
-# so its neighbours keep theirs.
+# output). NODE_OPTIONS lets one Node process take 8 GiB of the 12 for its
+# heap. V8's own default is a quarter of physical memory (~3 GiB here), and
+# this image once pinned it lower still, at 1,536 MB — an eighth, meant as a
+# fair share among the 16 seats — under which this repository's own two `tsc`
+# passes die with "heap out of memory" (they pass at 3,072 MB with ~2 GB of
+# RSS each; measured), and which is a quarter of the large-monorepo typecheck
+# the instance size exists for (docs/reference/specs/execution.md item 16). A
+# per-process heap limit never shared memory between processes (16 × 1,536 MB
+# already exceeded the instance); the cgroup does that. So the cap is a
+# runaway guard, sized for the largest legitimate command with room, and the
+# same as the sandbox image's; src/deploy/imageNode.test.ts holds the two equal.
 ENV CI=1 \
     VITEST_MAX_WORKERS=1 VITEST_MAX_THREADS=1 VITEST_MAX_FORKS=1 VITEST_MIN_THREADS=1 VITEST_MIN_FORKS=1 \
     UV_THREADPOOL_SIZE=4 \
-    NODE_OPTIONS=--max-old-space-size=1536
+    NODE_OPTIONS=--max-old-space-size=8192
 
 # Node 24, not the base's. The 0.13.0-next base ships Node 22.23.2 like the
 # 0.12.9 one (copied from node:22-slim: the binary at /usr/local/bin/node, npm

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

@@ -31,6 +31,13 @@ USER root
 # (src/execution/bashTimeout.ts); changing it requires a container rebuild +
 # redeploy.
 ENV COMMAND_TIMEOUT_MS=1240000
+# One Node process may take 8 GiB of the 12 for its heap. V8's own default is
+# a quarter of physical memory (~3 GiB on this instance), which would refuse
+# the very command the instance size was chosen for — a large monorepo's
+# typecheck near 8 GB (docs/reference/specs/execution.md item 16) — while the
+# box sat three-quarters empty. The same cap as the resident image's;
+# src/deploy/imageNode.test.ts holds the two equal.
+ENV NODE_OPTIONS=--max-old-space-size=8192
 # docker.io + iptables: a Docker engine for runs whose tests need containers
 # (act's default job mode, testcontainers, compose, image builds). Nothing
 # starts the daemon at boot — the wrapper below does, on the first `docker`

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.249.1",
+  "version": "1.250.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.249.1",
+      "version": "1.250.0",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -20445,7 +20445,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.249.1",
+      "version": "1.250.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.249.1",
+  "version": "1.250.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",
@@ -39,7 +39,7 @@
     "cli": "tsx src/cli.ts",
     "verify": "npm run verify:root && npm run verify --workspaces --if-present && npm run check:site",
     "verify:root": "npm run check:consistency && npm run typecheck && npm run lint && npm run format:check && npm test && npm run check:dist",
-    "check:consistency": "npm run check:lockfile && npm run check:sandbox-pair && npm run skills:check && npm run licenses:check && npm run docs:check && npm run pr-title:check && npm run specs:check && npm run decisions:check && npm run hygiene:check && npm run check:project-facts && npm run agents:check && npm run clock:check && npm run screenshots:check",
+    "check:consistency": "npm run check:lockfile && npm run check:sandbox-pair && npm run skills:check && npm run licenses:check && npm run docs:check && npm run pr-title:check && npm run specs:check && npm run decisions:check && npm run hygiene:check && npm run check:project-facts && npm run check:registry-drift && npm run agents:check && npm run clock:check && npm run screenshots:check",
     "ci:gate": "node scripts/ci-gate.mjs",
     "fix": "npm run docs:gen && npm run pr-title:gen && npm run agents:gen && npm run clock:gen && npm run hygiene:gen && npm run deploy:gen && npm run skills:sync && npm run lint:fix && npm run format",
     "deploy:gen": "npm run --silent cli -- deploy init",
@@ -50,6 +50,7 @@
     "pr-title:gen": "node scripts/pr-title-vocabulary.mjs --write",
     "pr-title:check": "node scripts/pr-title-vocabulary.mjs",
     "check:project-facts": "node scripts/check-project-facts.mjs",
+    "check:registry-drift": "tsx scripts/registry-drift.ts",
     "agents:gen": "tsx scripts/agents-gen.ts",
     "clock:gen": "tsx scripts/clock-allowlist.mts --write",
     "clock:check": "tsx scripts/clock-allowlist.mts",

package/dist/assets/project.json

@@ -127,6 +127,10 @@
       "does": "Every copy of the project's names, repository, docs URL and contact address equals `project.json`; its description, topics and npm package fit their rules.",
       "when": "After editing `project.json` or a community file; part of `check:consistency`."
     },
+    "check:registry-drift": {
+      "does": "Every example-config model ref still resolves against the pinned pi registry.",
+      "when": "After a pi bump; part of `check:consistency`."
+    },
     "skills:sync": {
       "does": "Vendors the skills listed in `skills/manifest.yaml`.",
       "when": "After changing the manifest; part of `fix`."

package/dist/assets/source.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.249.1",
-  "commit": "7fa16da36339e9c0b04e3f9c037002efcf5975f4",
-  "builtAt": "2026-09-18T08:08:43.148Z"
+  "version": "1.250.0",
+  "commit": "4ac4b778bce59eddec48e214def56ad7aa7c62d2",
+  "builtAt": "2026-09-18T19:28:39.901Z"
 }

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

@@ -148,7 +148,7 @@ export function statusCardRule(examples = '"Implement the fix", "Run the test su
   );
 }
 
-const PR_DESCRIPTION_TEMPLATE = `PR description — submit it with the submit_pr_description tool for EVERY PR (this is the default, not something to wait to be asked for). Switchboard renders the GitHub body from the object you submit, so never author PR-body markdown yourself. Before submitting, judge your title with the ${PR_TITLE_GUARD} gate — \`npm run check:pr-title -- "<title>"\` — and submit only a title it accepts; the same gate refuses the PR in CI, and on Switchboard's own repository the tool refuses the same titles with the gate's own sentence, so fix the title and resubmit rather than pushing on. The body is a fixed-size MAP for the reader with everything for agents collapsed under it; every field is capped in visible characters (a link's URL is not counted) and the tool refuses an object over a cap naming the field and the count — cut and resubmit. Prose is unwrapped — no hard line breaks inside a paragraph. Always hyperlink the triggering issue/request. Never fabricate validation — state exactly what you ran and the real result. BEFORE authoring the pointers, load the \`pr-description\` skill with use_skill — it defines how to choose at most seven pointers, the mechanical anchor rules and what goes below the fold; follow it for every PR.
+const PR_DESCRIPTION_TEMPLATE = `PR description — submit it with the submit_pr_description tool for EVERY PR (this is the default, not something to wait to be asked for). Switchboard renders the GitHub body from the object you submit, so never author PR-body markdown yourself. Before submitting, judge your title with the ${PR_TITLE_GUARD} gate — \`npm run check:pr-title -- "<title>"\` — and submit only a title it accepts; the same gate refuses the PR in CI, and on Switchboard's own repository the tool refuses the same titles with the gate's own sentence, so fix the title and resubmit rather than pushing on. The body is a fixed-size MAP for the reader with everything for agents collapsed under it; every field is capped in visible characters (a link's URL is not counted) and the tool refuses an object over a cap naming every field over it with the count, how many visible characters to remove and a prefix that fits — take the prefix as is, or remove at least that many visible characters (shortening a URL removes nothing), and resubmit once. Prose is unwrapped — no hard line breaks inside a paragraph. Always hyperlink the triggering issue/request. Never fabricate validation — state exactly what you ran and the real result. BEFORE authoring the pointers, load the \`pr-description\` skill with use_skill — it defines how to choose at most seven pointers, the mechanical anchor rules and what goes below the fold; follow it for every PR.
 EVERY PR includes one that already exists when you push — opened by a person, by dependabot, or by an earlier run. After EVERY push to such a PR: read its current title and body (\`github_issue_get\` with the PR number works for pull requests; \`gh pr view\` where gh exists), judge them against the change as it now stands at the pushed head, and submit the object that describes the PR as it is NOW — carry forward what the existing body says that is still true (a dependency bump's release notes belong in why), add what you changed, and anchor the pointers at the new head. Switchboard replaces the PR's title and body with your rendering. A description that describes an earlier state of its branch is a bug; "it is someone else's PR" is never a reason to leave it.
 - **title** (≤72 characters in all): the changelog line — \`type(scope): what a reader can now do or expect\`, one change, one clause, present tense. The type and the scope spend the same budget as the description, so the description is short; the body carries the rest. The tool refuses a longer title naming the count, and so does the gate in CI.
 - **TL;DR** (\`tldr\`, rendered first, ≤300): two sentences for a reader with zero context — what this PR does and why it matters.

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

@@ -91,6 +91,12 @@ export const POLICY: readonly Rule[] = [
   // `all` and a named `grants` entry hold it).
   { action: "costs:write", resource: "command", when: [grant("costs:write")] },
 
+  // ── providers ────────────────────────────────────────────────────────────
+  // `providers check` reads the provider's own endpoints on request: a browser
+  // session's read baseline, a grant everywhere else — an on-request provider
+  // read is never a chat baseline, like the costs reads.
+  { action: "providers:read", resource: "command", when: [grant("providers:read")] },
+
   // ── repos ────────────────────────────────────────────────────────────────
   { action: "repo:read", resource: "command", when: [grant("repo:read")] },
   { action: "repo:write", resource: "repo", when: [grant("repo:write")] },

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

@@ -85,6 +85,19 @@ export const DRAIN = {
   defaultMinutes: 60,
 } as const;
 
+/** How long an intake receipt row is kept on the run history object
+ *  (docs/reference/specs/run-history.md item 59; docs/decisions/0058): the larger of one day
+ *  and the reconnect catch-up window the write named plus the drain deadline
+ *  (`DRAIN.maxMinutes`, the longest a fleet drain may last), so a catch-up
+ *  that runs after the longest allowed drain still reads the verdict instead
+ *  of deciding the reply again. The window is clamped to a month so a
+ *  misconfigured writer cannot make retention unbounded. */
+export const INTAKE_WINDOW_MAX_MS = 30 * DAY_MS;
+export function intakeReceiptRetentionMs(catchUpWindowMs: number): number {
+  const window = Math.min(Math.max(0, catchUpWindowMs), INTAKE_WINDOW_MAX_MS);
+  return Math.max(DAY_MS, window + minutesToMs(DRAIN.maxMinutes));
+}
+
 /** The presets that run the tool loop, and the one pipeline preset. */
 export const LOOP_PRESETS = ["general", "coding", "review", "research", "explore", "conductor"] as const;
 export type LoopPreset = (typeof LOOP_PRESETS)[number];