@alexeiled/pi-fusion 0.8.0 → 0.9.0

package/README.md

@@ -140,6 +140,8 @@ Do not use it for trivial edits, formatting, or obvious one-step fixes.
 /fusion -p <name> <prompt>
 /fusion status
 /fusion stop
+/fusion continue <fusion-run-id> <panelist-number>
+/fusion finish <fusion-run-id> <panelist-number>
 /fusion init
 ```
 
@@ -208,7 +210,9 @@ For commands, config, and troubleshooting details, see [`docs/user-guide.md`](./
 - Project config lives at `.pi/fusion.json`. Global config lives at `~/.pi/agent/fusion.json`.
 - Output appears as a Pi custom message. Active progress also uses the `fusion` status key.
 - Active runs are reconciled from `pi-subagents` lifecycle artifacts, not only completion events. Verified panel outputs survive a panel deadline; unavailable perspectives and timeout failures are disclosed in a partial report when quorum is not met or coverage is incomplete.
-- Timeouts end the current child or workflow attempt. Fusion never automatically retries panelists, restarts a panel, or extends a deadline; start a new run manually after the terminal report.
+- Normal panels refill free concurrency slots immediately. Agreement-stopping panels retain quorum-sized rounds. Default panel time covers the configured concurrency waves; explicit deadlines remain hard caps.
+- Optional `panelistSoftTimeoutMs` asks the parent for a deadline decision. The parent can approve one continuation within the existing hard budget or ask for current findings. No reply within one minute requests finalization. Fusion reserves one minute to finalize, never revives children or extends hard deadlines, and cannot guarantee a final answer from an unresponsive provider.
+- Incomplete terminal snapshots get a bounded five-second reconciliation window. Late errors are retained; at a confirmed workflow deadline, genuinely absent slots become explicit failures instead of discarding successful answers.
 - `pi-fusion` does not own the footer.
 - Fusion sends your prompt and any inspected snippets to every panel model, and to the judge, through `pi-subagents`.
 - Reports include available per-panel and judge time, aggregate model time, usage, estimated cost, and model failure details. Missing provider usage is shown as unknown. `$0.0000` is a known zero cost.

package/agents/fusion-panelist-full.md

@@ -30,7 +30,9 @@ same working directory at the same time.
 - `web_research` is slow and expensive. Use `web_search` or `web_answer` unless
   the task truly needs a deep report.
 
-Work independently. Do not ask other agents. Do not run subagents.
+Work independently. Do not consult other panelists. Do not run subagents.
+Parent supervisor coordination is allowed for progress updates and deadline decisions.
+When asked to finalize, return verified findings and name unfinished checks.
 
 Return concise Markdown with these sections.
 

package/agents/fusion-panelist-web.md

@@ -18,7 +18,9 @@ Requires `pi-web-providers`. Without it every task using this agent fails with
 Work independently. Inspect relevant local files when the task needs code evidence.
 Search the web when the task turns on external facts: library behaviour, version
 differences, standards, or anything you would otherwise have to guess. Cite what
-you retrieved. Do not edit files. Do not ask other agents. Do not run subagents.
+you retrieved. Do not edit files. Do not consult other panelists. Do not run subagents.
+Parent supervisor coordination is allowed for progress updates and deadline decisions.
+When asked to finalize, return verified findings and name unfinished checks.
 
 Return concise Markdown with these sections.
 

package/agents/fusion-panelist.md

@@ -15,7 +15,9 @@ You are a pi-fusion panelist.
 Work independently. Inspect relevant local files when the task needs code evidence.
 You have no web access: answer from the repository and your own knowledge, and say
 so plainly when a question turns on external facts you cannot retrieve.
-Do not edit files. Do not ask other agents. Do not run subagents.
+Do not edit files. Do not consult other panelists. Do not run subagents.
+Parent supervisor coordination is allowed for progress updates and deadline decisions.
+When asked to finalize, return verified findings and name unfinished checks.
 
 If the task defines an exact caller output contract, follow it instead of the
 sections and decision record below. Return only the caller's required syntax.

package/docs/user-guide.md

@@ -45,6 +45,8 @@ Preferred command shape:
 /fusion --panel <entries> <prompt>
 /fusion status
 /fusion stop
+/fusion continue <fusion-run-id> <panelist-number>
+/fusion finish <fusion-run-id> <panelist-number>
 /fusion init
 ```
 
@@ -152,10 +154,11 @@ Profile:
 
 - `panel`: one or more panel members
 - `judge`: judge agent config
-- `concurrency`: max parallel panelists. When `stopWhenPanelAgrees` is on, Fusion initially executes only the resolved synthesis quorum (capped by `concurrency`) before launching another batch, so a non-default quorum—not always the first two—governs early agreement.
+- `concurrency`: max parallel panelists. Ordinary panels immediately start the next queued member when a slot finishes or fails, while retaining configured result order. When `stopWhenPanelAgrees` is on, Fusion initially executes only the resolved synthesis quorum (capped by `concurrency`) before launching another batch, so a non-default quorum—not always the first two—governs early agreement.
 - `timeoutMs`: legacy shared wall-clock timeout in milliseconds. It is a fallback only; `/fusion status` warns when it supplied an effective deadline.
+- `panelistSoftTimeoutMs`: optional soft deadline, measured from each child's actual start, not its queue time. Requires `pi-subagents` RPC advertising `nonRecoveringSteer`. It must leave more than one minute before the effective hard child deadline, and the panel budget must cover every concurrency wave plus grace.
 - `panelistTimeoutMs`: per-panelist deadline. Fusion caps it below the enclosing panel deadline.
