faberun 0.26.0 → 0.26.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "faberun",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "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/cli/launch.mjs

@@ -24,6 +24,7 @@ import { readRunNodes } from "../run/node-store.mjs";
 import { spawn } from "node:child_process";
 import { validateContract } from "../contract/index.mjs";
 import { runDirectory } from "../run/paths.mjs";
+import { livePreflightCeilingSec } from "../engine/live-preflight.mjs";
 
 /**
  * The file a detached child is spawned as. It must be the CLI and not this
@@ -94,7 +95,7 @@ export function detachArgv(argv, options = {}) {
  * @param {number} [timeoutMs]
  * @returns {Promise<BootstrapRecord>}
  */
-export async function waitForBootstrap(runDir, pid, child = null, timeoutMs = 30_000) {
+export async function waitForBootstrap(runDir, pid, child = null, timeoutMs = bootstrapReadyTimeoutMs()) {
   const deadline = Date.now() + timeoutMs;
   const nonce = child?.bootstrapNonce;
   if (!nonce) throw new Error(`detached bootstrap has no start nonce for pid ${pid}`);
@@ -157,6 +158,18 @@ export async function waitForBootstrap(runDir, pid, child = null, timeoutMs = 30
   cleanupBootstrapAttempts(runDir);
   throw new Error(`detached bootstrap did not become ready for pid ${pid}`);
 }
+/**
+ * The controller answers ready only after the dispatch gate's live preflight,
+ * so the launcher waits for that ask on top of its own 30s start-up margin.
+ * Measured 2026-09-27: with a fixed 30s wait, a gate asking Opus at `xhigh`
+ * made `run --detach` and `plan --detach` report "did not become ready" for
+ * controllers that then came up and ran.
+ *
+ * @returns {number}
+ */
+export function bootstrapReadyTimeoutMs() {
+  return 30_000 + livePreflightCeilingSec() * 1000;
+}
 /**
  * @param {string} runDir
  * @param {BootstrapRecord} bootstrap

package/src/engine/live-preflight.mjs

@@ -46,7 +46,7 @@ const LIVE_PREFLIGHT_OUTPUT_LIMIT_BYTES = 512 * 1024;
  * whole is part of the answer.
  *
  * @param {string} contractPath
- * @param {{static?: boolean, liveTimeoutSec?: number, persisted?: boolean}} [options]
+ * @param {{static?: boolean, liveTimeoutSec?: number, minimumTimeoutSec?: number, persisted?: boolean}} [options]
  * @returns {Promise<ProbeResult[]>}
  */
 export async function preflightContract(contractPath, options = {}) {
@@ -70,7 +70,7 @@ export async function preflightContract(contractPath, options = {}) {
  * once, so a caller cannot accidentally ask a different question.
  *
  * @param {{runtime: RuntimeSnapshot, requiredCapabilitySets?: import("../harnesses/index.mjs").CapabilityRequirements[]}[]} entries
- * @param {{static?: boolean, liveTimeoutSec?: number, cwd?: string}} [options]
+ * @param {{static?: boolean, liveTimeoutSec?: number, minimumTimeoutSec?: number, cwd?: string}} [options]
  * @returns {Promise<ProbeResult[]>}
  */
 export async function preflightRuntimes(entries, options = {}) {
@@ -80,7 +80,7 @@ export async function preflightRuntimes(entries, options = {}) {
   ));
   if (options.static === true) return staticChecks;
 
-  const timeoutSec = livePreflightTimeout(options.liveTimeoutSec);
+  const configuredTimeoutSec = configuredLivePreflightTimeout(options.liveTimeoutSec);
   let liveRepo;
   try {
     liveRepo = createLivePreflightRepo();
@@ -95,7 +95,7 @@ export async function preflightRuntimes(entries, options = {}) {
   }
   try {
     return await Promise.all(staticChecks.map(async (check, index) => {
-      const live = await livePreflight(runtimes[index], liveRepo, timeoutSec);
+      const live = await livePreflight(runtimes[index], liveRepo, configuredTimeoutSec ?? Math.max(options.minimumTimeoutSec ?? 0, defaultLivePreflightTimeout(runtimes[index])));
       const liveDetail = live.status === "done"
         ? `live done · usage ${formatUsage(live.usage)} · cost ${formatCost(live.costUsd)}`
         : `live ${live.status} · ${live.error?.code ?? "provider_error"}: ${redactProviderText(live.error?.message ?? "generation failed")} · usage ${formatUsage(live.usage)} · cost ${formatCost(live.costUsd)}`;
@@ -116,16 +116,54 @@ export async function preflightRuntimes(entries, options = {}) {
     rmSync(liveRepo, { recursive: true, force: true });
   }
 }
-/** @param {number|undefined} configured */
-function livePreflightTimeout(configured) {
+/**
+ * An explicit budget (option, then environment) applies to every runtime.
+ *
+ * @param {number|undefined} configured
+ * @returns {number|null}
+ */
+function configuredLivePreflightTimeout(configured) {
   const raw = configured ?? (process.env.FABERUN_PREFLIGHT_TIMEOUT_SEC === undefined
-    ? 15
+    ? null
     : Number(process.env.FABERUN_PREFLIGHT_TIMEOUT_SEC));
+  if (raw === null) return null;
   if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0) {
     throw new TypeError("preflight live timeout must be a positive number of seconds");
   }
   return raw;
 }
+/**
+ * Without an explicit budget, the wait follows the runtime's reasoning effort:
+ * a model at high effort thinks before answering even a one-word prompt.
+ * Measured 2026-09-26: Opus 5.5 at `xhigh` failed every `faberun plan`
+ * preflight at 15 s and passed once the budget was raised, so the planning
+ * pipeline was refusing a runtime that was healthy.
+ *
+ * @param {RuntimeSnapshot} runtime
+ * @returns {number}
+ */
+export function defaultLivePreflightTimeout(runtime) {
+  // Keep LIVE_PREFLIGHT_CEILING_SEC equal to the largest value returned here.
+  const reasoning = /** @type {{reasoning?: unknown}} */ (runtime).reasoning;
+  if (reasoning === "xhigh" || reasoning === "max") return 180;
+  if (reasoning === "high") return 60;
+  return 15;
+}
+/**
+ * The longest a live preflight can take without an explicit budget: what a
+ * detached launcher must be willing to wait before the controller it spawned
+ * can report ready, because the dispatch gate asks before it does.
+ */
+export const LIVE_PREFLIGHT_CEILING_SEC = 180;
+/**
+ * The longest one live preflight ask may take under the current environment.
+ *
+ * @returns {number}
+ */
+export function livePreflightCeilingSec() {
+  const override = Number(process.env.FABERUN_PREFLIGHT_TIMEOUT_SEC);
+  return process.env.FABERUN_PREFLIGHT_TIMEOUT_SEC !== undefined && Number.isFinite(override) && override > 0 ? override : LIVE_PREFLIGHT_CEILING_SEC;
+}
 /** @returns {string} */
 function createLivePreflightRepo() {
   const directory = mkdtempSync(join(tmpdir(), "faberun-preflight-"));

package/src/engine/run-identity.mjs

@@ -507,11 +507,12 @@ export async function assertEnvironmentReady(contract, runDir, sourceIdentity) {
   // worker and no judge, and can spend no availability.
   if (blocking === null && launchMayDispatch(runDir)) {
     // measured 2026-09-22: asking four routed runtimes in parallel took about
-    // 18s, so the default budget is 60s. FABERUN_PREFLIGHT_TIMEOUT_SEC stays
-    // the operator override; preflightContract validates it, so only a valid
-    // number is lifted here.
+    // 18s, so no runtime is given less than 60s here; a runtime at high
+    // reasoning effort gets its longer default (defaultLivePreflightTimeout).
+    // FABERUN_PREFLIGHT_TIMEOUT_SEC stays the operator override for every
+    // runtime; preflightContract validates it, so only a valid number is lifted.
     const override = Number(process.env.FABERUN_PREFLIGHT_TIMEOUT_SEC);
-    const timeoutSec = process.env.FABERUN_PREFLIGHT_TIMEOUT_SEC !== undefined && Number.isFinite(override) && override > 0 ? override : 60;
+    const timeoutSec = process.env.FABERUN_PREFLIGHT_TIMEOUT_SEC !== undefined && Number.isFinite(override) && override > 0 ? override : undefined;
     const probes = await livePreflightProbes(contract, runDir, sourceIdentity, timeoutSec);
     const silent = probes.filter((probe) => liveSilenceCause(probe) !== null);
     writeJsonAtomic(join(runDir, "env-preflight.json"), evidence(silent.length === 0, probes));
@@ -536,6 +537,8 @@ export async function assertEnvironmentReady(contract, runDir, sourceIdentity) {
   throw Object.assign(new Error(`env_preflight_failed: ${blocking} · the run stays resumable: fix the environment and resume ${runDir}`), { code: "env_preflight_failed" });
 }
 
+/** No routed runtime is given less than this by the dispatch gate. */
+const GATE_MINIMUM_PREFLIGHT_SEC = 60;
 /**
  * The live half of the gate for one launch. Every routed runtime either holds
  * a verdict this machine recorded inside its freshness window -- reused, the
@@ -552,7 +555,7 @@ export async function assertEnvironmentReady(contract, runDir, sourceIdentity) {
  * @param {ValidatedContract} contract
  * @param {string} runDir
  * @param {SourceIdentity|undefined} sourceIdentity
- * @param {number} timeoutSec
+ * @param {number|undefined} timeoutSec
  * @returns {Promise<ProbeResult[]>}
  */
 async function livePreflightProbes(contract, runDir, sourceIdentity, timeoutSec) {
@@ -628,7 +631,7 @@ async function livePreflightProbes(contract, runDir, sourceIdentity, timeoutSec)
       };
     });
   }
-  const probes = await preflightContract(join(runDir, "contract.json"), { liveTimeoutSec: timeoutSec, persisted: true });
+  const probes = await preflightContract(join(runDir, "contract.json"), { ...(timeoutSec === undefined ? {} : { liveTimeoutSec: timeoutSec }), minimumTimeoutSec: GATE_MINIMUM_PREFLIGHT_SEC, persisted: true });
   // What this launch bought is durable from here on: every ask that reached a
   // provider -- a refusal included, an answer being an answer -- is recorded
   // under the provider's own identity. Silence and a command that never