@coreplane/switchboard 1.220.0 → 1.220.1

package/dist/assets/package-lock.json

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

package/dist/assets/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard",
-  "version": "1.220.0",
+  "version": "1.220.1",
   "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.220.0",
-  "commit": "cf86e5df3d3256037bf4925a9e13de0b61483df3",
-  "builtAt": "2026-09-15T02:39:37.781Z"
+  "version": "1.220.1",
+  "commit": "b9b9146c723243aee57baf92e710d8454fa6b36d",
+  "builtAt": "2026-09-15T05:12:47.232Z"
 }

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

@@ -622,6 +622,19 @@ export function parseExitPrefix(output: string): { failed: boolean; exitCode?: n
   return /^\d+$/.test(m[1]) ? { failed: true, exitCode: Number(m[1]) } : { failed: true };
 }
 
+/** A tool that could not do what it was asked answers the model with a text
+ *  that opens `error:` (`attach_file`, the `submit_*` tools, the run tools —
+ *  each declares `failsInText` on its `RunnableTool`) instead of throwing, so
+ *  the model can read the reason and go on. The record must call that result
+ *  what the model reads it as: `ok:false`. Both loops (the native runner and
+ *  the pi bridge) derive `ok` for such a tool through this one reader; bash
+ *  keeps `parseExitPrefix`; a tool relaying content it did not write is never
+ *  read this way. Ordinary output that merely contains the word later on is a
+ *  success. */
+export function toolTextFailed(output: string): boolean {
+  return /^\s*error:/i.test(stripAnsi(output));
+}
+
 /** Upper bound on a `tool_result.output` — large enough for a test run or a
  *  diff to read in full on the run page, small enough that a run of ordinary
  *  length fits the registry's backlog whole (the backlog is bounded by count AND

package/dist/cli.js

@@ -408,8 +408,11 @@ var init_store = __esm({
         const res = await this.fetchImpl(signed);
         if (res.status === 404) return null;
         if (!res.ok) throw new Error(`artifact store: HEAD ${key} answered HTTP ${res.status}`);
-        const size = Number(res.headers.get("content-length"));
-        if (!Number.isFinite(size) || size < 0) throw new Error(`artifact store: HEAD ${key} answered without a length`);
+        const length = res.headers.get("content-length");
+        const size = length === null ? Number.NaN : Number(length);
+        if (!Number.isFinite(size) || size < 0) {
+          throw new Error(`artifact store: HEAD ${key} answered HTTP ${res.status} without a length`);
+        }
         return { size, contentType: res.headers.get("content-type") ?? "application/octet-stream" };
       }
       async get(key) {
@@ -7993,6 +7996,9 @@ function parseExitPrefix(output) {
   if (!m) return { failed: false, exitCode: 0 };
   return /^\d+$/.test(m[1]) ? { failed: true, exitCode: Number(m[1]) } : { failed: true };
 }
+function toolTextFailed(output) {
+  return /^\s*error:/i.test(stripAnsi(output));
+}
 function capClean(clean) {
   const text = clean.trim();
   if (text.length <= TOOL_OUTPUT_CAP) return text;
@@ -25933,7 +25939,11 @@ function fileNameOf2(path) {
   return segments2[segments2.length - 1] ?? path;
 }
 function putCommandFor(path, contentType, url) {
-  return `curl -fsS -T ${shellQuote(path)} -H ${shellQuote(`Content-Type: ${contentType}`)} ${shellQuote(url)}`;
+  return `curl -fsS -T ${shellQuote(path)} -H ${shellQuote(`Content-Type: ${contentType}`)} -o /dev/null -w ${shellQuote(PUT_REPORT_FORMAT)} ${shellQuote(url)}`;
+}
+function parsePutReport(output) {
+  const m = /(\d{3}) (\d{1,15})\s*$/.exec(output);
+  return m ? { httpCode: Number(m[1]), sentBytes: Number(m[2]) } : null;
 }
 function postCommandFor(path, url) {
   return `curl -fsS --upload-file ${shellQuote(path)} -X POST ${shellQuote(url)}`;
@@ -25968,11 +25978,14 @@ async function attachThroughStore(path, name, lead, artifacts, ctx) {
   if (parseExitPrefix(putOut).failed) {
     return `error: the upload of ${name} to the artifact store failed: ${putOut.trim()}`;
   }
+  const report2 = parsePutReport(putOut);
+  const curlSaid = report2 ? `; curl reported HTTP ${report2.httpCode} after sending ${report2.sentBytes} bytes` : "";
   const head = await artifacts.store.head(key);
-  if (!head)
-    return `error: the artifact store holds nothing under ${key} after the upload of ${name} \u2014 nothing was posted`;
+  if (!head) {
+    return `error: the artifact store holds nothing under ${key} after the upload of ${name}${curlSaid} \u2014 nothing was posted`;
+  }
   if (head.size !== size) {
-    return `error: the artifact store holds ${head.size} bytes for ${name}, not the ${size} measured \u2014 nothing was posted`;
+    return `error: the artifact store holds ${head.size} bytes for ${name}, not the ${size} measured${curlSaid} \u2014 nothing was posted`;
   }
   ctx.publish?.({ type: "artifact", direction: "out", key, name, size, contentType });
   if (!ctx.uploadTicket) {
@@ -26000,7 +26013,7 @@ async function attachThroughStore(path, name, lead, artifacts, ctx) {
   }
   return `attached ${name} (${size} bytes) to the conversation and the run page`;
 }
-var MAX_ARTIFACT_BYTES, TRANSFER_FLOOR_BYTES_PER_MS, TRANSFER_SETUP_MS, STAT_TIMEOUT_MS, describe2, secs, attachFileTool;
+var MAX_ARTIFACT_BYTES, TRANSFER_FLOOR_BYTES_PER_MS, TRANSFER_SETUP_MS, STAT_TIMEOUT_MS, describe2, secs, PUT_REPORT_FORMAT, attachFileTool;
 var init_attach = __esm({
   "../../src/tools/attach.ts"() {
     "use strict";
@@ -26016,8 +26029,10 @@ var init_attach = __esm({
     STAT_TIMEOUT_MS = 3e4;
     describe2 = (err2) => err2 instanceof Error ? err2.message : String(err2);
     secs = (ms) => Math.max(0, Math.round(ms / 1e3));
+    PUT_REPORT_FORMAT = "\\n%{http_code} %{size_upload}";
     attachFileTool = {
       name: "attach_file",
+      failsInText: true,
       description: `Post a file from the workspace into the conversation so the person sees it inline \u2014 a screenshot (e.g. from \`playwright screenshot\`), a rendered PDF, a recording, a log. Use it whenever you produce an image worth showing: a link to a file is not a picture. Whole files only: up to ${MAX_ARTIFACT_BYTES} bytes (1 GiB) where the artifact store is configured, ${MAX_READ_BYTES} bytes otherwise \u2014 the result says which.`,
       inputSchema: {
         type: "object",
@@ -26557,6 +26572,7 @@ var init_runs2 = __esm({
     CHILDREN_PAGES_MAX = 25;
     spawnRunTool = {
       name: "spawn_run",
+      failsInText: true,
       description: `Start a child run as the person who asked you: an ordinary Switchboard run of the named preset, in a thread of its own in this channel, under their permissions \u2014 what they could start by hand with \`agent:<preset>\`. The child is a reader of this conversation: it starts from this conversation's text so far (every user and assistant turn, never your tool calls or their results) plus \`prompt\`, its one new turn \u2014 so say what it should do. Presets a child can run: ${CHILD_PRESETS().join(", ")}; a preset that writes (${WRITE_PRESETS().join(", ")}) is refused \`spawn_identity\`. \`repo\` (owner/name) for a preset that works in a repository (${REPO_PRESETS().join(", ")}); \`budget\` narrows the child's wall clock in whole minutes (at least 2; it is also capped by what is left of yours). Returns the child's run id, its thread and a link, or a refusal by name: a preset or repository the requester may not use, a boundary the child's profile exceeds, the fan-out cap, or a channel that cannot open a thread. A child cannot spawn children.`,
       inputSchema: {
         type: "object",
@@ -26599,6 +26615,7 @@ var init_runs2 = __esm({
     };
     sendToRunTool = {
       name: "send_to_run",
+      failsInText: true,
       description: "Steer one of your live children: `text` reaches it as a follow-up at its next step, the way a reply in its thread would \u2014 sent as the person who asked you, and recorded on the child's run page as coming from this run. Use it when the request changed or a child is heading the wrong way. Refused by name: `not_found` (an unknown id, or a run the requester may not read), `not_child` (a run you did not spawn), `not_live` (it already ended \u2014 its status is given, nothing is sent; get_run_status has its reply), or the child's agent's allowlist. A child that finishes before its next step never reads it.",
       inputSchema: {
         type: "object",
@@ -26638,6 +26655,7 @@ var init_runs2 = __esm({
     AWAIT_IDS_MAX = 50;
     awaitRunsTool = {
       name: "await_runs",
+      failsInText: true,
       description: "Wait for runs \u2014 normally your children \u2014 to end, and get each one's end as data: its terminal status (completed, failed, refused, stopped_soft, stopped_hard, interrupted) with its final reply wrapped as untrusted content; `running` for one still live when the wait was cut; `not_found` for an unknown id or one the requester may not read. The wait ends at the first of: every named run ended; `timeoutMinutes` (optional, whole minutes); the edge of your own budget (a minute before your clock runs out \u2014 write up what came back and name what is still running, which keeps running); a stop; a follow-up landing in this thread (it rides your next turn). `ended` says which. An interrupted child is reported, never restarted. A child is its thread: when a person's reply in a child's thread started a later run there, the child's row follows that run \u2014 `continuedBy` names it, and `status` and `finalReply` are its \u2014 never the child's first reply alone.",
       inputSchema: {
         type: "object",
@@ -27037,6 +27055,7 @@ ${raw.trim()}`;
     };
     submitVerdictTool = {
       name: "submit_verdict",
+      failsInText: true,
       description: "Record your review verdict. REQUIRED before your final message when reviewing a PR: `approve` when there are no blocking issues (nits alone are not blocking), `request_changes` otherwise. Switchboard writes the verdict as the first line of the GitHub comment itself (`LGTM:` only for approve); a review with no submitted verdict is posted as NOT approving. Call it once, after your analysis; a later call replaces the earlier one. `head` is the commit you reviewed \u2014 run `git rev-parse HEAD` in the checkout you read and tested and pass its output; Switchboard posts to the PR only if that commit IS the PR's head, so a review of the wrong branch can never land on a PR. Enumerate EVERY issue you report in `findings` with STABLE ids assigned in order (F1, F2, \u2026) \u2014 a fix round references findings by these ids, so never renumber them. Severity is exactly one of blocking|major|minor|nit; the entry carries the file (plus line when it points at one) and a one-line title, while the full explanation stays in your review text keyed by the same ids. An `approve` carrying a `blocking` finding is downgraded to `request_changes` \u2014 approve only when nothing blocking remains.",
       inputSchema: {
         type: "object",
@@ -27087,6 +27106,7 @@ ${raw.trim()}`;
     };
     submitDispositionsTool = {
       name: "submit_dispositions",
+      failsInText: true,
       description: "Record one disposition per review finding after addressing them: `fixed` (the finding is addressed in your pushed code) or `declined` (deliberately not doing it \u2014 the note says why). `findingId` is the finding's stable id from the review (F1, F2, \u2026) \u2014 use exactly those ids; an id the review never issued answers nothing and is dropped when the plan runner reads your record. Every finding gets exactly one entry, every severity included (nits too). Call it once with the complete set after your last push; a later call replaces the earlier one. The set rides this run's record, where the plan runner reads it for the re-review.",
       inputSchema: {
         type: "object",
@@ -27118,6 +27138,7 @@ ${raw.trim()}`;
     };
     submitPrDescriptionTool = {
       name: "submit_pr_description",
+      failsInText: true,
       description: "Submit the PR description as a typed object. REQUIRED after pushing your branch: Switchboard renders the GitHub PR body from this object at the pushed head and opens (or updates) the pull request itself \u2014 never open a PR yourself. Fields map 1:1 to the rendered sections; `title` becomes the PR's title; tour anchors are (path, from, to) line ranges at your pushed head. Call it after your last push; if you push again afterwards, call it again \u2014 the last valid call wins. An invalid object returns an error naming the field to fix; correct it and resubmit.",
       inputSchema: {
         type: "object",
@@ -27211,6 +27232,7 @@ ${raw.trim()}`;
     });
     submitHandoffTool = {
       name: "submit_handoff",
+      failsInText: true,
       description: "Submit the unit handoff as a typed object \u2014 REQUIRED when your first user turn carries a `## Contract` block: once, after submit_pr_description and before your final message. `deviations`: where you departed from the unit as written (from, to, why); `followUps`: what you found and did not do, and where it belongs (what, where); `unproven`: which of the unit's test scenarios or criteria you could not prove, and why (criterion, why). Switchboard records it on the run and posts it to the unit's board issue, where a person decides each row. Submit empty lists when there is nothing to say \u2014 never skip it. A later call replaces the earlier one; an invalid object returns an error naming the field to fix.",
       inputSchema: {
         type: "object",
@@ -27994,17 +28016,17 @@ ${stagedLine}` : prompt }];
       try {
         const output = await untilHardStop(tool.run(tu.input ?? {}, ctx));
         const text2 = toolResultText(output);
-        const exit = tu.name === "bash" ? parseExitPrefix(text2) : void 0;
+        const exit = tu.name === "bash" ? parseExitPrefix(text2) : { failed: tool.failsInText === true && toolTextFailed(text2) };
         emit({
           type: "tool_result",
           tool: tu.name,
-          ok: !exit?.failed,
+          ok: !exit.failed,
           callId: tu.id,
-          ...exit?.exitCode !== void 0 ? { exitCode: exit.exitCode } : {},
+          ...exit.exitCode !== void 0 ? { exitCode: exit.exitCode } : {},
           ...prepareToolResult(text2),
           ...spanId
         });
-        settle2(!exit?.failed, exit?.exitCode !== void 0 ? { exitCode: exit.exitCode } : {});
+        settle2(!exit.failed, exit.exitCode !== void 0 ? { exitCode: exit.exitCode } : {});
         return { type: "tool_result", toolUseId: tu.id, content: capToolResultContent(output) };
       } catch (err2) {
         if (err2 instanceof HardStopError) throw err2;
@@ -31289,7 +31311,7 @@ var init_bridge2 = __esm({
         const tool = open2?.tool ?? str5(event.toolName);
         const isError = event.isError === true;
         const text = piResultText(event.result);
-        const exit = tool === "bash" ? piBashExit(text, isError) : { failed: isError, ...isError ? {} : {} };
+        const exit = tool === "bash" ? piBashExit(text, isError) : { failed: isError || this.deps.textFailing?.has(tool) === true && toolTextFailed(text) };
         const ok2 = !exit.failed;
         this.emit({
           type: "tool_result",
@@ -31739,7 +31761,13 @@ async function runPiHarness(deps, run2) {
     run2.onProgress?.(summary);
     emit({ type: "run_note", kind, summary, ...mode ? { mode } : {} });
   };
-  const bridge = new PiBridge({ emit, onProgress: run2.onProgress, agentSpan, clock: clock3 });
+  const bridge = new PiBridge({
+    emit,
+    onProgress: run2.onProgress,
+    agentSpan,
+    clock: clock3,
+    textFailing: new Set(run2.tools.filter((t) => t.failsInText).map((t) => t.name))
+  });
   let paths;
   const remainingMs = run2.resume?.remainingMs ?? run2.agent.maxMinutes * 6e4;
   const deadline = now() + remainingMs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coreplane/switchboard",
-  "version": "1.220.0",
+  "version": "1.220.1",
   "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",
   "homepage": "https://openswitchboard.dev",