-- `panelTimeoutMs`: panel workflow wall-clock deadline.
+- `panelTimeoutMs`: panel workflow wall-clock deadline. When neither it nor legacy `timeoutMs` is set, the default is 15 minutes multiplied by `ceil(panel size / concurrency)`. An explicit short deadline can still cut queued work off; soft-deadline profiles reject insufficient wave budgets.
 - `panelGraceMs`: reserved time between a child deadline and the enclosing panel deadline (default 5 seconds).
 - `judgeTimeoutMs`: synthesis workflow deadline. For every deadline the precedence is per-run CLI/tool/RPC override, stage profile field, legacy `timeoutMs`, then the built-in default.
 - `minimumSuccessfulPanelists`: `"majority"` (default), `"all"`, or a positive number. It is the panel quorum for synthesis. For a multi-member panel, numeric `1` is effectively `2`: synthesis needs two candidate answers. A one-member panel remains a direct single-panel result.
@@ -168,6 +171,44 @@ Profile:
 
 Timeouts are hard workflow deadlines. A child terminated at the deadline can report exit 143. Fusion durably keeps verified completed slots, turns terminal running/interrupted slots into typed failures, and fails closed when lifecycle sources genuinely disagree. A timed-out judge never becomes a panel-only success. When at least one valid panel result exists, Fusion produces either synthesis at quorum or an explicitly unsynthesized partial report below quorum; failures and timeouts are disclosed as missing coverage. Only zero successful outputs fail outright. Fusion never automatically retries a failed panelist, restarts a panel, or extends a deadline.
 
+### Soft deadline decisions
+
+For a six-member panel with concurrency four, a bounded review budget can be:
+
+```json
+{
+  "panelistSoftTimeoutMs": 600000,
+  "panelistTimeoutMs": 960000,
+  "panelTimeoutMs": 2100000,
+  "panelGraceMs": 30000,
+  "judgeTimeoutMs": 600000
+}
+```
+
+After ten minutes of actual child runtime, Fusion asks the parent agent to decide
+and requests a progress update from that panelist. The parent may ask the user,
+then call `resolve_fusion_deadline` with the Fusion `runId`, one-based `panelist`
+number, and `decision: "continue"` or `"finish"`. Users can use the corresponding
+`/fusion continue` or `/fusion finish` command. The judge is not involved.
+
+A decision is accepted only for the same live child in a pending request. No
+reply within one minute requests finalization. A continuation uses the already
+reserved budget: in this example, investigation ends at minute 15 and the hard
+stop remains minute 16. There is no second extension. Decisions survive reload;
+expired requests and completed/replaced children cannot receive a new grant.
+
+Guidance is sent through non-recovering `steer` RPC. Receipts are not proof of
+model compliance. Missing routes are visible in `/fusion status`; Fusion does
+not revive a child, reset a timer, or retry inference. A blocked provider or tool
+may not produce a final answer before the hard stop. Verified completed answers
+remain available for partial reporting.
+
+At a terminal workflow deadline, incomplete lifecycle snapshots get up to five
+seconds to settle. A late child error keeps its actual cause. After that window,
+slots still absent with unambiguous identities become deadline failures. Duplicate
+or conflicting identities still fail closed. Incomplete *successful* workflows
+are not silently repaired into successes.
+
 Panel member:
 
 - `id`: stable machine name

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexeiled/pi-fusion",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Stronger answers for hard Pi questions via a parallel model panel + judge, built on pi-subagents",
   "type": "module",
   "main": "./src/index.ts",

package/src/commands.ts

@@ -19,6 +19,8 @@ const FUSION_HELP = [
   "/fusion --panel <models> <prompt>",
   "/fusion status",
   "/fusion stop",
+  "/fusion continue <fusion-run-id> <panelist-number>",
+  "/fusion finish <fusion-run-id> <panelist-number>",
   "/fusion init",
 ].join("\n");
 
@@ -29,6 +31,7 @@ export interface FusionRuntimeCommandHandler {
   ): Promise<unknown>;
   showStatus(ctx: ExtensionCommandContext): Promise<unknown>;
   cancelActiveRun(ctx: ExtensionCommandContext): Promise<unknown>;
