@alexeiled/pi-fusion 0.7.0 → 0.8.0

package/src/run-store.ts

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
 import type {
   FusionPhase,
+  FusionProfileSnapshot,
+  FusionRecoveryState,
   FusionRun,
   ModelAttempt,
   PanelDecision,
@@ -25,6 +27,9 @@ export type FusionRunSummary = Omit<
     | "profileName"
     | "operationId"
     | "outputContract"
+    | "completionQuality"
+    | "effectiveTimeouts"
+    | "recovery"
     | "phase"
     | "createdAt"
     | "updatedAt"
@@ -45,6 +50,10 @@ export interface FusionRunStartInput {
   baseProfileName?: string;
   operationId?: string;
   outputContract?: FusionRun["outputContract"];
+  minimumSuccessfulPanelists?: FusionRun["minimumSuccessfulPanelists"];
+  profileSnapshot?: FusionRun["profileSnapshot"];
+  timeoutOverrides?: FusionRun["timeoutOverrides"];
+  effectiveTimeouts?: FusionRun["effectiveTimeouts"];
   phase?: Exclude<FusionPhase, FusionTerminalPhase>;
   createdAt?: number;
 }
@@ -60,8 +69,12 @@ export interface FusionRunPatch {
   judgeRunId?: string;
   judgeAsyncDir?: string;
   judgeObservation?: FusionRun["judgeObservation"];
+  completionQuality?: FusionRun["completionQuality"];
   panelOutputs?: FusionRun["panelOutputs"];
   panelFailures?: FusionRun["panelFailures"];
+  recovery?: FusionRun["recovery"];
+  /** `null` clears an intent once the RPC returned its durable remote ID. */
+  spawnIntent?: FusionRun["spawnIntent"] | null;
   report?: string;
   error?: string;
   updatedAt?: number;
@@ -71,6 +84,8 @@ export interface FusionRunTransitionPatch {
   chainRunId?: string;
   panelRunId?: string;
   judgeRunId?: string;
+  recovery?: FusionRun["recovery"];
+  spawnIntent?: FusionRun["spawnIntent"];
   report?: string;
   error?: string;
   updatedAt?: number;
@@ -107,6 +122,7 @@ export class FusionRunStore {
   private readonly now: () => number;
   private readonly idFactory: () => string;
   private readonly persistence: FusionRunStorePersistence | undefined;
+  private restoreError: string | undefined;
 
   constructor(options: FusionRunStoreOptions = {}) {
     this.now = options.now ?? Date.now;
@@ -134,6 +150,11 @@ export class FusionRunStore {
     return runId ? this.getRunById(runId) : undefined;
   }
 
+  /** A corrupt newest snapshot must never revive an older active run. */
+  getRestoreError(): string | undefined {
+    return this.restoreError;
+  }
+
   startRun(input: FusionRunStartInput): FusionRun {
     if (this.activeRun) {
       throw new FusionRunStoreError(
@@ -167,13 +188,25 @@ export class FusionRunStore {
       ...(input.outputContract !== undefined
         ? { outputContract: input.outputContract }
         : {}),
+      ...(input.minimumSuccessfulPanelists !== undefined
+        ? { minimumSuccessfulPanelists: input.minimumSuccessfulPanelists }
+        : {}),
+      ...(input.profileSnapshot !== undefined
+        ? { profileSnapshot: cloneProfileSnapshot(input.profileSnapshot) }
+        : {}),
+      ...(input.timeoutOverrides !== undefined
+        ? { timeoutOverrides: { ...input.timeoutOverrides } }
+        : {}),
+      ...(input.effectiveTimeouts !== undefined
+        ? { effectiveTimeouts: { ...input.effectiveTimeouts } }
+        : {}),
       phase: input.phase ?? "chain",
       createdAt,
       updatedAt: createdAt,
     };
+    this.persistRun(run);
     this.activeRun = run;
     this.rememberRun(run);
-    this.persistRun(run);
     return cloneRun(run);
   }
 
@@ -221,11 +254,26 @@ export class FusionRunStore {
   restoreFromEntries(
     entries: readonly unknown[],
   ): FusionRunSummary | undefined {
-    const states = readFusionRunStates(entries);
+    this.restoreError = undefined;
     this.runsById.clear();
     this.runIdsByOperationId.clear();
-    for (const state of states) this.rememberRun(state);
 
+    const latestPersisted = lastFusionRunEnvelope(entries);
+    if (
+      latestPersisted &&
+      (!isFusionRunEntry(latestPersisted) || !isFusionRunState(latestPersisted.data))
+    ) {
+      // History readers may skip malformed entries, but restore must not adopt
+      // an older active state after a newer snapshot was corrupted.
+      this.activeRun = undefined;
+      this.lastRunSummary = undefined;
+      this.restoreError =
+        "Latest persisted fusion run snapshot is invalid; refusing stale active-run recovery.";
+      return undefined;
+    }
+
+    const states = readFusionRunStates(entries);
+    for (const state of states) this.rememberRun(state);
     const latestState = states.at(-1);
     const summary = readLastFusionRunSummary(entries);
     this.activeRun =
@@ -346,12 +394,20 @@ function applyPatch(
   if (patch.judgeObservation !== undefined) {
     updated.judgeObservation = cloneObservation(patch.judgeObservation);
   }
+  if (patch.completionQuality !== undefined) {
+    updated.completionQuality = patch.completionQuality;
+  }
   if (patch.panelOutputs !== undefined) {
     updated.panelOutputs = clonePanelOutputs(patch.panelOutputs);
   }
   if (patch.panelFailures !== undefined) {
     updated.panelFailures = clonePanelFailures(patch.panelFailures);
   }
+  if (patch.recovery !== undefined) updated.recovery = cloneRecovery(patch.recovery);
+  if (patch.spawnIntent === null) delete updated.spawnIntent;
+  else if (patch.spawnIntent !== undefined) {
+    updated.spawnIntent = cloneSpawnIntent(patch.spawnIntent);
+  }
   if (patch.report !== undefined) updated.report = patch.report;
   if (patch.error !== undefined) updated.error = patch.error;
   return updated;
@@ -371,6 +427,10 @@ function applyTransitionPatch(
   if (patch.chainRunId !== undefined) updated.chainRunId = patch.chainRunId;
   if (patch.panelRunId !== undefined) updated.panelRunId = patch.panelRunId;
   if (patch.judgeRunId !== undefined) updated.judgeRunId = patch.judgeRunId;
+  if (patch.recovery !== undefined) updated.recovery = cloneRecovery(patch.recovery);
+  if (patch.spawnIntent !== undefined) {
+    updated.spawnIntent = cloneSpawnIntent(patch.spawnIntent);
+  }
   if (patch.report !== undefined) updated.report = patch.report;
   if (patch.error !== undefined) updated.error = patch.error;
   return updated;
@@ -387,6 +447,13 @@ function toRunSummary(
     ...(run.outputContract !== undefined
       ? { outputContract: run.outputContract }
       : {}),
+    ...(run.completionQuality !== undefined
+      ? { completionQuality: run.completionQuality }
+      : {}),
+    ...(run.effectiveTimeouts !== undefined
+      ? { effectiveTimeouts: { ...run.effectiveTimeouts } }
+      : {}),
+    ...(run.recovery !== undefined ? { recovery: cloneRecovery(run.recovery) } : {}),
     phase: run.phase,
     createdAt: run.createdAt,
     updatedAt: run.updatedAt,
@@ -415,6 +482,21 @@ function cloneRun(run: FusionRun): FusionRun {
     ...(run.outputContract !== undefined
       ? { outputContract: run.outputContract }
       : {}),
+    ...(run.minimumSuccessfulPanelists !== undefined
+      ? { minimumSuccessfulPanelists: run.minimumSuccessfulPanelists }
+      : {}),
+    ...(run.profileSnapshot !== undefined
+      ? { profileSnapshot: cloneProfileSnapshot(run.profileSnapshot) }
+      : {}),
+    ...(run.timeoutOverrides !== undefined
+      ? { timeoutOverrides: { ...run.timeoutOverrides } }
+      : {}),
+    ...(run.effectiveTimeouts !== undefined
+      ? { effectiveTimeouts: { ...run.effectiveTimeouts } }
+      : {}),
+    ...(run.completionQuality !== undefined
+      ? { completionQuality: run.completionQuality }
+      : {}),
     phase: run.phase,
     createdAt: run.createdAt,
     updatedAt: run.updatedAt,
@@ -445,6 +527,10 @@ function cloneRun(run: FusionRun): FusionRun {
     ...(run.panelFailures !== undefined
       ? { panelFailures: clonePanelFailures(run.panelFailures) }
       : {}),
+    ...(run.recovery !== undefined ? { recovery: cloneRecovery(run.recovery) } : {}),
+    ...(run.spawnIntent !== undefined
+      ? { spawnIntent: cloneSpawnIntent(run.spawnIntent) }
+      : {}),
     ...(run.report !== undefined ? { report: run.report } : {}),
     ...(run.error !== undefined ? { error: run.error } : {}),
   };
@@ -454,17 +540,30 @@ function cloneRunSummary(summary: FusionRunSummary): FusionRunSummary {
   return toRunSummary(summary);
 }
 
-function isFusionRunEntry(
-  value: unknown,
-): value is { type: "custom"; customType: string; data: unknown } {
+function lastFusionRunEnvelope(entries: readonly unknown[]): unknown {
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    // Locate the newest entry by its envelope before inspecting data. A
+    // malformed data field (or its absence) must not revive an older run.
+    if (isFusionRunEnvelope(entry)) return entry;
+  }
+  return undefined;
+}
+
+function isFusionRunEnvelope(value: unknown): value is Record<string, unknown> {
   return (
     isRecord(value) &&
     value.type === "custom" &&
-    value.customType === FUSION_RUN_ENTRY_TYPE &&
-    "data" in value
+    value.customType === FUSION_RUN_ENTRY_TYPE
   );
 }
 
+function isFusionRunEntry(
+  value: unknown,
+): value is { type: "custom"; customType: string; data: unknown } {
+  return isFusionRunEnvelope(value) && "data" in value;
+}
+
 function isFusionRunState(value: unknown): value is FusionRun {
   if (!isRecord(value)) return false;
   if (!isNonEmptyString(value.id)) return false;
@@ -479,6 +578,47 @@ function isFusionRunState(value: unknown): value is FusionRun {
   ) {
     return false;
   }
+  if (
+    value.minimumSuccessfulPanelists !== undefined &&
+    value.minimumSuccessfulPanelists !== "majority" &&
+    value.minimumSuccessfulPanelists !== "all" &&
+    (!isFiniteNumber(value.minimumSuccessfulPanelists) ||
+      !Number.isInteger(value.minimumSuccessfulPanelists) ||
+      value.minimumSuccessfulPanelists < 1)
+  ) {
+    return false;
+  }
+  if (
+    value.profileSnapshot !== undefined &&
+    !isProfileSnapshot(value.profileSnapshot)
+  ) {
+    return false;
+  }
+  // Snapshots are the canonical quorum record for new runs. Older records may
+  // also carry the run-level policy, but it must resolve to the same quorum.
+  if (
+    value.profileSnapshot !== undefined &&
+    value.minimumSuccessfulPanelists !== undefined &&
+    resolvePersistedQuorum(
+      value.minimumSuccessfulPanelists,
+      value.profileSnapshot.panel.length,
+    ) !== value.profileSnapshot.minimumSuccessfulPanelists
+  ) {
+    return false;
+  }
+  if (value.timeoutOverrides !== undefined && !isTimeoutOverrides(value.timeoutOverrides)) {
+    return false;
+  }
+  if (value.effectiveTimeouts !== undefined && !isEffectiveTimeouts(value.effectiveTimeouts)) {
+    return false;
+  }
+  if (
+    value.completionQuality !== undefined &&
+    value.completionQuality !== "complete" &&
+    value.completionQuality !== "partial"
+  ) {
+    return false;
+  }
   if (
     value.inlinePanel !== undefined &&
     (!Array.isArray(value.inlinePanel) ||
@@ -556,19 +696,51 @@ function isFusionRunState(value: unknown): value is FusionRun {
   ) {
     return false;
   }
+  if (value.recovery !== undefined && !isRecoveryState(value.recovery)) {
+    return false;
+  }
+  if (value.spawnIntent !== undefined && !isSpawnIntent(value.spawnIntent)) {
+    return false;
+  }
   if (value.report !== undefined && typeof value.report !== "string") {
     return false;
   }
   if (value.error !== undefined && typeof value.error !== "string") {
     return false;
   }
-  return true;
+  return (
+    value.profileSnapshot === undefined ||
+    validateFusionRunPanelSlots(value, value.profileSnapshot.panel.length) ===
+      undefined
+  );
 }
 
 function isFusionRunSummary(value: unknown): value is FusionRunSummary {
   return isFusionRunState(value) && isTerminalPhase(value.phase);
 }
 
+function isTimeoutOverrides(value: unknown): boolean {
+  if (!isRecord(value)) return false;
+  return [
+    value.panelistTimeoutMs,
+    value.panelTimeoutMs,
+    value.panelGraceMs,
+    value.judgeTimeoutMs,
+  ].every((timeout) => timeout === undefined || (isFiniteNumber(timeout) && Number.isInteger(timeout) && timeout > 0));
+}
+
+function isEffectiveTimeouts(value: unknown): boolean {
+  return (
+    isTimeoutOverrides(value) &&
+    isRecord(value) &&
+    isFiniteNumber(value.panelistTimeoutMs) &&
+    isFiniteNumber(value.panelTimeoutMs) &&
+    isFiniteNumber(value.panelGraceMs) &&
+    isFiniteNumber(value.judgeTimeoutMs) &&
+    typeof value.usesLegacyTimeout === "boolean"
+  );
+}
+
 function isFusionPhase(value: unknown): value is FusionPhase {
   return (
     value === "panel" ||
@@ -584,6 +756,45 @@ function isTerminalPhase(value: unknown): value is FusionTerminalPhase {
   return value === "done" || value === "failed" || value === "cancelled";
 }
 
+/**
+ * Checks persisted slot references before they are restored or merged. Legacy
+ * runs omit a profile snapshot, so their caller supplies the safely resolved
+ * profile length during restore.
+ */
+export function validateFusionRunPanelSlots(
+  run: Pick<
+    FusionRun,
+    "panelOutputs" | "panelFailures" | "panelStoppedIndices" | "recovery"
+  >,
+  panelLength: number,
+): string | undefined {
+  const slotGroups: ReadonlyArray<readonly number[] | undefined> = [
+    run.panelOutputs?.map((output) => output.index),
+    run.panelFailures?.map((failure) => failure.index),
+    run.panelStoppedIndices,
+    run.recovery?.failedPanelIndices,
+  ];
+  for (const slots of slotGroups) {
+    for (const slot of slots ?? []) {
+      if (!isPanelSlotIndex(slot) || slot >= panelLength) {
+        return `Persisted panel slot ${String(slot)} is outside the configured panel.`;
+      }
+    }
+  }
+  return undefined;
+}
+
+function resolvePersistedQuorum(
+  policy: NonNullable<FusionRun["minimumSuccessfulPanelists"]>,
+  panelLength: number,
+): number {
+  if (policy === "all") return panelLength;
+  if (typeof policy === "number") {
+    return panelLength > 1 ? Math.max(2, Math.min(policy, panelLength)) : 1;
+  }
+  return Math.ceil(panelLength / 2);
+}
+
 function isPanelOutputArray(
   value: unknown,
 ): value is NonNullable<FusionRun["panelOutputs"]> {
@@ -595,7 +806,7 @@ function isPanelOutput(
 ): value is NonNullable<FusionRun["panelOutputs"]>[number] {
   return (
     isRecord(value) &&
-    isFiniteNumber(value.index) &&
+    isPanelSlotIndex(value.index) &&
     isNonEmptyString(value.agent) &&
     typeof value.output === "string" &&
     (value.id === undefined || typeof value.id === "string") &&
@@ -622,7 +833,7 @@ function isPanelFailure(
 ): value is NonNullable<FusionRun["panelFailures"]>[number] {
   return (
     isRecord(value) &&
-    isFiniteNumber(value.index) &&
+    isPanelSlotIndex(value.index) &&
     isNonEmptyString(value.agent) &&
     typeof value.summary === "string" &&
     (value.id === undefined || typeof value.id === "string") &&
@@ -638,6 +849,144 @@ function isPanelFailure(
   );
 }
 
+function isProfileSnapshot(value: unknown): value is FusionProfileSnapshot {
+  if (!isRecord(value) || !Array.isArray(value.panel) || value.panel.length === 0) {
+    return false;
+  }
+  if (!value.panel.every(isSnapshotPanelMember) || !isSnapshotJudge(value.judge)) {
+    return false;
+  }
+  if (
+    !isFiniteNumber(value.minimumSuccessfulPanelists) ||
+    !Number.isInteger(value.minimumSuccessfulPanelists) ||
+    value.minimumSuccessfulPanelists < 1 ||
+    value.minimumSuccessfulPanelists > value.panel.length
+  ) {
+    return false;
+  }
+  if (value.context !== undefined && value.context !== "fresh" && value.context !== "fork") {
+    return false;
+  }
+  if (value.stopWhenPanelAgrees !== undefined && typeof value.stopWhenPanelAgrees !== "boolean") {
+    return false;
+  }
+  if (value.blindPanelLabels !== undefined && typeof value.blindPanelLabels !== "boolean") {
+    return false;
+  }
+  if (value.synthesis !== undefined && value.synthesis !== "select" && value.synthesis !== "merge") {
+    return false;
+  }
+  return value.judgeToolBudget === undefined || isSnapshotToolBudget(value.judgeToolBudget);
+}
+
+function isSnapshotPanelMember(value: unknown): boolean {
+  if (!isRecord(value) || !isNonEmptyString(value.id) || !isSnapshotAgent(value.agent)) {
+    return false;
+  }
+  return (
+    (value.label === undefined || isNonEmptyString(value.label)) &&
+    (value.model === undefined || isNonEmptyString(value.model)) &&
+    (value.thinking === undefined || isThinkingLevel(value.thinking)) &&
+    (value.role === undefined || typeof value.role === "string") &&
+    (value.question === undefined || isNonEmptyString(value.question))
+  );
+}
+
+function isSnapshotJudge(value: unknown): boolean {
+  return (
+    isRecord(value) &&
+    isSnapshotAgent(value.agent) &&
+    (value.model === undefined || isNonEmptyString(value.model)) &&
+    (value.thinking === undefined || isThinkingLevel(value.thinking))
+  );
+}
+
+function isSnapshotAgent(value: unknown): boolean {
+  return (
+    isNonEmptyString(value) &&
+    /^[^\s.]+(?:\.[^\s.]+)*$/.test(value.trim())
+  );
+}
+
+function isThinkingLevel(value: unknown): boolean {
+  return value === "off" || value === "minimal" || value === "low" ||
+    value === "medium" || value === "high" || value === "xhigh";
+}
+
+function isSnapshotToolBudget(value: unknown): boolean {
+  if (!isRecord(value) || (value.soft === undefined && value.hard === undefined)) {
+    return false;
+  }
+  if (value.soft !== undefined && (!isFiniteNumber(value.soft) || !Number.isInteger(value.soft) || value.soft < 1)) {
+    return false;
+  }
+  if (value.hard !== undefined && (!isFiniteNumber(value.hard) || !Number.isInteger(value.hard) || value.hard < 1)) {
+    return false;
+  }
+  if (typeof value.soft === "number" && typeof value.hard === "number" && value.soft > value.hard) {
+    return false;
+  }
+  return value.block === undefined || value.block === "*" ||
+    (Array.isArray(value.block) && value.block.length > 0 && value.block.every(isNonEmptyString));
+}
+
+function cloneProfileSnapshot(snapshot: FusionProfileSnapshot): FusionProfileSnapshot {
+  return {
+    panel: snapshot.panel.map((member) => ({ ...member })),
+    judge: { ...snapshot.judge },
+    minimumSuccessfulPanelists: snapshot.minimumSuccessfulPanelists,
+    ...(snapshot.context !== undefined ? { context: snapshot.context } : {}),
+    ...(snapshot.stopWhenPanelAgrees !== undefined
+      ? { stopWhenPanelAgrees: snapshot.stopWhenPanelAgrees }
+      : {}),
+    ...(snapshot.blindPanelLabels !== undefined
+      ? { blindPanelLabels: snapshot.blindPanelLabels }
+      : {}),
+    ...(snapshot.judgeToolBudget !== undefined
+      ? {
+          judgeToolBudget: {
+            ...snapshot.judgeToolBudget,
+            ...(Array.isArray(snapshot.judgeToolBudget.block)
+              ? { block: [...snapshot.judgeToolBudget.block] }
+              : {}),
+          },
+        }
+      : {}),
+    ...(snapshot.synthesis !== undefined ? { synthesis: snapshot.synthesis } : {}),
+  };
+}
+
+function isRecoveryState(value: unknown): value is FusionRecoveryState {
+  return (
+    isRecord(value) &&
+    value.retryDeferred === true &&
+    Array.isArray(value.failedPanelIndices) &&
+    value.failedPanelIndices.every(isPanelSlotIndex)
+  );
+}
+
+function isPanelSlotIndex(value: unknown): value is number {
+  return isFiniteNumber(value) && Number.isInteger(value) && value >= 0;
+}
+
+function cloneRecovery(recovery: FusionRecoveryState): FusionRecoveryState {
+  return { ...recovery, failedPanelIndices: [...recovery.failedPanelIndices] };
+}
+
+function isSpawnIntent(value: unknown): value is FusionRun["spawnIntent"] {
+  return (
+    isRecord(value) &&
+    (value.stage === "panel" || value.stage === "judge") &&
+    isFiniteNumber(value.requestedAt)
+  );
+}
+
+function cloneSpawnIntent(
+  intent: NonNullable<FusionRun["spawnIntent"]>,
+): NonNullable<FusionRun["spawnIntent"]> {
+  return { ...intent };
+}
+
 function clonePanelOutputs(
   outputs: NonNullable<FusionRun["panelOutputs"]>,
 ): NonNullable<FusionRun["panelOutputs"]> {

package/src/status.ts

@@ -52,7 +52,7 @@ export function formatFusionStatusText(
     run.phase === "judge" ? run.judgeRunId : (run.chainRunId ?? run.panelRunId);
   const phase = phaseLabel ?? run.phase;
   if (progress) {
-    return `fusion: panel · ${formatProgressCounts(progress)} · ${run.profileName}`;
+    return `fusion: ${phase} · ${formatProgressCounts(progress)} · ${run.profileName}`;
   }
   if (activeRunId) {
     return `fusion: ${phase} · ${run.profileName} · ${activeRunId}`;

package/src/types.ts

@@ -45,16 +45,41 @@ export interface JudgeConfig {
   thinking?: ThinkingLevel;
 }
 
+export type MinimumSuccessfulPanelists = "majority" | "all" | number;
+
+/** Per-run deadline overrides accepted by CLI, tool, and RPC starts. */
+export interface FusionTimeoutOverrides {
+  panelistTimeoutMs?: number;
+  panelTimeoutMs?: number;
+  panelGraceMs?: number;
+  judgeTimeoutMs?: number;
+}
+
+export interface EffectiveFusionTimeouts {
+  panelistTimeoutMs: number;
+  panelTimeoutMs: number;
+  panelGraceMs: number;
+  judgeTimeoutMs: number;
+  /** True when the legacy shared timeout supplied one or more deadline values. */
+  usesLegacyTimeout: boolean;
+}
+
 export interface FusionProfile {
   panel: PanelMemberConfig[];
   judge: JudgeConfig;
   concurrency?: number;
   /** Legacy shared wall-clock timeout used when a stage timeout is absent. */
   timeoutMs?: number;
+  /** Per-child deadline. It is capped below the enclosing panel deadline. */
+  panelistTimeoutMs?: number;
   /** Wall-clock timeout for the complete panel workflow. */
   panelTimeoutMs?: number;
+  /** Time reserved between child and enclosing panel deadlines. */
+  panelGraceMs?: number;
   /** Wall-clock timeout for the synthesis workflow. */
   judgeTimeoutMs?: number;
+  /** Successful panel outputs required for synthesis. Defaults to a majority. */
+  minimumSuccessfulPanelists?: MinimumSuccessfulPanelists;
   context?: FusionContextMode;
   stopWhenPanelAgrees?: boolean;
   /**
@@ -172,6 +197,7 @@ export interface ParsedFusionArgs {
   outputContract?: CallerOutputContract;
   /** Inline panel entries from `--panel`: `<model>` or `<agent>:<model>`. */
   panel?: string[];
+  timeoutOverrides?: FusionTimeoutOverrides;
 }
 
 export interface PanelOutput {
@@ -210,6 +236,43 @@ export interface FailedPanelSummary {
 export type FusionPhase =
   "panel" | "chain" | "judge" | "done" | "failed" | "cancelled";
 
+export type CompletionQuality = "complete" | "partial";
+
+/**
+ * The start-time settings required after a process restart. This intentionally
+ * excludes panel execution-only values (concurrency, panel tool budget, and
+ * raw timeout fields): the panel is already running, while resolved deadlines
+ * are persisted separately in `effectiveTimeouts`.
+ */
+export interface FusionProfileSnapshot {
+  panel: PanelMemberConfig[];
+  judge: JudgeConfig;
+  minimumSuccessfulPanelists: number;
+  context?: FusionContextMode;
+  stopWhenPanelAgrees?: boolean;
+  blindPanelLabels?: boolean;
+  judgeToolBudget?: ToolBudget;
+  synthesis?: FusionSynthesisMode;
+}
+
+/** Persisted recovery metadata for a terminal run. Failed-only retry is not
+ * yet exposed, so this records exactly which slots a future explicit retry may
+ * safely target without replaying verified completed work. */
+export interface FusionRecoveryState {
+  retryDeferred: true;
+  failedPanelIndices: number[];
+}
+
+/**
+ * Durable record written before a public RPC spawn. The public API cannot
+ * query by this correlation token, so a restored intent without its returned
+ * run ID is deliberately failed instead of risking a duplicate remote run.
+ */
+export interface FusionSpawnIntent {
+  stage: "panel" | "judge";
+  requestedAt: number;
+}
+
 export interface FusionRun {
   id: string;
   prompt: string;
@@ -224,6 +287,16 @@ export interface FusionRun {
   baseProfileName?: string;
   operationId?: string;
   outputContract?: CallerOutputContract;
+  /** Persisted start policy so recovery is not changed by later config edits. */
+  minimumSuccessfulPanelists?: MinimumSuccessfulPanelists;
+  /**
+   * Additive start-time profile snapshot. Old sessions omit it and retain the
+   * legacy config lookup fallback during restore.
+   */
+  profileSnapshot?: FusionProfileSnapshot;
+  timeoutOverrides?: FusionTimeoutOverrides;
+  effectiveTimeouts?: EffectiveFusionTimeouts;
+  completionQuality?: CompletionQuality;
   phase: FusionPhase;
   createdAt: number;
   updatedAt: number;
@@ -238,6 +311,8 @@ export interface FusionRun {
   judgeObservation?: RunObservation;
   panelOutputs?: PanelOutput[];
   panelFailures?: FailedPanelSummary[];
+  recovery?: FusionRecoveryState;
+  spawnIntent?: FusionSpawnIntent;
   report?: string;
   error?: string;
 }