@alexeiled/pi-fusion 0.7.0 → 0.9.0

package/src/run-builder.ts

@@ -2,6 +2,9 @@ import {
   callerOutputContractInstructions,
   detectCallerOutputContract,
 } from "./caller-contract.js";
+import { FusionArgsError } from "./errors.js";
+import { PANEL_FINALIZE_RESERVE_MS } from "./panel-deadlines.js";
+import { resolveMinimumSuccessfulPanelists } from "./panel-quorum.js";
 import {
   PANEL_DECISION_CLOSE,
   PANEL_DECISION_OPEN,
@@ -13,6 +16,8 @@ import {
   panelItemLabel,
   resolveSynthesisMode,
   type CallerOutputContract,
+  type EffectiveFusionTimeouts,
+  type FusionTimeoutOverrides,
   THINKING_LEVELS,
   type FailedPanelSummary,
   type FusionProfile,
@@ -31,6 +36,8 @@ export const FUSION_ACCEPTANCE_DISABLED = {
 export type FusionAcceptanceDisabled = typeof FUSION_ACCEPTANCE_DISABLED;
 
 const DEFAULT_STAGE_TIMEOUT_MS = 900_000;
+const DEFAULT_PANELIST_TIMEOUT_MS = 840_000;
+const DEFAULT_PANEL_GRACE_MS = 5_000;
 const DEFAULT_TOOL_BUDGET: ToolBudget = {
   soft: 8,
   hard: 12,
@@ -48,6 +55,8 @@ export interface PanelSubagentTaskParams {
   model?: string;
   /** Per-task cap so a panelist finalises before the workflow timeout. */
   toolBudget: ToolBudget;
+  /** Child deadline, always shorter than the enclosing panel workflow. */
+  timeoutMs?: number;
 }
 
 export interface PanelWorkflowTaskParams extends PanelSubagentTaskParams {
@@ -100,6 +109,9 @@ export interface BuildJudgeSpawnParamsInput {
    */
   runId: string;
   callerContract?: CallerOutputContract;
+  timeoutOverrides?: FusionTimeoutOverrides;
+  /** Persisted at panel start so restored fallback judges keep their deadline. */
+  effectiveTimeouts?: EffectiveFusionTimeouts;
 }
 
 const PANEL_OUTPUT_CONTRACT = [
@@ -168,7 +180,9 @@ export function buildPanelSpawnParams(
   profile: FusionProfile,
   prompt: string,
   callerContract?: CallerOutputContract,
+  timeoutOverrides?: FusionTimeoutOverrides,
 ): PanelSpawnParams {
+  const timeouts = resolveEffectiveTimeouts(profile, timeoutOverrides);
   const concurrency = profile.concurrency ?? profile.panel.length;
   const tasks: PanelWorkflowTaskParams[] = profile.panel.map(
     (member, index) => ({
@@ -179,22 +193,30 @@ export function buildPanelSpawnParams(
         profile.stopWhenPanelAgrees === true,
         profile.panelToolBudget ?? DEFAULT_TOOL_BUDGET,
         callerContract,
+        timeouts.panelistTimeoutMs,
+        timeouts.panelistSoftTimeoutMs !== undefined,
       ),
     }),
   );
 
+  const requiredSuccessfulPanelists = resolveMinimumSuccessfulPanelists(
+    profile.minimumSuccessfulPanelists,
+    profile.panel.length,
+  );
+
   return {
     workflowScript: buildPanelWorkflowScript(
       tasks,
       concurrency,
       profile.stopWhenPanelAgrees === true,
+      requiredSuccessfulPanelists,
     ),
     async: true,
     context: profile.context ?? "fresh",
     output: true,
     outputMode: "inline",
     acceptance: FUSION_ACCEPTANCE_DISABLED,
-    timeoutMs: resolveStageTimeout(profile.panelTimeoutMs, profile.timeoutMs),
+    timeoutMs: timeouts.panelTimeoutMs,
   };
 }
 
@@ -223,10 +245,9 @@ export function buildJudgeSpawnParams(
     output: true,
     outputMode: "inline",
     acceptance: FUSION_ACCEPTANCE_DISABLED,
-    timeoutMs: resolveStageTimeout(
-      input.profile.judgeTimeoutMs,
-      input.profile.timeoutMs,
-    ),
+    timeoutMs:
+      input.effectiveTimeouts?.judgeTimeoutMs ??
+      resolveEffectiveTimeouts(input.profile, input.timeoutOverrides).judgeTimeoutMs,
   };
 }
 
@@ -234,13 +255,41 @@ function buildPanelWorkflowScript(
   tasks: readonly PanelWorkflowTaskParams[],
   concurrency: number,
   stopWhenAgrees: boolean,
+  requiredSuccessfulPanelists: number,
 ): string {
   const serializedTasks = JSON.stringify(tasks);
+  if (!stopWhenAgrees) {
+    return [
+      `const tasks = ${serializedTasks};`,
+      `const concurrency = ${concurrency};`,
+      "const results = new Array(tasks.length);",
+      "const pending = new Map();",
+      "let next = 0;",
+      "while (next < tasks.length || pending.size > 0) {",
+      "  while (next < tasks.length && pending.size < concurrency) {",
+      "    const index = next++;",
+      "    const { key, ...task } = tasks[index];",
+      "    const pendingRun = runs.run(key, task);",
+      "    pending.set(index, Promise.all([pendingRun]).then(([result]) => ({ index, result })));",
+      "  }",
+      "  const { index, result } = await Promise.race(pending.values());",
+      "  results[index] = result;",
+      "  pending.delete(index);",
+      "}",
+      "return results;",
+    ].join("\n");
+  }
+  // Agreement panels deliberately use quorum-sized rounds: starting speculative
+  // replacements would spend more calls before the current votes can agree.
+  // Start no more work than the resolved quorum requires. This preserves the
+  // two-at-a-time majority behavior while allowing a larger configured quorum
+  // to be observed before agreement can stop the remaining panelists.
   const effectiveConcurrency = stopWhenAgrees
-    ? Math.min(concurrency, 2)
+    ? Math.min(concurrency, requiredSuccessfulPanelists)
     : concurrency;
   const stopLogic = stopWhenAgrees
     ? [
+        `const requiredSuccessfulPanelists = ${requiredSuccessfulPanelists};`,
         "const decisions = results",
         "  .filter((result) => result && result.ok === true)",
         "  .map((result) => {",
@@ -250,7 +299,7 @@ function buildPanelWorkflowScript(
         "    try { return JSON.parse(match[1]); } catch { return undefined; }",
         "  })",
         "  .filter((decision) => decision && typeof decision.recommendation === \"string\" && decision.confidence === \"high\" && decision.needsMoreEvidence === false);",
-        "if (decisions.length >= 2 && results.length < tasks.length) {",
+        "if (decisions.length >= requiredSuccessfulPanelists && results.length < tasks.length) {",
         "  const recommendation = decisions[0].recommendation.trim().toLocaleLowerCase().replace(/[^\\p{L}\\p{N}]+/gu, \" \" ).trim(),",
         "    agrees = recommendation && decisions.every((decision) => decision.recommendation.trim().toLocaleLowerCase().replace(/[^\\p{L}\\p{N}]+/gu, \" \" ).trim() === recommendation);",
         "  if (agrees) {",
@@ -278,8 +327,72 @@ function buildPanelWorkflowScript(
 function resolveStageTimeout(
   stageTimeoutMs: number | undefined,
   legacyTimeoutMs: number | undefined,
+  defaultTimeoutMs = DEFAULT_STAGE_TIMEOUT_MS,
 ): number {
-  return stageTimeoutMs ?? legacyTimeoutMs ?? DEFAULT_STAGE_TIMEOUT_MS;
+  return stageTimeoutMs ?? legacyTimeoutMs ?? defaultTimeoutMs;
+}
+
+/** Resolves and records the deadline precedence used for one start attempt. */
+export function resolveEffectiveTimeouts(
+  profile: FusionProfile,
+  overrides: FusionTimeoutOverrides | undefined = undefined,
+): EffectiveFusionTimeouts {
+  const concurrency = profile.concurrency ?? profile.panel.length;
+  const waves = Math.ceil(profile.panel.length / concurrency);
+  const panelTimeoutMs = resolveStageTimeout(
+    overrides?.panelTimeoutMs ?? profile.panelTimeoutMs,
+    profile.timeoutMs,
+    DEFAULT_STAGE_TIMEOUT_MS * waves,
+  );
+  const panelGraceMs = resolveStageTimeout(
+    overrides?.panelGraceMs ?? profile.panelGraceMs,
+    undefined,
+    DEFAULT_PANEL_GRACE_MS,
+  );
+  const requestedPanelistTimeoutMs = resolveStageTimeout(
+    overrides?.panelistTimeoutMs ?? profile.panelistTimeoutMs,
+    profile.timeoutMs,
+    DEFAULT_PANELIST_TIMEOUT_MS,
+  );
+  if (panelGraceMs >= panelTimeoutMs) {
+    throw new FusionArgsError(
+      `panelGraceMs (${panelGraceMs}ms) must be shorter than panelTimeoutMs (${panelTimeoutMs}ms).`,
+    );
+  }
+  // A child must conclude before the enclosing workflow. The validated grace
+  // interval guarantees this cap remains a meaningful deadline.
+  const panelistTimeoutMs = Math.min(
+    requestedPanelistTimeoutMs,
+    panelTimeoutMs - panelGraceMs,
+  );
+  const softTimeoutMs = profile.panelistSoftTimeoutMs;
+  if (softTimeoutMs !== undefined && (!Number.isInteger(softTimeoutMs) || softTimeoutMs <= 0)) {
+    throw new FusionArgsError("panelistSoftTimeoutMs must be a positive integer.");
+  }
+  if (softTimeoutMs !== undefined && panelTimeoutMs < waves * panelistTimeoutMs + panelGraceMs) {
+    throw new FusionArgsError("The panel deadline must cover every concurrency wave plus grace when soft deadlines are enabled.");
+  }
+  if (softTimeoutMs !== undefined && softTimeoutMs >= panelistTimeoutMs - PANEL_FINALIZE_RESERVE_MS) {
+    throw new FusionArgsError("panelistSoftTimeoutMs must leave more than one minute before the effective panelist hard deadline.");
+  }
+  return {
+    ...(softTimeoutMs !== undefined ? { panelistSoftTimeoutMs: softTimeoutMs } : {}),
+    panelistTimeoutMs,
+    panelTimeoutMs,
+    panelGraceMs,
+    judgeTimeoutMs: resolveStageTimeout(
+      overrides?.judgeTimeoutMs ?? profile.judgeTimeoutMs,
+      profile.timeoutMs,
+    ),
+    usesLegacyTimeout:
+      profile.timeoutMs !== undefined &&
+      (overrides?.panelistTimeoutMs === undefined &&
+        profile.panelistTimeoutMs === undefined ||
+        overrides?.panelTimeoutMs === undefined &&
+          profile.panelTimeoutMs === undefined ||
+        overrides?.judgeTimeoutMs === undefined &&
+          profile.judgeTimeoutMs === undefined),
+  };
 }
 
 function buildPanelTaskParams(
@@ -288,6 +401,8 @@ function buildPanelTaskParams(
   includeDecisionRecord: boolean,
   toolBudget: ToolBudget,
   callerContract?: CallerOutputContract,
+  timeoutMs?: number,
+  allowSupervisor = false,
 ): PanelSubagentTaskParams {
   const model = appendThinkingSuffix(member.model, member.thinking);
   return {
@@ -297,6 +412,7 @@ function buildPanelTaskParams(
       prompt,
       includeDecisionRecord,
       callerContract,
+      allowSupervisor,
     ),
     output: true,
     outputMode: "inline",
@@ -304,6 +420,7 @@ function buildPanelTaskParams(
     skill: false,
     acceptance: FUSION_ACCEPTANCE_DISABLED,
     toolBudget,
+    ...(timeoutMs ? { timeoutMs } : {}),
     ...(model ? { model } : {}),
   };
 }
@@ -313,6 +430,7 @@ function buildPanelTask(
   prompt: string,
   includeDecisionRecord: boolean,
   callerContractOverride?: CallerOutputContract,
+  allowSupervisor = false,
 ): string {
   const role = member.role?.trim() || "independent analysis and critique";
   const callerContract =
@@ -326,7 +444,9 @@ function buildPanelTask(
     "Instructions:",
     "- Work independently from the other panelists.",
     "- Read-only: inspect only; leave files, git state, and the workspace untouched.",
-    "- Do not ask other agents.",
+    allowSupervisor
+      ? "- Do not consult other panelists. Parent supervisor coordination is allowed only for progress updates and deadline decisions."
+      : "- Do not ask other agents.",
     "- Do not run subagents.",
     "- Use local inspection only when code evidence is needed.",
     "- Be concise and cite evidence when you inspect files.",

package/src/run-observations.ts

@@ -151,7 +151,9 @@ export function extractRunObservation(value: unknown): RunObservation {
   const providerFailures = summarizeProviderFailures(
     rawError &&
       attemptFailures.length === 0 &&
-      (value.success === false || value.state === "failed")
+      (value.success === false ||
+        value.state === "failed" ||
+        value.status === "failed")
       ? [
           {
             provider: model ? providerFromModel(model) : "unknown provider",