+  resolvePanelDeadline?(runId: string, panelist: number, decision: "continue" | "finish"): Promise<unknown>;
 }
 
 export function registerFusionCommands(
@@ -43,6 +46,20 @@ export function registerFusionCommands(
         return;
       }
 
+      const decision = args.trim().match(/^(continue|finish)\s+(\S+)\s+([1-9]\d*)$/);
+      if (decision && handler.resolvePanelDeadline) {
+        try {
+          await handler.resolvePanelDeadline(decision[2]!, Number(decision[3]), decision[1] === "continue" ? "continue" : "finish");
+          ctx.ui.notify("Deadline decision recorded; guidance requested. Hard deadline unchanged.", "info");
+        } catch (error: unknown) {
+          ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+        }
+        return;
+      }
+      if (/^(continue|finish)(?:\s|$)/.test(args.trim())) {
+        ctx.ui.notify("Use /fusion continue|finish <fusion-run-id> <panelist-number>.", "error");
+        return;
+      }
       const inlineCommand = parseFusionInlineCommand(args);
       if (inlineCommand === "init") {
         await runFusionInit(ctx);

package/src/config.ts

@@ -325,6 +325,7 @@ function isFusionProfile(value: unknown): value is FusionProfile {
     return false;
   if (value.timeoutMs !== undefined && !isPositiveInteger(value.timeoutMs))
     return false;
+  if (value.panelistSoftTimeoutMs !== undefined && !isPositiveInteger(value.panelistSoftTimeoutMs)) return false;
   if (
     value.panelistTimeoutMs !== undefined &&
     !isPositiveInteger(value.panelistTimeoutMs)

package/src/index.ts

@@ -69,7 +69,7 @@ function registerFusionTool(
       );
       const text =
         result.status === "started"
-          ? "Fusion panel review started. The report will be posted when the panel and judge finish."
+          ? "Fusion panel review started. The report will be posted when the panel finishes; synthesis may be skipped below quorum."
           : result.status === "conflict"
             ? `A fusion run is already active (${result.activeRunId}). Do not start another; wait for its report.`
             : `Fusion review failed to start: ${result.status === "failed" ? result.error : result.status}`;
@@ -98,11 +98,26 @@ export default function fusionExtension(pi: ExtensionAPI): void {
   const orchestrator = new FusionOrchestrator({
     rpc: new SubagentsRpcClient({ events: pi.events }),
     runStore: store,
-    sendMessage: (message) => pi.sendMessage(message),
+    sendMessage: (message, options) => pi.sendMessage(message, options),
   });
 
   registerFusionCommands(pi, orchestrator);
   registerFusionTool(pi, orchestrator);
+  pi.registerTool({
+    name: "resolve_fusion_deadline",
+    label: "Fusion Deadline Decision",
+    description: "Answer a pending Fusion soft-deadline request. Continue once within the existing hard budget, or ask the panelist to finish with current findings. Does not restart runs or extend hard deadlines. Delivery receipt is not proof the model complied.",
+    parameters: Type.Object({
+      runId: Type.String({ minLength: 1 }),
+      panelist: Type.Integer({ minimum: 1, description: "One-based panelist number from the deadline notice" }),
+      decision: Type.String({ enum: ["continue", "finish"] }),
+    }),
+    async execute(_id, params) {
+      if (params.decision !== "continue" && params.decision !== "finish") throw new Error("Expected continue or finish.");
+      const details = await orchestrator.resolvePanelDeadline(params.runId, params.panelist, params.decision);
+      return { content: [{ type: "text", text: "Decision recorded and guidance requested. The hard deadline is unchanged; the receipt does not prove model compliance." }], details };
+    },
+  });
 
   const unsubscribeComplete = pi.events.on(
     SUBAGENT_ASYNC_COMPLETE_EVENT,

package/src/lifecycle-reconcile.ts

@@ -43,6 +43,8 @@ export interface ReconcilePanelResultsOptions {
   stoppedPanelIndices?: readonly number[];
   /** A workflow deadline terminalized running child slots as timeout failures. */
   terminalizeRunning?: boolean;
+  /** Only after the terminal-snapshot grace period, and only at a deadline. */
+  allowMissingAtDeadline?: boolean;
 }
 
 /**
@@ -82,6 +84,7 @@ export function reconcilePanelResults(
       return error(
         `Terminal subagents data described ${eventResults.outputs.length + eventResults.failures.length} of ${expectedCount} configured panel members.`,
         "$.results",
+        "incomplete-lifecycle",
       );
     }
     return eventResults;
@@ -100,6 +103,7 @@ export function reconcilePanelResults(
       ? { terminalizeRunning: true }
       : { completedOnly: true }),
     limit: expectedCount,
+    ...(options.allowMissingAtDeadline ? { requireStableSlotIdentity: true } : {}),
     ...(options.stoppedPanelIndices
       ? { stoppedPanelIndices: options.stoppedPanelIndices }
       : {}),
@@ -160,9 +164,34 @@ export function reconcilePanelResults(
     missingStatusIndices.length > 0 &&
     missingStatusIndices.every((index) => stopped.has(index));
   if (!missingWereStopped) {
+    if (options.terminalizeRunning && options.allowMissingAtDeadline) {
+      const reconciled = mergeTerminalDeadlineResults(
+        eventResults, statusResults, statusPayload, resultPayload,
+      );
+      for (const index of missingStatusIndices) {
+        const output = eventResults.outputs.find((item) => item.index === index);
+        const failure = eventResults.failures.find((item) => item.index === index);
+        if (output) reconciled.outputs.push(output);
+        else if (failure) reconciled.failures.push(failure);
+        else {
+          const member = profile.panel[index]!;
+          reconciled.failures.push({
+            index, agent: member.agent, id: member.id,
+            ...(member.label ? { label: member.label } : {}),
+            ...(member.model ? { configuredModel: member.model } : {}),
+            summary: "No terminal result was reported before the workflow deadline.",
+            reason: "timeout",
+          });
+        }
+      }
+      reconciled.outputs.sort((a, b) => a.index - b.index);
+      reconciled.failures.sort((a, b) => a.index - b.index);
+      return reconciled;
+    }
     return error(
       `Terminal subagents status described ${statusCount} of ${expectedCount} configured panel members.`,
       "$.steps",
+      statusCount === 0 && !options.terminalizeRunning ? "unknown-result-shape" : "incomplete-lifecycle",
     );
   }
 
@@ -433,11 +462,12 @@ function unknownArray(value: unknown): readonly unknown[] | undefined {
 function error(
   message: string,
   path: string,
+  code: "unknown-result-shape" | "incomplete-lifecycle" = "unknown-result-shape",
 ): ExtractPanelResultsResult {
   return {
     ok: false,
     error: {
-      code: "unknown-result-shape",
+      code,
       message,
       path,
     },

package/src/orchestrator.ts

@@ -1,3 +1,4 @@
+import { deadlineSteerMessage, planPanelDeadlines, PANEL_DECISION_WAIT_MS } from "./panel-deadlines.js";
 import { applyClaudeAliasShorthand } from "./claude-aliases.js";
 import {
   detectCallerOutputContract,
@@ -23,10 +24,12 @@ import {
 import {
   extractPanelResults,
   type ExtractPanelResultsSuccess,
+  type ExtractPanelResultsResult,
 } from "./result-extract.js";
 import {
   reconcileIndexedLifecycleResult,
   reconcilePanelResults,
+  type ReconcilePanelResultsOptions,
 } from "./lifecycle-reconcile.js";
 import {
   appendThinkingSuffix,
@@ -59,6 +62,7 @@ import {
   type FusionProfileSnapshot,
   type FusionRun,
   type PanelOutput,
+  type PanelDeadlineState,
   type ParsedFusionArgs,
 } from "./types.js";
 import {
@@ -66,7 +70,7 @@ import {
   hasStrongPanelAgreement,
   mergeRunObservations,
 } from "./run-observations.js";
-import type { SubagentsTargetParams } from "./subagents-rpc.js";
+import type { SubagentsTargetParams, SubagentsSteerParams } from "./subagents-rpc.js";
 
 export const SUBAGENT_ASYNC_COMPLETE_EVENT = "subagent:async-complete";
 
@@ -95,6 +99,7 @@ export interface FusionRpcClientLike {
   status(params?: SubagentsTargetParams): Promise<unknown>;
   stop(params: SubagentsTargetParams): Promise<unknown>;
   interrupt(params: SubagentsTargetParams): Promise<unknown>;
+  steer?(params: SubagentsSteerParams): Promise<unknown>;
 }
 
 export interface FusionMessageSink {
@@ -103,7 +108,7 @@ export interface FusionMessageSink {
     content: string;
     display: boolean;
     details?: unknown;
-  }): void;
+  }, options?: { triggerTurn: boolean; deliverAs: "steer" }): void;
 }
 
 export interface FusionOrchestratorDeps {
@@ -144,6 +149,7 @@ export class FusionOrchestrator {
   private reconcileTimer: NodeJS.Timeout | undefined;
   private reconciling = false;
   private pendingCompletionPayload: unknown;
+  private readonly incompleteTerminalSince = new Map<string, number>();
 
   constructor(deps: FusionOrchestratorDeps) {
     this.rpc = deps.rpc;
@@ -172,8 +178,9 @@ export class FusionOrchestrator {
       return { status: "conflict", activeRunId: existing.id };
     }
 
+    let subagentsInfo: unknown;
     try {
-      await this.rpc.ping();
+      subagentsInfo = await this.rpc.ping();
       this.installWarning = undefined;
     } catch (error: unknown) {
       const message = `pi-subagents RPC is unavailable: ${errorMessage(error)}`;
@@ -207,6 +214,11 @@ export class FusionOrchestrator {
         );
         resolved = this.resolveProfile(aliased, inlineName);
       }
+      if (resolved.profile.panelistSoftTimeoutMs !== undefined &&
+        (!this.rpc.steer || !isRecord(subagentsInfo) || !isRecord(subagentsInfo.capabilities) ||
+          subagentsInfo.capabilities.nonRecoveringSteer !== true)) {
+        throw new FusionArgsError("Soft deadlines require pi-subagents RPC with nonRecoveringSteer. Update pi-subagents and reload Pi, or omit panelistSoftTimeoutMs.");
+      }
       this.configWarning = undefined;
     } catch (error: unknown) {
       const message = errorMessage(error);
@@ -608,6 +620,109 @@ export class FusionOrchestrator {
     return this.runStore.getActiveRun();
   }
 
+  async resolvePanelDeadline(
+    runId: string,
+    panelist: number,
+    decision: "continue" | "finish",
+  ): Promise<{ decision: string; receipt: unknown }> {
+    const active = this.runStore.getActiveRun();
+    if (!active || active.id !== runId || active.phase !== "panel" || !active.panelRunId) {
+      throw new FusionArgsError("The requested Fusion panel is no longer active.");
+    }
+    if (!Number.isInteger(panelist) || panelist < 1 || (decision !== "continue" && decision !== "finish")) {
+      throw new FusionArgsError("Expected a one-based panelist number and continue or finish.");
+    }
+    const state = active.panelDeadlines?.find((item) => item.index === panelist - 1);
+    if (!state || state.status !== "pending") throw new FusionArgsError("No pending deadline decision for that panelist.");
+    const payload = await this.rpc.status({ id: active.panelRunId });
+    const matches = findStepsArray(payload).filter((step) => isRecord(step) &&
+      step.runId === state.childRunId && (step.status ?? step.state) === "running" &&
+      (step.workflowKey ?? step.key ?? step.agent) === `panel-${panelist}`);
+    const latest = this.runStore.getActiveRun();
+    if (latest?.id !== runId || latest.phase !== "panel" ||
+      latest.panelDeadlines?.find((item) => item.index === state.index)?.status !== "pending" ||
+      isTerminalSubagentState(extractSubagentState(payload)) || matches.length !== 1 ||
+      Date.now() >= Math.min(state.requestedAt + PANEL_DECISION_WAIT_MS, state.finalizeAt)) {
+      throw new FusionArgsError("Deadline decision expired or the panelist is no longer running.");
+    }
+    const updated: PanelDeadlineState = { ...state, status: decision === "continue" ? "continued" : "finishing" };
+    this.savePanelDeadline(runId, updated);
+    const receipt = await this.steerPanelDeadline(runId, updated);
+    return { decision, receipt };
+  }
+
+  private savePanelDeadline(runId: string, state: PanelDeadlineState): void {
+    const active = this.runStore.getActiveRun();
+    if (active?.id !== runId || active.phase !== "panel") return;
+    this.runStore.updateRun(runId, {
+      panelDeadlines: [...(active.panelDeadlines ?? []).filter((item) => item.index !== state.index), state],
+    });
+  }
+
+  private async steerPanelDeadline(runId: string, state: PanelDeadlineState): Promise<unknown> {
+    try {
+      if (!this.rpc.steer) throw new Error("pi-subagents steer RPC is unavailable.");
+      return await this.rpc.steer({ id: state.childRunId, message: deadlineSteerMessage(state), mode: "auto" });
+    } catch (error: unknown) {
+      const message = `Could not send deadline guidance to panel-${state.index + 1}: ${errorMessage(error)}`;
+      const latest = this.runStore.getActiveRun();
+      if (latest?.id === runId && latest.panelDeadlines?.find((item) => item.index === state.index)?.status === state.status) {
+        this.savePanelDeadline(runId, { ...state, deliveryError: message });
+      }
+      this.notify(this.context, message, "warning");
+      throw new Error(message, { cause: error });
+    }
+  }
+
+  private async handlePanelDeadlines(active: FusionRun, statusPayload: unknown): Promise<void> {
+    const actions = planPanelDeadlines(this.runStore.getActiveRun() ?? active, findStepsArray(statusPayload), Date.now());
+    for (const action of actions) {
+      if (this.runStore.getActiveRun()?.id !== active.id) return;
+      this.savePanelDeadline(active.id, action.state);
+      if (action.kind === "ask") {
+        const panelist = action.state.index + 1;
+        const member = active.profileSnapshot?.panel[action.state.index];
+        const step = findStepsArray(statusPayload).find((item) => isRecord(item) && item.runId === action.state.childRunId);
+        const content = [
+          `Fusion soft deadline: ${member ? memberLabel(member) : `panel-${panelist}`}.`,
+          `Fusion run: ${active.id}. Child run: ${action.state.childRunId}.`,
+          `Last observed activity (not verified findings): ${describeStepActivity(step)?.slice(0,500) ?? "unknown"}.`,
+          `Call resolve_fusion_deadline with runId=${active.id}, panelist=${panelist}, decision=continue or finish. Ask the user if the extra work needs their decision.`,
+          `Without a decision within ${PANEL_DECISION_WAIT_MS / 1000}s, the panelist will be asked to return its current answer. One continuation is allowed, only within the existing hard deadline.`,
+          `User command: /fusion continue ${active.id} ${panelist} or /fusion finish ${active.id} ${panelist}.`,
+        ].join("\n");
+        this.sendMessage?.({ customType: "fusion-deadline", content, display: true }, { triggerTurn: true, deliverAs: "steer" });
+      }
+      try {
+        await this.steerPanelDeadline(active.id, action.state);
+      } catch {
+        // The recorded delivery error is visible; never revive a child or reset its budget.
+      }
+    }
+  }
+
+  private reconcileTerminalPanel(
+    active: FusionRun,
+    extracted: ExtractPanelResultsSuccess,
+    statusPayload: unknown,
+    profile: FusionProfile,
+    lifecyclePayload: unknown,
+    options: ReconcilePanelResultsOptions,
+  ): ExtractPanelResultsResult | undefined {
+    const since = this.incompleteTerminalSince.get(active.id);
+    const graceExpired = since !== undefined && Date.now() - since >= WORKFLOW_RESULT_ARTIFACT_GRACE_MS;
+    const result = reconcilePanelResults(extracted, statusPayload, profile, lifecyclePayload, {
+      ...options,
+      ...(graceExpired && options.terminalizeRunning ? { allowMissingAtDeadline: true } : {}),
+    });
+    if (!result.ok && result.error.code === "incomplete-lifecycle" && !graceExpired) {
+      if (since === undefined) this.incompleteTerminalSince.set(active.id, Date.now());
+      return undefined;
+    }
+    this.incompleteTerminalSince.delete(active.id);
+    return result;
+  }
+
   private async reconcileActiveRun(
     eventPayload?: unknown,
   ): Promise<FusionCommandResult> {
@@ -623,13 +738,13 @@ export class FusionOrchestrator {
     this.reconciling = true;
     try {
       if (active.phase === "panel") {
-        return this.handleLegacyPanelComplete(active, eventPayload);
+        return await this.handleLegacyPanelComplete(active, eventPayload);
       }
       if (active.phase === "chain") {
-        return this.handleChainComplete(active, eventPayload);
+        return await this.handleChainComplete(active, eventPayload);
       }
       if (active.phase === "judge") {
-        return this.handleJudgeComplete(active, eventPayload);
+        return await this.handleJudgeComplete(active, eventPayload);
       }
       return { status: "ignored" };
     } finally {
@@ -694,7 +809,8 @@ export class FusionOrchestrator {
       );
     }
 
-    const observedPanels = reconcilePanelResults(
+    const observedPanels = this.reconcileTerminalPanel(
+      active,
       extracted,
       snapshot.statusPayload,
       profile,
@@ -707,6 +823,7 @@ export class FusionOrchestrator {
           : {}),
       },
     );
+    if (!observedPanels) return { status: "ignored" };
     if (!observedPanels.ok) {
       return this.failActiveRun(
         `${observedPanels.error.message} (${observedPanels.error.path})`,
@@ -827,6 +944,7 @@ export class FusionOrchestrator {
     const panelIsTerminal =
       snapshot.resultIsTerminal ||
       isTerminalSubagentState(extractSubagentState(snapshot.statusPayload));
+    if (!panelIsTerminal) await this.handlePanelDeadlines(active, snapshot.statusPayload);
     if (!active.panelStopReason && !panelIsTerminal) {
       if (
         partial &&
@@ -886,7 +1004,8 @@ export class FusionOrchestrator {
       );
     }
 
-    const observedPanels = reconcilePanelResults(
+    const observedPanels = this.reconcileTerminalPanel(
+      active,
       extracted,
       snapshot.statusPayload,
       profile,
@@ -899,6 +1018,7 @@ export class FusionOrchestrator {
           : {}),
       },
     );
+    if (!observedPanels) return { status: "ignored" };
     if (!observedPanels.ok) {
       return this.failActiveRun(
         `${observedPanels.error.message} (${observedPanels.error.path})`,
@@ -1381,6 +1501,7 @@ export class FusionOrchestrator {
   }
 
   private clearActiveRuntime(): void {
+    this.incompleteTerminalSince.clear();
     this.activeProfile = undefined;
     this.stopReconcileLoop();
   }
@@ -1654,6 +1775,9 @@ function formatFusionStatusReport(input: {
     lines.push(`Profile: ${input.active.profileName}`);
     lines.push(`Phase: ${input.details?.phaseLabel ?? input.active.phase}`);
     appendEffectiveTimeouts(lines, input.active);
+    for (const deadline of input.active.panelDeadlines ?? []) {
+      lines.push(`Panel-${deadline.index + 1} deadline: ${deadline.status}${deadline.deliveryError ? ` (${deadline.deliveryError})` : ""}`);
+    }
     if (input.active.chainRunId)
       lines.push(`Chain run: ${input.active.chainRunId}`);
     else if (input.active.panelRunId)
@@ -1706,6 +1830,9 @@ function appendEffectiveTimeouts(
   lines.push(
     `Deadlines: panelist ${timeouts.panelistTimeoutMs}ms, panel ${timeouts.panelTimeoutMs}ms (+${timeouts.panelGraceMs}ms grace), judge ${timeouts.judgeTimeoutMs}ms`,
   );
+  if (timeouts.panelistSoftTimeoutMs !== undefined) {
+    lines.push(`Soft deadline: ${timeouts.panelistSoftTimeoutMs}ms per child; decision wait ${PANEL_DECISION_WAIT_MS}ms; hard deadlines are unchanged.`);
+  }
   if (timeouts.usesLegacyTimeout) {
     lines.push("Warning: legacy timeoutMs supplied one or more effective deadlines.");
   }
@@ -2139,7 +2266,7 @@ function withWorkflowDeadlineFailures(
     ...failure,
     summary: failure.summary.includes(deadlineError)
       ? failure.summary
-      : `${deadlineError}\n${failure.summary}`,
+      : `${deadlineError} ${failure.summary}`,
     reason: failure.reason ?? "timeout",
   }));
 }

package/src/panel-deadlines.ts

@@ -0,0 +1,90 @@
+import type { FusionRun, PanelDeadlineState } from "./types.js";
+import { isRecord } from "./utils.js";
+
+export const PANEL_FINALIZE_RESERVE_MS = 60_000;
+export const PANEL_DECISION_WAIT_MS = 60_000;
+
+export interface PanelDeadlineAction {
+  state: PanelDeadlineState;
+  kind: "ask" | "finish";
+}
+
+/** Plan controls only for unambiguous, live children of the current panel. */
+export function planPanelDeadlines(
+  run: FusionRun,
+  steps: readonly unknown[],
+  now: number,
+): PanelDeadlineAction[] {
+  const timeouts = run.effectiveTimeouts;
+  if (!timeouts?.panelistSoftTimeoutMs || !run.profileSnapshot) return [];
+  const candidates = steps.flatMap((step) => {
+    if (!isRecord(step) || (step.status ?? step.state) !== "running") return [];
+    const key = step.workflowKey ?? step.key ?? step.agent;
+    const match =
+      typeof key === "string" ? key.match(/^panel-([1-9]\d*)$/) : undefined;
+    const index = match ? Number(match[1]) - 1 : undefined;
+    if (
+      index === undefined ||
+      index >= run.profileSnapshot!.panel.length ||
+      typeof step.runId !== "string" ||
+      !step.runId.trim() ||
+      typeof step.startedAt !== "number" ||
+      !Number.isFinite(step.startedAt)
+    )
+      return [];
+    return [{ index, childRunId: step.runId, startedAt: step.startedAt }];
+  });
+  const actions: PanelDeadlineAction[] = [];
+  for (const child of candidates) {
+    if (
+      candidates.filter(
+        (item) =>
+          item.index === child.index || item.childRunId === child.childRunId,
+      ).length !== 1
+    )
+      continue;
+    const previous = run.panelDeadlines?.find(
+      (item) => item.index === child.index,
+    );
+    // A different run ID in the same slot is not authority to control it.
+    if (previous && previous.childRunId !== child.childRunId) continue;
+    const hardDeadlineAt = child.startedAt + timeouts.panelistTimeoutMs;
+    if (now >= hardDeadlineAt || previous?.status === "finishing") continue;
+    const finalizeAt = hardDeadlineAt - PANEL_FINALIZE_RESERVE_MS;
+    if (previous) {
+      const finishAt =
+        previous.status === "pending"
+          ? Math.min(previous.requestedAt + PANEL_DECISION_WAIT_MS, finalizeAt)
+          : finalizeAt;
+      if (now >= finishAt)
+        actions.push({
+          kind: "finish",
+          state: { ...previous, status: "finishing" },
+        });
+    } else if (now >= child.startedAt + timeouts.panelistSoftTimeoutMs) {
+      const finishing = now >= finalizeAt;
+      actions.push({
+        kind: finishing ? "finish" : "ask",
+        state: {
+          index: child.index,
+          childRunId: child.childRunId,
+          requestedAt: now,
+          finalizeAt,
+          hardDeadlineAt,
+          status: finishing ? "finishing" : "pending",
+        },
+      });
+    }
+  }
+  return actions;
+}
+
+export function deadlineSteerMessage(state: PanelDeadlineState): string {
+  if (state.status === "finishing") {
+    return "Fusion time budget: stop new investigation and return your best current answer now in the original output contract. State unfinished checks and uncertainty. Do not restart or wait for another decision. The hard deadline is unchanged.";
+  }
+  if (state.status === "continued") {
+    return `Fusion continuation approved within the existing budget. Finish investigation by ${new Date(state.finalizeAt).toISOString()} and return the answer. The hard deadline is unchanged; there will be no further extension.`;
+  }
+  return "Fusion soft deadline reached. At the next safe point, send a short progress_update through contact_supervisor if available: findings so far, unfinished checks, and time needed. Do not block waiting in a supervisor tool. Finish the current check while the parent decides whether to continue; do not expand scope. If no decision arrives, Fusion will ask you to finalize shortly. Keep the original final-output contract.";
+}

package/src/result-extract.ts

@@ -10,7 +10,7 @@ import {
 import type { PanelMemberConfig } from "./types.js";
 
 export type ResultExtractErrorCode =
-  "missing-results" | "unknown-result-shape" | "missing-result-field";
+  "missing-results" | "unknown-result-shape" | "missing-result-field" | "incomplete-lifecycle";
 
 export interface ResultExtractError {
   code: ResultExtractErrorCode;

package/src/run-builder.ts

@@ -3,6 +3,7 @@ import {
   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,
@@ -193,6 +194,7 @@ export function buildPanelSpawnParams(
         profile.panelToolBudget ?? DEFAULT_TOOL_BUDGET,
         callerContract,
         timeouts.panelistTimeoutMs,
+        timeouts.panelistSoftTimeoutMs !== undefined,
       ),
     }),
   );
@@ -256,6 +258,29 @@ function buildPanelWorkflowScript(
   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.
@@ -312,9 +337,12 @@ 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,
@@ -337,7 +365,18 @@ export function resolveEffectiveTimeouts(
     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,
@@ -363,6 +402,7 @@ function buildPanelTaskParams(
   toolBudget: ToolBudget,
   callerContract?: CallerOutputContract,
   timeoutMs?: number,
+  allowSupervisor = false,
 ): PanelSubagentTaskParams {
   const model = appendThinkingSuffix(member.model, member.thinking);
   return {
@@ -372,6 +412,7 @@ function buildPanelTaskParams(
       prompt,
       includeDecisionRecord,
       callerContract,
+      allowSupervisor,
     ),
     output: true,
     outputMode: "inline",
@@ -389,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 =
@@ -402,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",

package/src/run-store.ts

@@ -66,6 +66,7 @@ export interface FusionRunPatch {
   panelAsyncDir?: string;
   panelStopReason?: FusionRun["panelStopReason"];
   panelStoppedIndices?: FusionRun["panelStoppedIndices"];
+  panelDeadlines?: FusionRun["panelDeadlines"];
   judgeRunId?: string;
   judgeAsyncDir?: string;
   judgeObservation?: FusionRun["judgeObservation"];
@@ -387,6 +388,7 @@ function applyPatch(
   if (patch.panelStoppedIndices !== undefined) {
     updated.panelStoppedIndices = [...patch.panelStoppedIndices];
   }
+  if (patch.panelDeadlines !== undefined) updated.panelDeadlines = patch.panelDeadlines.map((item) => ({ ...item }));
   if (patch.judgeRunId !== undefined) updated.judgeRunId = patch.judgeRunId;
   if (patch.judgeAsyncDir !== undefined) {
     updated.judgeAsyncDir = patch.judgeAsyncDir;
@@ -514,6 +516,9 @@ function cloneRun(run: FusionRun): FusionRun {
     ...(run.panelStoppedIndices !== undefined
       ? { panelStoppedIndices: [...run.panelStoppedIndices] }
       : {}),
+    ...(run.panelDeadlines !== undefined
+      ? { panelDeadlines: run.panelDeadlines.map((item) => ({ ...item })) }
+      : {}),
     ...(run.judgeRunId !== undefined ? { judgeRunId: run.judgeRunId } : {}),
     ...(run.judgeAsyncDir !== undefined
       ? { judgeAsyncDir: run.judgeAsyncDir }
@@ -669,6 +674,7 @@ function isFusionRunState(value: unknown): value is FusionRun {
   ) {
     return false;
   }
+  if (value.panelDeadlines !== undefined && !isPanelDeadlines(value.panelDeadlines)) return false;
   if (value.judgeRunId !== undefined && typeof value.judgeRunId !== "string") {
     return false;
   }
@@ -719,9 +725,27 @@ function isFusionRunSummary(value: unknown): value is FusionRunSummary {
   return isFusionRunState(value) && isTerminalPhase(value.phase);
 }
 
+function isPanelDeadlines(value: unknown): boolean {
+  if (!Array.isArray(value)) return false;
+  const slots = new Set<number>();
+  const children = new Set<string>();
+  return value.every((item: unknown) => {
+    if (!isRecord(item) || !isPanelSlotIndex(item.index) || !isNonEmptyString(item.childRunId) ||
+      !isFiniteNumber(item.requestedAt) || !isFiniteNumber(item.finalizeAt) || !isFiniteNumber(item.hardDeadlineAt) ||
+      item.finalizeAt >= item.hardDeadlineAt ||
+      !["pending", "continued", "finishing"].includes(String(item.status)) ||
+      (item.deliveryError !== undefined && typeof item.deliveryError !== "string") ||
+      slots.has(item.index) || children.has(item.childRunId)) return false;
+    slots.add(item.index);
+    children.add(item.childRunId);
+    return true;
+  });
+}
+
 function isTimeoutOverrides(value: unknown): boolean {
   if (!isRecord(value)) return false;
   return [
+    value.panelistSoftTimeoutMs,
     value.panelistTimeoutMs,
     value.panelTimeoutMs,
     value.panelGraceMs,
@@ -764,7 +788,7 @@ function isTerminalPhase(value: unknown): value is FusionTerminalPhase {
 export function validateFusionRunPanelSlots(
   run: Pick<
     FusionRun,
-    "panelOutputs" | "panelFailures" | "panelStoppedIndices" | "recovery"
+    "panelOutputs" | "panelFailures" | "panelStoppedIndices" | "panelDeadlines" | "recovery"
   >,
   panelLength: number,
 ): string | undefined {
@@ -772,6 +796,7 @@ export function validateFusionRunPanelSlots(
     run.panelOutputs?.map((output) => output.index),
     run.panelFailures?.map((failure) => failure.index),
     run.panelStoppedIndices,
+    run.panelDeadlines?.map((item) => item.index),
     run.recovery?.failedPanelIndices,
   ];
   for (const slots of slotGroups) {

package/src/subagents-rpc.ts

@@ -11,6 +11,7 @@ export const SUBAGENTS_RPC_METHODS = [
   "status",
   "stop",
   "interrupt",
+  "steer",
 ] as const;
 
 export type SubagentsRpcMethod = (typeof SUBAGENTS_RPC_METHODS)[number];
@@ -42,6 +43,11 @@ export interface SubagentsTargetParams {
   index?: number;
 }
 
+export interface SubagentsSteerParams extends SubagentsTargetParams {
+  message: string;
+  mode: "auto";
+}
+
 export type SubagentsSpawnParams = object;
 
 export interface SubagentsRpcRequestEnvelope {
@@ -145,6 +151,10 @@ export class SubagentsRpcClient {
     this.source = options.source ?? { extension: "pi-fusion" };
   }
 
+  steer(params: SubagentsSteerParams): Promise<unknown> {
+    return this.request("steer", params);
+  }
+
   request<T = unknown>(
     method: SubagentsRpcMethod,
     params?: unknown,

package/src/types.ts

@@ -56,6 +56,7 @@ export interface FusionTimeoutOverrides {
 }
 
 export interface EffectiveFusionTimeouts {
+  panelistSoftTimeoutMs?: number;
   panelistTimeoutMs: number;
   panelTimeoutMs: number;
   panelGraceMs: number;
@@ -70,6 +71,8 @@ export interface FusionProfile {
   concurrency?: number;
   /** Legacy shared wall-clock timeout used when a stage timeout is absent. */
   timeoutMs?: number;
+  /** Opt-in parent decision before the hard child deadline; reserves one minute to finalize. */
+  panelistSoftTimeoutMs?: number;
   /** Per-child deadline. It is capped below the enclosing panel deadline. */
   panelistTimeoutMs?: number;
   /** Wall-clock timeout for the complete panel workflow. */
@@ -273,6 +276,16 @@ export interface FusionSpawnIntent {
   requestedAt: number;
 }
 
+export interface PanelDeadlineState {
+  index: number;
+  childRunId: string;
+  requestedAt: number;
+  finalizeAt: number;
+  hardDeadlineAt: number;
+  status: "pending" | "continued" | "finishing";
+  deliveryError?: string;
+}
+
 export interface FusionRun {
   id: string;
   prompt: string;
@@ -306,6 +319,7 @@ export interface FusionRun {
   panelAsyncDir?: string;
   panelStopReason?: "agreement";
   panelStoppedIndices?: number[];
+  panelDeadlines?: PanelDeadlineState[];
   judgeRunId?: string;
   judgeAsyncDir?: string;
   judgeObservation?: RunObservation;