privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-5QL3AR26.mjs

@@ -0,0 +1,4665 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  FusionArtifactStore,
+  buildFusionFailureSummary,
+  buildFusionRunProgress
+} from "./c-Z4ALQMJC.mjs";
+import {
+  FUSION_CANDIDATE_MAX_OUTPUT_BYTES,
+  FUSION_DIAGNOSTICS_MAX_BYTES,
+  FUSION_EVALUATION_MAX_OUTPUT_BYTES,
+  FUSION_MERGE_MAX_OUTPUT_BYTES,
+  FUSION_REASON_WORKFLOW,
+  assertChildOutputWithinContract,
+  assertWorkflowCapability,
+  buildBlindEvaluationInput,
+  buildCandidatePrompt,
+  buildEvaluationPrompt,
+  buildEvaluationRepairPrompt,
+  buildMergeInput,
+  buildMergePrompt,
+  fusionJsonRenderedTextBytes,
+  fusionWorkflowProfile
+} from "./c-EBZZNGSF.mjs";
+import {
+  buildFusionSourcePolicy,
+  canonicalizeFusionPublicUrl,
+  readFusionSourcePolicyFile,
+  sourcePolicyCanonicalBytes
+} from "./c-JJWZBY7L.mjs";
+import {
+  FUSION_BUDGET_PLAN_SCHEMA_VERSION,
+  FUSION_CALIBRATION_VIOLATION_SCHEMA_VERSION,
+  FUSION_CANDIDATE_IDS,
+  FUSION_EVALUATION_SCHEMA_VERSION,
+  FUSION_FORBIDDEN_TOOLS,
+  FUSION_INPUT_SCHEMA_VERSION,
+  FUSION_INSPECT_TOOLS,
+  FUSION_NO_TOOLS_CAPABILITY,
+  FUSION_RESEARCH_TOOLS,
+  FUSION_RESULT_SCHEMA_VERSION,
+  FUSION_TOOL_CALL_LOG_SCHEMA_VERSION,
+  FUSION_VALIDATE_CANDIDATE_SCHEMA_VERSION,
+  FUSION_WEB_FETCH_TOOL_NAME,
+  FusionError,
+  addFusionUsage,
+  cloneFusionUsage,
+  createEmptyFusionUsage
+} from "./c-37GM3GMU.mjs";
+import {
+  TOKEN_BUDGET_AFFINE_F_TOKENS,
+  TOKEN_BUDGET_CALIBRATION_VERSION,
+  TOKEN_BUDGET_FAMILY_CALIBRATIONS,
+  TOKEN_BUDGET_LARGE_PROMPT_MIN_BYTES,
+  TOKEN_BUDGET_RATE_SCALE,
+  allowedInputTokens,
+  estimateInputTokens,
+  isUsableContextWindow,
+  knownTextSegment,
+  maxKnownTextBytesForTokens,
+  resolveTokenBudgetFamily,
+  unknownOutputContractSegment
+} from "./c-US2PUNZL.mjs";
+import {
+  canonicalJson
+} from "./c-KIVXWBYD.mjs";
+import {
+  assertWindowsCommandLineWithinLimit,
+  piLaunchArgv,
+  resolvePiLaunch
+} from "./c-KIEMEFWW.mjs";
+import {
+  resolveAnthropicAttributionExtensionPath
+} from "./c-BFW6CDVL.mjs";
+import "./c-DR7XQI32.mjs";
+import {
+  isJsonObject,
+  parseJsonText
+} from "./c-I3C6LBW4.mjs";
+import "./c-B2Y7VNHU.mjs";
+import "./c-SKMK3PEE.mjs";
+import "./c-I54OKQHW.mjs";
+import "./c-UPBH5AXY.mjs";
+import "./c-7UOG7POX.mjs";
+import "./c-E4Z3Y5B5.mjs";
+import "./c-6ZO2SADQ.mjs";
+import "./c-JKTFXTGF.mjs";
+import "./c-CRBXNKFO.mjs";
+import "./c-KP6CRIP4.mjs";
+import "./c-RSKCUPJF.mjs";
+import "./c-PTN4S6G2.mjs";
+import "./c-P6N5DQGZ.mjs";
+import "./c-6LOBR4I6.mjs";
+import "./c-3STKRSVO.mjs";
+import "./c-YRDO2WEF.mjs";
+import "./c-BHNIF2AR.mjs";
+import "./c-ABXULAFL.mjs";
+import "./c-2G3BBHRJ.mjs";
+import "./c-O5PP6CTX.mjs";
+import "./c-CDBEJSBF.mjs";
+import "./c-DEE67DJO.mjs";
+import "./c-WO3QSZUU.mjs";
+import "./c-S2RVHR3M.mjs";
+import "./c-EQBKXWNX.mjs";
+import "./c-RQJJ26T4.mjs";
+import "./c-L5GHWG5G.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/pi-background-tasks/src/core/fusion/orchestrator.ts?ext=pi-background-tasks
+import { createHash as createHash4, randomBytes as nodeRandomBytes } from "node:crypto";
+
+// node_modules/pi-background-tasks/src/core/fusion/budget.ts?ext=pi-background-tasks
+import { createHash } from "node:crypto";
+var FUSION_CALIBRATED_BYTES_PER_TOKEN = TOKEN_BUDGET_FAMILY_CALIBRATIONS;
+var FUSION_OUTPUT_RESERVE_RATE_X100 = 200;
+var FUSION_UTILIZATION_WARNING_THRESHOLD_BASIS_POINTS = 8e3;
+var BASIS_POINTS_DENOMINATOR = 1e4;
+function ceilDiv(numerator, denominator) {
+  if (!Number.isSafeInteger(numerator) || numerator < 0) {
+    throw new TypeError("ceilDiv numerator must be a non-negative safe integer");
+  }
+  if (!Number.isSafeInteger(denominator) || denominator <= 0) {
+    throw new TypeError("ceilDiv denominator must be a positive safe integer");
+  }
+  if (numerator === 0) return 0;
+  return Math.floor((numerator - 1) / denominator) + 1;
+}
+__name(ceilDiv, "ceilDiv");
+var FUSION_RESERVED_OUTPUT_TOKENS = ceilDiv(
+  FUSION_MERGE_MAX_OUTPUT_BYTES * TOKEN_BUDGET_RATE_SCALE,
+  FUSION_OUTPUT_RESERVE_RATE_X100
+);
+var FUSION_FRAMING_RESERVE_TOKENS = 0;
+var FUSION_SAFETY_RESERVE_TOKENS = 4096;
+var FUSION_MIN_CANONICAL_INPUT_TOKENS = 8192;
+var FUSION_MIN_CONTEXT_WINDOW_TOKENS = FUSION_MIN_CANONICAL_INPUT_TOKENS + FUSION_RESERVED_OUTPUT_TOKENS + FUSION_FRAMING_RESERVE_TOKENS + FUSION_SAFETY_RESERVE_TOKENS;
+var FUSION_BUDGET_POLICY = {
+  id: "fusion-budget-policy-v4",
+  route_output_reserve_strategy: "max_fusion_contract_or_model_max",
+  calibration_version: TOKEN_BUDGET_CALIBRATION_VERSION,
+  calibration_table: FUSION_CALIBRATED_BYTES_PER_TOKEN,
+  reserved_output_tokens: FUSION_RESERVED_OUTPUT_TOKENS,
+  framing_reserve_tokens: FUSION_FRAMING_RESERVE_TOKENS,
+  safety_reserve_tokens: FUSION_SAFETY_RESERVE_TOKENS,
+  candidate_output_contract_bytes: FUSION_CANDIDATE_MAX_OUTPUT_BYTES,
+  evaluation_output_contract_bytes: FUSION_EVALUATION_MAX_OUTPUT_BYTES,
+  merge_output_contract_bytes: FUSION_MERGE_MAX_OUTPUT_BYTES,
+  diagnostics_contract_bytes: FUSION_DIAGNOSTICS_MAX_BYTES,
+  utilization_warning_threshold_basis_points: FUSION_UTILIZATION_WARNING_THRESHOLD_BASIS_POINTS
+};
+var REASON_EMPTY_REMEDIATION = Object.freeze([
+  "Start a fresh Pi conversation, or run fusion_reason earlier in the session.",
+  "Raise the route's context window with a larger-context subscription model via /fusion-models.",
+  "Restate only the required prior findings in the fusion_reason prompt."
+]);
+var REASON_REQUEST_REMEDIATION = Object.freeze([
+  "Provide a shorter fusion_reason prompt.",
+  "Start a fresh Pi conversation, or run fusion_reason earlier in the session.",
+  "Raise the route's context window with a larger-context subscription model via /fusion-models."
+]);
+var INVESTIGATE_EMPTY_REMEDIATION = Object.freeze([
+  "Split the repository investigation into smaller independently complete path or subsystem scopes.",
+  "Raise the route's context window with a larger-context subscription model via /fusion-models."
+]);
+var INVESTIGATE_REQUEST_REMEDIATION = Object.freeze([
+  "Narrow the fusion_investigate objective, repository scope, or required evidence.",
+  "Raise the route's context window with a larger-context subscription model via /fusion-models."
+]);
+var RESEARCH_EMPTY_REMEDIATION = Object.freeze([
+  "Split the research into smaller independently complete source sets.",
+  "Raise the route's context window with a larger-context subscription model via /fusion-models."
+]);
+var RESEARCH_REQUEST_REMEDIATION = Object.freeze([
+  "Narrow the fusion_research question or split large declared-source sets across independent runs.",
+  "Raise the route's context window with a larger-context subscription model via /fusion-models."
+]);
+var VALIDATE_EMPTY_REMEDIATION = Object.freeze([
+  "Split validation into smaller independently complete change or acceptance-criterion scopes.",
+  "Raise the route's context window with a larger-context subscription model via /fusion-models."
+]);
+var VALIDATE_REQUEST_REMEDIATION = Object.freeze([
+  "Narrow the fusion_validate scope, acceptance criteria, or supplied verification evidence.",
+  "Raise the route's context window with a larger-context subscription model via /fusion-models."
+]);
+function cleanRemediation(profile, requestDeterminesFeasibility) {
+  if (profile.id === "investigate") {
+    return requestDeterminesFeasibility ? INVESTIGATE_REQUEST_REMEDIATION : INVESTIGATE_EMPTY_REMEDIATION;
+  }
+  if (profile.id === "research") {
+    return requestDeterminesFeasibility ? RESEARCH_REQUEST_REMEDIATION : RESEARCH_EMPTY_REMEDIATION;
+  }
+  if (profile.id === "validate") {
+    return requestDeterminesFeasibility ? VALIDATE_REQUEST_REMEDIATION : VALIDATE_EMPTY_REMEDIATION;
+  }
+  return requestDeterminesFeasibility ? REASON_REQUEST_REMEDIATION : REASON_EMPTY_REMEDIATION;
+}
+__name(cleanRemediation, "cleanRemediation");
+var RESERVATION_REMEDIATION = Object.freeze([
+  "Route the blocking stage to a model with larger byte capacity.",
+  "Keep producer output contracts intact; do not shrink or truncate child answers.",
+  "Inspect budget-plan.json for the advisory reservation component before retrying."
+]);
+var DENSE_REMEDIATION = Object.freeze([
+  "Remove or externalize low-whitespace dense ASCII payloads (base64, minified code, PEM/hex blocks), then retry.",
+  "The prompt is preserved; no content was clipped to fit."
+]);
+var MULTIBYTE_REMEDIATION = Object.freeze([
+  "This rejection is dominated by multibyte UTF-8 content; use a larger-context route or split the non-Latin/CJK-heavy task.",
+  "The budget plan includes the stricter multibyte advisory ceiling separately from the fatal estimate.",
+  "The prompt is preserved; no content was clipped to fit."
+]);
+var EMPTY_CANDIDATES = Object.freeze([
+  Object.freeze({ candidate_id: "A", response: "" }),
+  Object.freeze({ candidate_id: "B", response: "" }),
+  Object.freeze({ candidate_id: "C", response: "" })
+]);
+var EMPTY_EVALUATION = Object.freeze({
+  schema_version: FUSION_EVALUATION_SCHEMA_VERSION,
+  candidate_assessments: Object.freeze([
+    Object.freeze({
+      candidate_id: "A",
+      summary: "",
+      strengths: Object.freeze([]),
+      limitations: Object.freeze([]),
+      useful_contributions: Object.freeze([]),
+      risks: Object.freeze([])
+    }),
+    Object.freeze({
+      candidate_id: "B",
+      summary: "",
+      strengths: Object.freeze([]),
+      limitations: Object.freeze([]),
+      useful_contributions: Object.freeze([]),
+      risks: Object.freeze([])
+    }),
+    Object.freeze({
+      candidate_id: "C",
+      summary: "",
+      strengths: Object.freeze([]),
+      limitations: Object.freeze([]),
+      useful_contributions: Object.freeze([]),
+      risks: Object.freeze([])
+    })
+  ]),
+  agreements: Object.freeze([]),
+  conflicts: Object.freeze([]),
+  synthesis_plan: Object.freeze({
+    must_include: Object.freeze([]),
+    must_resolve: Object.freeze([]),
+    must_avoid: Object.freeze([])
+  })
+});
+function utf8Bytes(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+__name(utf8Bytes, "utf8Bytes");
+function sha256Hex(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+__name(sha256Hex, "sha256Hex");
+function requirePositiveContextWindow(model, role) {
+  const value = model.contextWindow;
+  if (!isUsableContextWindow(value)) {
+    throw new FusionError(
+      `fusion ${role} route ${model.qualifiedId} has no usable context window capacity`,
+      { code: "model_capacity_unknown", childCreated: false }
+    );
+  }
+  return value;
+}
+__name(requirePositiveContextWindow, "requirePositiveContextWindow");
+function formatRateX100(value) {
+  const whole = Math.floor(value / TOKEN_BUDGET_RATE_SCALE);
+  const frac = String(value % TOKEN_BUDGET_RATE_SCALE).padStart(2, "0");
+  return `${String(whole)}.${frac}`;
+}
+__name(formatRateX100, "formatRateX100");
+function routeCapacity(model, role) {
+  const contextWindow = requirePositiveContextWindow(model, role);
+  const reservedOutputTokens = Math.max(FUSION_RESERVED_OUTPUT_TOKENS, model.maxOutputTokens);
+  const allowed = allowedInputTokens(contextWindow, {
+    reservedOutputTokens,
+    framingReserveTokens: FUSION_FRAMING_RESERVE_TOKENS,
+    safetyReserveTokens: FUSION_SAFETY_RESERVE_TOKENS
+  });
+  if (allowed < FUSION_MIN_CANONICAL_INPUT_TOKENS) {
+    const minimumContextWindow = reservedOutputTokens + FUSION_FRAMING_RESERVE_TOKENS + FUSION_SAFETY_RESERVE_TOKENS + FUSION_MIN_CANONICAL_INPUT_TOKENS;
+    throw new FusionError(
+      `fusion ${role} route ${model.qualifiedId} has a ${String(contextWindow)}-token context window, but Fusion requires at least ${String(minimumContextWindow)} tokens: ${String(reservedOutputTokens)} reserved for the route's configured maximum output + ${String(FUSION_FRAMING_RESERVE_TOKENS)} framing + ${String(FUSION_SAFETY_RESERVE_TOKENS)} safety + ${String(FUSION_MIN_CANONICAL_INPUT_TOKENS)} usable input. Choose a larger-context or lower-max-output subscription model for this slot with /fusion-models.`,
+      { code: "model_capacity_unknown", childCreated: false }
+    );
+  }
+  const family = resolveTokenBudgetFamily({ provider: model.provider, model: model.model });
+  const rateSource = estimateInputTokens({
+    family: family.family,
+    calibrationBacked: family.backed,
+    familyResolution: family.resolution,
+    allowedInputTokens: allowed,
+    scope: "fusion",
+    segments: [
+      {
+        kind: "known_text",
+        bytes: TOKEN_BUDGET_LARGE_PROMPT_MIN_BYTES,
+        multibyteBytes: 0,
+        denseBytes: 0,
+        asciiWhitespaceBytes: TOKEN_BUDGET_LARGE_PROMPT_MIN_BYTES
+      }
+    ]
+  }).rateSource;
+  return {
+    role,
+    provider: model.provider,
+    model: model.model,
+    qualified_id: model.qualifiedId,
+    context_window_tokens: contextWindow,
+    reserved_output_tokens: reservedOutputTokens,
+    framing_reserve_tokens: FUSION_FRAMING_RESERVE_TOKENS,
+    safety_reserve_tokens: FUSION_SAFETY_RESERVE_TOKENS,
+    allowed_input_tokens: allowed,
+    family: family.family,
+    rate_source: rateSource,
+    byte_capacity_utf8_bytes: Math.floor(
+      allowed * rateSource.effective_rate_bytes_per_token_x100 / TOKEN_BUDGET_RATE_SCALE
+    )
+  };
+}
+__name(routeCapacity, "routeCapacity");
+function fusionRouteCapacities(models) {
+  return [
+    routeCapacity(models.candidates[0], "candidate-1"),
+    routeCapacity(models.candidates[1], "candidate-2"),
+    routeCapacity(models.candidates[2], "candidate-3"),
+    routeCapacity(models.evaluator, "evaluator"),
+    routeCapacity(models.merger, "merger")
+  ];
+}
+__name(fusionRouteCapacities, "fusionRouteCapacities");
+function fusionLimitingRoute(routes) {
+  let limiting;
+  for (const route of routes) {
+    if (limiting === void 0 || route.byte_capacity_utf8_bytes < limiting.byte_capacity_utf8_bytes || route.byte_capacity_utf8_bytes === limiting.byte_capacity_utf8_bytes && route.role.localeCompare(limiting.role) < 0) {
+      limiting = route;
+    }
+  }
+  if (limiting === void 0) {
+    throw new FusionError("fusion budget planning received no configured routes", {
+      code: "model_capacity_unknown",
+      childCreated: false
+    });
+  }
+  return limiting;
+}
+__name(fusionLimitingRoute, "fusionLimitingRoute");
+function routeByRole(routes, role) {
+  const route = routes.find((item) => item.role === role);
+  if (route === void 0) {
+    throw new FusionError(`fusion budget route ${role} is missing`, {
+      code: "model_capacity_unknown",
+      childCreated: false
+    });
+  }
+  return route;
+}
+__name(routeByRole, "routeByRole");
+function candidateRole(slot) {
+  if (slot === 1) return "candidate-1";
+  if (slot === 2) return "candidate-2";
+  return "candidate-3";
+}
+__name(candidateRole, "candidateRole");
+function estimateRouteInput(route, segments) {
+  return estimateInputTokens({
+    family: route.family,
+    calibrationBacked: route.rate_source.backed,
+    familyResolution: route.rate_source.model_resolution,
+    allowedInputTokens: route.allowed_input_tokens,
+    scope: "fusion",
+    segments
+  });
+}
+__name(estimateRouteInput, "estimateRouteInput");
+function utilizationBasisPoints(tokens, allowed) {
+  return ceilDiv(tokens * BASIS_POINTS_DENOMINATOR, allowed);
+}
+__name(utilizationBasisPoints, "utilizationBasisPoints");
+function forecastEntry(draft) {
+  const inputSegments = [knownTextSegment(draft.system_prompt), knownTextSegment(draft.empty_user_prompt)];
+  const inputBytes = inputSegments.reduce((sum, segment) => sum + segment.bytes, 0);
+  const inputOnly = estimateRouteInput(draft.route, inputSegments);
+  const reservationSegments = draft.upstream_output_contract_bytes === 0 ? inputSegments : [...inputSegments, unknownOutputContractSegment(draft.upstream_output_contract_bytes)];
+  const reservation = estimateRouteInput(draft.route, reservationSegments);
+  const forecastUtf8Bytes = inputBytes + draft.upstream_output_contract_bytes;
+  const entry = {
+    budget_stage: draft.budget_stage,
+    route: draft.route,
+    conditional: draft.conditional,
+    check_kind: "input_only_preflight",
+    input_utf8_bytes: inputBytes,
+    upstream_output_contract_bytes: draft.upstream_output_contract_bytes,
+    forecast_utf8_bytes: forecastUtf8Bytes,
+    input_only_input_tokens_upper_bound: inputOnly.tokens,
+    forecast_input_tokens_upper_bound: reservation.tokens,
+    allowed_input_tokens: draft.route.allowed_input_tokens,
+    input_only_signed_headroom_tokens: draft.route.allowed_input_tokens - inputOnly.tokens,
+    signed_headroom_tokens: draft.route.allowed_input_tokens - reservation.tokens,
+    input_only_utilization_basis_points: utilizationBasisPoints(
+      inputOnly.tokens,
+      draft.route.allowed_input_tokens
+    ),
+    utilization_basis_points: utilizationBasisPoints(
+      reservation.tokens,
+      draft.route.allowed_input_tokens
+    ),
+    input_only_estimate: inputOnly,
+    reservation_estimate: reservation,
+    fits: inputOnly.tokens <= draft.route.allowed_input_tokens,
+    reservation_fits: reservation.tokens <= draft.route.allowed_input_tokens
+  };
+  if (draft.slot !== void 0) entry.slot = draft.slot;
+  return entry;
+}
+__name(forecastEntry, "forecastEntry");
+function maxKnownTextBytes(route) {
+  return maxKnownTextBytesForTokens({
+    family: route.family,
+    calibrationBacked: route.rate_source.backed,
+    familyResolution: route.rate_source.model_resolution,
+    allowedInputTokens: route.allowed_input_tokens,
+    scope: "fusion"
+  });
+}
+__name(maxKnownTextBytes, "maxKnownTextBytes");
+function blockerFromEntry(entry) {
+  return {
+    ...entry,
+    overage_tokens: Math.max(0, entry.input_only_input_tokens_upper_bound - entry.allowed_input_tokens),
+    bytes_over: Math.max(0, entry.input_utf8_bytes - maxKnownTextBytes(entry.route))
+  };
+}
+__name(blockerFromEntry, "blockerFromEntry");
+function blockerOrder(blocker) {
+  if (blocker.budget_stage === "candidate") return blocker.slot ?? 1;
+  if (blocker.budget_stage === "evaluation") return 4;
+  if (blocker.budget_stage === "merge") return 5;
+  return 6;
+}
+__name(blockerOrder, "blockerOrder");
+function selectBlockers(entries) {
+  return entries.filter((entry) => !entry.fits).map(blockerFromEntry).sort((left, right) => {
+    const byOrder = blockerOrder(left) - blockerOrder(right);
+    if (byOrder !== 0) return byOrder;
+    return left.route.role.localeCompare(right.route.role);
+  });
+}
+__name(selectBlockers, "selectBlockers");
+function selectPrimaryBlocker(blockers) {
+  const mandatory = blockers.find((blocker) => !blocker.conditional);
+  return mandatory ?? blockers[0];
+}
+__name(selectPrimaryBlocker, "selectPrimaryBlocker");
+function replaceRequestText(input, text) {
+  return {
+    ...input,
+    request: {
+      ...input.request,
+      text,
+      sha256: sha256Hex(text)
+    }
+  };
+}
+__name(replaceRequestText, "replaceRequestText");
+function visibleTextBytes(input) {
+  const projection = input.context?.kind === "session_projection" ? input.context.conversation_projection : "conversation_projection" in input ? input.conversation_projection : void 0;
+  if (projection === void 0) return 0;
+  let total = 0;
+  for (const entry of projection.entries) {
+    if (entry[0] === "t") total += utf8Bytes(JSON.stringify(entry[4]));
+  }
+  return total;
+}
+__name(visibleTextBytes, "visibleTextBytes");
+function omissionReceiptBytes(input) {
+  const projection = input.context?.kind === "session_projection" ? input.context.conversation_projection : "conversation_projection" in input ? input.conversation_projection : void 0;
+  if (projection === void 0) return 0;
+  let total = 0;
+  for (const entry of projection.entries) {
+    if (entry[0] === "o") total += utf8Bytes(JSON.stringify(entry));
+  }
+  return total;
+}
+__name(omissionReceiptBytes, "omissionReceiptBytes");
+function warningFromEntry(entry) {
+  if (!entry.fits) return void 0;
+  if (!entry.reservation_fits) {
+    return {
+      ...entry,
+      warning_kind: "worst_case_reservation",
+      threshold_basis_points: FUSION_UTILIZATION_WARNING_THRESHOLD_BASIS_POINTS
+    };
+  }
+  if (entry.utilization_basis_points >= FUSION_UTILIZATION_WARNING_THRESHOLD_BASIS_POINTS) {
+    return {
+      ...entry,
+      warning_kind: "input_utilization",
+      threshold_basis_points: FUSION_UTILIZATION_WARNING_THRESHOLD_BASIS_POINTS
+    };
+  }
+  return void 0;
+}
+__name(warningFromEntry, "warningFromEntry");
+function warningsFor(entries) {
+  return entries.flatMap((entry) => {
+    const warning = warningFromEntry(entry);
+    return warning === void 0 ? [] : [warning];
+  });
+}
+__name(warningsFor, "warningsFor");
+function entryLabel(entry) {
+  const slot = entry.slot === void 0 ? "" : `-${String(entry.slot)}`;
+  const conditional = entry.conditional ? " (conditional)" : "";
+  return `${entry.budget_stage}${slot}${conditional}`;
+}
+__name(entryLabel, "entryLabel");
+function blockingChildLabel(entry) {
+  if (entry.budget_stage === "candidate") return `candidate-${String(entry.slot ?? 1)}`;
+  if (entry.budget_stage === "evaluation_repair") return "evaluator-repair";
+  if (entry.budget_stage === "evaluation") return "evaluator";
+  return "merger";
+}
+__name(blockingChildLabel, "blockingChildLabel");
+function formatTable(entries) {
+  const lines = entries.map(
+    (entry) => `${entryLabel(entry)} | route=${entry.route.qualified_id} | input=${String(entry.input_only_input_tokens_upper_bound)} | reserved=${String(entry.forecast_input_tokens_upper_bound)} | allowed=${String(entry.allowed_input_tokens)} | input_headroom=${String(entry.input_only_signed_headroom_tokens)} | reservation_headroom=${String(entry.signed_headroom_tokens)} | ${entry.fits ? "input-fits" : "input-over"} | ${entry.reservation_fits ? "reservation-fits" : "reservation-warn"}`
+  );
+  return lines.join("\n");
+}
+__name(formatTable, "formatTable");
+function formatComposition(composition) {
+  return [
+    `visible text ${String(composition.visible_text_bytes)} B`,
+    `omission receipts ${String(composition.omission_receipt_bytes)} B`,
+    `projection metadata ${String(composition.projection_metadata_bytes)} B`,
+    `request ${String(composition.request_bytes)} B`,
+    `static stage framing ${String(composition.static_stage_framing_bytes)} B`,
+    `upstream output contracts ${String(composition.upstream_output_contract_bytes)} B`
+  ].join("; ");
+}
+__name(formatComposition, "formatComposition");
+function dominantRemediation(verdict, composition, dominantByteClass, profile) {
+  if (dominantByteClass === "dense_ascii") return DENSE_REMEDIATION;
+  if (dominantByteClass === "multibyte") return MULTIBYTE_REMEDIATION;
+  if (composition === void 0) return remediationFor(verdict, profile);
+  const entries = [
+    { name: "visible", bytes: composition.visible_text_bytes },
+    { name: "request", bytes: composition.request_bytes },
+    { name: "reservation", bytes: composition.upstream_output_contract_bytes }
+  ].sort((left, right) => right.bytes - left.bytes);
+  const dominant = entries[0];
+  if (dominant?.name === "reservation") return RESERVATION_REMEDIATION;
+  if (dominant?.name === "request" && !verdict.still_fails_with_empty_request) {
+    return profile.contextKind === "clean_task" ? cleanRemediation(profile, true) : REASON_REQUEST_REMEDIATION;
+  }
+  if (profile.contextKind === "clean_task") return cleanRemediation(profile, false);
+  return REASON_EMPTY_REMEDIATION;
+}
+__name(dominantRemediation, "dominantRemediation");
+function remediationFor(verdict, profile) {
+  if (profile.contextKind === "clean_task") {
+    return cleanRemediation(profile, !verdict.still_fails_with_empty_request);
+  }
+  return verdict.still_fails_with_empty_request ? REASON_EMPTY_REMEDIATION : REASON_REQUEST_REMEDIATION;
+}
+__name(remediationFor, "remediationFor");
+function formatEmptyRequestVerdict(verdict) {
+  if (verdict.still_fails_with_empty_request) {
+    return `Empty-request counterfactual: still fails with ${String(verdict.blockers_with_empty_request.length)} blocking stage(s), so shortening the request cannot make this workflow fit.`;
+  }
+  if (verdict.minimum_request_byte_reduction === 0) {
+    return "Empty-request counterfactual: fits; no request reduction is required by the current plan.";
+  }
+  return `Empty-request counterfactual: fits, so request size determines feasibility; reduce the request by at least ${String(verdict.minimum_request_byte_reduction)} UTF-8 bytes, leaving at most ${String(verdict.maximum_safe_request_utf8_bytes)} UTF-8 bytes.`;
+}
+__name(formatEmptyRequestVerdict, "formatEmptyRequestVerdict");
+function stageFromBudgetStage(stage) {
+  if (stage === "merge") return "merge";
+  if (stage === "candidate") return "candidate";
+  return "evaluation";
+}
+__name(stageFromBudgetStage, "stageFromBudgetStage");
+function routeTable(routes) {
+  return [...routes].sort((left, right) => {
+    const byCapacity = left.byte_capacity_utf8_bytes - right.byte_capacity_utf8_bytes;
+    if (byCapacity !== 0) return byCapacity;
+    return left.role.localeCompare(right.role);
+  }).map((route) => ({
+    role: route.role,
+    qualified_id: route.qualified_id,
+    allowed_input_tokens: route.allowed_input_tokens,
+    family: route.family,
+    effective_rate_bytes_per_token_x100: route.rate_source.effective_rate_bytes_per_token_x100,
+    byte_capacity_utf8_bytes: route.byte_capacity_utf8_bytes,
+    backed: route.rate_source.backed
+  }));
+}
+__name(routeTable, "routeTable");
+function segmentTokensForBytes(route, bytes) {
+  if (bytes <= 0) return 0;
+  const estimate = estimateRouteInput(route, [
+    { kind: "known_text", bytes, multibyteBytes: 0, denseBytes: 0 }
+  ]);
+  const segment = estimate.perSegment[0];
+  return segment === void 0 ? 0 : segment.tokens;
+}
+__name(segmentTokensForBytes, "segmentTokensForBytes");
+function contractTokens(bytes) {
+  return bytes;
+}
+__name(contractTokens, "contractTokens");
+function componentBreakdown(composition, route) {
+  const empty = {
+    visible_text_bytes: 0,
+    omission_receipt_bytes: 0,
+    projection_metadata_bytes: 0,
+    request_bytes: 0,
+    static_stage_framing_bytes: 0,
+    upstream_output_contract_bytes: 0
+  };
+  const item = composition ?? empty;
+  return {
+    visible_text: {
+      bytes: item.visible_text_bytes,
+      tokens: segmentTokensForBytes(route, item.visible_text_bytes)
+    },
+    omission_receipts: {
+      bytes: item.omission_receipt_bytes,
+      tokens: segmentTokensForBytes(route, item.omission_receipt_bytes)
+    },
+    projection_metadata: {
+      bytes: item.projection_metadata_bytes,
+      tokens: segmentTokensForBytes(route, item.projection_metadata_bytes)
+    },
+    request: {
+      bytes: item.request_bytes,
+      tokens: segmentTokensForBytes(route, item.request_bytes)
+    },
+    static_stage_framing: {
+      bytes: item.static_stage_framing_bytes,
+      tokens: segmentTokensForBytes(route, item.static_stage_framing_bytes)
+    },
+    upstream_output_contracts: {
+      bytes: item.upstream_output_contract_bytes,
+      tokens: contractTokens(item.upstream_output_contract_bytes)
+    }
+  };
+}
+__name(componentBreakdown, "componentBreakdown");
+function medianCounterfactual(primary) {
+  if (!primary.route.rate_source.backed) {
+    return { forecast_input_tokens_upper_bound: null, signed_headroom_tokens: null, fits: null };
+  }
+  const median = primary.route.rate_source.provenance.median_bpt_x1000;
+  if (median === null) return { forecast_input_tokens_upper_bound: null, signed_headroom_tokens: null, fits: null };
+  const variableTokens = ceilDiv(primary.input_utf8_bytes * 1e3, median);
+  const tokens = variableTokens + TOKEN_BUDGET_AFFINE_F_TOKENS;
+  return {
+    forecast_input_tokens_upper_bound: tokens,
+    signed_headroom_tokens: primary.allowed_input_tokens - tokens,
+    fits: tokens <= primary.allowed_input_tokens
+  };
+}
+__name(medianCounterfactual, "medianCounterfactual");
+function inputCounterfactuals(primary, plan) {
+  return {
+    empty_request: plan.empty_request,
+    without_reservation: {
+      forecast_input_tokens_upper_bound: primary.input_only_input_tokens_upper_bound,
+      signed_headroom_tokens: primary.input_only_signed_headroom_tokens,
+      fits: primary.fits
+    },
+    at_median_rate: medianCounterfactual(primary)
+  };
+}
+__name(inputCounterfactuals, "inputCounterfactuals");
+function budgetErrorCode(checkKind) {
+  return checkKind === "rendered_prompt" ? "prompt_budget_exceeded_measured" : "prompt_budget_exceeded_forecast";
+}
+__name(budgetErrorCode, "budgetErrorCode");
+var FusionBudget = class {
+  static {
+    __name(this, "FusionBudget");
+  }
+  routes;
+  limiting;
+  contextPolicyId;
+  candidateCapability;
+  profile;
+  constructor(models, contextPolicyId, candidateCapability = FUSION_REASON_WORKFLOW.candidateCapability, profile = FUSION_REASON_WORKFLOW) {
+    this.routes = fusionRouteCapacities(models);
+    this.limiting = fusionLimitingRoute(this.routes);
+    this.contextPolicyId = contextPolicyId;
+    this.candidateCapability = candidateCapability;
+    this.profile = profile;
+  }
+  get allowedInputTokens() {
+    return this.limiting.allowed_input_tokens;
+  }
+  get resultRateSources() {
+    return this.routes.map((route) => route.rate_source);
+  }
+  get unknownProviderWarnings() {
+    return this.routes.flatMap((route) => {
+      const warning = route.rate_source.warning;
+      return route.rate_source.backed || warning === null ? [] : [`${route.qualified_id}: ${warning}`];
+    });
+  }
+  routeForStage(stage, slot) {
+    if (stage === "candidate") return routeByRole(this.routes, candidateRole(slot ?? 1));
+    if (stage === "merge") return routeByRole(this.routes, "merger");
+    return routeByRole(this.routes, "evaluator");
+  }
+  drafts(input) {
+    const candidateSystemPrompt = this.profile.candidateSystemPrompt(this.candidateCapability);
+    const candidatePrompt = buildCandidatePrompt(input);
+    const blindInput = buildBlindEvaluationInput(input, EMPTY_CANDIDATES);
+    const evaluationPrompt = buildEvaluationPrompt(blindInput);
+    const repairPrompt = buildEvaluationRepairPrompt({
+      schema_version: "pi-background-tasks.fusion-evaluation-repair-input.v1",
+      original_blind_input: blindInput,
+      invalid_output: "",
+      validation_errors: []
+    });
+    const mergePrompt = buildMergePrompt(buildMergeInput(input, EMPTY_CANDIDATES, EMPTY_EVALUATION));
+    return [
+      {
+        budget_stage: "candidate",
+        slot: 1,
+        route: this.routeForStage("candidate", 1),
+        conditional: false,
+        system_prompt: candidateSystemPrompt,
+        empty_user_prompt: candidatePrompt,
+        upstream_output_contract_bytes: 0
+      },
+      {
+        budget_stage: "candidate",
+        slot: 2,
+        route: this.routeForStage("candidate", 2),
+        conditional: false,
+        system_prompt: candidateSystemPrompt,
+        empty_user_prompt: candidatePrompt,
+        upstream_output_contract_bytes: 0
+      },
+      {
+        budget_stage: "candidate",
+        slot: 3,
+        route: this.routeForStage("candidate", 3),
+        conditional: false,
+        system_prompt: candidateSystemPrompt,
+        empty_user_prompt: candidatePrompt,
+        upstream_output_contract_bytes: 0
+      },
+      {
+        budget_stage: "evaluation",
+        route: this.routeForStage("evaluation"),
+        conditional: false,
+        system_prompt: this.profile.evaluatorSystemPrompt,
+        empty_user_prompt: evaluationPrompt,
+        upstream_output_contract_bytes: 3 * FUSION_CANDIDATE_MAX_OUTPUT_BYTES
+      },
+      {
+        budget_stage: "merge",
+        route: this.routeForStage("merge"),
+        conditional: false,
+        system_prompt: this.profile.mergerSystemPrompt,
+        empty_user_prompt: mergePrompt,
+        upstream_output_contract_bytes: 3 * FUSION_CANDIDATE_MAX_OUTPUT_BYTES + FUSION_EVALUATION_MAX_OUTPUT_BYTES
+      },
+      {
+        budget_stage: "evaluation_repair",
+        route: this.routeForStage("evaluation_repair"),
+        conditional: true,
+        system_prompt: this.profile.evaluationRepairSystemPrompt,
+        empty_user_prompt: repairPrompt,
+        upstream_output_contract_bytes: 3 * FUSION_CANDIDATE_MAX_OUTPUT_BYTES + FUSION_EVALUATION_MAX_OUTPUT_BYTES + FUSION_DIAGNOSTICS_MAX_BYTES
+      }
+    ];
+  }
+  entries(input) {
+    return this.drafts(input).map(forecastEntry);
+  }
+  composition(input, blocker) {
+    const canonicalBytes = utf8Bytes(buildCandidatePrompt(input));
+    const emptyRequestCanonicalBytes = utf8Bytes(buildCandidatePrompt(replaceRequestText(input, "")));
+    const requestBytes = canonicalBytes - emptyRequestCanonicalBytes;
+    const visible = visibleTextBytes(input);
+    const omissions = omissionReceiptBytes(input);
+    const projectionMetadata = canonicalBytes - requestBytes - visible - omissions;
+    const draft = this.drafts(input).find(
+      (item) => item.budget_stage === blocker.budget_stage && item.slot === blocker.slot
+    );
+    if (draft === void 0) {
+      throw new FusionError("primary budget blocker disappeared during composition", {
+        code: "orchestration_failed",
+        childCreated: false
+      });
+    }
+    return {
+      visible_text_bytes: visible,
+      omission_receipt_bytes: omissions,
+      projection_metadata_bytes: projectionMetadata,
+      request_bytes: requestBytes,
+      static_stage_framing_bytes: utf8Bytes(draft.system_prompt) + utf8Bytes(draft.empty_user_prompt) - canonicalBytes,
+      upstream_output_contract_bytes: draft.upstream_output_contract_bytes
+    };
+  }
+  emptyRequestVerdict(input, entries) {
+    const emptyEntries = this.entries(replaceRequestText(input, ""));
+    const emptyBlockers = selectBlockers(emptyEntries);
+    let reduction = 0;
+    for (const entry of entries) {
+      reduction = Math.max(reduction, entry.input_utf8_bytes - maxKnownTextBytes(entry.route));
+    }
+    reduction = Math.max(0, reduction);
+    const requestBytes = utf8Bytes(input.request.text);
+    return {
+      request_utf8_bytes: requestBytes,
+      still_fails_with_empty_request: emptyBlockers.length > 0,
+      shortening_request_can_help: emptyBlockers.length === 0,
+      minimum_request_byte_reduction: reduction,
+      maximum_safe_request_utf8_bytes: Math.max(0, requestBytes - reduction),
+      blockers_with_empty_request: emptyBlockers
+    };
+  }
+  failure(primary, plan, artifactDir, measurementKind, checkKind) {
+    const composition = plan.primary_blocker_composition;
+    const dominantByteClass = primary.input_only_estimate.rateSource.dominant_byte_class;
+    const remediation = dominantRemediation(
+      plan.empty_request,
+      composition,
+      dominantByteClass,
+      this.profile
+    );
+    const tokensOver = primary.input_only_input_tokens_upper_bound - primary.allowed_input_tokens;
+    const budget = {
+      budget_stage: primary.budget_stage,
+      measurement_kind: measurementKind,
+      check_kind: checkKind,
+      measured_utf8_bytes: primary.input_utf8_bytes,
+      measured_input_tokens_upper_bound: primary.input_only_input_tokens_upper_bound,
+      allowed_input_tokens: primary.allowed_input_tokens,
+      limiting_model: {
+        provider: primary.route.provider,
+        model: primary.route.model,
+        qualified_id: primary.route.qualified_id,
+        context_window_tokens: primary.route.context_window_tokens
+      },
+      rate_source: primary.input_only_estimate.rateSource,
+      backed: primary.input_only_estimate.rateSource.backed,
+      dominant_byte_class: dominantByteClass,
+      component_breakdown: componentBreakdown(composition, primary.route),
+      byte_class_breakdown: primary.input_only_estimate.byte_class_breakdown,
+      dense_regions: [],
+      bytes_over: primary.bytes_over,
+      tokens_over: Math.max(0, tokensOver),
+      required_allowed_tokens: primary.input_only_input_tokens_upper_bound,
+      route_table: routeTable(this.routes),
+      counterfactuals: inputCounterfactuals(primary, plan),
+      stage_upstream_actuals: [],
+      policy_id: FUSION_BUDGET_POLICY.id,
+      calibration_version: TOKEN_BUDGET_CALIBRATION_VERSION,
+      context_policy_id: this.contextPolicyId,
+      remediation,
+      blockers: plan.blockers,
+      artifact_dir: artifactDir
+    };
+    if (primary.slot !== void 0) budget.slot = primary.slot;
+    const compositionText = composition === void 0 ? "unavailable" : formatComposition(composition);
+    const additional = plan.blockers.filter((blocker) => blocker !== primary).map((blocker) => `${entryLabel(blocker)} route=${blocker.route.qualified_id}`).join("; ");
+    const rateText = `${primary.route.family} ${formatRateX100(primary.input_only_estimate.rateSource.effective_rate_bytes_per_token_x100)} B/tok + ${String(primary.input_only_estimate.rateSource.affine_f_tokens)} tokens (${primary.input_only_estimate.rateSource.source}, backed=${String(primary.input_only_estimate.rateSource.backed)}, dominant=${dominantByteClass})`;
+    const sourceWarning = primary.input_only_estimate.rateSource.warning;
+    const routeWarning = sourceWarning === null ? "" : ` Rate warning: ${sourceWarning}.`;
+    const checkText = checkKind === "input_only_preflight" ? "input-only preflight forecast" : "exact rendered prompt measurement";
+    const dominantText = dominantByteClass === "multibyte" ? " Dominant byte class is multibyte UTF-8; the fatal gate uses the conservative multibyte rate and the plan separately records the provable 1.00 B/tok advisory ceiling." : dominantByteClass === "dense_ascii" ? " Dominant byte class is dense ASCII/low-whitespace content; the whitespace gate is a heuristic token-density proxy, not a bound." : ` Dominant byte class is ${dominantByteClass}.`;
+    const message = `Fusion prompt budget exceeded by ${checkText} before ${blockingChildLabel(primary)} child creation. Primary blocking stage: ${entryLabel(primary)} on route ${primary.route.qualified_id}. Forecast ${String(primary.input_utf8_bytes)} UTF-8 bytes (<= ${String(primary.input_only_input_tokens_upper_bound)} input tokens) against ${String(primary.allowed_input_tokens)} allowed input tokens, over by ${String(Math.max(0, tokensOver))} tokens. Estimator: ${rateText}.${routeWarning}${dominantText} The ${blockingChildLabel(primary)} child was not created. Nothing was clipped, dropped, or substituted. Artifact directory: ${artifactDir}.
+Per-stage forecast table:
+${formatTable(plan.stages)}
+Primary blocker byte composition: ${compositionText}.
+Additional blockers: ${additional.length === 0 ? "none" : additional}.
+${formatEmptyRequestVerdict(plan.empty_request)}
+Route byte-capacity order: ${routeTable(this.routes).map((route) => `${route.qualified_id}=${String(route.byte_capacity_utf8_bytes)}B`).join(", ")}.
+Remediation: ${remediation.join(" ")}`;
+    const details = {
+      code: budgetErrorCode(checkKind),
+      childCreated: false,
+      budget,
+      stage: stageFromBudgetStage(primary.budget_stage)
+    };
+    if (primary.slot !== void 0) return new FusionError(message, { ...details, slot: primary.slot });
+    return new FusionError(message, details);
+  }
+  planMetadata(input) {
+    return {
+      workflow: this.profile.id,
+      context: {
+        kind: this.profile.contextKind,
+        policy_id: input?.context?.policy_id ?? this.contextPolicyId
+      },
+      fixed_candidate_policy: {
+        capability: this.candidateCapability,
+        tools: this.profile.candidateTools
+      },
+      tool_policy: {
+        candidate_tools: this.profile.candidateTools,
+        evaluation_tools: [],
+        merge_tools: []
+      }
+    };
+  }
+  plan(input) {
+    const stages = this.entries(input);
+    const blockers = selectBlockers(stages);
+    const primary = selectPrimaryBlocker(blockers);
+    const emptyRequest = this.emptyRequestVerdict(input, stages);
+    const base = {
+      schema_version: FUSION_BUDGET_PLAN_SCHEMA_VERSION,
+      ...this.planMetadata(input),
+      policy: FUSION_BUDGET_POLICY,
+      routes: this.routes,
+      stages,
+      blockers,
+      empty_request: emptyRequest,
+      warnings: warningsFor(stages)
+    };
+    if (primary === void 0) return base;
+    return {
+      ...base,
+      primary_blocker: primary,
+      primary_blocker_composition: this.composition(input, primary)
+    };
+  }
+  assertPlanFits(plan, artifactDir) {
+    if (plan.primary_blocker !== void 0) {
+      throw this.failure(
+        plan.primary_blocker,
+        plan,
+        artifactDir,
+        "stage_forecast",
+        "input_only_preflight"
+      );
+    }
+  }
+  assertStagePrompt(stage, systemPrompt, userPrompt, slot) {
+    const route = this.routeForStage(stage, slot);
+    const inputSegments = [knownTextSegment(systemPrompt), knownTextSegment(userPrompt)];
+    const inputBytes = inputSegments.reduce((sum, segment) => sum + segment.bytes, 0);
+    const estimate = estimateRouteInput(route, inputSegments);
+    if (estimate.tokens <= route.allowed_input_tokens) return;
+    const entry = {
+      budget_stage: stage,
+      route,
+      conditional: stage === "evaluation_repair",
+      check_kind: "input_only_preflight",
+      input_utf8_bytes: inputBytes,
+      upstream_output_contract_bytes: 0,
+      forecast_utf8_bytes: inputBytes,
+      input_only_input_tokens_upper_bound: estimate.tokens,
+      forecast_input_tokens_upper_bound: estimate.tokens,
+      allowed_input_tokens: route.allowed_input_tokens,
+      input_only_signed_headroom_tokens: route.allowed_input_tokens - estimate.tokens,
+      signed_headroom_tokens: route.allowed_input_tokens - estimate.tokens,
+      input_only_utilization_basis_points: utilizationBasisPoints(estimate.tokens, route.allowed_input_tokens),
+      utilization_basis_points: utilizationBasisPoints(estimate.tokens, route.allowed_input_tokens),
+      input_only_estimate: estimate,
+      reservation_estimate: estimate,
+      fits: false,
+      reservation_fits: false
+    };
+    if (slot !== void 0) entry.slot = slot;
+    const blocker = blockerFromEntry(entry);
+    const plan = {
+      schema_version: FUSION_BUDGET_PLAN_SCHEMA_VERSION,
+      ...this.planMetadata(),
+      policy: FUSION_BUDGET_POLICY,
+      routes: this.routes,
+      stages: [entry],
+      blockers: [blocker],
+      primary_blocker: blocker,
+      empty_request: {
+        request_utf8_bytes: 0,
+        still_fails_with_empty_request: true,
+        shortening_request_can_help: false,
+        minimum_request_byte_reduction: blocker.bytes_over,
+        maximum_safe_request_utf8_bytes: 0,
+        blockers_with_empty_request: [blocker]
+      },
+      warnings: []
+    };
+    throw this.failure(blocker, plan, "stage prompt re-measurement", "rendered_prompt", "rendered_prompt");
+  }
+  calibrationViolationForCompletedChild(stage, systemPrompt, userPrompt, result, slot) {
+    const route = this.routeForStage(stage, slot);
+    const inputSegments = [knownTextSegment(systemPrompt), knownTextSegment(userPrompt)];
+    const promptUtf8Bytes = inputSegments.reduce((sum, segment) => sum + segment.bytes, 0);
+    const estimate = estimateRouteInput(route, inputSegments);
+    const observedUsage = result.firstRequestUsage;
+    if (observedUsage === void 0) return void 0;
+    const billedInput = observedUsage.input + observedUsage.cacheRead + observedUsage.cacheWrite;
+    if (billedInput <= estimate.tokens) return void 0;
+    const violation = {
+      schema_version: FUSION_CALIBRATION_VIOLATION_SCHEMA_VERSION,
+      stage,
+      attempt: result.attempt,
+      route: {
+        provider: result.provider,
+        model: result.model,
+        qualified_id: result.qualifiedId
+      },
+      family: route.family,
+      rate_source: estimate.rateSource,
+      prompt_utf8_bytes: promptUtf8Bytes,
+      prompt_sha256: sha256Hex(`${systemPrompt}\0${userPrompt}`),
+      observation_scope: "first_provider_request",
+      provider_request_count: result.providerRequestCount ?? 1,
+      forecast_input_tokens: estimate.tokens,
+      billed_input_tokens: billedInput,
+      billed_input_breakdown: {
+        input: observedUsage.input,
+        cache_read: observedUsage.cacheRead,
+        cache_write: observedUsage.cacheWrite
+      },
+      under_forecast_tokens: billedInput - estimate.tokens,
+      byte_class_breakdown: estimate.byte_class_breakdown,
+      dominant_byte_class: estimate.rateSource.dominant_byte_class
+    };
+    if (slot !== void 0) violation.slot = slot;
+    return violation;
+  }
+};
+
+// node_modules/pi-background-tasks/src/core/fusion/evaluation.ts?ext=pi-background-tasks
+var MAX_REPAIR_ERROR_CHARS = 500;
+var MAX_REPAIR_ERROR_COUNT = 24;
+var MAX_REPAIR_ERROR_TOTAL_CHARS = 4e3;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(errorText, "errorText");
+function closed(record, keys, label, errors) {
+  const expected = new Set(keys);
+  for (const key of Object.keys(record)) {
+    if (!expected.has(key)) errors.push(`${label} contains unknown key ${key}`);
+  }
+  for (const key of keys) {
+    if (!Object.prototype.hasOwnProperty.call(record, key))
+      errors.push(`${label} is missing key ${key}`);
+  }
+}
+__name(closed, "closed");
+function nonBlankString(value, label, errors) {
+  if (typeof value !== "string") {
+    errors.push(`${label} must be a string`);
+    return void 0;
+  }
+  if (value.trim().length === 0) {
+    errors.push(`${label} must be non-blank`);
+    return void 0;
+  }
+  return value;
+}
+__name(nonBlankString, "nonBlankString");
+function stringList(value, label, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`${label} must be an array`);
+    return void 0;
+  }
+  const out = [];
+  for (const [index, item] of value.entries()) {
+    const parsed = nonBlankString(item, `${label}[${String(index)}]`, errors);
+    if (parsed !== void 0) out.push(parsed);
+  }
+  return out;
+}
+__name(stringList, "stringList");
+function candidateId(value, label, errors) {
+  if (value === "A" || value === "B" || value === "C") return value;
+  errors.push(`${label} must be A, B, or C`);
+  return void 0;
+}
+__name(candidateId, "candidateId");
+function tuple3(items, label, errors) {
+  if (items.length !== 3) {
+    errors.push(`${label} must contain exactly three entries`);
+    return void 0;
+  }
+  const first = items[0];
+  const second = items[1];
+  const third = items[2];
+  if (first === void 0 || second === void 0 || third === void 0) {
+    errors.push(`${label} must not contain empty positions`);
+    return void 0;
+  }
+  return [first, second, third];
+}
+__name(tuple3, "tuple3");
+function parseAssessment(value, label, errors) {
+  if (!isRecord(value)) {
+    errors.push(`${label} must be an object`);
+    return void 0;
+  }
+  closed(
+    value,
+    ["candidate_id", "summary", "strengths", "limitations", "useful_contributions", "risks"],
+    label,
+    errors
+  );
+  const id = candidateId(value["candidate_id"], `${label}.candidate_id`, errors);
+  const summary = nonBlankString(value["summary"], `${label}.summary`, errors);
+  const strengths = stringList(value["strengths"], `${label}.strengths`, errors);
+  const limitations = stringList(value["limitations"], `${label}.limitations`, errors);
+  const useful = stringList(value["useful_contributions"], `${label}.useful_contributions`, errors);
+  const risks = stringList(value["risks"], `${label}.risks`, errors);
+  if (id === void 0 || summary === void 0 || strengths === void 0 || limitations === void 0 || useful === void 0 || risks === void 0) {
+    return void 0;
+  }
+  return { candidate_id: id, summary, strengths, limitations, useful_contributions: useful, risks };
+}
+__name(parseAssessment, "parseAssessment");
+function parsePosition(value, label, errors) {
+  if (!isRecord(value)) {
+    errors.push(`${label} must be an object`);
+    return void 0;
+  }
+  closed(value, ["candidate_id", "position"], label, errors);
+  const id = candidateId(value["candidate_id"], `${label}.candidate_id`, errors);
+  const position = nonBlankString(value["position"], `${label}.position`, errors);
+  if (id === void 0 || position === void 0) return void 0;
+  return { candidate_id: id, position };
+}
+__name(parsePosition, "parsePosition");
+function parseConflict(value, label, errors) {
+  if (!isRecord(value)) {
+    errors.push(`${label} must be an object`);
+    return void 0;
+  }
+  closed(value, ["topic", "positions", "resolution"], label, errors);
+  const topic = nonBlankString(value["topic"], `${label}.topic`, errors);
+  const positionsRaw = value["positions"];
+  const positions = [];
+  if (!Array.isArray(positionsRaw)) {
+    errors.push(`${label}.positions must be an array`);
+  } else {
+    for (const [index, item] of positionsRaw.entries()) {
+      const parsed = parsePosition(item, `${label}.positions[${String(index)}]`, errors);
+      if (parsed !== void 0) positions.push(parsed);
+    }
+    const distinctIds = new Set(positions.map((position) => position.candidate_id));
+    if (distinctIds.size < 2)
+      errors.push(`${label}.positions must include at least two distinct candidates`);
+    if (distinctIds.size !== positions.length)
+      errors.push(`${label}.positions candidate_id values must be unique`);
+  }
+  const resolution = nonBlankString(value["resolution"], `${label}.resolution`, errors);
+  if (topic === void 0 || resolution === void 0 || !Array.isArray(positionsRaw))
+    return void 0;
+  return { topic, positions, resolution };
+}
+__name(parseConflict, "parseConflict");
+function parseContribution(value, label, errors) {
+  if (!isRecord(value)) {
+    errors.push(`${label} must be an object`);
+    return void 0;
+  }
+  closed(value, ["candidate_id", "contribution"], label, errors);
+  const id = candidateId(value["candidate_id"], `${label}.candidate_id`, errors);
+  const contribution = nonBlankString(value["contribution"], `${label}.contribution`, errors);
+  if (id === void 0 || contribution === void 0) return void 0;
+  return { candidate_id: id, contribution };
+}
+__name(parseContribution, "parseContribution");
+function parseContributionList(value, label, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`${label} must be an array`);
+    return void 0;
+  }
+  const out = [];
+  for (const [index, item] of value.entries()) {
+    const parsed = parseContribution(item, `${label}[${String(index)}]`, errors);
+    if (parsed !== void 0) out.push(parsed);
+  }
+  return out;
+}
+__name(parseContributionList, "parseContributionList");
+function parseSynthesisPlan(value, label, errors) {
+  if (!isRecord(value)) {
+    errors.push(`${label} must be an object`);
+    return void 0;
+  }
+  closed(value, ["must_include", "must_resolve", "must_avoid"], label, errors);
+  const include = parseContributionList(value["must_include"], `${label}.must_include`, errors);
+  const resolve2 = stringList(value["must_resolve"], `${label}.must_resolve`, errors);
+  const avoid = stringList(value["must_avoid"], `${label}.must_avoid`, errors);
+  if (include === void 0 || resolve2 === void 0 || avoid === void 0) return void 0;
+  return { must_include: include, must_resolve: resolve2, must_avoid: avoid };
+}
+__name(parseSynthesisPlan, "parseSynthesisPlan");
+function parseAssessmentList(value, label, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`${label} must be an array`);
+    return void 0;
+  }
+  const parsed = [];
+  for (const [index, item] of value.entries()) {
+    const assessment = parseAssessment(item, `${label}[${String(index)}]`, errors);
+    if (assessment !== void 0) parsed.push(assessment);
+  }
+  const ids = new Set(parsed.map((assessment) => assessment.candidate_id));
+  for (const id of FUSION_CANDIDATE_IDS) {
+    if (!ids.has(id)) errors.push(`${label} must contain candidate ${id}`);
+  }
+  if (ids.size !== parsed.length) errors.push(`${label} candidate_id values must be unique`);
+  return tuple3(parsed, label, errors);
+}
+__name(parseAssessmentList, "parseAssessmentList");
+function parseConflictList(value, label, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`${label} must be an array`);
+    return void 0;
+  }
+  const out = [];
+  for (const [index, item] of value.entries()) {
+    const parsed = parseConflict(item, `${label}[${String(index)}]`, errors);
+    if (parsed !== void 0) out.push(parsed);
+  }
+  return out;
+}
+__name(parseConflictList, "parseConflictList");
+function parseValidationGroups(value, label, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`${label} must be an array`);
+    return [];
+  }
+  const groups = [];
+  for (const [index, item] of value.entries()) {
+    const itemLabel = `${label}[${String(index)}]`;
+    if (!isRecord(item)) {
+      errors.push(`${itemLabel} must be an object`);
+      continue;
+    }
+    closed(
+      item,
+      ["group_id", "source_ids", "severity", "location", "evidence", "impact", "summary", "rationale"],
+      itemLabel,
+      errors
+    );
+    const groupId = nonBlankString(item["group_id"], `${itemLabel}.group_id`, errors);
+    const sourceIds = stringList(item["source_ids"], `${itemLabel}.source_ids`, errors);
+    const severity = nonBlankString(item["severity"], `${itemLabel}.severity`, errors);
+    const location = nonBlankString(item["location"], `${itemLabel}.location`, errors);
+    const evidence = nonBlankString(item["evidence"], `${itemLabel}.evidence`, errors);
+    const impact = nonBlankString(item["impact"], `${itemLabel}.impact`, errors);
+    const summary = nonBlankString(item["summary"], `${itemLabel}.summary`, errors);
+    const rationale = nonBlankString(item["rationale"], `${itemLabel}.rationale`, errors);
+    if (sourceIds !== void 0 && sourceIds.length === 0) {
+      errors.push(`${itemLabel}.source_ids must not be empty`);
+    }
+    if (severity !== void 0 && !["critical", "high", "minor"].includes(severity)) {
+      errors.push(`${itemLabel}.severity invalid`);
+    }
+    if (groupId !== void 0 && sourceIds !== void 0 && sourceIds.length > 0 && severity !== void 0 && location !== void 0 && evidence !== void 0 && impact !== void 0 && summary !== void 0 && rationale !== void 0) {
+      groups.push({
+        group_id: groupId,
+        source_ids: sourceIds,
+        severity,
+        location,
+        evidence,
+        impact,
+        summary,
+        rationale
+      });
+    }
+  }
+  return groups;
+}
+__name(parseValidationGroups, "parseValidationGroups");
+function parseValidationAccounting(value, label, errors) {
+  if (!isRecord(value)) {
+    errors.push(`${label} must be an object`);
+    return void 0;
+  }
+  closed(value, ["findings", "decisions", "groups"], label, errors);
+  const findingsRaw = value["findings"];
+  const decisionsRaw = value["decisions"];
+  const groups = parseValidationGroups(value["groups"], `${label}.groups`, errors);
+  const findings = [];
+  if (!Array.isArray(findingsRaw)) errors.push(`${label}.findings must be an array`);
+  else {
+    for (const [index, item] of findingsRaw.entries()) {
+      const itemLabel = `${label}.findings[${String(index)}]`;
+      if (!isRecord(item)) {
+        errors.push(`${itemLabel} must be an object`);
+        continue;
+      }
+      closed(item, ["id", "candidate_id", "severity", "location", "evidence", "impact", "summary"], itemLabel, errors);
+      const id = nonBlankString(item["id"], `${itemLabel}.id`, errors);
+      const candidate = candidateId(item["candidate_id"], `${itemLabel}.candidate_id`, errors);
+      const severity = nonBlankString(item["severity"], `${itemLabel}.severity`, errors);
+      const location = nonBlankString(item["location"], `${itemLabel}.location`, errors);
+      const evidence = nonBlankString(item["evidence"], `${itemLabel}.evidence`, errors);
+      const impact = nonBlankString(item["impact"], `${itemLabel}.impact`, errors);
+      const summary = nonBlankString(item["summary"], `${itemLabel}.summary`, errors);
+      if (severity !== void 0 && !["critical", "high", "minor"].includes(severity)) errors.push(`${itemLabel}.severity invalid`);
+      if (id !== void 0 && candidate !== void 0 && severity !== void 0 && location !== void 0 && evidence !== void 0 && impact !== void 0 && summary !== void 0) {
+        findings.push({ id, candidate_id: candidate, severity, location, evidence, impact, summary });
+      }
+    }
+  }
+  const decisions = [];
+  if (!Array.isArray(decisionsRaw)) errors.push(`${label}.decisions must be an array`);
+  else {
+    for (const [index, item] of decisionsRaw.entries()) {
+      const itemLabel = `${label}.decisions[${String(index)}]`;
+      if (!isRecord(item)) {
+        errors.push(`${itemLabel} must be an object`);
+        continue;
+      }
+      const allowedDecisionKeys = /* @__PURE__ */ new Set(["source_id", "disposition", "rationale", "group_id"]);
+      for (const key of Object.keys(item)) {
+        if (!allowedDecisionKeys.has(key)) errors.push(`${itemLabel} contains unknown key ${key}`);
+      }
+      for (const key of ["source_id", "disposition", "rationale"]) {
+        if (!Object.prototype.hasOwnProperty.call(item, key)) errors.push(`${itemLabel} is missing key ${key}`);
+      }
+      const sourceId = nonBlankString(item["source_id"], `${itemLabel}.source_id`, errors);
+      const disposition = nonBlankString(item["disposition"], `${itemLabel}.disposition`, errors);
+      const rationale = nonBlankString(item["rationale"], `${itemLabel}.rationale`, errors);
+      const group = item["group_id"] === void 0 ? void 0 : nonBlankString(item["group_id"], `${itemLabel}.group_id`, errors);
+      if (disposition !== void 0 && disposition !== "include" && disposition !== "exclude") errors.push(`${itemLabel}.disposition invalid`);
+      if (sourceId !== void 0 && (disposition === "include" || disposition === "exclude") && rationale !== void 0) {
+        const decision = { source_id: sourceId, disposition, rationale };
+        if (group !== void 0) decision.group_id = group;
+        decisions.push(decision);
+      }
+    }
+  }
+  const accounting = { findings, decisions, groups };
+  errors.push(...validateFusionFindingAccounting(accounting));
+  return accounting;
+}
+__name(parseValidationAccounting, "parseValidationAccounting");
+function validateFusionEvaluation(value) {
+  const errors = [];
+  if (!isRecord(value)) return { ok: false, errors: ["evaluation must be a JSON object"] };
+  const evaluationAllowed = /* @__PURE__ */ new Set(["schema_version", "candidate_assessments", "agreements", "conflicts", "synthesis_plan", "validation_accounting"]);
+  for (const key of Object.keys(value)) {
+    if (!evaluationAllowed.has(key)) errors.push(`evaluation contains unknown key ${key}`);
+  }
+  for (const key of ["schema_version", "candidate_assessments", "agreements", "conflicts", "synthesis_plan"]) {
+    if (!Object.prototype.hasOwnProperty.call(value, key)) errors.push(`evaluation is missing key ${key}`);
+  }
+  if (value["schema_version"] !== FUSION_EVALUATION_SCHEMA_VERSION) {
+    errors.push("evaluation.schema_version mismatch");
+  }
+  const assessments = parseAssessmentList(
+    value["candidate_assessments"],
+    "evaluation.candidate_assessments",
+    errors
+  );
+  const agreements = stringList(value["agreements"], "evaluation.agreements", errors);
+  const conflicts = parseConflictList(value["conflicts"], "evaluation.conflicts", errors);
+  const plan = parseSynthesisPlan(value["synthesis_plan"], "evaluation.synthesis_plan", errors);
+  const validationAccounting = Object.prototype.hasOwnProperty.call(value, "validation_accounting") ? parseValidationAccounting(value["validation_accounting"], "evaluation.validation_accounting", errors) : void 0;
+  if (errors.length > 0 || assessments === void 0 || agreements === void 0 || conflicts === void 0 || plan === void 0) {
+    return { ok: false, errors };
+  }
+  const parsedValue = {
+    schema_version: FUSION_EVALUATION_SCHEMA_VERSION,
+    candidate_assessments: assessments,
+    agreements,
+    conflicts,
+    synthesis_plan: plan
+  };
+  if (validationAccounting !== void 0) parsedValue.validation_accounting = validationAccounting;
+  return { ok: true, value: parsedValue };
+}
+__name(validateFusionEvaluation, "validateFusionEvaluation");
+function boundedEvaluationErrors(errors) {
+  const bounded = [];
+  let total = 0;
+  for (const error of errors) {
+    if (bounded.length >= MAX_REPAIR_ERROR_COUNT) break;
+    const perError = error.length <= MAX_REPAIR_ERROR_CHARS ? error : `${error.slice(0, MAX_REPAIR_ERROR_CHARS - 1)}\u2026`;
+    const remaining = MAX_REPAIR_ERROR_TOTAL_CHARS - total;
+    if (remaining <= 0) break;
+    const next = perError.length <= remaining ? perError : `${perError.slice(0, Math.max(0, remaining - 1))}\u2026`;
+    bounded.push(next);
+    total += next.length;
+  }
+  if (errors.length > bounded.length)
+    bounded.push(`\u2026 ${String(errors.length - bounded.length)} more validation errors omitted`);
+  return bounded;
+}
+__name(boundedEvaluationErrors, "boundedEvaluationErrors");
+function formatEvaluationErrors(errors) {
+  return boundedEvaluationErrors(errors).join("; ");
+}
+__name(formatEvaluationErrors, "formatEvaluationErrors");
+function parseValidationCandidateFinding(value, label, errors) {
+  if (!isRecord(value)) {
+    errors.push(`${label} must be an object`);
+    return void 0;
+  }
+  closed(value, ["severity", "location", "evidence", "impact", "summary"], label, errors);
+  const severity = nonBlankString(value["severity"], `${label}.severity`, errors);
+  const location = nonBlankString(value["location"], `${label}.location`, errors);
+  const evidence = nonBlankString(value["evidence"], `${label}.evidence`, errors);
+  const impact = nonBlankString(value["impact"], `${label}.impact`, errors);
+  const summary = nonBlankString(value["summary"], `${label}.summary`, errors);
+  if (severity !== void 0 && !["critical", "high", "minor"].includes(severity)) errors.push(`${label}.severity invalid`);
+  if (severity === void 0 || location === void 0 || evidence === void 0 || impact === void 0 || summary === void 0) return void 0;
+  return { severity, location, evidence, impact, summary };
+}
+__name(parseValidationCandidateFinding, "parseValidationCandidateFinding");
+function fencedValidationCandidateJson(text) {
+  const trimmed = text.trim();
+  const openingPattern = /```json[ \t]*\r?\n/giu;
+  const openings = [...trimmed.matchAll(openingPattern)];
+  if (openings.length !== 1) return void 0;
+  const opening = openings[0];
+  if (opening === void 0) return void 0;
+  const headerEnd = opening.index + opening[0].length;
+  const closing = trimmed.indexOf("```", headerEnd);
+  if (closing < 0 || trimmed.slice(closing + 3).includes("```")) return void 0;
+  if (trimmed.slice(closing + 3).trim().length > 0) return void 0;
+  const preamble = trimmed.slice(0, opening.index).trim();
+  if (Buffer.byteLength(preamble, "utf8") > 2e3 || preamble.includes("```")) return void 0;
+  const payload = trimmed.slice(headerEnd, closing).trim();
+  if (payload.length === 0 || payload.includes("```")) return void 0;
+  return {
+    payload,
+    normalization: preamble.length === 0 ? "markdown_json_fence" : "prose_then_markdown_json_fence"
+  };
+}
+__name(fencedValidationCandidateJson, "fencedValidationCandidateJson");
+function recoverFencedFusionValidationCandidateReport(text, candidateId2) {
+  const recovered = fencedValidationCandidateJson(text);
+  if (recovered === void 0) return void 0;
+  return {
+    report: parseFusionValidationCandidateReport(recovered.payload, candidateId2),
+    response: recovered.payload,
+    normalization: recovered.normalization
+  };
+}
+__name(recoverFencedFusionValidationCandidateReport, "recoverFencedFusionValidationCandidateReport");
+function parseFusionValidationCandidateReport(text, candidateId2) {
+  let parsed;
+  try {
+    parsed = parseJsonText(text);
+  } catch (error) {
+    throw new FusionError(
+      `validation candidate ${candidateId2} output must be structured JSON only: ${errorText(error)}`,
+      { code: "evaluation_invalid", stage: "candidate" }
+    );
+  }
+  const errors = [];
+  if (!isRecord(parsed)) {
+    errors.push("validation candidate report must be an object");
+  } else {
+    closed(parsed, ["schema_version", "findings", "verified", "limitations"], "validation candidate report", errors);
+  }
+  if (!isRecord(parsed)) {
+    throw new FusionError(`validation candidate ${candidateId2} output failed schema validation: ${formatEvaluationErrors(errors)}`, {
+      code: "evaluation_invalid",
+      stage: "candidate"
+    });
+  }
+  if (parsed["schema_version"] !== FUSION_VALIDATE_CANDIDATE_SCHEMA_VERSION) errors.push("validation candidate report.schema_version mismatch");
+  const rawFindings = parsed["findings"];
+  const findings = [];
+  if (!Array.isArray(rawFindings)) errors.push("validation candidate report.findings must be an array");
+  else {
+    for (const [index, item] of rawFindings.entries()) {
+      const finding = parseValidationCandidateFinding(item, `validation candidate report.findings[${String(index)}]`, errors);
+      if (finding !== void 0) findings.push(finding);
+    }
+  }
+  const verified = stringList(parsed["verified"], "validation candidate report.verified", errors);
+  const limitations = stringList(parsed["limitations"], "validation candidate report.limitations", errors);
+  if (errors.length > 0) {
+    throw new FusionError(`validation candidate ${candidateId2} output failed schema validation: ${formatEvaluationErrors(errors)}`, {
+      code: "evaluation_invalid",
+      stage: "candidate"
+    });
+  }
+  return {
+    findings: findings.map((finding, index) => ({
+      id: stableFusionFindingId(candidateId2, index + 1),
+      candidate_id: candidateId2,
+      ...finding
+    })),
+    verified: verified ?? [],
+    limitations: limitations ?? []
+  };
+}
+__name(parseFusionValidationCandidateReport, "parseFusionValidationCandidateReport");
+function stableFusionFindingId(candidateId2, ordinal) {
+  if (!Number.isSafeInteger(ordinal) || ordinal <= 0) {
+    throw new FusionError("validation finding ordinal must be a positive integer", {
+      code: "evaluation_invalid",
+      stage: "evaluation"
+    });
+  }
+  return `${candidateId2}-F${String(ordinal).padStart(3, "0")}`;
+}
+__name(stableFusionFindingId, "stableFusionFindingId");
+function validateFusionFindingAccounting(accounting) {
+  const errors = [];
+  const sourceIds = /* @__PURE__ */ new Set();
+  const perCandidateOrdinal = { A: 0, B: 0, C: 0 };
+  for (const [index, finding] of accounting.findings.entries()) {
+    const label = `finding[${String(index)}]`;
+    perCandidateOrdinal[finding.candidate_id] += 1;
+    if (finding.id !== stableFusionFindingId(finding.candidate_id, perCandidateOrdinal[finding.candidate_id])) {
+      errors.push(`${label}.id must be the stable host id for its candidate and ordinal`);
+    }
+    if (!["critical", "high", "minor"].includes(finding.severity)) errors.push(`${label}.severity invalid`);
+    for (const key of ["location", "evidence", "impact", "summary"]) {
+      if (finding[key].trim().length === 0) errors.push(`${label}.${key} must be non-blank`);
+    }
+    if (sourceIds.has(finding.id)) errors.push(`${label}.id duplicate`);
+    sourceIds.add(finding.id);
+  }
+  const accounted = /* @__PURE__ */ new Set();
+  for (const [index, decision] of accounting.decisions.entries()) {
+    const label = `decision[${String(index)}]`;
+    if (!sourceIds.has(decision.source_id)) errors.push(`${label}.source_id does not name a candidate finding`);
+    if (accounted.has(decision.source_id)) errors.push(`${label}.source_id accounted more than once`);
+    accounted.add(decision.source_id);
+    if (decision.disposition !== "include" && decision.disposition !== "exclude") errors.push(`${label}.disposition invalid`);
+    if (decision.rationale.trim().length === 0) errors.push(`${label}.rationale must be non-blank`);
+    if (decision.disposition === "include" && (decision.group_id === void 0 || decision.group_id.trim().length === 0)) {
+      errors.push(`${label}.group_id required for included findings`);
+    }
+    if (decision.disposition === "exclude" && decision.group_id !== void 0) {
+      errors.push(`${label}.group_id must be omitted for excluded findings`);
+    }
+  }
+  for (const id of sourceIds) {
+    if (!accounted.has(id)) errors.push(`source finding ${id} was not accounted exactly once`);
+  }
+  const groupsById = /* @__PURE__ */ new Map();
+  for (const [index, group] of accounting.groups.entries()) {
+    const label = `group[${String(index)}]`;
+    if (groupsById.has(group.group_id)) errors.push(`${label}.group_id duplicate`);
+    groupsById.set(group.group_id, group);
+    if (!["critical", "high", "minor"].includes(group.severity)) errors.push(`${label}.severity invalid`);
+    for (const key of ["location", "evidence", "impact", "summary", "rationale"]) {
+      if (group[key].trim().length === 0) errors.push(`${label}.${key} must be non-blank`);
+    }
+    if (group.source_ids.length === 0) errors.push(`${label}.source_ids must not be empty`);
+    const groupSourceIds = /* @__PURE__ */ new Set();
+    for (const sourceId of group.source_ids) {
+      if (!sourceIds.has(sourceId)) errors.push(`${label}.source_ids contains unknown finding ${sourceId}`);
+      if (groupSourceIds.has(sourceId)) errors.push(`${label}.source_ids contains duplicate ${sourceId}`);
+      groupSourceIds.add(sourceId);
+    }
+  }
+  const includedByGroup = /* @__PURE__ */ new Map();
+  for (const decision of accounting.decisions) {
+    if (decision.disposition !== "include" || decision.group_id === void 0) continue;
+    const group = groupsById.get(decision.group_id);
+    if (group === void 0) {
+      errors.push(`included source finding ${decision.source_id} references unknown group ${decision.group_id}`);
+      continue;
+    }
+    const members = includedByGroup.get(decision.group_id) ?? /* @__PURE__ */ new Set();
+    members.add(decision.source_id);
+    includedByGroup.set(decision.group_id, members);
+  }
+  for (const group of accounting.groups) {
+    const expected = [...group.source_ids].sort();
+    const actual = [...includedByGroup.get(group.group_id) ?? /* @__PURE__ */ new Set()].sort();
+    if (expected.length !== actual.length || expected.some((id, index) => id !== actual[index])) {
+      errors.push(`group ${group.group_id} source_ids must exactly match included decisions assigned to that group`);
+    }
+  }
+  return errors;
+}
+__name(validateFusionFindingAccounting, "validateFusionFindingAccounting");
+function sanitizeValidationRationale(value) {
+  return value.replace(/\b[ABC]-F\d{3}\b/gu, "source finding").replace(/\bcandidate [ABC]\b/giu, "one reviewer").replace(/\b[ABC]:\s*/gu, "");
+}
+__name(sanitizeValidationRationale, "sanitizeValidationRationale");
+function renderValidatedFusionValidationReport(accounting, coverage) {
+  const errors = validateFusionFindingAccounting(accounting);
+  if (errors.length > 0) {
+    throw new FusionError(`validation accounting invalid before render: ${formatEvaluationErrors(errors)}`, {
+      code: "evaluation_invalid",
+      stage: "merge"
+    });
+  }
+  const severityOrder = { critical: 0, high: 1, minor: 2 };
+  const renderedFindings = [...accounting.groups].sort(
+    (left, right) => severityOrder[left.severity] - severityOrder[right.severity] || left.location.localeCompare(right.location) || left.group_id.localeCompare(right.group_id)
+  );
+  const lines = ["# Validation report", ""];
+  if (renderedFindings.length === 0) {
+    lines.push("No included findings were identified by the validated accounting.", "");
+  } else {
+    lines.push("## Findings", "");
+    for (const finding of renderedFindings) {
+      lines.push(`### ${finding.severity}: ${finding.summary}`, "");
+      lines.push(`- Location: ${finding.location}`);
+      lines.push(`- Evidence: ${finding.evidence}`);
+      lines.push(`- Impact: ${finding.impact}`);
+      lines.push(`- Inclusion rationale: ${sanitizeValidationRationale(finding.rationale)}`, "");
+    }
+  }
+  const exclusions = accounting.decisions.filter((decision) => decision.disposition === "exclude").sort((left, right) => left.source_id.localeCompare(right.source_id));
+  if (exclusions.length > 0) {
+    lines.push("## Excluded source findings", "");
+    for (const decision of exclusions) lines.push(`- ${sanitizeValidationRationale(decision.rationale)}`);
+    lines.push("");
+  }
+  if (coverage !== void 0) {
+    lines.push("## Verified", "");
+    if (coverage.verified.length === 0) lines.push("- No verification statements were provided.");
+    else for (const item of coverage.verified) lines.push(`- ${item}`);
+    lines.push("", "## Limitations", "");
+    if (coverage.limitations.length === 0) lines.push("- No limitations were provided.");
+    else for (const item of coverage.limitations) lines.push(`- ${item}`);
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+__name(renderValidatedFusionValidationReport, "renderValidatedFusionValidationReport");
+
+// node_modules/pi-background-tasks/src/core/fusion/pi-child.ts?ext=pi-background-tasks
+import { spawn as nodeSpawn } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { constants, existsSync } from "node:fs";
+import { open } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// node_modules/pi-background-tasks/src/core/fusion/child-protocol.ts?ext=pi-background-tasks
+import { createHash as createHash2 } from "node:crypto";
+var FUSION_CHILD_RESULT_SCHEMA_VERSION = "pi-background-tasks.fusion-child-result.v4";
+var FUSION_CHILD_RESULT_PREFIX = "PI_FUSION_CHILD_RESULT ";
+var FUSION_CHILD_SETTLEMENT_SCHEMA_VERSION = "pi-background-tasks.fusion-child-settlement.v3";
+var FUSION_CHILD_SETTLEMENT_PREFIX = "PI_FUSION_CHILD_SETTLEMENT ";
+var FUSION_TOOL_CALL_LOG_PATH_ENV = "PI_FUSION_TOOL_CALL_LOG_PATH";
+var FUSION_CANDIDATE_OUTPUT_RECOVERY_PATH_ENV = "PI_FUSION_CANDIDATE_OUTPUT_RECOVERY_PATH";
+var FUSION_RESEARCH_ENABLED_ENV = "PI_FUSION_RESEARCH_ENABLED";
+var FUSION_SOURCE_POLICY_PATH_ENV = "PI_FUSION_SOURCE_POLICY_PATH";
+var FUSION_SOURCE_POLICY_SHA256_ENV = "PI_FUSION_SOURCE_POLICY_SHA256";
+var FUSION_TOOL_CALL_SEAL_SCHEMA_VERSION = "pi-background-tasks.fusion-tool-call-seal.v1";
+var FUSION_TOOL_CALL_SEAL_SUFFIX = ".seal.json";
+var FUSION_RUNTIME_GUARD_SCHEMA_VERSION = "pi-background-tasks.fusion-runtime-guard.v2";
+var FUSION_RUNTIME_GUARD_PREFIX = "PI_FUSION_RUNTIME_GUARD ";
+var FUSION_CHILD_MAX_PROVIDER_REQUESTS = 550;
+var FUSION_CHILD_MAX_TOOL_CALLS = 600;
+var FUSION_CHILD_MAX_TOTAL_TOOL_RESULT_BYTES = 32 * 1024 * 1024;
+function protocolSha256(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+__name(protocolSha256, "protocolSha256");
+function serializeFusionChildResultRecords(records) {
+  return Buffer.from(
+    records.length === 0 ? "" : `${records.map((record) => JSON.stringify(record)).join("\n")}
+`,
+    "utf8"
+  );
+}
+__name(serializeFusionChildResultRecords, "serializeFusionChildResultRecords");
+function hasZeroUsage(record) {
+  const usage = record.usage;
+  return usage.input === 0 && usage.output === 0 && usage.cacheRead === 0 && usage.cacheWrite === 0 && usage.totalTokens === 0 && usage.cost.input === 0 && usage.cost.output === 0 && usage.cost.cacheRead === 0 && usage.cost.cacheWrite === 0 && usage.cost.total === 0;
+}
+__name(hasZeroUsage, "hasZeroUsage");
+function isRecoverableFusionChildErrorRecord(record) {
+  return record.stop_reason === "error" && record.text_blocks.length === 0 && record.text_sha256 === protocolSha256(Buffer.alloc(0)) && hasZeroUsage(record) && record.output_contract.recovery_role === "none";
+}
+__name(isRecoverableFusionChildErrorRecord, "isRecoverableFusionChildErrorRecord");
+function isOversizedOriginal(record) {
+  const output = record.output_contract;
+  return output.recovery_role === "oversized_original" && output.candidate_limit_bytes === FUSION_CANDIDATE_MAX_OUTPUT_BYTES && output.json_rendered_bytes > FUSION_CANDIDATE_MAX_OUTPUT_BYTES && record.stop_reason === "stop";
+}
+__name(isOversizedOriginal, "isOversizedOriginal");
+function outputRecoveryProtocolInvalid(records) {
+  const originals = records.flatMap(
+    (record, ordinal) => record.output_contract.recovery_role === "oversized_original" ? [ordinal] : []
+  );
+  const replacements = records.flatMap(
+    (record, ordinal) => record.output_contract.recovery_role === "replacement" ? [ordinal] : []
+  );
+  for (const record of records) {
+    const output = record.output_contract;
+    if (output.candidate_limit_bytes !== null && output.candidate_limit_bytes !== FUSION_CANDIDATE_MAX_OUTPUT_BYTES) {
+      return true;
+    }
+    if (output.recovery_role !== "none" && output.candidate_limit_bytes === null) return true;
+    if (output.recovery_role === "oversized_original" && !isOversizedOriginal(record)) return true;
+  }
+  if (originals.length === 0 && replacements.length === 0) return false;
+  if (originals.length !== 1 || replacements.length !== 1) return true;
+  const original = originals[0];
+  const replacement = replacements[0];
+  return original === void 0 || replacement === void 0 || original !== records.length - 2 || replacement !== records.length - 1;
+}
+__name(outputRecoveryProtocolInvalid, "outputRecoveryProtocolInvalid");
+function finalCandidateOutputExceedsContract(records) {
+  const final = records.at(-1);
+  if (final === void 0) return false;
+  const output = final.output_contract;
+  return output.candidate_limit_bytes === FUSION_CANDIDATE_MAX_OUTPUT_BYTES && output.json_rendered_bytes > FUSION_CANDIDATE_MAX_OUTPUT_BYTES;
+}
+__name(finalCandidateOutputExceedsContract, "finalCandidateOutputExceedsContract");
+function buildFusionChildSettlement(records, runtimeGuardFailed = false, cacheObservationFailed = false, outputRecoveryFailed = false) {
+  const finalRecordIndex = records.length === 0 ? null : records.length - 1;
+  const final = records.at(-1);
+  const recoveredErrorOrdinals = records.flatMap(
+    (record, ordinal) => ordinal < records.length - 1 && isRecoverableFusionChildErrorRecord(record) ? [ordinal] : []
+  );
+  const recoveredOutputCapOrdinals = records.flatMap(
+    (record, ordinal) => ordinal < records.length - 1 && isOversizedOriginal(record) ? [ordinal] : []
+  );
+  const invalidRecovery = outputRecoveryProtocolInvalid(records);
+  const invalidNonFinal = records.some(
+    (record, ordinal) => ordinal < records.length - 1 && record.stop_reason !== "toolUse" && !isRecoverableFusionChildErrorRecord(record) && !isOversizedOriginal(record)
+  );
+  let failureReason = null;
+  if (runtimeGuardFailed) failureReason = "runtime_guard";
+  else if (cacheObservationFailed) failureReason = "cache_observation";
+  else if (final === void 0) failureReason = "no_records";
+  else if (final.stop_reason !== "stop") failureReason = "final_not_stop";
+  else if (outputRecoveryFailed || invalidRecovery || finalCandidateOutputExceedsContract(records)) {
+    failureReason = "output_recovery";
+  } else if (invalidNonFinal) failureReason = "invalid_non_final";
+  return {
+    schema_version: FUSION_CHILD_SETTLEMENT_SCHEMA_VERSION,
+    status: failureReason === null ? "complete" : "failed",
+    record_count: records.length,
+    records_sha256: protocolSha256(serializeFusionChildResultRecords(records)),
+    final_record_index: finalRecordIndex,
+    final_text_sha256: final?.text_sha256 ?? null,
+    recovered_error_ordinals: recoveredErrorOrdinals,
+    recovered_output_cap_ordinals: recoveredOutputCapOrdinals,
+    failure_reason: failureReason
+  };
+}
+__name(buildFusionChildSettlement, "buildFusionChildSettlement");
+
+// node_modules/pi-background-tasks/src/core/fusion/claude-cache.ts?ext=pi-background-tasks
+var FUSION_CLAUDE_CACHE_OBSERVATION_SCHEMA_VERSION = "pi-background-tasks.fusion-claude-cache-observation.v1";
+var FUSION_CLAUDE_CACHE_RETENTION_ENV = "PI_CACHE_RETENTION";
+var FUSION_CLAUDE_CACHE_BREAKPOINT_LIMIT = 4;
+
+// node_modules/pi-background-tasks/src/core/fusion/pi-child.ts?ext=pi-background-tasks
+var __pvMetaUrl = __pvUrl("../node_modules/pi-background-tasks/src/core/fusion/pi-child.ts");
+var FUSION_CHILD_STDOUT_LIMIT_BYTES = 32 * 1024 * 1024;
+var FUSION_CHILD_STDERR_LIMIT_BYTES = 16 * 1024 * 1024;
+var FUSION_CHILD_TIMEOUT_MS = 50 * 60 * 1e3;
+var FUSION_CHILD_IDLE_TIMEOUT_MS = 35 * 60 * 1e3;
+var FUSION_CHILD_KILL_GRACE_MS = 3e3;
+var FUSION_CHILD_SIGKILL_WAIT_MS = 5e3;
+var FUSION_PI_CHILD_O_NOFOLLOW = typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
+var FUSION_CHILD_REMOVED_ENV_KEYS = [
+  "PI_SESSION_ID",
+  "PI_SESSION_FILE",
+  "PI_PROVIDER",
+  "PI_MODEL",
+  "PI_REASONING_LEVEL",
+  "OPENROUTER_API_KEY",
+  "OPENROUTER_BASE_URL",
+  "OPENAI_API_KEY",
+  "OPENAI_BASE_URL",
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_BASE_URL",
+  "AZURE_OPENAI_API_KEY",
+  "AZURE_OPENAI_BASE_URL",
+  "AZURE_OPENAI_ENDPOINT",
+  "AZURE_OPENAI_RESOURCE_NAME",
+  "AZURE_OPENAI_API_VERSION",
+  "AZURE_OPENAI_DEPLOYMENT_NAME_MAP",
+  "AZURE_OPENAI_AD_TOKEN",
+  "PI_API_KEY",
+  "PI_API_BASE_URL",
+  "PI_AUTH_FILE",
+  FUSION_TOOL_CALL_LOG_PATH_ENV,
+  FUSION_CANDIDATE_OUTPUT_RECOVERY_PATH_ENV,
+  FUSION_RESEARCH_ENABLED_ENV,
+  FUSION_SOURCE_POLICY_PATH_ENV,
+  FUSION_SOURCE_POLICY_SHA256_ENV
+];
+var FusionChildRunError = class extends FusionError {
+  static {
+    __name(this, "FusionChildRunError");
+  }
+  events;
+  response;
+  stderr;
+  exitCode;
+  signalName;
+  usage;
+  provider;
+  modelName;
+  qualifiedId;
+  outputRecovery;
+  constructor(error, events, response, stderr, close, observed, outputRecovery) {
+    const details = {
+      code: error.code,
+      transient: error.transient,
+      childCreated: error.childCreated
+    };
+    if (error.stage !== void 0) details.stage = error.stage;
+    if (error.slot !== void 0) details.slot = error.slot;
+    if (error.attempt !== void 0) details.attempt = error.attempt;
+    if (error.artifactDir !== void 0) details.artifactDir = error.artifactDir;
+    super(error.message, details);
+    this.name = "FusionChildRunError";
+    this.events = events;
+    this.response = response;
+    this.stderr = stderr;
+    this.exitCode = close.code;
+    this.signalName = close.signal;
+    this.usage = cloneFusionUsage(observed.usage);
+    this.provider = observed.provider;
+    this.modelName = observed.model;
+    this.qualifiedId = observed.qualifiedId;
+    this.outputRecovery = outputRecovery;
+  }
+};
+function fusionPiChildEnv(env = process.env, provider) {
+  const out = { ...env };
+  const removed = new Set(FUSION_CHILD_REMOVED_ENV_KEYS);
+  for (const inheritedKey of Object.keys(out)) {
+    if (removed.has(inheritedKey.toUpperCase())) Reflect.deleteProperty(out, inheritedKey);
+  }
+  out["PI_SKIP_VERSION_CHECK"] = "1";
+  if (provider === "anthropic" && out[FUSION_CLAUDE_CACHE_RETENTION_ENV] === void 0) {
+    out[FUSION_CLAUDE_CACHE_RETENTION_ENV] = "long";
+  }
+  return out;
+}
+__name(fusionPiChildEnv, "fusionPiChildEnv");
+function resolveFusionChildExtensionPath(moduleUrl = __pvMetaUrl, pathExists = existsSync) {
+  const modulePath = fileURLToPath(moduleUrl);
+  const extension = modulePath.endsWith(".ts") ? "fusion-child.ts" : "fusion-child.js";
+  const candidate = resolve(dirname(modulePath), "../../../extensions", extension);
+  if (!pathExists(candidate)) {
+    throw new Error(`Fusion child metadata extension is missing: ${candidate}`);
+  }
+  return candidate;
+}
+__name(resolveFusionChildExtensionPath, "resolveFusionChildExtensionPath");
+var FUSION_SANITIZED_PROVIDER = "anthropic";
+function assertFusionToolPolicyDisjoint(allowlist = FUSION_INSPECT_TOOLS, denylist = FUSION_FORBIDDEN_TOOLS) {
+  for (const forbidden of denylist) {
+    if (allowlist.includes(forbidden)) {
+      throw new FusionError(
+        `fusion inspect capability would enable the forbidden tool ${forbidden}`,
+        { code: "orchestration_failed", childCreated: false }
+      );
+    }
+  }
+}
+__name(assertFusionToolPolicyDisjoint, "assertFusionToolPolicyDisjoint");
+function researchToolAllowlist() {
+  return FUSION_RESEARCH_TOOLS;
+}
+__name(researchToolAllowlist, "researchToolAllowlist");
+function fusionToolArgv(capability) {
+  if (capability === "reason") return ["--no-tools"];
+  if (capability === "inspect") {
+    assertFusionToolPolicyDisjoint(FUSION_INSPECT_TOOLS);
+    return [
+      "--no-builtin-tools",
+      "--tools",
+      FUSION_INSPECT_TOOLS.join(","),
+      "--exclude-tools",
+      FUSION_FORBIDDEN_TOOLS.join(",")
+    ];
+  }
+  if (capability === "research") {
+    const allowlist = researchToolAllowlist();
+    assertFusionToolPolicyDisjoint(allowlist);
+    return [
+      "--no-builtin-tools",
+      "--tools",
+      allowlist.join(","),
+      "--exclude-tools",
+      FUSION_FORBIDDEN_TOOLS.join(",")
+    ];
+  }
+  throw new FusionError(`fusion capability ${String(capability)} is not supported`, {
+    code: "orchestration_failed",
+    childCreated: false
+  });
+}
+__name(fusionToolArgv, "fusionToolArgv");
+function fusionChildExtensionPaths(model, childExtensionPath, resolveAttribution = resolveAnthropicAttributionExtensionPath) {
+  if (model.provider !== FUSION_SANITIZED_PROVIDER) return [childExtensionPath];
+  return [resolveAttribution(), childExtensionPath];
+}
+__name(fusionChildExtensionPaths, "fusionChildExtensionPaths");
+function buildFusionPiChildArgv(model, systemPrompt, childExtensionPath = resolveFusionChildExtensionPath(), capability = FUSION_NO_TOOLS_CAPABILITY, resolveAttribution = resolveAnthropicAttributionExtensionPath) {
+  const extensionArgs = fusionChildExtensionPaths(
+    model,
+    childExtensionPath,
+    resolveAttribution
+  ).flatMap((path) => ["--extension", path]);
+  return [
+    "--mode",
+    "text",
+    "--no-session",
+    ...fusionToolArgv(capability),
+    "--no-extensions",
+    "--no-skills",
+    "--no-prompt-templates",
+    "--no-themes",
+    "--no-context-files",
+    ...extensionArgs,
+    "--provider",
+    model.provider,
+    "--model",
+    model.model,
+    "--thinking",
+    model.thinkingLevel,
+    "--system-prompt",
+    systemPrompt
+  ];
+}
+__name(buildFusionPiChildArgv, "buildFusionPiChildArgv");
+var SHA256_HEX_PATTERN = /^[0-9a-f]{64}$/;
+var FUSION_CHILD_RESULT_PREFIX_BYTES = Buffer.from(FUSION_CHILD_RESULT_PREFIX, "utf8");
+var FUSION_CHILD_SETTLEMENT_PREFIX_BYTES = Buffer.from(FUSION_CHILD_SETTLEMENT_PREFIX, "utf8");
+var FUSION_RUNTIME_GUARD_PREFIX_BYTES = Buffer.from(FUSION_RUNTIME_GUARD_PREFIX, "utf8");
+var PI_EXTENSION_ERROR_PREFIX_BYTES = Buffer.from("Extension error (", "utf8");
+function assertClosedRecord(value, keys, label) {
+  if (!isJsonObject(value) || Array.isArray(value)) throw new Error(`${label} must be an object`);
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+    throw new Error(`${label} keys mismatch: expected ${expected.join(", ")}`);
+  }
+  return value;
+}
+__name(assertClosedRecord, "assertClosedRecord");
+function assertClosedRecordWithOptional(value, requiredKeys, optionalKeys, label) {
+  if (!isJsonObject(value) || Array.isArray(value)) throw new Error(`${label} must be an object`);
+  const allowed = /* @__PURE__ */ new Set([...requiredKeys, ...optionalKeys]);
+  const actual = Object.keys(value).sort();
+  const missing = requiredKeys.filter((key) => !Object.hasOwn(value, key));
+  const unknownKeys = actual.filter((key) => !allowed.has(key));
+  if (missing.length > 0 || unknownKeys.length > 0) {
+    throw new Error(
+      `${label} keys mismatch: required ${[...requiredKeys].sort().join(", ")}; optional ${[
+        ...optionalKeys
+      ].sort().join(", ")}`
+    );
+  }
+  return value;
+}
+__name(assertClosedRecordWithOptional, "assertClosedRecordWithOptional");
+function requireNonBlankString(record, key, label) {
+  const value = record[key];
+  if (typeof value !== "string" || value.trim().length === 0)
+    throw new Error(`${label}.${key} must be a non-blank string`);
+  return value;
+}
+__name(requireNonBlankString, "requireNonBlankString");
+function requireSha256(record, key, label) {
+  const value = record[key];
+  if (typeof value !== "string" || !SHA256_HEX_PATTERN.test(value))
+    throw new Error(`${label}.${key} must be a lowercase SHA-256 hex digest`);
+  return value;
+}
+__name(requireSha256, "requireSha256");
+function requireUsageInteger(record, key, label) {
+  const value = record[key];
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+    throw new Error(`${label}.${key} must be a non-negative safe integer`);
+  return value;
+}
+__name(requireUsageInteger, "requireUsageInteger");
+function requirePositiveSafeInteger(record, key, label) {
+  const value = requireUsageInteger(record, key, label);
+  if (value === 0) throw new Error(`${label}.${key} must be a positive safe integer`);
+  return value;
+}
+__name(requirePositiveSafeInteger, "requirePositiveSafeInteger");
+function requireCostNumber(record, key, label) {
+  const value = record[key];
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+    throw new Error(`${label}.${key} must be a non-negative finite number`);
+  return value;
+}
+__name(requireCostNumber, "requireCostNumber");
+function parseCompactUsage(value) {
+  const record = assertClosedRecordWithOptional(
+    value,
+    ["input", "output", "cacheRead", "cacheWrite", "totalTokens", "cost"],
+    ["cacheWrite1h", "reasoning"],
+    "fusion child usage"
+  );
+  const cost = assertClosedRecord(
+    record["cost"],
+    ["input", "output", "cacheRead", "cacheWrite", "total"],
+    "fusion child usage.cost"
+  );
+  const output = requireUsageInteger(record, "output", "fusion child usage");
+  const cacheWrite = requireUsageInteger(record, "cacheWrite", "fusion child usage");
+  const cacheWrite1h = record["cacheWrite1h"] === void 0 ? void 0 : requireUsageInteger(record, "cacheWrite1h", "fusion child usage");
+  const reasoning = record["reasoning"] === void 0 ? void 0 : requireUsageInteger(record, "reasoning", "fusion child usage");
+  if (cacheWrite1h !== void 0 && cacheWrite1h > cacheWrite) {
+    throw new Error("fusion child usage.cacheWrite1h must not exceed cacheWrite");
+  }
+  if (reasoning !== void 0 && reasoning > output) {
+    throw new Error("fusion child usage.reasoning must not exceed output");
+  }
+  return {
+    input: requireUsageInteger(record, "input", "fusion child usage"),
+    output,
+    cacheRead: requireUsageInteger(record, "cacheRead", "fusion child usage"),
+    cacheWrite,
+    ...cacheWrite1h === void 0 ? {} : { cacheWrite1h },
+    ...reasoning === void 0 ? {} : { reasoning },
+    totalTokens: requireUsageInteger(record, "totalTokens", "fusion child usage"),
+    cost: {
+      input: requireCostNumber(cost, "input", "fusion child usage.cost"),
+      output: requireCostNumber(cost, "output", "fusion child usage.cost"),
+      cacheRead: requireCostNumber(cost, "cacheRead", "fusion child usage.cost"),
+      cacheWrite: requireCostNumber(cost, "cacheWrite", "fusion child usage.cost"),
+      total: requireCostNumber(cost, "total", "fusion child usage.cost")
+    }
+  };
+}
+__name(parseCompactUsage, "parseCompactUsage");
+var FUSION_CLAUDE_CACHE_RETENTIONS = /* @__PURE__ */ new Set([
+  "none",
+  "short",
+  "long"
+]);
+function parseFusionClaudeCacheObservation(value, provider) {
+  const record = assertClosedRecord(
+    value,
+    [
+      "schema_version",
+      "applicability",
+      "source",
+      "requested_retention",
+      "effective_retention",
+      "breakpoint_count",
+      "request_ordinal"
+    ],
+    "fusion child cache observation"
+  );
+  if (record["schema_version"] !== FUSION_CLAUDE_CACHE_OBSERVATION_SCHEMA_VERSION) {
+    throw new Error("fusion child cache observation schema_version mismatch");
+  }
+  const applicability = record["applicability"];
+  const source = record["source"];
+  const requested = record["requested_retention"];
+  const effective = record["effective_retention"];
+  const breakpointCount = requireUsageInteger(
+    record,
+    "breakpoint_count",
+    "fusion child cache observation"
+  );
+  const requestOrdinal = requirePositiveSafeInteger(
+    record,
+    "request_ordinal",
+    "fusion child cache observation"
+  );
+  if (requestOrdinal > FUSION_CHILD_MAX_PROVIDER_REQUESTS) {
+    throw new Error("fusion child cache observation exceeds the provider request limit");
+  }
+  if (breakpointCount > FUSION_CLAUDE_CACHE_BREAKPOINT_LIMIT) {
+    throw new Error("fusion child cache observation exceeds the Anthropic breakpoint limit");
+  }
+  if (provider !== "anthropic") {
+    if (applicability !== "not_applicable" || source !== "not_applicable" || requested !== null || effective !== null || breakpointCount !== 0) {
+      throw new Error("non-Anthropic fusion child has contradictory cache observation");
+    }
+    return {
+      schema_version: FUSION_CLAUDE_CACHE_OBSERVATION_SCHEMA_VERSION,
+      applicability: "not_applicable",
+      source: "not_applicable",
+      requested_retention: null,
+      effective_retention: null,
+      breakpoint_count: 0,
+      request_ordinal: requestOrdinal
+    };
+  }
+  if (applicability !== "anthropic") {
+    throw new Error("Anthropic fusion child cache observation is not applicable");
+  }
+  if (source !== "default" && source !== FUSION_CLAUDE_CACHE_RETENTION_ENV) {
+    throw new Error("Anthropic fusion child cache observation source is invalid");
+  }
+  if (typeof requested !== "string" || !FUSION_CLAUDE_CACHE_RETENTIONS.has(requested) || typeof effective !== "string" || !FUSION_CLAUDE_CACHE_RETENTIONS.has(effective)) {
+    throw new Error("Anthropic fusion child cache retention is invalid");
+  }
+  const requestedRetention = requested;
+  const effectiveRetention = effective;
+  if (source === "default" && requestedRetention !== "long") {
+    throw new Error("default Anthropic cache policy did not request long retention");
+  }
+  if (effectiveRetention === "none" !== (breakpointCount === 0)) {
+    throw new Error("Anthropic fusion child cache retention/breakpoint evidence mismatch");
+  }
+  if (requestedRetention === "none" && effectiveRetention !== "none") {
+    throw new Error("disabled Anthropic cache policy reported active breakpoints");
+  }
+  if (effectiveRetention === "long" && requestedRetention !== "long") {
+    throw new Error("Anthropic long cache retention was not requested");
+  }
+  return {
+    schema_version: FUSION_CLAUDE_CACHE_OBSERVATION_SCHEMA_VERSION,
+    applicability: "anthropic",
+    source,
+    requested_retention: requestedRetention,
+    effective_retention: effectiveRetention,
+    breakpoint_count: breakpointCount,
+    request_ordinal: requestOrdinal
+  };
+}
+__name(parseFusionClaudeCacheObservation, "parseFusionClaudeCacheObservation");
+var FUSION_OUTPUT_RECOVERY_ROLES = /* @__PURE__ */ new Set([
+  "none",
+  "oversized_original",
+  "replacement"
+]);
+function parseChildOutputContract(value) {
+  const record = assertClosedRecord(
+    value,
+    ["json_rendered_bytes", "candidate_limit_bytes", "recovery_role"],
+    "fusion child result.output_contract"
+  );
+  const candidateLimitValue = record["candidate_limit_bytes"];
+  const candidateLimit = candidateLimitValue === null ? null : requirePositiveSafeInteger(
+    record,
+    "candidate_limit_bytes",
+    "fusion child result.output_contract"
+  );
+  if (candidateLimit !== null && candidateLimit !== FUSION_CANDIDATE_MAX_OUTPUT_BYTES) {
+    throw new Error("fusion child result candidate output limit mismatches the shared contract");
+  }
+  const recoveryRole = record["recovery_role"];
+  if (typeof recoveryRole !== "string" || !FUSION_OUTPUT_RECOVERY_ROLES.has(recoveryRole)) {
+    throw new Error("fusion child result.output_contract.recovery_role is invalid");
+  }
+  if (recoveryRole !== "none" && candidateLimit === null) {
+    throw new Error("fusion child result output recovery has no candidate contract");
+  }
+  return {
+    json_rendered_bytes: requireUsageInteger(
+      record,
+      "json_rendered_bytes",
+      "fusion child result.output_contract"
+    ),
+    candidate_limit_bytes: candidateLimit,
+    recovery_role: recoveryRole
+  };
+}
+__name(parseChildOutputContract, "parseChildOutputContract");
+function parseChildResultMetadata(value) {
+  const record = assertClosedRecord(
+    value,
+    [
+      "schema_version",
+      "provider",
+      "model",
+      "stop_reason",
+      "text_blocks",
+      "text_sha256",
+      "usage",
+      "cache_observation",
+      "output_contract"
+    ],
+    "fusion child result"
+  );
+  if (record["schema_version"] !== FUSION_CHILD_RESULT_SCHEMA_VERSION)
+    throw new Error("fusion child result schema_version mismatch");
+  const textBlocksValue = record["text_blocks"];
+  if (!Array.isArray(textBlocksValue))
+    throw new Error("fusion child result.text_blocks must be an array");
+  const textBlocks = textBlocksValue.map((value2, index) => {
+    const label = `fusion child result.text_blocks[${String(index)}]`;
+    const block = assertClosedRecord(value2, ["utf8_bytes", "sha256"], label);
+    return {
+      utf8_bytes: requireUsageInteger(block, "utf8_bytes", label),
+      sha256: requireSha256(block, "sha256", label)
+    };
+  });
+  const usage = parseCompactUsage(record["usage"]);
+  const provider = requireNonBlankString(record, "provider", "fusion child result");
+  return {
+    schema_version: FUSION_CHILD_RESULT_SCHEMA_VERSION,
+    provider,
+    model: requireNonBlankString(record, "model", "fusion child result"),
+    stop_reason: requireNonBlankString(record, "stop_reason", "fusion child result"),
+    text_blocks: textBlocks,
+    text_sha256: requireSha256(record, "text_sha256", "fusion child result"),
+    usage,
+    cache_observation: parseFusionClaudeCacheObservation(record["cache_observation"], provider),
+    output_contract: parseChildOutputContract(record["output_contract"])
+  };
+}
+__name(parseChildResultMetadata, "parseChildResultMetadata");
+var FUSION_RUNTIME_GUARD_CODES = /* @__PURE__ */ new Set([
+  "provider_request_limit",
+  "provider_payload_invalid",
+  "claude_cache_policy",
+  "tool_call_limit"
+]);
+function parseFusionRuntimeGuard(stderr) {
+  const frames = [];
+  let cursor = 0;
+  for (; ; ) {
+    const frameStart = stderr.indexOf(FUSION_RUNTIME_GUARD_PREFIX_BYTES, cursor);
+    if (frameStart < 0) break;
+    const payloadStart = frameStart + FUSION_RUNTIME_GUARD_PREFIX_BYTES.length;
+    const newline = stderr.indexOf(10, payloadStart);
+    if (newline < 0) throw new Error("fusion runtime guard frame is not newline-terminated");
+    const bytes = stderr.subarray(payloadStart, newline);
+    const text = bytes.toString("utf8");
+    if (!Buffer.from(text, "utf8").equals(bytes)) {
+      throw new Error("fusion runtime guard frame is not valid UTF-8");
+    }
+    const record = assertClosedRecord(
+      parseJsonText(text),
+      [
+        "schema_version",
+        "code",
+        "provider",
+        "model",
+        "request_ordinal",
+        "tool_call_count",
+        "payload_bytes",
+        "payload_sha256",
+        "message"
+      ],
+      "fusion runtime guard"
+    );
+    if (record["schema_version"] !== FUSION_RUNTIME_GUARD_SCHEMA_VERSION) {
+      throw new Error("fusion runtime guard schema_version mismatch");
+    }
+    const code = requireNonBlankString(record, "code", "fusion runtime guard");
+    if (!FUSION_RUNTIME_GUARD_CODES.has(code)) {
+      throw new Error(`fusion runtime guard code is unsupported: ${code}`);
+    }
+    const frame = {
+      schema_version: FUSION_RUNTIME_GUARD_SCHEMA_VERSION,
+      code,
+      provider: requireNonBlankString(record, "provider", "fusion runtime guard"),
+      model: requireNonBlankString(record, "model", "fusion runtime guard"),
+      request_ordinal: requirePositiveSafeInteger(
+        record,
+        "request_ordinal",
+        "fusion runtime guard"
+      ),
+      tool_call_count: requireUsageInteger(record, "tool_call_count", "fusion runtime guard"),
+      payload_bytes: requireUsageInteger(record, "payload_bytes", "fusion runtime guard"),
+      payload_sha256: requireSha256(record, "payload_sha256", "fusion runtime guard"),
+      message: requireNonBlankString(record, "message", "fusion runtime guard")
+    };
+    const emptyPayloadHash = createHash3("sha256").update(Buffer.alloc(0)).digest("hex");
+    if (frame.code === "claude_cache_policy" || frame.code === "provider_payload_invalid") {
+      if (frame.payload_bytes !== 0 || frame.payload_sha256 !== emptyPayloadHash) {
+        throw new Error("fusion runtime guard invalid-payload evidence mismatch");
+      }
+    }
+    if (frame.code === "provider_request_limit" && frame.request_ordinal <= FUSION_CHILD_MAX_PROVIDER_REQUESTS) {
+      throw new Error("fusion runtime guard provider request limit was not exceeded");
+    }
+    if (frame.code === "tool_call_limit") {
+      if (frame.tool_call_count <= FUSION_CHILD_MAX_TOOL_CALLS) {
+        throw new Error("fusion runtime guard tool call limit was not exceeded");
+      }
+      if (frame.payload_bytes !== 0 || frame.payload_sha256 !== emptyPayloadHash) {
+        throw new Error("fusion runtime guard tool call limit payload evidence mismatch");
+      }
+    }
+    frames.push(frame);
+    cursor = newline + 1;
+  }
+  if (frames.length > 1) throw new Error("fusion child emitted multiple runtime guard frames");
+  return frames[0];
+}
+__name(parseFusionRuntimeGuard, "parseFusionRuntimeGuard");
+var FUSION_CHILD_SETTLEMENT_FAILURE_REASONS = /* @__PURE__ */ new Set([
+  "no_records",
+  "final_not_stop",
+  "invalid_non_final",
+  "runtime_guard",
+  "cache_observation",
+  "output_recovery"
+]);
+function parseFusionChildSettlement(stderr) {
+  const frames = [];
+  let cursor = 0;
+  for (; ; ) {
+    const frameStart = stderr.indexOf(FUSION_CHILD_SETTLEMENT_PREFIX_BYTES, cursor);
+    if (frameStart < 0) break;
+    const payloadStart = frameStart + FUSION_CHILD_SETTLEMENT_PREFIX_BYTES.length;
+    const newline = stderr.indexOf(10, payloadStart);
+    if (newline < 0) throw new Error("fusion child settlement frame is not newline-terminated");
+    const bytes = stderr.subarray(payloadStart, newline);
+    const text = bytes.toString("utf8");
+    if (!Buffer.from(text, "utf8").equals(bytes)) {
+      throw new Error("fusion child settlement frame is not valid UTF-8");
+    }
+    const record = assertClosedRecord(
+      parseJsonText(text),
+      [
+        "schema_version",
+        "status",
+        "record_count",
+        "records_sha256",
+        "final_record_index",
+        "final_text_sha256",
+        "recovered_error_ordinals",
+        "recovered_output_cap_ordinals",
+        "failure_reason"
+      ],
+      "fusion child settlement"
+    );
+    if (record["schema_version"] !== FUSION_CHILD_SETTLEMENT_SCHEMA_VERSION) {
+      throw new Error("fusion child settlement schema_version mismatch");
+    }
+    const status = record["status"];
+    if (status !== "complete" && status !== "failed") {
+      throw new Error("fusion child settlement.status is invalid");
+    }
+    const recordCount = requireUsageInteger(record, "record_count", "fusion child settlement");
+    const finalIndexValue = record["final_record_index"];
+    const finalRecordIndex = finalIndexValue === null ? null : requireUsageInteger(record, "final_record_index", "fusion child settlement");
+    const finalHashValue = record["final_text_sha256"];
+    const finalTextSha256 = finalHashValue === null ? null : requireSha256(record, "final_text_sha256", "fusion child settlement");
+    const recoveredValue = record["recovered_error_ordinals"];
+    if (!Array.isArray(recoveredValue)) {
+      throw new Error("fusion child settlement.recovered_error_ordinals must be an array");
+    }
+    const recoveredErrorOrdinals = recoveredValue.map((value, index) => {
+      if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(
+          `fusion child settlement.recovered_error_ordinals[${String(index)}] must be a non-negative safe integer`
+        );
+      }
+      return value;
+    });
+    for (let index = 0; index < recoveredErrorOrdinals.length; index += 1) {
+      const ordinal = recoveredErrorOrdinals[index];
+      if (ordinal === void 0 || ordinal >= recordCount - 1 || index > 0 && ordinal <= (recoveredErrorOrdinals[index - 1] ?? -1)) {
+        throw new Error("fusion child settlement recovered-error ordinals are not canonical");
+      }
+    }
+    const recoveredOutputValue = record["recovered_output_cap_ordinals"];
+    if (!Array.isArray(recoveredOutputValue)) {
+      throw new Error("fusion child settlement.recovered_output_cap_ordinals must be an array");
+    }
+    const recoveredOutputCapOrdinals = recoveredOutputValue.map((value, index) => {
+      if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(
+          `fusion child settlement.recovered_output_cap_ordinals[${String(index)}] must be a non-negative safe integer`
+        );
+      }
+      return value;
+    });
+    for (let index = 0; index < recoveredOutputCapOrdinals.length; index += 1) {
+      const ordinal = recoveredOutputCapOrdinals[index];
+      if (ordinal === void 0 || ordinal >= recordCount - 1 || index > 0 && ordinal <= (recoveredOutputCapOrdinals[index - 1] ?? -1)) {
+        throw new Error("fusion child settlement recovered-output ordinals are not canonical");
+      }
+    }
+    const failureValue = record["failure_reason"];
+    let failureReason;
+    if (failureValue === null) failureReason = null;
+    else if (typeof failureValue === "string" && FUSION_CHILD_SETTLEMENT_FAILURE_REASONS.has(
+      failureValue
+    )) {
+      failureReason = failureValue;
+    } else {
+      throw new Error("fusion child settlement.failure_reason is invalid");
+    }
+    if (status === "complete" !== (failureReason === null)) {
+      throw new Error("fusion child settlement status/failure_reason mismatch");
+    }
+    if (recordCount === 0) {
+      if (finalRecordIndex !== null || finalTextSha256 !== null) {
+        throw new Error("fusion child settlement empty stream has final-record evidence");
+      }
+    } else if (finalRecordIndex !== recordCount - 1 || finalTextSha256 === null) {
+      throw new Error("fusion child settlement final-record evidence mismatch");
+    }
+    frames.push({
+      schema_version: FUSION_CHILD_SETTLEMENT_SCHEMA_VERSION,
+      status,
+      record_count: recordCount,
+      records_sha256: requireSha256(record, "records_sha256", "fusion child settlement"),
+      final_record_index: finalRecordIndex,
+      final_text_sha256: finalTextSha256,
+      recovered_error_ordinals: recoveredErrorOrdinals,
+      recovered_output_cap_ordinals: recoveredOutputCapOrdinals,
+      failure_reason: failureReason
+    });
+    cursor = newline + 1;
+  }
+  if (frames.length > 1) throw new Error("fusion child emitted multiple settlement frames");
+  return frames[0];
+}
+__name(parseFusionChildSettlement, "parseFusionChildSettlement");
+function assertFusionChildSettlementOrdering(stderr) {
+  const settlementStart = stderr.indexOf(FUSION_CHILD_SETTLEMENT_PREFIX_BYTES);
+  if (settlementStart < 0) return;
+  if (stderr.indexOf(FUSION_CHILD_RESULT_PREFIX_BYTES, settlementStart) >= 0) {
+    throw new Error("fusion child emitted result metadata after terminal settlement");
+  }
+}
+__name(assertFusionChildSettlementOrdering, "assertFusionChildSettlementOrdering");
+function stripChildControlFrames(stderr) {
+  const prefixes = [FUSION_CHILD_SETTLEMENT_PREFIX_BYTES, FUSION_RUNTIME_GUARD_PREFIX_BYTES];
+  const diagnostics = [];
+  let cursor = 0;
+  for (; ; ) {
+    let next = -1;
+    let prefix;
+    for (const candidate of prefixes) {
+      const found = stderr.indexOf(candidate, cursor);
+      if (found >= 0 && (next < 0 || found < next)) {
+        next = found;
+        prefix = candidate;
+      }
+    }
+    if (next < 0 || prefix === void 0) {
+      if (cursor < stderr.length) diagnostics.push(stderr.subarray(cursor));
+      break;
+    }
+    if (next > cursor) diagnostics.push(stderr.subarray(cursor, next));
+    const newline = stderr.indexOf(10, next + prefix.length);
+    if (newline < 0) throw new Error("fusion child control frame is not newline-terminated");
+    cursor = newline + 1;
+  }
+  return Buffer.concat(diagnostics);
+}
+__name(stripChildControlFrames, "stripChildControlFrames");
+function assertFusionRuntimeGuardMatchesModel(guard, model) {
+  const routeUnknown = guard.provider === "unknown" && guard.model === "unknown";
+  if (!routeUnknown && (guard.provider !== model.provider || guard.model !== model.model)) {
+    throw new Error(
+      `fusion runtime guard route mismatch: expected ${model.qualifiedId}, observed ${guard.provider}/${guard.model}`
+    );
+  }
+  if (routeUnknown && guard.code !== "provider_payload_invalid") {
+    throw new Error("fusion runtime guard omitted the route for a route-bound refusal");
+  }
+}
+__name(assertFusionRuntimeGuardMatchesModel, "assertFusionRuntimeGuardMatchesModel");
+function parseFusionChildStderr(stderr) {
+  parseFusionRuntimeGuard(stderr);
+  const settlement = parseFusionChildSettlement(stderr);
+  assertFusionChildSettlementOrdering(stderr);
+  const records = [];
+  const diagnostics = [];
+  let cursor = 0;
+  for (; ; ) {
+    const frameStart = stderr.indexOf(FUSION_CHILD_RESULT_PREFIX_BYTES, cursor);
+    if (frameStart < 0) {
+      if (cursor < stderr.length) diagnostics.push(stderr.subarray(cursor));
+      break;
+    }
+    if (frameStart > cursor) diagnostics.push(stderr.subarray(cursor, frameStart));
+    const payloadStart = frameStart + FUSION_CHILD_RESULT_PREFIX_BYTES.length;
+    const newline = stderr.indexOf(10, payloadStart);
+    if (newline < 0) throw new Error("fusion child metadata frame is not newline-terminated");
+    const payloadBytes = stderr.subarray(payloadStart, newline);
+    const payloadText = payloadBytes.toString("utf8");
+    if (!Buffer.from(payloadText, "utf8").equals(payloadBytes))
+      throw new Error("fusion child metadata frame is not valid UTF-8");
+    let parsed;
+    try {
+      parsed = parseJsonText(payloadText);
+    } catch (error) {
+      throw new Error(
+        `fusion child metadata frame is invalid JSON: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    records.push(parseChildResultMetadata(parsed));
+    cursor = newline + 1;
+  }
+  const resultEvents = serializeFusionChildResultRecords(records);
+  const events = settlement === void 0 ? resultEvents : Buffer.concat([resultEvents, Buffer.from(`${JSON.stringify(settlement)}
+`, "utf8")]);
+  return {
+    records,
+    events,
+    diagnostics: stripChildControlFrames(Buffer.concat(diagnostics))
+  };
+}
+__name(parseFusionChildStderr, "parseFusionChildStderr");
+function parseToolCallLogRecord(value, label) {
+  const record = assertClosedRecordWithOptional(
+    value,
+    [
+      "schema_version",
+      "ordinal",
+      "tool_name",
+      "arguments_sha256",
+      "arguments_bytes",
+      "result_bytes",
+      "result_sha256",
+      "status",
+      "duration_ms"
+    ],
+    ["url", "rejected_url_sha256", "final_url", "http_status", "response_bytes", "content_sha256"],
+    label
+  );
+  if (record["schema_version"] !== FUSION_TOOL_CALL_LOG_SCHEMA_VERSION) {
+    throw new Error(`${label}.schema_version mismatch`);
+  }
+  const status = record["status"];
+  if (status !== "ok" && status !== "error") throw new Error(`${label}.status is invalid`);
+  const parsedRecord = {
+    schema_version: FUSION_TOOL_CALL_LOG_SCHEMA_VERSION,
+    ordinal: requireUsageInteger(record, "ordinal", label),
+    tool_name: requireNonBlankString(record, "tool_name", label),
+    arguments_sha256: requireSha256(record, "arguments_sha256", label),
+    arguments_bytes: requireUsageInteger(record, "arguments_bytes", label),
+    result_bytes: requireUsageInteger(record, "result_bytes", label),
+    result_sha256: requireSha256(record, "result_sha256", label),
+    status,
+    duration_ms: requireUsageInteger(record, "duration_ms", label)
+  };
+  if (record["url"] !== void 0) parsedRecord.url = requireNonBlankString(record, "url", label);
+  if (record["rejected_url_sha256"] !== void 0)
+    parsedRecord.rejected_url_sha256 = requireSha256(record, "rejected_url_sha256", label);
+  if (record["final_url"] !== void 0)
+    parsedRecord.final_url = requireNonBlankString(record, "final_url", label);
+  if (record["http_status"] !== void 0)
+    parsedRecord.http_status = requireUsageInteger(record, "http_status", label);
+  if (record["response_bytes"] !== void 0)
+    parsedRecord.response_bytes = requireUsageInteger(record, "response_bytes", label);
+  if (record["content_sha256"] !== void 0)
+    parsedRecord.content_sha256 = requireSha256(record, "content_sha256", label);
+  return parsedRecord;
+}
+__name(parseToolCallLogRecord, "parseToolCallLogRecord");
+function parseFusionToolCallLog(bytes) {
+  if (bytes.length === 0) {
+    return {
+      bytes,
+      records: [],
+      summary: { count: 0, total_result_bytes: 0, trace_complete: true }
+    };
+  }
+  if (bytes.at(-1) !== 10) {
+    throw new Error("fusion tool-call log has trailing partial line");
+  }
+  const text = bytes.toString("utf8");
+  if (!Buffer.from(text, "utf8").equals(bytes)) {
+    throw new Error("fusion tool-call log is not valid UTF-8");
+  }
+  const lines = text.split("\n");
+  lines.pop();
+  const records = lines.map((line, index) => {
+    let parsed;
+    try {
+      parsed = parseJsonText(line);
+    } catch (error) {
+      throw new Error(
+        `fusion tool-call log line ${String(index)} is invalid JSON: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    return parseToolCallLogRecord(parsed, `fusion tool-call log line ${String(index)}`);
+  });
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, record] of records.entries()) {
+    if (seen.has(record.ordinal)) {
+      throw new Error(`fusion tool-call log duplicate ordinal ${String(record.ordinal)}`);
+    }
+    seen.add(record.ordinal);
+    if (record.ordinal !== index) {
+      throw new Error(
+        `fusion tool-call log ordinal gap: expected ${String(index)}, observed ${String(record.ordinal)}`
+      );
+    }
+  }
+  return {
+    bytes,
+    records,
+    summary: {
+      count: records.length,
+      total_result_bytes: records.reduce((sum, record) => sum + record.result_bytes, 0),
+      trace_complete: true
+    }
+  };
+}
+__name(parseFusionToolCallLog, "parseFusionToolCallLog");
+async function assertCompletedToolPolicy(trace, capability, sourcePolicy) {
+  const allowed = capability === "inspect" ? FUSION_INSPECT_TOOLS : capability === "research" ? FUSION_RESEARCH_TOOLS : [];
+  const allowedSet = new Set(allowed);
+  const declared = capability === "research" && sourcePolicy !== void 0 ? new Set(
+    (await readFusionSourcePolicyFile(sourcePolicy.path, sourcePolicy.sha256)).sources.map(
+      (source) => source.canonical_url
+    )
+  ) : void 0;
+  for (const record of trace.records) {
+    if (!allowedSet.has(record.tool_name)) {
+      throw new Error(`fusion child used non-allowlisted tool ${record.tool_name}`);
+    }
+    if (capability === "research" && record.tool_name === FUSION_WEB_FETCH_TOOL_NAME) {
+      if (sourcePolicy === void 0 || declared === void 0)
+        throw new Error("fusion research source policy missing during audit");
+      if (record.status === "ok") {
+        if (record.url === void 0) throw new Error("fusion research fetch audit is missing url");
+        const canonicalUrl = canonicalizeFusionPublicUrl(record.url);
+        if (record.url !== canonicalUrl)
+          throw new Error("fusion research fetch audit URL was not canonical");
+        if (!declared.has(canonicalUrl))
+          throw new Error("fusion research fetch audit URL was not declared");
+        if (record.rejected_url_sha256 !== void 0) {
+          throw new Error(
+            "fusion research successful fetch audit must not include rejected_url_sha256"
+          );
+        }
+        if (record.final_url === void 0)
+          throw new Error("fusion research fetch audit is missing final_url");
+        if (record.http_status === void 0)
+          throw new Error("fusion research fetch audit is missing http_status");
+        if (record.response_bytes === void 0)
+          throw new Error("fusion research fetch audit is missing response_bytes");
+        if (record.content_sha256 === void 0)
+          throw new Error("fusion research fetch audit is missing content_sha256");
+      } else {
+        if (record.url !== void 0 || record.final_url !== void 0) {
+          throw new Error("fusion research rejected fetch audit must not persist raw URL");
+        }
+        if (record.rejected_url_sha256 === void 0) {
+          throw new Error("fusion research rejected fetch audit is missing rejected_url_sha256");
+        }
+      }
+    }
+  }
+}
+__name(assertCompletedToolPolicy, "assertCompletedToolPolicy");
+function isNotFound(error) {
+  return isJsonObject(error) && error["code"] === "ENOENT";
+}
+__name(isNotFound, "isNotFound");
+async function readFusionToolCallLog(path) {
+  let handle;
+  try {
+    handle = await open(path, constants.O_RDONLY | FUSION_PI_CHILD_O_NOFOLLOW);
+  } catch (error) {
+    if (isNotFound(error)) {
+      throw new Error(
+        `fusion tool-call log is missing at ${path}; the inspect child never initialized its audit trail`
+      );
+    }
+    if (isJsonObject(error) && error["code"] === "ELOOP") {
+      throw new Error(
+        `fusion tool-call log at ${path} is a symlink; refusing to trust a redirected audit trail`
+      );
+    }
+    throw error;
+  }
+  try {
+    const stats = await handle.stat();
+    if (!stats.isFile()) {
+      throw new Error(
+        `fusion tool-call log at ${path} is not a regular file; refusing to trust a redirected audit trail`
+      );
+    }
+    return parseFusionToolCallLog(await handle.readFile());
+  } finally {
+    await handle.close();
+  }
+}
+__name(readFusionToolCallLog, "readFusionToolCallLog");
+async function assertFusionToolCallLogSeal(path, trace) {
+  const sealPath = `${path}${FUSION_TOOL_CALL_SEAL_SUFFIX}`;
+  let handle;
+  try {
+    handle = await open(sealPath, constants.O_RDONLY | FUSION_PI_CHILD_O_NOFOLLOW);
+  } catch (error) {
+    if (isNotFound(error)) throw new Error("fusion tool-call audit completion seal is missing");
+    if (isJsonObject(error) && error["code"] === "ELOOP") {
+      throw new Error("fusion tool-call audit completion seal is a symlink");
+    }
+    throw error;
+  }
+  try {
+    const stats = await handle.stat();
+    if (!stats.isFile())
+      throw new Error("fusion tool-call audit completion seal is not a regular file");
+    if (stats.size > 4096) throw new Error("fusion tool-call audit completion seal is oversized");
+    const bytes = await handle.readFile();
+    if (bytes.at(-1) !== 10) throw new Error("fusion tool-call audit completion seal is partial");
+    const text = bytes.toString("utf8");
+    if (!Buffer.from(text, "utf8").equals(bytes)) {
+      throw new Error("fusion tool-call audit completion seal is not UTF-8");
+    }
+    const parsed = parseJsonText(text);
+    if (!isJsonObject(parsed) || Array.isArray(parsed)) {
+      throw new Error("fusion tool-call audit completion seal must be an object");
+    }
+    const keys = Object.keys(parsed).sort();
+    const expected = [
+      "log_sha256",
+      "record_count",
+      "schema_version",
+      "status",
+      "total_result_bytes"
+    ];
+    if (keys.join("\0") !== expected.join("\0")) {
+      throw new Error("fusion tool-call audit completion seal keys mismatch");
+    }
+    if (parsed["schema_version"] !== FUSION_TOOL_CALL_SEAL_SCHEMA_VERSION) {
+      throw new Error("fusion tool-call audit completion seal schema mismatch");
+    }
+    if (parsed["status"] !== "complete") {
+      throw new Error("fusion tool-call audit completion seal reports a failed audit");
+    }
+    const recordCount = requireUsageInteger(parsed, "record_count", "fusion tool-call audit seal");
+    const totalResultBytes = requireUsageInteger(
+      parsed,
+      "total_result_bytes",
+      "fusion tool-call audit seal"
+    );
+    const logSha256 = requireSha256(parsed, "log_sha256", "fusion tool-call audit seal");
+    if (recordCount !== trace.summary.count) {
+      throw new Error("fusion tool-call audit completion seal record count mismatch");
+    }
+    if (recordCount > FUSION_CHILD_MAX_TOOL_CALLS) {
+      throw new Error(
+        `fusion tool-call audit exceeds tool-call limit ${String(FUSION_CHILD_MAX_TOOL_CALLS)}`
+      );
+    }
+    if (totalResultBytes !== trace.summary.total_result_bytes) {
+      throw new Error("fusion tool-call audit completion seal result-byte total mismatch");
+    }
+    if (logSha256 !== sha256Buffer(trace.bytes)) {
+      throw new Error("fusion tool-call audit completion seal log hash mismatch");
+    }
+    if (totalResultBytes > FUSION_CHILD_MAX_TOTAL_TOOL_RESULT_BYTES) {
+      throw new Error(
+        `fusion tool-call audit exceeds aggregate result-byte limit ${String(FUSION_CHILD_MAX_TOTAL_TOOL_RESULT_BYTES)}`
+      );
+    }
+  } finally {
+    await handle.close();
+  }
+}
+__name(assertFusionToolCallLogSeal, "assertFusionToolCallLogSeal");
+function sha256Buffer(bytes) {
+  return createHash3("sha256").update(bytes).digest("hex");
+}
+__name(sha256Buffer, "sha256Buffer");
+function reconstructFinalText(response, record) {
+  const blocks = [];
+  let cursor = 0;
+  for (const [index, block] of record.text_blocks.entries()) {
+    const end = cursor + block.utf8_bytes;
+    if (end > response.length)
+      throw new Error(`Pi final text block ${String(index)} is shorter than its metadata length`);
+    const bytes = response.subarray(cursor, end);
+    if (sha256Buffer(bytes) !== block.sha256)
+      throw new Error(`Pi final text block ${String(index)} hash mismatch`);
+    blocks.push(bytes);
+    if (response.at(end) !== 10)
+      throw new Error(`Pi final text block ${String(index)} lacks its print-mode newline`);
+    cursor = end + 1;
+  }
+  if (cursor !== response.length)
+    throw new Error("Pi final text stdout contains bytes outside declared text blocks");
+  const joined = Buffer.concat(blocks);
+  if (sha256Buffer(joined) !== record.text_sha256)
+    throw new Error("Pi final text aggregate hash mismatch");
+  const text = joined.toString("utf8");
+  if (!Buffer.from(text, "utf8").equals(joined))
+    throw new Error("Pi final text is not valid UTF-8");
+  if (fusionJsonRenderedTextBytes(text) !== record.output_contract.json_rendered_bytes) {
+    throw new Error("Pi final text JSON-rendered byte count mismatch");
+  }
+  if (text.trim().length === 0) throw new Error("Pi assistant response is empty");
+  return text;
+}
+__name(reconstructFinalText, "reconstructFinalText");
+async function readCandidateOutputRecovery(path, evidence) {
+  let handle;
+  try {
+    handle = await open(path, constants.O_RDONLY | FUSION_PI_CHILD_O_NOFOLLOW);
+  } catch (error) {
+    if (isNotFound(error))
+      throw new Error("fusion oversized candidate response artifact is missing");
+    if (isJsonObject(error) && error["code"] === "ELOOP") {
+      throw new Error("fusion oversized candidate response artifact is a symlink");
+    }
+    throw error;
+  }
+  try {
+    const stats = await handle.stat();
+    if (!stats.isFile()) {
+      throw new Error("fusion oversized candidate response artifact is not a regular file");
+    }
+    if (stats.size > FUSION_CHILD_STDOUT_LIMIT_BYTES) {
+      throw new Error(
+        `fusion oversized candidate response artifact exceeds ${String(FUSION_CHILD_STDOUT_LIMIT_BYTES)} bytes`
+      );
+    }
+    const bytes = await handle.readFile();
+    if (sha256Buffer(bytes) !== evidence.original_text_sha256) {
+      throw new Error("fusion oversized candidate response artifact hash mismatch");
+    }
+    const text = bytes.toString("utf8");
+    if (!Buffer.from(text, "utf8").equals(bytes)) {
+      throw new Error("fusion oversized candidate response artifact is not valid UTF-8");
+    }
+    if (fusionJsonRenderedTextBytes(text) !== evidence.original_json_rendered_bytes) {
+      throw new Error("fusion oversized candidate response JSON-rendered byte count mismatch");
+    }
+    if (evidence.original_json_rendered_bytes <= evidence.limit_bytes) {
+      throw new Error("fusion output recovery original did not exceed the candidate contract");
+    }
+    return { ...evidence, original_text: text };
+  } finally {
+    await handle.close();
+  }
+}
+__name(readCandidateOutputRecovery, "readCandidateOutputRecovery");
+function parsedCandidateOutputRecovery(records, status) {
+  const originalRecordIndex = records.findIndex(
+    (record) => record.output_contract.recovery_role === "oversized_original"
+  );
+  if (originalRecordIndex < 0) return void 0;
+  const original = records[originalRecordIndex];
+  if (original === void 0) throw new Error("Pi output recovery original record disappeared");
+  const replacementRecordIndex = records.findIndex(
+    (record) => record.output_contract.recovery_role === "replacement"
+  );
+  const replacement = replacementRecordIndex < 0 ? void 0 : records[replacementRecordIndex];
+  return {
+    kind: "same_session_compression",
+    limit_bytes: FUSION_CANDIDATE_MAX_OUTPUT_BYTES,
+    original_record_index: originalRecordIndex,
+    replacement_record_index: replacementRecordIndex < 0 ? null : replacementRecordIndex,
+    original_json_rendered_bytes: original.output_contract.json_rendered_bytes,
+    replacement_json_rendered_bytes: replacement?.output_contract.json_rendered_bytes ?? null,
+    original_text_sha256: original.text_sha256,
+    status
+  };
+}
+__name(parsedCandidateOutputRecovery, "parsedCandidateOutputRecovery");
+var FusionPiCompactResultParser = class {
+  static {
+    __name(this, "FusionPiCompactResultParser");
+  }
+  expectedProvider;
+  expectedModel;
+  constructor(expectedProvider, expectedModel) {
+    this.expectedProvider = expectedProvider;
+    this.expectedModel = expectedModel;
+  }
+  snapshot(stderr) {
+    try {
+      const parsed = parseFusionChildStderr(stderr);
+      return this.observedFromRecords(parsed.records);
+    } catch {
+      return { usage: createEmptyFusionUsage() };
+    }
+  }
+  finishOutputRecoveryFailure(response, stderr) {
+    const parsed = parseFusionChildStderr(stderr);
+    const settlement = parseFusionChildSettlement(stderr);
+    if (settlement === void 0) throw new Error("Pi child emitted no terminal result settlement");
+    const expectedSettlement = buildFusionChildSettlement(parsed.records);
+    if (JSON.stringify(settlement) !== JSON.stringify(expectedSettlement)) {
+      throw new Error("Pi child terminal result settlement does not match the metadata stream");
+    }
+    if (settlement.status !== "failed" || settlement.failure_reason !== "output_recovery") {
+      throw new Error("Pi child did not report a failed candidate output recovery");
+    }
+    if (parsed.diagnostics.includes(PI_EXTENSION_ERROR_PREFIX_BYTES)) {
+      throw new Error("Pi child reported an extension error diagnostic");
+    }
+    const final = parsed.records.at(-1);
+    if (final === void 0) throw new Error("Pi child emitted no compact result metadata");
+    for (const record of parsed.records) this.assertModel(record);
+    this.assertCacheObservationOrdinals(parsed.records);
+    this.assertTranscriptStopReasons(parsed.records);
+    reconstructFinalText(response, final);
+    const outputRecovery = parsedCandidateOutputRecovery(parsed.records, "failed");
+    if (outputRecovery === void 0) {
+      throw new Error("Pi child output-recovery failure omitted the oversized original");
+    }
+    const observed = this.observedFromRecords(parsed.records);
+    return {
+      usage: observed.usage,
+      provider: final.provider,
+      model: final.model,
+      qualifiedId: `${final.provider}/${final.model}`,
+      events: parsed.events,
+      diagnostics: parsed.diagnostics,
+      outputRecovery
+    };
+  }
+  finish(response, stderr) {
+    const parsed = parseFusionChildStderr(stderr);
+    const runtimeGuard = parseFusionRuntimeGuard(stderr);
+    if (runtimeGuard !== void 0) {
+      throw new Error(`Pi child runtime guard refused the run: ${runtimeGuard.message}`);
+    }
+    const settlement = parseFusionChildSettlement(stderr);
+    if (settlement === void 0) throw new Error("Pi child emitted no terminal result settlement");
+    const expectedSettlement = buildFusionChildSettlement(parsed.records);
+    if (JSON.stringify(settlement) !== JSON.stringify(expectedSettlement)) {
+      throw new Error("Pi child terminal result settlement does not match the metadata stream");
+    }
+    if (parsed.diagnostics.includes(PI_EXTENSION_ERROR_PREFIX_BYTES)) {
+      throw new Error("Pi child reported an extension error diagnostic");
+    }
+    const final = parsed.records.at(-1);
+    if (final === void 0) throw new Error("Pi child emitted no compact result metadata");
+    for (const record of parsed.records) this.assertModel(record);
+    this.assertCacheObservationOrdinals(parsed.records);
+    this.assertTranscriptStopReasons(parsed.records);
+    if (settlement.status !== "complete") {
+      throw new Error(
+        `Pi child terminal result settlement failed: ${settlement.failure_reason ?? "unknown"}`
+      );
+    }
+    const observed = this.observedFromRecords(parsed.records);
+    const text = reconstructFinalText(response, final);
+    return {
+      text,
+      usage: observed.usage,
+      firstRequestUsage: cloneFusionUsage(parsed.records[0]?.usage ?? createEmptyFusionUsage()),
+      providerRequestCount: parsed.records.length,
+      provider: final.provider,
+      model: final.model,
+      qualifiedId: `${final.provider}/${final.model}`,
+      events: parsed.events,
+      diagnostics: parsed.diagnostics,
+      outputRecovery: parsedCandidateOutputRecovery(parsed.records, "completed")
+    };
+  }
+  assertModel(record) {
+    if (record.provider !== this.expectedProvider || record.model !== this.expectedModel) {
+      throw new Error(
+        `Pi assistant model mismatch: expected ${this.expectedProvider}/${this.expectedModel}, observed ${record.provider}/${record.model}`
+      );
+    }
+  }
+  assertCacheObservationOrdinals(records) {
+    let priorOrdinal = 0;
+    for (const [index, record] of records.entries()) {
+      const ordinal = record.cache_observation.request_ordinal;
+      if (ordinal <= priorOrdinal) {
+        throw new Error(
+          `Pi child cache observation ordinal is not increasing at result ${String(index)}: previous ${String(priorOrdinal)}, observed ${String(ordinal)}`
+        );
+      }
+      priorOrdinal = ordinal;
+    }
+  }
+  assertTranscriptStopReasons(records) {
+    for (const [index, record] of records.entries()) {
+      const isFinal = index === records.length - 1;
+      if (isFinal) {
+        if (record.stop_reason !== "stop") {
+          throw new Error(this.stopReasonError("final", "stop", record.stop_reason, true));
+        }
+      } else if (record.stop_reason !== "toolUse" && !isRecoverableFusionChildErrorRecord(record) && record.output_contract.recovery_role !== "oversized_original") {
+        throw new Error(
+          this.stopReasonError(
+            `non-final record ${index}`,
+            "toolUse, a settled zero-usage retry marker, or one oversized original",
+            record.stop_reason,
+            true
+          )
+        );
+      }
+    }
+  }
+  stopReasonError(position, expected, observed, includeStopDetail) {
+    const prefix = `Pi ${position} stop reason is not ${expected}: ${observed}`;
+    if (!includeStopDetail) return prefix;
+    switch (observed) {
+      case "length":
+        return `${prefix} (model output was truncated)`;
+      case "error":
+        return `${prefix} (Pi reported an error stop)`;
+      case "aborted":
+        return `${prefix} (Pi reported an aborted stop)`;
+      case "pending":
+        return `${prefix} (Pi reported a pending stop)`;
+      default:
+        return prefix;
+    }
+  }
+  observedFromRecords(records) {
+    const usage = createEmptyFusionUsage();
+    for (const record of records) addFusionUsage(usage, record.usage);
+    const final = records.at(-1);
+    if (final === void 0) return { usage };
+    return {
+      usage,
+      provider: final.provider,
+      model: final.model,
+      qualifiedId: `${final.provider}/${final.model}`
+    };
+  }
+};
+function appendCapped(chunks, currentBytes, chunk, limit) {
+  if (currentBytes >= limit)
+    return { bytes: currentBytes, accepted: Buffer.alloc(0), exceeded: true };
+  const remaining = limit - currentBytes;
+  if (chunk.length <= remaining) {
+    chunks.push(chunk);
+    return { bytes: currentBytes + chunk.length, accepted: chunk, exceeded: false };
+  }
+  const accepted = chunk.subarray(0, remaining);
+  if (accepted.length > 0) chunks.push(accepted);
+  return { bytes: limit, accepted, exceeded: true };
+}
+__name(appendCapped, "appendCapped");
+function codeOf(error) {
+  return isJsonObject(error) && typeof error["code"] === "string" ? error["code"] : void 0;
+}
+__name(codeOf, "codeOf");
+function isTransientSpawnCode(code) {
+  return code === "EAGAIN" || code === "EMFILE" || code === "ENFILE";
+}
+__name(isTransientSpawnCode, "isTransientSpawnCode");
+function childError(message, code, input, transient = false, childCreated = true) {
+  const details = {
+    code,
+    stage: input.stage,
+    attempt: input.attempt,
+    transient,
+    childCreated
+  };
+  if (input.slot !== void 0) details.slot = input.slot;
+  return new FusionError(message, details);
+}
+__name(childError, "childError");
+function withCleanupErrors(error, cleanupErrors) {
+  if (cleanupErrors.length === 0) return error;
+  const details = {
+    code: error.code,
+    transient: error.transient,
+    childCreated: error.childCreated
+  };
+  if (error.stage !== void 0) details.stage = error.stage;
+  if (error.slot !== void 0) details.slot = error.slot;
+  if (error.attempt !== void 0) details.attempt = error.attempt;
+  if (error.artifactDir !== void 0) details.artifactDir = error.artifactDir;
+  return new FusionError(
+    `${error.message}; process cleanup issues: ${cleanupErrors.join("; ")}`,
+    details
+  );
+}
+__name(withCleanupErrors, "withCleanupErrors");
+function defaultSpawn(command, args, options) {
+  return nodeSpawn(command, args, options);
+}
+__name(defaultSpawn, "defaultSpawn");
+function trackTimer(timer) {
+  return timer;
+}
+__name(trackTimer, "trackTimer");
+function rememberCleanupErrors(state, signal, errors) {
+  for (const error of errors) state.cleanupErrors.push(`${signal}: ${error}`);
+}
+__name(rememberCleanupErrors, "rememberCleanupErrors");
+function terminateChild(child, state, platform, killProcess, killGraceMs, sigkillWaitMs, settleSyntheticClose) {
+  if (state.settled || state.terminationStarted) return;
+  state.terminationStarted = true;
+  const termResult = sendSignal(child, platform, killProcess, "SIGTERM");
+  rememberCleanupErrors(state, "SIGTERM", termResult.errors);
+  if (!termResult.sent && state.primaryError === void 0) {
+    state.primaryError = new FusionError(
+      `Pi child SIGTERM failed: ${termResult.errors.join("; ")}`,
+      {
+        code: "child_exit_failed",
+        childCreated: true
+      }
+    );
+  }
+  state.termTimer = trackTimer(
+    setTimeout(() => {
+      if (state.settled) return;
+      const killResult = sendSignal(child, platform, killProcess, "SIGKILL");
+      rememberCleanupErrors(state, "SIGKILL", killResult.errors);
+      if (!killResult.sent && state.primaryError === void 0) {
+        state.primaryError = new FusionError(
+          `Pi child SIGKILL failed: ${killResult.errors.join("; ")}`,
+          {
+            code: "child_exit_failed",
+            childCreated: true
+          }
+        );
+      }
+    }, killGraceMs)
+  );
+  state.waitTimer = trackTimer(
+    setTimeout(() => {
+      if (state.settled) return;
+      const message = "Pi child did not emit close after SIGKILL wait";
+      state.cleanupErrors.push(message);
+      if (state.primaryError === void 0) {
+        state.primaryError = new FusionError(message, {
+          code: "child_exit_failed",
+          childCreated: true
+        });
+      }
+      settleSyntheticClose({ code: null, signal: "SIGKILL" });
+    }, killGraceMs + sigkillWaitMs)
+  );
+}
+__name(terminateChild, "terminateChild");
+function sendSignal(child, platform, killProcess, signal) {
+  const errors = [];
+  const pid = child.pid;
+  if (platform !== "win32" && pid !== void 0) {
+    try {
+      if (killProcess(-pid, signal)) return { sent: true, errors };
+      errors.push("process group kill returned false");
+    } catch (error) {
+      errors.push(
+        `process group kill failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  try {
+    if (child.kill(signal)) return { sent: true, errors };
+    errors.push("child kill returned false");
+  } catch (error) {
+    errors.push(`child kill failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return { sent: false, errors };
+}
+__name(sendSignal, "sendSignal");
+function cleanupTimers(state) {
+  if (state.termTimer !== void 0) clearTimeout(state.termTimer);
+  if (state.waitTimer !== void 0) clearTimeout(state.waitTimer);
+  if (state.timeoutTimer !== void 0) clearTimeout(state.timeoutTimer);
+  if (state.idleTimer !== void 0) clearTimeout(state.idleTimer);
+  state.termTimer = void 0;
+  state.waitTimer = void 0;
+  state.timeoutTimer = void 0;
+  state.idleTimer = void 0;
+}
+__name(cleanupTimers, "cleanupTimers");
+async function writePromptToStdin(child, prompt) {
+  const stdin = child.stdin;
+  if (stdin === void 0 || stdin === null) throw new Error("Pi child stdin pipe is unavailable");
+  await new Promise((resolve2, reject) => {
+    let settled = false;
+    const fail = /* @__PURE__ */ __name((error) => {
+      if (settled) return;
+      settled = true;
+      stdin.off("error", fail);
+      reject(error);
+    }, "fail");
+    const finish = /* @__PURE__ */ __name(() => {
+      if (settled) return;
+      settled = true;
+      stdin.off("error", fail);
+      resolve2();
+    }, "finish");
+    stdin.once("error", fail);
+    stdin.write(Buffer.from(prompt, "utf8"), (error) => {
+      if (error !== void 0 && error !== null) {
+        fail(error);
+        return;
+      }
+      stdin.end(finish);
+    });
+  });
+}
+__name(writePromptToStdin, "writePromptToStdin");
+async function runPiChild(options) {
+  if (options.signal?.aborted) {
+    throw childError(
+      "Pi child launch cancelled before spawn",
+      "child_cancelled",
+      options,
+      false,
+      false
+    );
+  }
+  const spawnImpl = options.spawn ?? defaultSpawn;
+  const killProcess = options.killProcess ?? process.kill.bind(process);
+  const platform = options.platform ?? process.platform;
+  const capability = options.capability ?? FUSION_NO_TOOLS_CAPABILITY;
+  const env = fusionPiChildEnv(options.env ?? process.env, options.model.provider);
+  if (options.candidateOutputRecoveryPath !== void 0) {
+    if (options.stage !== "candidate") {
+      throw childError(
+        "candidate output recovery may be enabled only for candidate children",
+        "orchestration_failed",
+        options,
+        false,
+        false
+      );
+    }
+    env[FUSION_CANDIDATE_OUTPUT_RECOVERY_PATH_ENV] = options.candidateOutputRecoveryPath;
+  }
+  if (capability !== "reason") {
+    if (options.toolCallLogPath === void 0) {
+      throw childError(
+        `fusion ${capability} child requires a tool-call log path`,
+        "orchestration_failed",
+        options,
+        false,
+        false
+      );
+    }
+    env[FUSION_TOOL_CALL_LOG_PATH_ENV] = options.toolCallLogPath;
+    if (capability === "research") {
+      if (options.sourcePolicy === void 0) {
+        throw childError(
+          "fusion research child requires a source-policy path and hash",
+          "orchestration_failed",
+          options,
+          false,
+          false
+        );
+      }
+      env[FUSION_RESEARCH_ENABLED_ENV] = "1";
+      env[FUSION_SOURCE_POLICY_PATH_ENV] = options.sourcePolicy.path;
+      env[FUSION_SOURCE_POLICY_SHA256_ENV] = options.sourcePolicy.sha256;
+    }
+  }
+  const stdoutLimit = options.stdoutLimitBytes ?? FUSION_CHILD_STDOUT_LIMIT_BYTES;
+  const stderrLimit = options.stderrLimitBytes ?? FUSION_CHILD_STDERR_LIMIT_BYTES;
+  const timeoutMs = options.timeoutMs ?? FUSION_CHILD_TIMEOUT_MS;
+  const idleTimeoutMs = options.idleTimeoutMs ?? FUSION_CHILD_IDLE_TIMEOUT_MS;
+  const killGraceMs = options.killGraceMs ?? FUSION_CHILD_KILL_GRACE_MS;
+  const sigkillWaitMs = options.sigkillWaitMs ?? FUSION_CHILD_SIGKILL_WAIT_MS;
+  const argv = buildFusionPiChildArgv(
+    options.model,
+    options.systemPrompt,
+    options.childExtensionPath ?? resolveFusionChildExtensionPath(),
+    capability
+  );
+  const parser = new FusionPiCompactResultParser(options.model.provider, options.model.model);
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  let stdoutBytes = 0;
+  let stderrBytes = 0;
+  const state = {
+    primaryError: void 0,
+    cleanupErrors: [],
+    terminationStarted: false,
+    termTimer: void 0,
+    waitTimer: void 0,
+    timeoutTimer: void 0,
+    idleTimer: void 0,
+    settled: false
+  };
+  let child;
+  try {
+    const launchDeps = options.piLaunchDependencies === void 0 ? { platform } : { ...options.piLaunchDependencies, platform };
+    const launch = resolvePiLaunch(launchDeps);
+    assertWindowsCommandLineWithinLimit(launch, argv, platform, `fusion-${options.stage}`);
+    child = spawnImpl(launch.executable, piLaunchArgv(launch, argv), {
+      cwd: options.cwd,
+      detached: platform !== "win32",
+      shell: false,
+      stdio: ["pipe", "pipe", "pipe"],
+      env,
+      windowsHide: true
+    });
+  } catch (error) {
+    const code = codeOf(error);
+    throw childError(
+      `Pi child spawn failed: ${error instanceof Error ? error.message : String(error)}`,
+      "child_spawn_failed",
+      options,
+      isTransientSpawnCode(code),
+      false
+    );
+  }
+  let settleClose = /* @__PURE__ */ __name(() => void 0, "settleClose");
+  const closePromise = new Promise((resolve2) => {
+    settleClose = /* @__PURE__ */ __name((close) => {
+      if (state.settled) return;
+      state.settled = true;
+      resolve2(close);
+    }, "settleClose");
+  });
+  const resetIdleTimer = /* @__PURE__ */ __name(() => {
+    if (state.settled) return;
+    if (state.idleTimer !== void 0) clearTimeout(state.idleTimer);
+    state.idleTimer = trackTimer(
+      setTimeout(() => {
+        if (state.settled) return;
+        if (state.primaryError === void 0) {
+          state.primaryError = childError(
+            `Pi child produced no output for ${String(idleTimeoutMs)}ms (stalled)`,
+            "child_timeout",
+            options
+          );
+        }
+        terminateChild(
+          child,
+          state,
+          platform,
+          killProcess,
+          killGraceMs,
+          sigkillWaitMs,
+          settleClose
+        );
+      }, idleTimeoutMs)
+    );
+  }, "resetIdleTimer");
+  const abortListener = /* @__PURE__ */ __name(() => {
+    if (state.settled) return;
+    if (state.primaryError === void 0) {
+      state.primaryError = childError("Pi child cancelled", "child_cancelled", options);
+    }
+    terminateChild(child, state, platform, killProcess, killGraceMs, sigkillWaitMs, settleClose);
+  }, "abortListener");
+  const stdoutListener = /* @__PURE__ */ __name((data) => {
+    resetIdleTimer();
+    const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data, "utf8");
+    const appended = appendCapped(stdoutChunks, stdoutBytes, chunk, stdoutLimit);
+    stdoutBytes = appended.bytes;
+    if (appended.exceeded && state.primaryError === void 0) {
+      state.primaryError = childError(
+        `Pi child final response exceeded ${String(stdoutLimit)} bytes`,
+        "child_output_cap",
+        options
+      );
+      terminateChild(child, state, platform, killProcess, killGraceMs, sigkillWaitMs, settleClose);
+    }
+  }, "stdoutListener");
+  const stderrListener = /* @__PURE__ */ __name((data) => {
+    resetIdleTimer();
+    const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data, "utf8");
+    const appended = appendCapped(stderrChunks, stderrBytes, chunk, stderrLimit);
+    stderrBytes = appended.bytes;
+    if (appended.exceeded && state.primaryError === void 0) {
+      state.primaryError = childError(
+        `Pi child stderr exceeded ${String(stderrLimit)} bytes`,
+        "child_output_cap",
+        options
+      );
+      terminateChild(child, state, platform, killProcess, killGraceMs, sigkillWaitMs, settleClose);
+    }
+  }, "stderrListener");
+  const errorListener = /* @__PURE__ */ __name((error) => {
+    if (state.settled) return;
+    if (state.primaryError === void 0) {
+      const code = codeOf(error);
+      const childCreated = child.pid !== void 0;
+      state.primaryError = childError(
+        `Pi child process error: ${error.message}`,
+        "child_spawn_failed",
+        options,
+        isTransientSpawnCode(code),
+        childCreated
+      );
+    }
+    if (child.pid === void 0) settleClose({ code: null, signal: null });
+  }, "errorListener");
+  const closeListener = /* @__PURE__ */ __name((code, signal) => {
+    settleClose({ code, signal });
+  }, "closeListener");
+  child.stdout?.on("data", stdoutListener);
+  child.stderr?.on("data", stderrListener);
+  child.once("error", errorListener);
+  child.once("close", closeListener);
+  options.signal?.addEventListener("abort", abortListener, { once: true });
+  if (options.signal?.aborted) abortListener();
+  resetIdleTimer();
+  state.timeoutTimer = trackTimer(
+    setTimeout(() => {
+      if (state.primaryError === void 0) {
+        state.primaryError = childError(
+          `Pi child timed out after ${String(timeoutMs)}ms`,
+          "child_timeout",
+          options
+        );
+      }
+      terminateChild(child, state, platform, killProcess, killGraceMs, sigkillWaitMs, settleClose);
+    }, timeoutMs)
+  );
+  try {
+    try {
+      if (state.primaryError === void 0) await writePromptToStdin(child, options.userPrompt);
+    } catch (error) {
+      if (state.primaryError === void 0) {
+        state.primaryError = childError(
+          `Pi child stdin write failed: ${error instanceof Error ? error.message : String(error)}`,
+          "child_stdin_failed",
+          options
+        );
+      }
+      terminateChild(child, state, platform, killProcess, killGraceMs, sigkillWaitMs, settleClose);
+    }
+    const close = await closePromise;
+    const response = Buffer.concat(stdoutChunks);
+    const rawStderr = Buffer.concat(stderrChunks);
+    const observed = parser.snapshot(rawStderr);
+    let compactEvents = Buffer.alloc(0);
+    let diagnostics = rawStderr;
+    try {
+      const decoded = parseFusionChildStderr(rawStderr);
+      compactEvents = decoded.events;
+      diagnostics = decoded.diagnostics;
+    } catch {
+    }
+    const readPartialOutputRecovery = /* @__PURE__ */ __name(async () => {
+      let parsedRecords;
+      try {
+        parsedRecords = parseFusionChildStderr(rawStderr).records;
+      } catch {
+        return void 0;
+      }
+      const evidence = parsedCandidateOutputRecovery(parsedRecords, "failed");
+      if (evidence === void 0) return void 0;
+      if (options.candidateOutputRecoveryPath === void 0) {
+        throw new Error("fusion child emitted output-recovery evidence without an artifact path");
+      }
+      return readCandidateOutputRecovery(options.candidateOutputRecoveryPath, evidence);
+    }, "readPartialOutputRecovery");
+    const primary = state.primaryError;
+    if (primary !== void 0) {
+      let outputRecovery2;
+      try {
+        outputRecovery2 = await readPartialOutputRecovery();
+      } catch (error) {
+        state.cleanupErrors.push(
+          `output recovery evidence invalid: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      throw new FusionChildRunError(
+        withCleanupErrors(primary, state.cleanupErrors),
+        compactEvents,
+        response,
+        diagnostics,
+        close,
+        observed,
+        outputRecovery2
+      );
+    }
+    let terminalSettlement;
+    try {
+      terminalSettlement = parseFusionChildSettlement(rawStderr);
+    } catch (error) {
+      throw new FusionChildRunError(
+        withCleanupErrors(
+          childError(
+            `Pi child terminal settlement invalid: ${error instanceof Error ? error.message : String(error)}`,
+            "child_event_invalid",
+            options
+          ),
+          state.cleanupErrors
+        ),
+        compactEvents,
+        response,
+        diagnostics,
+        close,
+        observed
+      );
+    }
+    if (terminalSettlement?.failure_reason === "output_recovery") {
+      try {
+        const failure = parser.finishOutputRecoveryFailure(response, rawStderr);
+        if (options.candidateOutputRecoveryPath === void 0) {
+          throw new Error(
+            "fusion child output-recovery failure omitted the configured artifact path"
+          );
+        }
+        const outputRecovery2 = await readCandidateOutputRecovery(
+          options.candidateOutputRecoveryPath,
+          failure.outputRecovery
+        );
+        const recoveryMessage = outputRecovery2.replacement_json_rendered_bytes === null ? `Pi child could not complete its one allowed same-session candidate compression continuation; the ${String(outputRecovery2.original_json_rendered_bytes)}-byte original is preserved and nothing was truncated` : `Pi child compressed candidate response is still ${String(outputRecovery2.replacement_json_rendered_bytes)} JSON-rendered bytes, exceeding the ${String(outputRecovery2.limit_bytes)}-byte output contract; both responses are preserved and nothing was truncated`;
+        throw new FusionChildRunError(
+          withCleanupErrors(
+            childError(recoveryMessage, "child_output_cap", options),
+            state.cleanupErrors
+          ),
+          failure.events,
+          response,
+          failure.diagnostics,
+          close,
+          {
+            usage: failure.usage,
+            provider: failure.provider,
+            model: failure.model,
+            qualifiedId: failure.qualifiedId
+          },
+          outputRecovery2
+        );
+      } catch (error) {
+        if (error instanceof FusionChildRunError) throw error;
+        throw new FusionChildRunError(
+          withCleanupErrors(
+            childError(
+              `Pi child output-recovery evidence invalid: ${error instanceof Error ? error.message : String(error)}`,
+              "child_event_invalid",
+              options
+            ),
+            state.cleanupErrors
+          ),
+          compactEvents,
+          response,
+          diagnostics,
+          close,
+          observed
+        );
+      }
+    }
+    if (close.code !== 0 || close.signal !== null) {
+      let runtimeGuard;
+      try {
+        runtimeGuard = parseFusionRuntimeGuard(rawStderr);
+        if (runtimeGuard !== void 0) {
+          assertFusionRuntimeGuardMatchesModel(runtimeGuard, options.model);
+        }
+      } catch (error) {
+        throw new FusionChildRunError(
+          withCleanupErrors(
+            childError(
+              `Pi child runtime guard evidence invalid: ${error instanceof Error ? error.message : String(error)}`,
+              "child_event_invalid",
+              options
+            ),
+            state.cleanupErrors
+          ),
+          compactEvents,
+          response,
+          diagnostics,
+          close,
+          observed
+        );
+      }
+      throw new FusionChildRunError(
+        withCleanupErrors(
+          childError(
+            runtimeGuard?.message ?? `Pi child exited with code ${close.code === null ? "null" : String(close.code)}${close.signal === null ? "" : ` (${close.signal})`}`,
+            runtimeGuard === void 0 ? "child_exit_failed" : runtimeGuard.code === "claude_cache_policy" ? "child_cache_policy_invalid" : runtimeGuard.code === "provider_payload_invalid" ? "child_runtime_payload_invalid" : "child_runtime_limit_exceeded",
+            options
+          ),
+          state.cleanupErrors
+        ),
+        compactEvents,
+        response,
+        diagnostics,
+        close,
+        observed
+      );
+    }
+    let parsed;
+    try {
+      parsed = parser.finish(response, rawStderr);
+    } catch (error) {
+      throw new FusionChildRunError(
+        withCleanupErrors(
+          childError(
+            `Pi child compact result invalid: ${error instanceof Error ? error.message : String(error)}`,
+            "child_event_invalid",
+            options
+          ),
+          state.cleanupErrors
+        ),
+        compactEvents,
+        response,
+        diagnostics,
+        close,
+        observed
+      );
+    }
+    let outputRecovery;
+    if (parsed.outputRecovery !== void 0) {
+      if (options.candidateOutputRecoveryPath === void 0) {
+        throw new FusionChildRunError(
+          childError(
+            "Pi child output-recovery evidence has no configured artifact path",
+            "child_event_invalid",
+            options
+          ),
+          parsed.events,
+          response,
+          parsed.diagnostics,
+          close,
+          observed
+        );
+      }
+      try {
+        outputRecovery = await readCandidateOutputRecovery(
+          options.candidateOutputRecoveryPath,
+          parsed.outputRecovery
+        );
+      } catch (error) {
+        throw new FusionChildRunError(
+          childError(
+            `Pi child output-recovery artifact invalid: ${error instanceof Error ? error.message : String(error)}`,
+            "child_event_invalid",
+            options
+          ),
+          parsed.events,
+          response,
+          parsed.diagnostics,
+          close,
+          observed
+        );
+      }
+    }
+    let toolCallTrace;
+    if (capability !== "reason") {
+      const logPath = options.toolCallLogPath;
+      if (logPath === void 0) {
+        throw childError(
+          `fusion ${capability} child completed without a tool-call log path`,
+          "orchestration_failed",
+          options
+        );
+      }
+      try {
+        toolCallTrace = await readFusionToolCallLog(logPath);
+        await assertFusionToolCallLogSeal(logPath, toolCallTrace);
+        await assertCompletedToolPolicy(toolCallTrace, capability, options.sourcePolicy);
+      } catch (error) {
+        throw new FusionChildRunError(
+          withCleanupErrors(
+            childError(
+              `Pi child tool-call log invalid: ${error instanceof Error ? error.message : String(error)}`,
+              "child_event_invalid",
+              options
+            ),
+            state.cleanupErrors
+          ),
+          compactEvents,
+          response,
+          diagnostics,
+          close,
+          observed,
+          outputRecovery
+        );
+      }
+    }
+    const result = {
+      stage: options.stage,
+      attempt: options.attempt,
+      provider: parsed.provider,
+      model: parsed.model,
+      qualifiedId: parsed.qualifiedId,
+      text: parsed.text,
+      usage: parsed.usage,
+      firstRequestUsage: parsed.firstRequestUsage,
+      providerRequestCount: parsed.providerRequestCount,
+      events: parsed.events,
+      stderr: parsed.diagnostics,
+      exitCode: close.code,
+      signal: close.signal
+    };
+    if (options.slot !== void 0) result.slot = options.slot;
+    if (outputRecovery !== void 0) result.outputRecovery = outputRecovery;
+    if (toolCallTrace !== void 0) result.toolCallTrace = toolCallTrace;
+    return result;
+  } finally {
+    cleanupTimers(state);
+    options.signal?.removeEventListener("abort", abortListener);
+    child.stdout?.off("data", stdoutListener);
+    child.stderr?.off("data", stderrListener);
+    child.off("error", errorListener);
+    child.off("close", closeListener);
+  }
+}
+__name(runPiChild, "runPiChild");
+
+// node_modules/pi-background-tasks/src/core/fusion/orchestrator.ts?ext=pi-background-tasks
+function addFailedChildUsage(target, error) {
+  if (error instanceof FusionChildRunError) addFusionUsage(target, error.usage);
+}
+__name(addFailedChildUsage, "addFailedChildUsage");
+function errorText2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(errorText2, "errorText");
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord2, "isRecord");
+function hasOnlyKeys(value, allowed) {
+  const allowedSet = new Set(allowed);
+  return Object.keys(value).every((key) => allowedSet.has(key));
+}
+__name(hasOnlyKeys, "hasOnlyKeys");
+function isStrictCleanCanonicalInput(value) {
+  if (!isRecord2(value)) return false;
+  if (!hasOnlyKeys(value, ["schema_version", "workflow", "cwd", "request", "context"]))
+    return false;
+  const request = value["request"];
+  if (!isRecord2(request)) return false;
+  if (!hasOnlyKeys(request, ["source", "authority", "text", "sha256"])) return false;
+  const context = value["context"];
+  if (!isRecord2(context)) return false;
+  if (!hasOnlyKeys(context, ["kind", "policy_id", "declared_sources"])) return false;
+  if (context["kind"] !== "clean_task") return false;
+  const declaredSources = context["declared_sources"];
+  if (!Array.isArray(declaredSources)) return false;
+  for (const source of declaredSources) {
+    if (!isRecord2(source) || !hasOnlyKeys(source, ["url", "canonical_url", "purpose", "sha256"]))
+      return false;
+  }
+  return true;
+}
+__name(isStrictCleanCanonicalInput, "isStrictCleanCanonicalInput");
+function asFusionError(error, artifactDir, messageOverride) {
+  if (error instanceof FusionError) {
+    const details = {
+      code: error.code,
+      artifactDir,
+      transient: error.transient,
+      childCreated: error.childCreated
+    };
+    if (error.stage !== void 0) details.stage = error.stage;
+    if (error.slot !== void 0) details.slot = error.slot;
+    if (error.attempt !== void 0) details.attempt = error.attempt;
+    if (error.budget !== void 0) details.budget = error.budget;
+    if (error.runProgress !== void 0) details.runProgress = error.runProgress;
+    return new FusionError(messageOverride ?? error.message, details);
+  }
+  return new FusionError(messageOverride ?? errorText2(error), {
+    code: "orchestration_failed",
+    artifactDir,
+    childCreated: false
+  });
+}
+__name(asFusionError, "asFusionError");
+function formatFusionRunStage(name, stage) {
+  const notStarted = stage.not_started_slots === void 0 ? "" : `, ${String(stage.not_started_slots)} slot(s) not started`;
+  return `${name}=${stage.status} (${String(stage.children_created)} created, ${String(stage.children_completed)} completed, ${String(stage.children_failed)} failed, ${String(stage.children_cancelled)} cancelled${notStarted})`;
+}
+__name(formatFusionRunStage, "formatFusionRunStage");
+function summaryUnavailableNote(error) {
+  const detail = errorText2(error);
+  const detailBytes = Buffer.from(detail, "utf8");
+  if (detailBytes.length > 1024) {
+    return "failure-summary.json unavailable after terminal publication; write failure detail omitted because it exceeds the 1024-byte diagnostic cap.";
+  }
+  return `failure-summary.json unavailable after terminal publication: ${detail}`;
+}
+__name(summaryUnavailableNote, "summaryUnavailableNote");
+function withSummaryUnavailableNote(error, summaryError) {
+  const details = {
+    code: error.code,
+    transient: error.transient,
+    childCreated: error.childCreated
+  };
+  if (error.artifactDir !== void 0) details.artifactDir = error.artifactDir;
+  if (error.stage !== void 0) details.stage = error.stage;
+  if (error.slot !== void 0) details.slot = error.slot;
+  if (error.attempt !== void 0) details.attempt = error.attempt;
+  if (error.budget !== void 0) details.budget = error.budget;
+  if (error.runProgress !== void 0) details.runProgress = error.runProgress;
+  return new FusionError(`${error.message}
+${summaryUnavailableNote(summaryError)}`, details);
+}
+__name(withSummaryUnavailableNote, "withSummaryUnavailableNote");
+function formatFusionRunProgress(progress) {
+  const usage = progress.usage_so_far;
+  const optionalUsage = [
+    usage.cacheWrite1h === void 0 ? void 0 : `cacheWrite1h=${String(usage.cacheWrite1h)}`,
+    usage.reasoning === void 0 ? void 0 : `reasoning=${String(usage.reasoning)}`
+  ].filter((value) => value !== void 0);
+  const optionalText = optionalUsage.length === 0 ? "" : `, ${optionalUsage.join(", ")}`;
+  return `Run progress from durable attempts: ${formatFusionRunStage("candidates", progress.candidates)}; ${formatFusionRunStage("evaluation", progress.evaluation)}; ${formatFusionRunStage("merge", progress.merge)}. Usage so far: input=${String(usage.input)}, output=${String(usage.output)}, cacheRead=${String(usage.cacheRead)}, cacheWrite=${String(usage.cacheWrite)}${optionalText}, totalTokens=${String(usage.totalTokens)}, cost.input=${String(usage.cost.input)}, cost.output=${String(usage.cost.output)}, cost.cacheRead=${String(usage.cost.cacheRead)}, cost.cacheWrite=${String(usage.cost.cacheWrite)}, cost.total=${String(usage.cost.total)}.`;
+}
+__name(formatFusionRunProgress, "formatFusionRunProgress");
+function withRunProgress(error, artifactDir, progress) {
+  const base = asFusionError(error, artifactDir);
+  const details = {
+    code: base.code,
+    artifactDir,
+    transient: base.transient,
+    childCreated: base.childCreated,
+    runProgress: progress
+  };
+  if (base.stage !== void 0) details.stage = base.stage;
+  if (base.slot !== void 0) details.slot = base.slot;
+  if (base.attempt !== void 0) details.attempt = base.attempt;
+  if (base.budget !== void 0) details.budget = base.budget;
+  return new FusionError(`${base.message}
+${formatFusionRunProgress(progress)}`, details);
+}
+__name(withRunProgress, "withRunProgress");
+function withTerminalArtifactFailure(error, artifactDir, artifactError) {
+  const message = `${errorText2(error)}; additionally failed to write terminal fusion artifacts: ${errorText2(artifactError)}`;
+  return asFusionError(error, artifactDir, message);
+}
+__name(withTerminalArtifactFailure, "withTerminalArtifactFailure");
+function recordFailureInput(error, stage, slot, attempt, systemPrompt, prompt, responseKind) {
+  if (error instanceof FusionChildRunError) {
+    const base2 = {
+      stage,
+      attempt,
+      systemPrompt,
+      prompt,
+      events: error.events,
+      partialResponse: error.response,
+      stderr: error.stderr,
+      error: error.message,
+      status: error.code === "child_cancelled" ? "cancelled" : "failed",
+      responseKind,
+      childCreated: error.childCreated,
+      usage: error.usage,
+      ...error.outputRecovery === void 0 ? {} : { outputRecovery: error.outputRecovery }
+    };
+    if (slot !== void 0) base2.slot = slot;
+    if (error.provider !== void 0) base2.provider = error.provider;
+    if (error.modelName !== void 0) base2.model = error.modelName;
+    if (error.qualifiedId !== void 0) base2.qualifiedId = error.qualifiedId;
+    return base2;
+  }
+  const base = {
+    stage,
+    attempt,
+    systemPrompt,
+    prompt,
+    events: Buffer.alloc(0),
+    partialResponse: Buffer.alloc(0),
+    stderr: Buffer.alloc(0),
+    error: errorText2(error),
+    status: error instanceof FusionError && error.code === "child_cancelled" ? "cancelled" : "failed",
+    responseKind,
+    childCreated: error instanceof FusionError ? error.childCreated : false
+  };
+  if (slot !== void 0) base.slot = slot;
+  return base;
+}
+__name(recordFailureInput, "recordFailureInput");
+function retryableSpawn(error, attempt) {
+  if (!(error instanceof FusionError)) return false;
+  return attempt === 1 && error.code === "child_spawn_failed" && error.transient && !error.childCreated;
+}
+__name(retryableSpawn, "retryableSpawn");
+function childOptions(input, model, stage, attempt, capability, systemPrompt, userPrompt, signal, slot, toolCallLogPath, sourcePolicy, candidateOutputRecoveryPath) {
+  const out = {
+    stage,
+    attempt,
+    cwd: input.cwd,
+    model,
+    capability,
+    systemPrompt,
+    userPrompt,
+    signal
+  };
+  if (slot !== void 0) out.slot = slot;
+  if (toolCallLogPath !== void 0) out.toolCallLogPath = toolCallLogPath;
+  if (sourcePolicy !== void 0) out.sourcePolicy = sourcePolicy;
+  if (candidateOutputRecoveryPath !== void 0)
+    out.candidateOutputRecoveryPath = candidateOutputRecoveryPath;
+  return out;
+}
+__name(childOptions, "childOptions");
+function parseEvaluationAttempt(text, expectedValidationFindings) {
+  let parsed;
+  try {
+    parsed = parseJsonText(text);
+  } catch (error) {
+    return {
+      evaluation: void 0,
+      errors: [`evaluation output must be JSON only: ${errorText2(error)}`]
+    };
+  }
+  const result = validateFusionEvaluation(parsed);
+  if (!result.ok) return { evaluation: void 0, errors: result.errors };
+  if (expectedValidationFindings === void 0 && result.value.validation_accounting !== void 0) {
+    return {
+      evaluation: void 0,
+      errors: ["evaluation.validation_accounting is permitted only for fusion_validate"]
+    };
+  }
+  if (expectedValidationFindings !== void 0) {
+    const accountingErrors = validateEvaluationAccountsForSourceFindings(
+      result.value,
+      expectedValidationFindings
+    );
+    if (accountingErrors.length > 0) return { evaluation: void 0, errors: accountingErrors };
+  }
+  return { evaluation: result.value, errors: [] };
+}
+__name(parseEvaluationAttempt, "parseEvaluationAttempt");
+function randomIndex(limit, randomBytes) {
+  if (!Number.isInteger(limit) || limit <= 0 || limit > 4294967295) {
+    throw new FusionError(`invalid random limit ${String(limit)}`, {
+      code: "orchestration_failed",
+      childCreated: false
+    });
+  }
+  const range = 4294967296;
+  const ceiling = range - range % limit;
+  for (; ; ) {
+    const bytes = randomBytes(4);
+    if (bytes.length < 4) {
+      throw new FusionError("random byte source returned too few bytes", {
+        code: "orchestration_failed",
+        childCreated: false
+      });
+    }
+    const value = bytes.readUInt32BE(0);
+    if (value < ceiling) return value % limit;
+  }
+}
+__name(randomIndex, "randomIndex");
+function shuffledSlots(randomBytes) {
+  const slots = [1, 2, 3];
+  for (let i = slots.length - 1; i > 0; i--) {
+    const j = randomIndex(i + 1, randomBytes);
+    const left = slots[i];
+    const right = slots[j];
+    if (left === void 0 || right === void 0) {
+      throw new FusionError("random slot shuffle failed", {
+        code: "orchestration_failed",
+        childCreated: false
+      });
+    }
+    slots[i] = right;
+    slots[j] = left;
+  }
+  return slots;
+}
+__name(shuffledSlots, "shuffledSlots");
+function candidateBySlot(results, slot) {
+  const found = results.find((candidate) => candidate.slot === slot);
+  if (found === void 0) {
+    throw new FusionError(`candidate slot ${String(slot)} is missing`, {
+      code: "orchestration_failed",
+      childCreated: false
+    });
+  }
+  return found.result;
+}
+__name(candidateBySlot, "candidateBySlot");
+function candidateModel(models, slot) {
+  if (slot === 1) return models.candidates[0];
+  if (slot === 2) return models.candidates[1];
+  return models.candidates[2];
+}
+__name(candidateModel, "candidateModel");
+function anonymousCandidates(results, slots) {
+  const firstSlot = slots[0];
+  const secondSlot = slots[1];
+  const thirdSlot = slots[2];
+  if (firstSlot === void 0 || secondSlot === void 0 || thirdSlot === void 0) {
+    throw new FusionError("anonymous candidate shuffle produced too few slots", {
+      code: "orchestration_failed",
+      childCreated: false
+    });
+  }
+  const first = candidateBySlot(results, firstSlot);
+  const second = candidateBySlot(results, secondSlot);
+  const third = candidateBySlot(results, thirdSlot);
+  return {
+    map: { A: firstSlot, B: secondSlot, C: thirdSlot },
+    candidates: [
+      { candidate_id: "A", response: first.text },
+      { candidate_id: "B", response: second.text },
+      { candidate_id: "C", response: third.text }
+    ]
+  };
+}
+__name(anonymousCandidates, "anonymousCandidates");
+function sha256Text(value) {
+  return createHash4("sha256").update(value, "utf8").digest("hex");
+}
+__name(sha256Text, "sha256Text");
+function boundedContractError(error) {
+  const value = errorText2(error);
+  return value.length <= 1e3 ? value : `${value.slice(0, 999)}\u2026`;
+}
+__name(boundedContractError, "boundedContractError");
+async function prepareValidationSourceData(candidates, anonymousMap, store) {
+  const prepared = candidates.map((candidate) => ({ ...candidate }));
+  const findings = [];
+  const verified = [];
+  const limitations = [];
+  let normalizationCount = 0;
+  const failures = [];
+  for (const candidate of prepared) {
+    try {
+      const report = parseFusionValidationCandidateReport(
+        candidate.response,
+        candidate.candidate_id
+      );
+      findings.push(...report.findings);
+      verified.push(...report.verified);
+      limitations.push(...report.limitations);
+      continue;
+    } catch (strictError) {
+      try {
+        const recovered = recoverFencedFusionValidationCandidateReport(
+          candidate.response,
+          candidate.candidate_id
+        );
+        if (recovered === void 0) throw strictError;
+        await store.recordValidationCandidateContractEvent({
+          candidateId: candidate.candidate_id,
+          slot: anonymousMap[candidate.candidate_id],
+          status: "normalized",
+          detail: {
+            normalization: recovered.normalization,
+            original_sha256: sha256Text(candidate.response),
+            forwarded_sha256: sha256Text(recovered.response),
+            warning: "Candidate output violated the bare-JSON contract; a single complete JSON fence was removed and recorded."
+          }
+        });
+        candidate.response = recovered.response;
+        findings.push(...recovered.report.findings);
+        verified.push(...recovered.report.verified);
+        limitations.push(...recovered.report.limitations);
+        normalizationCount += 1;
+        continue;
+      } catch (recoveryError) {
+        failures.push({
+          candidate,
+          error: boundedContractError(recoveryError === strictError ? strictError : recoveryError)
+        });
+      }
+    }
+  }
+  if (normalizationCount > 0) {
+    limitations.push(
+      `${String(normalizationCount)} validation report${normalizationCount === 1 ? "" : "s"} required audited removal of a Markdown JSON wrapper; JSON content was unchanged.`
+    );
+  }
+  for (const failure2 of failures) {
+    await store.recordValidationCandidateContractEvent({
+      candidateId: failure2.candidate.candidate_id,
+      slot: anonymousMap[failure2.candidate.candidate_id],
+      status: "dropped",
+      detail: {
+        response_sha256: sha256Text(failure2.candidate.response),
+        error: failure2.error,
+        warning: "Candidate output could not be parsed under the strict or fenced-JSON contract."
+      }
+    });
+  }
+  if (failures.length > 1) {
+    throw new FusionError(
+      `fusion_validate cannot continue: ${String(failures.length)} of 3 candidate reports violated the structured-output contract`,
+      { code: "evaluation_invalid", stage: "candidate" }
+    );
+  }
+  const failure = failures[0];
+  if (failure !== void 0) {
+    const synthetic = canonicalJson({
+      schema_version: FUSION_VALIDATE_CANDIDATE_SCHEMA_VERSION,
+      findings: [],
+      verified: [],
+      limitations: [
+        "This validation report could not be parsed after strict contract checks; no findings or verification claims from it were included."
+      ]
+    });
+    failure.candidate.response = synthetic;
+    const report = parseFusionValidationCandidateReport(synthetic, failure.candidate.candidate_id);
+    limitations.push(...report.limitations);
+  }
+  return { candidates: prepared, findings, verified, limitations };
+}
+__name(prepareValidationSourceData, "prepareValidationSourceData");
+function validateEvaluationAccountsForSourceFindings(evaluation, sourceFindings) {
+  const errors = [];
+  const accounting = evaluation.validation_accounting;
+  if (accounting === void 0) {
+    return ["validation evaluator output must include validation_accounting"];
+  }
+  const expected = sourceFindings.map((finding) => canonicalJson(finding)).sort();
+  const actual = accounting.findings.map((finding) => canonicalJson(finding)).sort();
+  if (expected.length !== actual.length || expected.some((value, index) => value !== actual[index])) {
+    errors.push(
+      "validation evaluator validation_accounting.findings must exactly equal host-assigned source findings"
+    );
+  }
+  errors.push(...validateFusionFindingAccounting(accounting));
+  return errors;
+}
+__name(validateEvaluationAccountsForSourceFindings, "validateEvaluationAccountsForSourceFindings");
+function resolveRunProfile(input) {
+  if (input.profile !== void 0) return fusionWorkflowProfile(input.profile.id);
+  const workflow = input.canonicalInput.workflow;
+  const contextKind = input.canonicalInput.context?.kind;
+  if (workflow !== void 0 && workflow !== "reason") {
+    throw new FusionError(`fusion workflow profile is required for ${workflow} runs`, {
+      code: "orchestration_failed",
+      childCreated: false
+    });
+  }
+  if (contextKind === "clean_task") {
+    throw new FusionError("fusion workflow profile is required for clean-task runs", {
+      code: "orchestration_failed",
+      childCreated: false
+    });
+  }
+  return fusionWorkflowProfile("reason");
+}
+__name(resolveRunProfile, "resolveRunProfile");
+var FusionOrchestrator = class {
+  static {
+    __name(this, "FusionOrchestrator");
+  }
+  childRunner;
+  randomBytes;
+  now;
+  createArtifactStore;
+  constructor(options = {}) {
+    this.childRunner = options.childRunner ?? runPiChild;
+    this.randomBytes = options.randomBytes ?? nodeRandomBytes;
+    this.now = options.now;
+    this.createArtifactStore = options.createArtifactStore ?? FusionArtifactStore.create;
+  }
+  async run(input) {
+    if (input.canonicalInput.schema_version !== FUSION_INPUT_SCHEMA_VERSION) {
+      throw new FusionError("fusion orchestrator accepts only v5 canonical input", {
+        code: "orchestration_failed",
+        childCreated: false
+      });
+    }
+    const profile = resolveRunProfile(input);
+    const inputWorkflow = input.canonicalInput.workflow ?? profile.id;
+    const inputContextKind = input.canonicalInput.context?.kind ?? "session_projection";
+    if (inputWorkflow !== profile.id || inputContextKind !== profile.contextKind) {
+      throw new FusionError(
+        `fusion workflow profile ${profile.id} is incompatible with canonical input workflow=${String(inputWorkflow)} context=${String(inputContextKind)}`,
+        { code: "orchestration_failed", childCreated: false }
+      );
+    }
+    if (profile.contextKind === "clean_task" && !isStrictCleanCanonicalInput(input.canonicalInput)) {
+      throw new FusionError(
+        "clean-task fusion input must not carry parent context fields and must match the strict clean canonical shape",
+        {
+          code: "orchestration_failed",
+          childCreated: false
+        }
+      );
+    }
+    const candidateCapability = assertWorkflowCapability(profile, input.candidateCapability);
+    const storeOptions = {
+      cwd: input.cwd,
+      profile,
+      source: input.source,
+      config: input.config,
+      models: input.models,
+      capabilities: {
+        candidate: candidateCapability,
+        evaluation: FUSION_NO_TOOLS_CAPABILITY,
+        merge: FUSION_NO_TOOLS_CAPABILITY
+      }
+    };
+    if (input.sessionId !== void 0) storeOptions.sessionId = input.sessionId;
+    if (this.now !== void 0) storeOptions.now = this.now;
+    let serializedParsed;
+    try {
+      serializedParsed = parseJsonText(input.canonicalInputSerialized);
+    } catch (error) {
+      throw new FusionError(
+        `fusion canonical input artifact is not valid JSON: ${errorText2(error)}`,
+        {
+          code: "orchestration_failed",
+          childCreated: false
+        }
+      );
+    }
+    if (canonicalJson(serializedParsed) !== canonicalJson(input.canonicalInput)) {
+      throw new FusionError(
+        "fusion canonical input serialized bytes do not match canonical input object",
+        {
+          code: "orchestration_failed",
+          childCreated: false
+        }
+      );
+    }
+    const store = await this.createArtifactStore(storeOptions);
+    input.onProgress?.({ type: "state", state: "initializing" });
+    const usage = createEmptyFusionUsage();
+    const calibrationWarnings = [];
+    try {
+      await store.writeCanonicalInput(input.canonicalInputSerialized);
+      if (inputContextKind === "session_projection") {
+        if (input.contextLedger === void 0) {
+          throw new FusionError(
+            "session-projection fusion input requires an omission ledger artifact",
+            {
+              code: "orchestration_failed",
+              childCreated: false
+            }
+          );
+        }
+        await store.writeContextLedger(input.contextLedger);
+      } else if (input.contextLedger !== void 0) {
+        throw new FusionError("clean-task fusion input must not carry a parent omission ledger", {
+          code: "orchestration_failed",
+          childCreated: false
+        });
+      }
+      if (profile.id === "research") {
+        const cleanContext = input.canonicalInput.context;
+        if (cleanContext?.kind !== "clean_task") {
+          throw new FusionError("research workflow requires a clean-task canonical input", {
+            code: "orchestration_failed",
+            childCreated: false
+          });
+        }
+        const policy = buildFusionSourcePolicy(input.cwd, cleanContext.declared_sources);
+        await store.writeSourcePolicy(sourcePolicyCanonicalBytes(policy));
+      }
+      const budget = new FusionBudget(
+        input.models,
+        input.canonicalInput.context?.policy_id ?? "fusion-session-projection-v1",
+        candidateCapability,
+        profile
+      );
+      const budgetPlan = budget.plan(input.canonicalInput);
+      await store.writeBudgetPlan(budgetPlan);
+      budget.assertPlanFits(budgetPlan, store.artifactDir);
+      if (budgetPlan.warnings.length > 0) {
+        input.onProgress?.({
+          type: "budget_warning",
+          warnings: budgetPlan.warnings,
+          error: "fusion budget utilization warning"
+        });
+      }
+      await input.onReady?.({
+        runId: store.runId,
+        artifactDir: store.artifactDir,
+        artifactDirAbs: store.artifactDirAbs
+      });
+      if (input.signal?.aborted === true) {
+        throw new FusionError("fusion run cancelled before launch", {
+          code: "child_cancelled",
+          childCreated: false
+        });
+      }
+      await store.transition("candidates_running");
+      input.onProgress?.({ type: "state", state: "candidates_running" });
+      const candidateResults = await this.runCandidates(
+        input,
+        store,
+        usage,
+        budget,
+        calibrationWarnings,
+        profile,
+        candidateCapability
+      );
+      await store.transition("candidates_complete");
+      input.onProgress?.({ type: "state", state: "candidates_complete" });
+      const shuffled = anonymousCandidates(candidateResults, shuffledSlots(this.randomBytes));
+      await store.setAnonymousMap(shuffled.map);
+      const validationData = profile.id === "validate" ? await prepareValidationSourceData(shuffled.candidates, shuffled.map, store) : void 0;
+      const evaluationCandidates = validationData?.candidates ?? shuffled.candidates;
+      const blindInput = buildBlindEvaluationInput(
+        input.canonicalInput,
+        evaluationCandidates,
+        validationData?.findings
+      );
+      await store.writeBlindCandidates(buildEvaluationPrompt(blindInput));
+      await store.transition("evaluating");
+      input.onProgress?.({ type: "state", state: "evaluating" });
+      const evaluation = await this.runEvaluation(
+        input,
+        store,
+        usage,
+        blindInput,
+        budget,
+        calibrationWarnings,
+        profile,
+        validationData?.findings
+      );
+      await store.writeEvaluationJson(evaluation);
+      await store.transition("evaluation_complete");
+      input.onProgress?.({ type: "state", state: "evaluation_complete" });
+      await store.transition("merging");
+      input.onProgress?.({ type: "state", state: "merging" });
+      const mergeInput = buildMergeInput(input.canonicalInput, evaluationCandidates, evaluation);
+      const mergePrompt = buildMergePrompt(mergeInput);
+      budget.assertStagePrompt("merge", profile.mergerSystemPrompt, mergePrompt);
+      input.onProgress?.({ type: "merge_started" });
+      const merged = await this.runChildWithRetry(
+        input,
+        store,
+        usage,
+        input.models.merger,
+        "merge",
+        profile.mergerSystemPrompt,
+        mergePrompt,
+        input.signal ?? new AbortController().signal,
+        FUSION_NO_TOOLS_CAPABILITY,
+        void 0,
+        "md"
+      );
+      addFusionUsage(usage, merged.usage);
+      await store.recordChildAttempt({
+        result: merged,
+        systemPrompt: profile.mergerSystemPrompt,
+        prompt: mergePrompt,
+        responseKind: "md"
+      });
+      await this.recordCalibrationObservation(
+        input,
+        store,
+        budget,
+        calibrationWarnings,
+        "merge",
+        profile.mergerSystemPrompt,
+        mergePrompt,
+        merged
+      );
+      assertChildOutputWithinContract("merge", merged.text);
+      let finalMergedText = merged.text;
+      if (profile.id === "validate") {
+        const accounting = evaluation.validation_accounting;
+        if (accounting === void 0) {
+          throw new FusionError(
+            "fusion_validate evaluation completed without validation accounting",
+            {
+              code: "evaluation_invalid",
+              stage: "merge"
+            }
+          );
+        }
+        finalMergedText = renderValidatedFusionValidationReport(accounting, validationData);
+      }
+      if (finalMergedText !== merged.text)
+        assertChildOutputWithinContract("merge", finalMergedText);
+      const mergedRef = await store.writeMerged(finalMergedText);
+      await store.setUsage(usage);
+      const details = {
+        schema_version: FUSION_RESULT_SCHEMA_VERSION,
+        run_id: store.runId,
+        workflow: profile.id,
+        source: input.source,
+        status: "completed",
+        artifact_dir: store.artifactDir,
+        context: {
+          kind: inputContextKind,
+          policy_id: input.canonicalInput.context?.policy_id ?? "fusion-session-projection-v1"
+        },
+        tool_policy: {
+          candidate_tools: profile.candidateTools,
+          evaluation_tools: [],
+          merge_tools: []
+        },
+        models: store.snapshot().models,
+        evaluator_attempts: store.snapshot().attempts.filter((attempt) => attempt.stage === "evaluation").length,
+        usage,
+        budget: {
+          policy_id: FUSION_BUDGET_POLICY.id,
+          calibration_version: budgetPlan.policy.calibration_version,
+          route_table: budget.routes,
+          rate_sources: budget.resultRateSources,
+          unknown_provider_warnings: budget.unknownProviderWarnings,
+          calibration_warnings: calibrationWarnings
+        }
+      };
+      await store.writeCommittedResult(mergedRef, details);
+      await store.transition("completed");
+      input.onProgress?.({ type: "completed", runId: store.runId, artifactDir: store.artifactDir });
+      return { mergedText: finalMergedText, details };
+    } catch (error) {
+      const cancelled = input.signal?.aborted === true || error instanceof FusionError && error.code === "child_cancelled";
+      let terminalError;
+      try {
+        await store.setUsage(usage);
+        terminalError = withRunProgress(
+          error,
+          store.artifactDir,
+          buildFusionRunProgress(store.snapshot())
+        );
+        const terminalState = cancelled ? "cancelled" : "failed";
+        await store.writeError(terminalState, terminalError.message);
+        try {
+          const terminalManifest = store.snapshot();
+          await store.writeFailureSummary(
+            buildFusionFailureSummary({
+              manifest: terminalManifest,
+              terminalError,
+              progress: buildFusionRunProgress(terminalManifest),
+              terminalState,
+              createdAt: terminalManifest.updated_at
+            })
+          );
+        } catch (summaryError) {
+          terminalError = withSummaryUnavailableNote(terminalError, summaryError);
+        }
+      } catch (artifactError) {
+        throw withTerminalArtifactFailure(error, store.artifactDir, artifactError);
+      }
+      if (cancelled) {
+        input.onProgress?.({
+          type: "cancelled",
+          runId: store.runId,
+          artifactDir: store.artifactDir,
+          reason: terminalError.message
+        });
+      } else {
+        input.onProgress?.({
+          type: "failed",
+          runId: store.runId,
+          artifactDir: store.artifactDir,
+          error: terminalError.message
+        });
+      }
+      throw terminalError;
+    }
+  }
+  async runCandidates(input, store, usage, budget, calibrationWarnings, profile, candidateCapability) {
+    const controller = new AbortController();
+    const abortListener = /* @__PURE__ */ __name(() => controller.abort(), "abortListener");
+    input.signal?.addEventListener("abort", abortListener, { once: true });
+    if (input.signal?.aborted) controller.abort();
+    const systemPrompt = profile.candidateSystemPrompt(candidateCapability);
+    const prompt = buildCandidatePrompt(input.canonicalInput);
+    for (const slot of [1, 2, 3]) {
+      budget.assertStagePrompt("candidate", systemPrompt, prompt, slot);
+    }
+    let primaryError;
+    let completed = 0;
+    try {
+      if (controller.signal.aborted) {
+        throw new FusionError("fusion candidate wave cancelled before launch", {
+          code: "child_cancelled",
+          stage: "candidate",
+          childCreated: false
+        });
+      }
+      const tasks = [1, 2, 3].map((slot) => {
+        const model = candidateModel(input.models, slot);
+        const task = this.runChildWithRetry(
+          input,
+          store,
+          usage,
+          model,
+          "candidate",
+          systemPrompt,
+          prompt,
+          controller.signal,
+          candidateCapability,
+          slot,
+          profile.id === "validate" ? "txt" : "md"
+        ).then(async (result) => {
+          await store.recordChildAttempt({
+            result,
+            systemPrompt,
+            prompt,
+            responseKind: profile.id === "validate" ? "txt" : "md"
+          });
+          await this.recordCalibrationObservation(
+            input,
+            store,
+            budget,
+            calibrationWarnings,
+            "candidate",
+            systemPrompt,
+            prompt,
+            result,
+            slot
+          );
+          addFusionUsage(usage, result.usage);
+          await store.setUsage(usage);
+          assertChildOutputWithinContract("candidate", result.text);
+          completed += 1;
+          input.onProgress?.({ type: "candidate_completed", slot, completed, total: 3 });
+          return { slot, result };
+        });
+        return task.catch((error) => {
+          if (primaryError === void 0) {
+            primaryError = error;
+            controller.abort();
+          }
+          throw error;
+        });
+      });
+      const settled = await Promise.allSettled(tasks);
+      if (primaryError !== void 0) throw primaryError;
+      const results = [];
+      for (const item of settled) {
+        if (item.status === "fulfilled") results.push(item.value);
+        else throw item.reason;
+      }
+      return results.sort((left, right) => left.slot - right.slot);
+    } finally {
+      input.signal?.removeEventListener("abort", abortListener);
+    }
+  }
+  async runEvaluation(input, store, usage, blindInput, budget, calibrationWarnings, profile, expectedValidationFindings) {
+    const firstPrompt = buildEvaluationPrompt(blindInput);
+    budget.assertStagePrompt("evaluation", profile.evaluatorSystemPrompt, firstPrompt);
+    const first = await this.runEvaluationAttempt(
+      input,
+      store,
+      usage,
+      budget,
+      calibrationWarnings,
+      firstPrompt,
+      1,
+      false,
+      profile,
+      expectedValidationFindings
+    );
+    if (first.evaluation !== void 0) return first.evaluation;
+    const errors = boundedEvaluationErrors(first.errors);
+    input.onProgress?.({ type: "evaluation_retry", errors });
+    const repairPrompt = buildEvaluationRepairPrompt({
+      schema_version: "pi-background-tasks.fusion-evaluation-repair-input.v1",
+      original_blind_input: blindInput,
+      invalid_output: first.result.text,
+      validation_errors: errors
+    });
+    budget.assertStagePrompt(
+      "evaluation_repair",
+      profile.evaluationRepairSystemPrompt,
+      repairPrompt
+    );
+    const second = await this.runEvaluationAttempt(
+      input,
+      store,
+      usage,
+      budget,
+      calibrationWarnings,
+      repairPrompt,
+      2,
+      true,
+      profile,
+      expectedValidationFindings
+    );
+    if (second.evaluation !== void 0) return second.evaluation;
+    throw new FusionError(
+      `evaluation schema repair failed: ${formatEvaluationErrors(second.errors)}`,
+      {
+        code: "evaluation_invalid",
+        stage: "evaluation",
+        attempt: 2
+      }
+    );
+  }
+  async runEvaluationAttempt(input, store, usage, budget, calibrationWarnings, prompt, attempt, repair, profile, expectedValidationFindings) {
+    input.onProgress?.({ type: "evaluation_started", attempt, repair });
+    const systemPrompt = repair ? profile.evaluationRepairSystemPrompt : profile.evaluatorSystemPrompt;
+    const result = await this.runChildWithRetry(
+      input,
+      store,
+      usage,
+      input.models.evaluator,
+      "evaluation",
+      systemPrompt,
+      prompt,
+      input.signal ?? new AbortController().signal,
+      FUSION_NO_TOOLS_CAPABILITY,
+      void 0,
+      "txt",
+      attempt
+    );
+    addFusionUsage(usage, result.usage);
+    await store.recordChildAttempt({ result, systemPrompt, prompt, responseKind: "txt" });
+    await this.recordCalibrationObservation(
+      input,
+      store,
+      budget,
+      calibrationWarnings,
+      "evaluation",
+      systemPrompt,
+      prompt,
+      result
+    );
+    await store.setUsage(usage);
+    assertChildOutputWithinContract("evaluation", result.text);
+    const parsed = parseEvaluationAttempt(result.text, expectedValidationFindings);
+    return { result, evaluation: parsed.evaluation, errors: parsed.errors };
+  }
+  async recordCalibrationObservation(input, store, budget, calibrationWarnings, stage, systemPrompt, userPrompt, result, slot) {
+    const violation = budget.calibrationViolationForCompletedChild(
+      stage,
+      systemPrompt,
+      userPrompt,
+      result,
+      slot
+    );
+    if (violation === void 0) return;
+    calibrationWarnings.push(violation);
+    let artifact = "calibration-violation artifact was not written";
+    try {
+      const ref = await store.recordCalibrationViolation({
+        stage,
+        attempt: result.attempt,
+        violation,
+        ...slot === void 0 ? {} : { slot }
+      });
+      artifact = ref.path;
+    } catch (error) {
+      artifact = `calibration-violation artifact write failed: ${errorText2(error)}`;
+    }
+    input.onProgress?.({ type: "calibration_warning", warning: violation, artifact });
+  }
+  async runChildWithRetry(input, store, usage, model, stage, systemPrompt, userPrompt, signal, capability, slot, responseKind, fixedAttempt) {
+    const logicalAttempt = fixedAttempt ?? 1;
+    for (let launchTry = 1; launchTry <= 2; launchTry++) {
+      if (stage === "candidate" && slot !== void 0) {
+        input.onProgress?.({ type: "candidate_started", slot, attempt: logicalAttempt });
+      }
+      const toolCallLogPath = capability !== "reason" ? store.childToolCallLogPath(stage, slot, logicalAttempt) : void 0;
+      const sourcePolicy = capability === "research" ? store.sourcePolicyLaunchReference() : void 0;
+      const candidateOutputRecoveryPath = stage === "candidate" && slot !== void 0 ? store.childOutputRecoveryPath(slot, logicalAttempt, responseKind) : void 0;
+      try {
+        return await this.childRunner(
+          childOptions(
+            input,
+            model,
+            stage,
+            logicalAttempt,
+            capability,
+            systemPrompt,
+            userPrompt,
+            signal,
+            slot,
+            toolCallLogPath,
+            sourcePolicy,
+            candidateOutputRecoveryPath
+          )
+        );
+      } catch (error) {
+        if (!signal.aborted && retryableSpawn(error, launchTry) && launchTry === 1) continue;
+        addFailedChildUsage(usage, error);
+        await store.recordFailedAttempt(
+          recordFailureInput(
+            error,
+            stage,
+            slot,
+            logicalAttempt,
+            systemPrompt,
+            userPrompt,
+            responseKind
+          )
+        );
+        await store.setUsage(usage);
+        throw error;
+      }
+    }
+    const details = {
+      code: "orchestration_failed",
+      stage,
+      childCreated: false
+    };
+    if (slot !== void 0) details.slot = slot;
+    throw new FusionError(`${stage} child did not produce a result`, details);
+  }
+};
+export {
+  FusionOrchestrator,
+  buildFusionRunProgress,
+  summaryUnavailableNote
+};