@basein/runner 0.2.4 → 0.2.5

package/dist/control/server.js

@@ -715,6 +715,15 @@ export class ControlServer {
             logDetail("tool.pre.skipped", { run: run.runId, tool: toolName, why: "host housekeeping" });
             return {};
         }
+        // `run_scenario` with no live plan does nothing but answer "no scenario is
+        // armed". Recorded, that answer is a failed tool call, and a recording with
+        // one is never picked for calculation — observed in production on every
+        // first run in a project with the scenario server installed. With a live
+        // plan it is still recorded below, tagged `pinnedBy`.
+        if (this.replay.isDirectTool(toolName) && (!run.replay?.plan || run.replay.retired)) {
+            logDetail("tool.pre.skipped", { run: run.runId, tool: toolName, why: "no scenario armed" });
+            return {};
+        }
         const agentId = payload.agent_id ?? session.agentId;
         // The real intent, read from every line sharing this message's id
         // (segmented.md R-INTENT-3). `context` stays the *written* text only, with
@@ -1236,6 +1245,10 @@ export class ControlServer {
         // `tool_response` with no `tool_selected` before it.
         if (isHousekeeping(toolName))
             return {};
+        // Nor for an unarmed `run_scenario`. The plan may have retired since the
+        // pre hook, so the test is whether that hook opened a step, not the plan.
+        if (this.replay.isDirectTool(toolName) && !run.builtIns.has(toolUseId))
+            return {};
         const failed = payload.hook_event_name === "PostToolUseFailure" || payload.error !== undefined;
         // ── replay threading (docs/calculatedReplay.md §7.2) ─────────────────────
         // `toolOutputLogic` was authored against the bytes that were *recorded* for

package/dist/replay/tool-error.d.ts

@@ -3,16 +3,17 @@
  *
  * A step's tool call resolving is not the same as the step's work happening.
  * `executeStep` rejects only when a tool could not be run here; a tool that ran
- * and answered `Error: relation does not exist` resolves normally, with that
- * error as its response — which is right for threading (the output logic may
- * want to see it) and wrong for the verdict. Eight such steps once logged
- * `ok=true` each, the plan reported `steered_full`, and the ledger booked its
- * largest saving of the day on a replay that created nothing (docs/mcpmark.md §13).
+ * and reported a failure resolves normally, with that failure as its response —
+ * which is right for threading (the output logic may want to see it) and wrong
+ * for the verdict (docs/mcpmark.md §13).
  *
- * The signal is the MCP result itself: `isError: true` per the spec, or — for
- * servers that report failures as ordinary text, `postgres-mcp` among them — a
- * first text block that begins with the word "Error". Nothing else is read, and
- * a built-in's hook-shaped response is never judged.
+ * The signal is `isError: true` on the MCP result, per the spec, and nothing
+ * else — the same rule the recorder uses (`proxy/intercept.ts`), so a step is a
+ * success or an error in the recording and in its replay alike. A server that
+ * reports failures as ordinary text with `isError: false`, `postgres-mcp` among
+ * them, is taken at its word on both sides: its `Error: relation does not exist`
+ * is a successful call here, as it was when it was recorded. A built-in's
+ * hook-shaped response is never judged.
  */
 /**
  * The error a serialized `CallToolResult` reports, or undefined when it does

package/dist/replay/tool-error.js

@@ -3,16 +3,17 @@
  *
  * A step's tool call resolving is not the same as the step's work happening.
  * `executeStep` rejects only when a tool could not be run here; a tool that ran
- * and answered `Error: relation does not exist` resolves normally, with that
- * error as its response — which is right for threading (the output logic may
- * want to see it) and wrong for the verdict. Eight such steps once logged
- * `ok=true` each, the plan reported `steered_full`, and the ledger booked its
- * largest saving of the day on a replay that created nothing (docs/mcpmark.md §13).
+ * and reported a failure resolves normally, with that failure as its response —
+ * which is right for threading (the output logic may want to see it) and wrong
+ * for the verdict (docs/mcpmark.md §13).
  *
- * The signal is the MCP result itself: `isError: true` per the spec, or — for
- * servers that report failures as ordinary text, `postgres-mcp` among them — a
- * first text block that begins with the word "Error". Nothing else is read, and
- * a built-in's hook-shaped response is never judged.
+ * The signal is `isError: true` on the MCP result, per the spec, and nothing
+ * else — the same rule the recorder uses (`proxy/intercept.ts`), so a step is a
+ * success or an error in the recording and in its replay alike. A server that
+ * reports failures as ordinary text with `isError: false`, `postgres-mcp` among
+ * them, is taken at its word on both sides: its `Error: relation does not exist`
+ * is a successful call here, as it was when it was recorded. A built-in's
+ * hook-shaped response is never judged.
  */
 const MAX_ERROR_CHARS = 500;
 /**
@@ -27,17 +28,12 @@ export function toolResultError(serialized) {
     catch {
         return undefined;
     }
-    if (typeof parsed === "string")
-        return looksLikeError(parsed) ? clip(parsed) : undefined;
     if (!parsed || typeof parsed !== "object")
         return undefined;
     const result = parsed;
-    const text = firstText(result.content);
-    if (result.isError === true)
-        return clip(text ?? "the tool reported an error");
-    if (text !== undefined && looksLikeError(text))
-        return clip(text);
-    return undefined;
+    if (result.isError !== true)
+        return undefined;
+    return clip(firstText(result.content) ?? "the tool reported an error");
 }
 function firstText(content) {
     if (!Array.isArray(content))
@@ -49,10 +45,6 @@ function firstText(content) {
     }
     return undefined;
 }
-/** "Error: …" / "ERROR: …" / "error occurred" — not "Errors were fixed". */
-function looksLikeError(text) {
-    return /^\s*error\b/i.test(text);
-}
 function clip(text) {
     const trimmed = text.trim();
     return trimmed.length > MAX_ERROR_CHARS ? `${trimmed.slice(0, MAX_ERROR_CHARS)}…` : trimmed;