faberun 0.26.2 → 0.26.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "faberun",
-  "version": "0.26.2",
+  "version": "0.26.3",
   "description": "Faberun is a development orchestration system that turns intent into verified software: harness- and model-agnostic, it keeps the intent, coordinates the work, verifies the result and decides what happens next.",
   "type": "module",
   "bin": {

package/src/contract/runtime.mjs

@@ -11,7 +11,7 @@
  */
 import { assertObject, nonNegativeNumber, positiveInteger, positiveNumber, rejectUnknown, requireId, requireString, requireStringArray, requireTimestamp } from "./assert.mjs";
 import { composeAssignments } from "../engine/runtime-discovery.mjs";
-import { harnessCapabilities, resolvePermissionExecution, resolveVendor, validateCapabilityRequirements, writesWorkspace } from "../harnesses/index.mjs";
+import { harnessCapabilities, readOnlyModeOf, resolvePermissionExecution, resolveVendor, validateCapabilityRequirements, writesWorkspace } from "../harnesses/index.mjs";
 import { canonicalProvider } from "./provider.mjs";
 import { stableJson } from "../util.mjs";
 /** @typedef {import("./index.mjs").NodeStatus} NodeStatus */
@@ -246,8 +246,9 @@ export function judgeWriteWarnings(runtimes, defaults, nodes) {
     const runtime = runtimes[/** @type {string} */ (id)];
     const execution = resolvePermissionExecution(runtime);
     if (!execution.field || runtime[execution.field] === undefined || !writesWorkspace(runtime)) return [];
-    if (writesWorkspace({ ...runtime, [execution.field]: "read-only" })) return [];
-    return [`judge runtime ${id} declares ${execution.field} ${execution.mode}; a judge's verdict reaches the gate without writing, so declare ${execution.field} read-only`];
+    const readOnlyMode = readOnlyModeOf(runtime);
+    if (readOnlyMode === null) return [];
+    return [`judge runtime ${id} declares ${execution.field} ${execution.mode}; a judge's verdict reaches the gate without writing, so declare ${execution.field} ${readOnlyMode}`];
   });
 }
 /**

package/src/harnesses/claude/index.mjs

@@ -52,8 +52,11 @@ export const claudeHarness = {
     signalsProcesses: true,
   },
 
-  // Headless acceptEdits denies Bash; bypassPermissions executes commands.
-  permissionExecution: { field: "permissionMode", executingModes: ["bypassPermissions"], defaultMode: "acceptEdits" },
+  // Headless acceptEdits denies Bash; bypassPermissions executes commands;
+  // plan neither edits nor runs anything, the mode a judge or a preflight ask
+  // needs (measured 2026-09-27: an Opus judge left on the acceptEdits default
+  // edited the review it was grading and was blocked judge_protocol).
+  permissionExecution: { field: "permissionMode", executingModes: ["bypassPermissions"], defaultMode: "acceptEdits", readOnlyModes: ["plan"] },
 
   /** @param {import("../index.mjs").HarnessRuntime} runtime @returns {string} */
   executable(runtime) {

package/src/harnesses/index.mjs

@@ -157,6 +157,17 @@ export function resolvePermissionExecution(runtime) {
   return { executes: policy.executingModes.includes(mode), field: policy.field, mode, executingModes: policy.executingModes };
 }
 
+/**
+ * The mode in which a runtime's harness cannot write its workspace, or `null`
+ * when the harness declares none.
+ *
+ * @param {{harness: string}} runtime
+ * @returns {string|null}
+ */
+export function readOnlyModeOf(runtime) {
+  return getHarness(runtime.harness).permissionExecution?.readOnlyModes?.[0] ?? null;
+}
+
 /**
  * Whether a runtime can write its workspace. False only in a mode its adapter
  * declares read-only; RM-058 measured a codex reviewer under `read-only`

package/src/plan/template.mjs

@@ -236,6 +236,25 @@ function readFilesForKind(kind, inputs) {
   return [/** @type {string} */ (inputs.specPath)];
 }
 
+/**
+ * The wall clock one planning stage gets, from the reasoning effort of the
+ * runtime that runs it. A stage is a single long turn over the whole plan, so
+ * the contract default (2400 s) fits a draft at ordinary effort but not a
+ * revise at high effort. Measured 2026-09-27: Opus 5.5 at `xhigh` revising
+ * a 20-node plan against 13 findings was still reasoning when the 2400 s wall
+ * clock ended the stage, and the pipeline, which cannot resume a stage, lost
+ * the draft and review it had already paid for.
+ *
+ * @param {Record<string, unknown>|undefined} runtime
+ * @returns {number}
+ */
+export function planningStageTimeoutSec(runtime) {
+  const reasoning = runtime?.reasoning;
+  if (reasoning === "xhigh" || reasoning === "max") return 7200;
+  if (reasoning === "high") return 3600;
+  return 2400;
+}
+
 /**
  * Build one of the planning pipeline's one-node discovery contracts. Pure:
  * no file is read or written, and no model is invoked. The returned object is
@@ -273,10 +292,13 @@ export function buildPlanningContract(kind, inputs) {
     verification: [],
   };
 
+  const stageRuntime = runtimeId === undefined ? undefined : /** @type {Record<string, unknown>|undefined} */ (inputs.runtimes[runtimeId]);
+
   return {
     schemaVersion: PROTOCOL_SCHEMA_VERSION,
     contractVersion: CONTRACT_VERSION,
     id: `${inputs.campaignId}-plan-${inputs.phase}-${kind}-${inputs.n}`,
+    timeoutSec: planningStageTimeoutSec(stageRuntime),
     campaignId: inputs.campaignId,
     goal: inputs.goal ?? `Plan ${kind} for phase ${inputs.phase}`,
     cwd: inputs.cwd ?? ".",