@alexeiled/pi-fusion 0.7.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
 ```
 
@@ -156,7 +158,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 +209,15 @@ 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.
+- 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.
 - `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/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

@@ -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.
 
@@ -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,18 +154,60 @@ 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. 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. 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.
 - `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.
+
+### 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:
 
@@ -294,9 +338,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 +525,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 +545,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.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/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/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,18 +325,45 @@ 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)
+  ) {
+    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,29 +25,51 @@ 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,
       );
       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}`;
@@ -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,
         },
       };
@@ -70,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,