@alexeiled/pi-fusion 0.7.0 → 0.8.0

package/README.md

@@ -156,7 +156,7 @@ Other Pi extensions can control Fusion through the versioned event-bus contract
 Methods:
 
 - `ping` — return the RPC version and supported methods
-- `start` — requires `prompt` and a non-empty `operationId`. It accepts optional `profile` and versioned `outputContract` (`plan-review-v1`). Reusing an operation ID returns the original run instead of starting another, including after Fusion restores the Pi session history.
+- `start` — requires `prompt` and a non-empty `operationId`. It accepts optional `profile`, versioned `outputContract` (`plan-review-v1`), and positive-integer millisecond deadline overrides: `panelistTimeoutMs`, `panelTimeoutMs`, `panelGraceMs`, and `judgeTimeoutMs`. Reusing an operation ID returns the original run instead of starting another, including after Fusion restores the Pi session history.
 - `status` — return structured run state by `operationId`, `runId`, or the current/last run
 - `result` — return a terminal run and report. An active run returns `not_ready`
 - `cancel` — cancel the selected active run, or report that the selected terminal run was not cancelled
@@ -207,12 +207,13 @@ For commands, config, and troubleshooting details, see [`docs/user-guide.md`](./
 - Config is optional. Defaults work. Use `/fusion init` when you want project config.
 - 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.
+- 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.
 - `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.
 - `Model` is lifecycle metadata. `Configured model` is the profile request. Both appear when the run differs from the request.
-- `stopWhenPanelAgrees` is an opt-in profile setting. It requires matching high-confidence decision records with no request for more evidence, evaluates panelists in pairs so it can avoid starting later work, records skipped panelists in the report, and still runs the judge.
+- `stopWhenPanelAgrees` is an opt-in profile setting. It requires matching high-confidence decision records with no request for more evidence, initially executes only the configured synthesis quorum (not always two) so it can avoid starting later work, records skipped panelists in the report, and still runs the judge.
 - Panel answers reach the judge in an order seeded from the run id, not in config order. A fixed order advantages the same member on every run, because judges favour whichever candidate they see first or last.
 - Panelists can search the web by opting in to the `fusion-panelist-web` agent, which requires `pi-web-providers`. Defaults stay local-only on purpose: tool names are a strict allowlist, so an agent declaring a tool whose extension is missing fails every task that uses it.
 - `synthesis: "merge"` switches from picking the best answer to merging answers that covered different facets, using the `fusion-composer` agent. Panel members get facets through their optional `question` field. See the user guide.

package/docs/user-guide.md

@@ -29,7 +29,7 @@ prompts, or both. **Mixing models is the main lever.** The config that
 `/fusion init` writes sets no `model`. By default you therefore get one model in
 three roles. Give each member its own `model` to get the real benefit.
 
-Fusion launches new panels through `pi-subagents` `workflowScript`; the panel and judge remain separate durable runs. Older runs created as a single `pi-subagents` chain remain supported when restored.
+Fusion launches new panels through `pi-subagents` `workflowScript`; the panel and judge remain separate durable runs. At start, Fusion persists a small resolved profile snapshot (panel labels/models/roles, quorum, synthesis and judge settings) and uses it after restart, so later config edits cannot change an active run's reconciliation, report, or synthesis spawn. Older runs created before this snapshot, including single-chain runs, retain the legacy config-lookup restore fallback. Before each public RPC spawn, Fusion persists a spawn intent. If Pi crashes after that RPC might have started but before its remote run ID is saved, restore fails that local run with an explicit recovery warning instead of spawning a possible duplicate (public RPC cannot safely adopt by correlation key). A corrupt newest run snapshot is likewise refused rather than reviving an older active run.
 
 The base Pi session stays in control. Fusion is a tool for decisions, not a replacement for normal coding.
 
@@ -152,18 +152,21 @@ Profile:
 
 - `panel`: one or more panel members
 - `judge`: judge agent config
-- `concurrency`: max parallel panelists. When `stopWhenPanelAgrees` is on, Fusion evaluates the first two panelists before launching another batch so it can avoid work after strong agreement.
-- `timeoutMs`: legacy shared wall-clock timeout in milliseconds. It remains supported as the fallback for both stages. New profiles default to 15 minutes through the stage-specific fields; existing explicit `timeoutMs` values are preserved. Use a stage-specific field when panel and synthesis need different deadlines.
-- `panelTimeoutMs`: panel workflow wall-clock timeout. It overrides `timeoutMs` for the panel. The default profile uses 15 minutes.
-- `judgeTimeoutMs`: synthesis workflow wall-clock timeout. It overrides `timeoutMs` for the judge or composer. The default profile uses 15 minutes.
+- `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.
+- `timeoutMs`: legacy shared wall-clock timeout in milliseconds. It is a fallback only; `/fusion status` warns when it supplied an effective deadline.
+- `panelistTimeoutMs`: per-panelist deadline. Fusion caps it below the enclosing panel deadline.
+- `panelTimeoutMs`: panel workflow wall-clock deadline.
+- `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.
 - `context`: `fresh` or `fork`
-- `stopWhenPanelAgrees`: optional boolean, default `false`. When it is on, Fusion can stop the panelists that have not finished yet. All four conditions must hold: two or more finished panelists give the same normalized recommendation, every one of them reports `high` confidence, none of them asks for more evidence, and work remains. The judge still runs over the answers already collected. This policy is fixed on purpose. There is no threshold to tune.
+- `stopWhenPanelAgrees`: optional boolean, default `false`. When it is on, Fusion can stop the panelists that have not finished yet only after the configured synthesis quorum is already met. The agreement conditions also require two or more finished panelists to give the same normalized recommendation, every one to report `high` confidence, none to ask for more evidence, and work to remain. Thus an `"all"` quorum never skips unfinished panelists. The judge still runs over the answers already collected. This policy is fixed on purpose. There is no threshold to tune.
 - `synthesis`: rarely needed. Inferred from the panel — any member with a `question` means `merge`, otherwise `select`. Set it only to override that. See [Synthesis modes](#synthesis-modes).
 - `blindPanelLabels`: optional boolean, default `false`. When it is on, the judge sees `Candidate A`, `Candidate B`, and so on, instead of the configured labels. Fusion also withholds agent names and artifact paths, because they contain the member id. A role label reads as an authority cue before the judge compares any content. Your report always shows the real names.
 - `panelToolBudget`: optional `{ "soft": n, "hard": n, "block": "*" | [tools...] }` applied to each panelist. Fusion uses `{ "soft": 8, "hard": 12, "block": "*" }` when omitted. After `hard`, the selected tools are blocked so the panelist can still finalise.
 - `judgeToolBudget`: optional `{ "soft": n, "hard": n, "block": "*" | [tools...] }` for the judge or composer. Fusion uses `{ "soft": 8, "hard": 12, "block": "*" }` when omitted. `soft` is a nudge. After `hard`, the selected tools are blocked so synthesis can still finalise. `soft` or `hard` must be positive integers when present, and `soft` must not be larger than `hard` when both are present. Legacy soft-only budgets remain valid.
 
-Timeouts are hard workflow deadlines. A child terminated at the deadline can report exit 143. Fusion keeps completed panel slots and failed panel slots separate, never relabels a compact completion payload, and fails closed when lifecycle sources disagree. A timed-out judge never becomes a panel-only success. Synthesis also fails closed when any configured panelist is missing or failed, unless the missing slots were explicitly stopped after strong agreement.
+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.
 
 Panel member:
 
@@ -294,9 +297,7 @@ run does not fail, so a mismatch appears as an empty report, not as an error.
 }
 ```
 
-Under `merge`, one surviving panelist still goes to the composer. Fusion does
-not return that answer directly. One facet is not the answer, and the report must
-name what is missing.
+Under `merge`, surviving outputs at quorum go to the composer even when some facets are unavailable. The composer must name uncovered facets rather than presenting complete coverage. Below quorum Fusion posts an explicitly partial coverage report; it never presents one facet as the full answer.
 
 Judge:
 
@@ -483,7 +484,9 @@ For an economical mixed panel, give each member a fast or inexpensive frontier,
 - raise `panelTimeoutMs` or `judgeTimeoutMs` for slower models
 - keep `panelToolBudget` and `judgeToolBudget` bounded so agents finalise before the deadline
 - inspect `/fusion status`; panel failures and the workflow timeout must both be present
-- retry only after the run is terminal
+- a timeout ends that child/run attempt; Fusion does not retry panelists, restart the panel, or extend deadlines
+- failed-only retry is deliberately not exposed yet: terminal failure state persists the failed panel slot indices for recovery/provenance, but `/fusion` starts a new independent run rather than replaying only those slots
+- retry manually only after the run is terminal
 
 Run is stuck or no longer useful:
 
@@ -501,4 +504,4 @@ Notes:
 
 - `Panel run` is the normal panel phase for new Fusion runs.
 - `Judge run` is the normal synthesis phase for new runs. `Fallback judge run` appears only while restoring a legacy chain that completed without its judge result.
-- If `pi-subagents` completion notifications are delayed or missed, Fusion still reconciles from lifecycle artifacts written under the subagent async run directory.
+- If `pi-subagents` completion notifications are delayed or missed, Fusion still reconciles from lifecycle artifacts written under the subagent async run directory. The full result artifact is preferred over compact completion events.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexeiled/pi-fusion",
-  "version": "0.7.0",
+  "version": "0.8.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/skills/fusion-review/SKILL.md

@@ -76,10 +76,11 @@ better.
 ## After the call
 
 The tool returns at once. The panel and the synthesis step run in the background,
-and Fusion posts the report when they finish.
+and Fusion posts the report when they finish. A panel deadline can produce an explicitly partial report that names unavailable perspectives and timeout coverage gaps.
 
 - Do not call the tool again while a run is active. It returns a conflict with
   the id of the active run.
 - Do not summarize or predict the report. Wait for it.
 - To show progress or stop a run, tell the user to type `/fusion status` or
   `/fusion stop`. No tool does this.
+- Do not invoke another review automatically after a partial report or timeout. Fusion does not retry failed panelists; users can inspect `/fusion status` and manually rerun only after the current run is terminal.

package/src/config.ts

@@ -325,18 +325,44 @@ function isFusionProfile(value: unknown): value is FusionProfile {
     return false;
   if (value.timeoutMs !== undefined && !isPositiveInteger(value.timeoutMs))
     return false;
+  if (
+    value.panelistTimeoutMs !== undefined &&
+    !isPositiveInteger(value.panelistTimeoutMs)
+  ) {
+    return false;
+  }
   if (
     value.panelTimeoutMs !== undefined &&
     !isPositiveInteger(value.panelTimeoutMs)
   ) {
     return false;
   }
+  if (
+    value.panelGraceMs !== undefined &&
+    !isPositiveInteger(value.panelGraceMs)
+  ) {
+    return false;
+  }
+  const panelTimeoutMs = value.panelTimeoutMs ?? value.timeoutMs ?? 900_000;
+  const panelGraceMs = value.panelGraceMs ?? 5_000;
+  // Never accept a configuration that would leave child panelists a 1ms
+  // timeout after deadline capping. Overrides receive the same validation when
+  // their effective values are resolved at run start.
+  if (panelGraceMs >= panelTimeoutMs) return false;
   if (
     value.judgeTimeoutMs !== undefined &&
     !isPositiveInteger(value.judgeTimeoutMs)
   ) {
     return false;
   }
+  if (
+    value.minimumSuccessfulPanelists !== undefined &&
+    value.minimumSuccessfulPanelists !== "majority" &&
+    value.minimumSuccessfulPanelists !== "all" &&
+    !isPositiveInteger(value.minimumSuccessfulPanelists)
+  ) {
+    return false;
+  }
   if (value.context !== undefined && !isFusionContextMode(value.context))
     return false;
   if (

package/src/fusion-args.ts

@@ -1,8 +1,8 @@
 import { FusionArgsError } from "./errors.js";
-import type { ParsedFusionArgs } from "./types.js";
+import type { FusionTimeoutOverrides, ParsedFusionArgs } from "./types.js";
 
 const FUSION_USAGE =
-  "Usage: /fusion <prompt> | /fusion --profile <name> <prompt> | /fusion --panel <models> <prompt> | /fusion status | /fusion stop | /fusion init.";
+  "Usage: /fusion <prompt> | /fusion --profile <name> <prompt> | /fusion --panel <models> <prompt> [--panelist-timeout-ms n --panel-timeout-ms n --panel-grace-ms n --judge-timeout-ms n] | /fusion status | /fusion stop | /fusion init.";
 
 export type FusionInlineCommand = "init" | "status" | "stop";
 
@@ -28,6 +28,13 @@ export function parseFusionArgs(
 
   let profile: string | undefined;
   let panel: string[] | undefined;
+  const timeoutOverrides: FusionTimeoutOverrides = {};
+  const timeoutOptions: Record<string, keyof FusionTimeoutOverrides> = {
+    "--panelist-timeout-ms": "panelistTimeoutMs",
+    "--panel-timeout-ms": "panelTimeoutMs",
+    "--panel-grace-ms": "panelGraceMs",
+    "--judge-timeout-ms": "judgeTimeoutMs",
+  };
   const promptTokens: string[] = [];
 
   for (let index = 0; index < tokens.length; index++) {
@@ -81,6 +88,25 @@ export function parseFusionArgs(
       continue;
     }
 
+    const timeoutKey = timeoutOptions[token];
+    const timeoutEquals = Object.entries(timeoutOptions).find(([option]) =>
+      token.startsWith(`${option}=`),
+    );
+    if (promptTokens.length === 0 && (timeoutKey || timeoutEquals)) {
+      const key = timeoutKey ?? timeoutEquals?.[1];
+      const raw = timeoutKey ? tokens[index + 1] : token.slice((timeoutEquals?.[0].length ?? 0) + 1);
+      const value = raw ? Number(raw) : NaN;
+      if (!key || !Number.isInteger(value) || value <= 0) {
+        throw new FusionArgsError(`Timeout options require a positive integer milliseconds value. ${FUSION_USAGE}`);
+      }
+      if (timeoutOverrides[key] !== undefined) {
+        throw new FusionArgsError(`${token.split("=")[0]} can only be provided once.`);
+      }
+      timeoutOverrides[key] = value;
+      if (timeoutKey) index++;
+      continue;
+    }
+
     if (promptTokens.length === 0 && token.startsWith("-")) {
       throw new FusionArgsError(`Unknown option ${token}. ${FUSION_USAGE}`);
     }
@@ -95,6 +121,7 @@ export function parseFusionArgs(
     prompt,
     ...(profile ? { profile } : {}),
     ...(panel ? { panel } : {}),
+    ...(Object.keys(timeoutOverrides).length ? { timeoutOverrides } : {}),
   };
 }
 

package/src/fusion-rpc.ts

@@ -12,6 +12,7 @@ import type {
   CallerOutputContract,
   FusionPhase,
   FusionRun,
+  FusionTimeoutOverrides,
   ParsedFusionArgs,
 } from "./types.js";
 import { isNonEmptyString, isRecord } from "./utils.js";
@@ -151,6 +152,7 @@ interface StartParams {
   profile?: string;
   operationId: string;
   outputContract?: CallerOutputContract;
+  timeoutOverrides?: FusionTimeoutOverrides;
 }
 
 interface RunParams {
@@ -425,6 +427,8 @@ function parseStartParams(input: unknown): StartParams {
     );
   }
 
+  const timeoutOverrides = parseTimeoutOverrides(input);
+
   const outputContract = input.outputContract;
   if (outputContract !== undefined && !isCallerOutputContract(outputContract)) {
     throw invalidParams(
@@ -437,9 +441,31 @@ function parseStartParams(input: unknown): StartParams {
     operationId,
     ...(profile === undefined ? {} : { profile }),
     ...(outputContract === undefined ? {} : { outputContract }),
+    ...(timeoutOverrides ? { timeoutOverrides } : {}),
   };
 }
 
+function parseTimeoutOverrides(
+  input: Record<string, unknown>,
+): FusionTimeoutOverrides | undefined {
+  const fields = [
+    ["panelistTimeoutMs", "panelistTimeoutMs"],
+    ["panelTimeoutMs", "panelTimeoutMs"],
+    ["panelGraceMs", "panelGraceMs"],
+    ["judgeTimeoutMs", "judgeTimeoutMs"],
+  ] as const;
+  const overrides: FusionTimeoutOverrides = {};
+  for (const [wireName, key] of fields) {
+    const value = input[wireName];
+    if (value === undefined) continue;
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+      throw invalidParams(`${wireName} must be a positive integer when provided.`);
+    }
+    overrides[key] = value;
+  }
+  return Object.keys(overrides).length ? overrides : undefined;
+}
+
 function toParsedFusionArgs(input: StartParams): ParsedFusionArgs {
   return {
     prompt: input.prompt,
@@ -448,6 +474,9 @@ function toParsedFusionArgs(input: StartParams): ParsedFusionArgs {
     ...(input.outputContract === undefined
       ? {}
       : { outputContract: input.outputContract }),
+    ...(input.timeoutOverrides === undefined
+      ? {}
+      : { timeoutOverrides: input.timeoutOverrides }),
   };
 }
 

package/src/index.ts

@@ -25,23 +25,45 @@ function registerFusionTool(
       "Pass panel only when the user names the models to compare. Otherwise omit it and let the profile decide.",
     ],
     parameters: Type.Object({
-      prompt: Type.String({ description: "What to review or discuss" }),
+      prompt: Type.String({
+        minLength: 1,
+        pattern: ".*\\S.*",
+        description: "What to review or discuss (must contain non-whitespace text)",
+      }),
       profile: Type.Optional(
-        Type.String({ description: "Fusion profile name (optional)" }),
+        Type.String({ minLength: 1, description: "Fusion profile name (optional)" }),
       ),
       panel: Type.Optional(
-        Type.Array(Type.String(), {
+        Type.Array(Type.String({ minLength: 1 }), {
+          minItems: 1,
           description:
             "Models to use for this run, overriding the profile panel. Each entry is <model> or <agent>:<model>. Use only when the user names specific models.",
         }),
       ),
+      panelistTimeoutMs: Type.Optional(Type.Integer({ minimum: 1, description: "Per-panelist deadline in milliseconds" })),
+      panelTimeoutMs: Type.Optional(Type.Integer({ minimum: 1, description: "Panel workflow deadline in milliseconds" })),
+      panelGraceMs: Type.Optional(Type.Integer({ minimum: 1, description: "Reserved grace between child and panel deadlines in milliseconds" })),
+      judgeTimeoutMs: Type.Optional(Type.Integer({ minimum: 1, description: "Judge/composer deadline in milliseconds" })),
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const result = await orchestrator.startRun(
         {
           prompt: params.prompt,
-          ...(params.profile ? { profile: params.profile } : {}),
-          ...(params.panel?.length ? { panel: params.panel } : {}),
+          ...(params.profile !== undefined ? { profile: params.profile } : {}),
+          ...(params.panel !== undefined ? { panel: params.panel } : {}),
+          ...(params.panelistTimeoutMs !== undefined ||
+          params.panelTimeoutMs !== undefined ||
+          params.panelGraceMs !== undefined ||
+          params.judgeTimeoutMs !== undefined
+            ? {
+                timeoutOverrides: {
+                  ...(params.panelistTimeoutMs !== undefined ? { panelistTimeoutMs: params.panelistTimeoutMs } : {}),
+                  ...(params.panelTimeoutMs !== undefined ? { panelTimeoutMs: params.panelTimeoutMs } : {}),
+                  ...(params.panelGraceMs !== undefined ? { panelGraceMs: params.panelGraceMs } : {}),
+                  ...(params.judgeTimeoutMs !== undefined ? { judgeTimeoutMs: params.judgeTimeoutMs } : {}),
+                },
+              }
+            : {}),
         },
         ctx,
       );
@@ -57,6 +79,12 @@ function registerFusionTool(
           prompt: params.prompt,
           profile: params.profile,
           panel: params.panel,
+          timeoutOverrides: {
+            panelistTimeoutMs: params.panelistTimeoutMs,
+            panelTimeoutMs: params.panelTimeoutMs,
+            panelGraceMs: params.panelGraceMs,
+            judgeTimeoutMs: params.judgeTimeoutMs,
+          },
           status: result.status,
         },
       };

package/src/lifecycle-reconcile.ts

@@ -20,8 +20,11 @@ export function reconcileIndexedLifecycleResult(
 
   const statusSteps = findLifecycleArray(statusPayload, "steps");
   const rawStatusResults = findLifecycleArray(statusPayload, "results");
-  const statusResults =
-    statusSteps ?? (rawStatusResults?.length ? rawStatusResults : undefined);
+  const statusResults = authoritativeStatusLifecycleArray(
+    statusPayload,
+    statusSteps,
+    rawStatusResults,
+  );
   const statusResult = statusResults?.[index];
   if (statusResults && !isRecord(statusResult)) {
     return `Subagents event includes ${label} result ${index + 1}, but status does not.`;
@@ -38,6 +41,8 @@ export interface ReconcilePanelResultsOptions {
   allowedTrailingResults?: number;
   /** Indices intentionally absent from status after early agreement. */
   stoppedPanelIndices?: readonly number[];
+  /** A workflow deadline terminalized running child slots as timeout failures. */
+  terminalizeRunning?: boolean;
 }
 
 /**
@@ -64,8 +69,14 @@ export function reconcilePanelResults(
 
   const rawStatusSteps = findLifecycleArray(statusPayload, "steps");
   const rawStatusResults = findLifecycleArray(statusPayload, "results");
-  const rawStatus =
-    rawStatusSteps ?? (rawStatusResults?.length ? rawStatusResults : undefined);
+  // Preserve an explicit terminal `results: []`: it is authoritative even
+  // when it contains no child results. A running empty poll, however, is not
+  // a terminal lifecycle assertion and can race a completion event.
+  const rawStatus = authoritativeStatusLifecycleArray(
+    statusPayload,
+    rawStatusSteps,
+    rawStatusResults,
+  );
   if (!rawStatus) {
     if (eventResults.outputs.length + eventResults.failures.length !== expectedCount) {
       return error(
@@ -85,7 +96,9 @@ export function reconcilePanelResults(
 
   const statusResults = extractPanelResults(statusPayload, {
     panel: profile.panel,
-    completedOnly: true,
+    ...(options.terminalizeRunning
+      ? { terminalizeRunning: true }
+      : { completedOnly: true }),
     limit: expectedCount,
     ...(options.stoppedPanelIndices
       ? { stoppedPanelIndices: options.stoppedPanelIndices }
@@ -100,6 +113,25 @@ export function reconcilePanelResults(
 
   const statusCount =
     statusResults.outputs.length + statusResults.failures.length;
+  if (
+    !options.terminalizeRunning &&
+    eventResults.outputs.length + eventResults.failures.length === expectedCount
+  ) {
+    const eventSucceeded = new Set(eventResults.outputs.map((item) => item.index));
+    const statusSucceeded = new Set(statusResults.outputs.map((item) => item.index));
+    for (let index = 0; index < expectedCount; index++) {
+      const eventKnown =
+        eventSucceeded.has(index) || eventResults.failures.some((item) => item.index === index);
+      const statusKnown =
+        statusSucceeded.has(index) || statusResults.failures.some((item) => item.index === index);
+      if (eventKnown && statusKnown && eventSucceeded.has(index) !== statusSucceeded.has(index)) {
+        return error(
+          `Subagents event and status disagree about panel result ${index + 1}.`,
+          `$.steps[${index}]`,
+        );
+      }
+    }
+  }
   const eventCount =
     eventResults.outputs.length + eventResults.failures.length;
   const statusIndices = new Set([
@@ -113,7 +145,14 @@ export function reconcilePanelResults(
   ).filter((index) => !statusIndices.has(index));
 
   if (statusCount === expectedCount) {
-    return preserveAgreementReasons(statusResults, eventResults);
+    return options.terminalizeRunning
+      ? mergeTerminalDeadlineResults(
+          eventResults,
+          statusResults,
+          statusPayload,
+          resultPayload,
+        )
+      : preserveAgreementReasons(statusResults, eventResults);
   }
 
   const missingWereStopped =
@@ -137,6 +176,124 @@ export function reconcilePanelResults(
   return mergeObservations(eventResults, statusResults);
 }
 
+/**
+ * Status is normally authoritative. At a workflow deadline it can still show
+ * a child as running even though the completion artifact contains that child's
+ * verified final output. Keep that verified output, normalize only genuinely
+ * unfinished slots, and retain status observations/failure details.
+ */
+function mergeTerminalDeadlineResults(
+  event: ExtractPanelResultsSuccess,
+  status: ExtractPanelResultsSuccess,
+  statusPayload: unknown,
+  eventPayload: unknown,
+): ExtractPanelResultsSuccess {
+  const eventOutputs = new Map(event.outputs.map((item) => [item.index, item]));
+  const eventFailures = new Map(event.failures.map((item) => [item.index, item]));
+  const statusOutputs = new Map(status.outputs.map((item) => [item.index, item]));
+  const statusFailures = new Map(status.failures.map((item) => [item.index, item]));
+  const replaceableSlots = deadlineEventReplacementSlots(
+    statusPayload,
+    eventPayload,
+  );
+  const outputs: PanelOutput[] = [];
+  const failures: FailedPanelSummary[] = [];
+  const maxIndex = Math.max(
+    ...[...eventOutputs.keys(), ...eventFailures.keys(), ...statusOutputs.keys(), ...statusFailures.keys()],
+    -1,
+  );
+  for (let index = 0; index <= maxIndex; index++) {
+    const eventOutput = eventOutputs.get(index);
+    const eventFailure = eventFailures.get(index);
+    const statusOutput = statusOutputs.get(index);
+    const statusFailure = statusFailures.get(index);
+
+    // A completed status slot is authoritative even when a stale compact
+    // event reports a failure. Event data can replace only a status slot that
+    // deadline handling normalized from a nonterminal state, and only when
+    // both records identify the same public panel-N slot.
+    if (!replaceableSlots.has(index)) {
+      if (statusOutput) outputs.push(statusOutput);
+      else if (statusFailure) failures.push(statusFailure);
+      continue;
+    }
+
+    if (eventOutput) {
+      outputs.push(withObservation(eventOutput, statusFailure?.observation));
+    } else if (eventFailure) {
+      failures.push(withObservation(eventFailure, statusFailure?.observation));
+    } else if (statusFailure) {
+      failures.push(statusFailure);
+    }
+  }
+  return { ok: true, outputs, failures, ...(event.runId ? { runId: event.runId } : {}) };
+}
+
+/**
+ * Deadline reconciliation never trusts compact-event array order: failed
+ * children can be omitted or arrive late. A compact event may replace only a
+ * status record terminalized from a nonterminal state when both explicitly
+ * name the same public workflow slot.
+ */
+function deadlineEventReplacementSlots(
+  statusPayload: unknown,
+  eventPayload: unknown,
+): ReadonlySet<number> {
+  const statusResults =
+    findLifecycleArray(statusPayload, "steps") ??
+    findLifecycleArray(statusPayload, "results");
+  const eventResults = findLifecycleArray(eventPayload, "results");
+  if (!statusResults || !eventResults) return new Set<number>();
+
+  const nonterminalStatusSlots = new Set<number>();
+  for (const result of statusResults) {
+    const slot = stablePanelSlot(result);
+    if (slot !== undefined && isNonterminalLifecycleResult(result)) {
+      nonterminalStatusSlots.add(slot);
+    }
+  }
+
+  const matchingEventSlots = new Set<number>();
+  for (const result of eventResults) {
+    const slot = stablePanelSlot(result);
+    if (slot !== undefined && nonterminalStatusSlots.has(slot)) {
+      matchingEventSlots.add(slot);
+    }
+  }
+  return matchingEventSlots;
+}
+
+function stablePanelSlot(result: unknown): number | undefined {
+  if (!isRecord(result)) return undefined;
+  // Result extraction already accepts these lifecycle fields as zero-based
+  // public slots. Keep deadline matching exactly aligned; a numeric 1 must
+  // mean panel slot 1, never a guessed one-based panel-1.
+  for (const candidate of [result.index, result.taskIndex, result.stepIndex]) {
+    if (typeof candidate === "number" && Number.isInteger(candidate) && candidate >= 0) {
+      return candidate;
+    }
+  }
+  const key = firstString(
+    result.key,
+    result.taskKey,
+    result.stepKey,
+    result.agent,
+  );
+  const match = key?.match(/^panel-([1-9]\d*)$/);
+  return match ? Number(match[1]) - 1 : undefined;
+}
+
+function isNonterminalLifecycleResult(result: unknown): boolean {
+  if (!isRecord(result)) return false;
+  const status = firstString(result.status, result.state);
+  return (
+    status === "running" ||
+    status === "active" ||
+    status === "pending" ||
+    status === "queued"
+  );
+}
+
 function preserveAgreementReasons(
   status: ExtractPanelResultsSuccess,
   event: ExtractPanelResultsSuccess,
@@ -214,6 +371,46 @@ function findLifecycleArray(
   return undefined;
 }
 
+function authoritativeStatusLifecycleArray(
+  payload: unknown,
+  steps: readonly unknown[] | undefined,
+  results: readonly unknown[] | undefined,
+): readonly unknown[] | undefined {
+  const lifecycle = steps ?? results;
+  if (!lifecycle || lifecycle.length > 0 || isTerminalLifecyclePayload(payload)) {
+    return lifecycle;
+  }
+  return undefined;
+}
+
+function isTerminalLifecyclePayload(payload: unknown): boolean {
+  if (!isRecord(payload)) return false;
+  const state = firstString(payload.state, payload.status);
+  const textState = firstString(payload.text)?.match(
+    /(?:^|\n)(?:State|Status):\s*([^\n\r]+)/i,
+  )?.[1]?.trim();
+  if (
+    state === "complete" ||
+    textState === "complete" ||
+    textState === "completed" ||
+    textState === "done" ||
+    textState === "failed" ||
+    textState === "paused" ||
+    textState === "detached" ||
+    state === "completed" ||
+    state === "done" ||
+    state === "failed" ||
+    state === "paused" ||
+    state === "detached"
+  ) {
+    return true;
+  }
+  if (isRecord(payload.details) && isTerminalLifecyclePayload(payload.details)) {
+    return true;
+  }
+  return isRecord(payload.data) && isTerminalLifecyclePayload(payload.data);
+}
+
 function isFailedLifecycleResult(result: Record<string, unknown>): boolean {
   if (result.success === false) return true;
   if (result.timedOut === true || result.interrupted === true) return true;