@alexeiled/pi-fusion 0.6.1 → 0.7.0

package/src/orchestrator.ts

@@ -1,4 +1,8 @@
 import { applyClaudeAliasShorthand } from "./claude-aliases.js";
+import {
+  detectCallerOutputContract,
+  validateCallerOutput,
+} from "./caller-contract.js";
 import {
   buildInlinePanelProfile,
   loadFusionConfig,
@@ -17,6 +21,10 @@ import {
   extractPanelResults,
   type ExtractPanelResultsSuccess,
 } from "./result-extract.js";
+import {
+  reconcileIndexedLifecycleResult,
+  reconcilePanelResults,
+} from "./lifecycle-reconcile.js";
 import { appendThinkingSuffix, buildPanelSpawnParams } from "./run-builder.js";
 import { FusionRunStore, FusionRunStoreError } from "./run-store.js";
 import {
@@ -188,6 +196,8 @@ export class FusionOrchestrator {
       return { status: "failed", error: message };
     }
 
+    const outputContract =
+      args.outputContract ?? detectCallerOutputContract(args.prompt);
     let run: FusionRun;
     try {
       run = this.runStore.startRun({
@@ -199,6 +209,7 @@ export class FusionOrchestrator {
         ...(args.operationId !== undefined
           ? { operationId: args.operationId }
           : {}),
+        ...(outputContract ? { outputContract } : {}),
         phase: "panel",
       });
     } catch (error: unknown) {
@@ -219,7 +230,7 @@ export class FusionOrchestrator {
 
     try {
       const spawnResult = await this.rpc.spawn(
-        buildPanelSpawnParams(resolved.profile, args.prompt),
+        buildPanelSpawnParams(resolved.profile, args.prompt, outputContract),
       );
       const spawnError = extractSubagentFailure(spawnResult);
       if (spawnError) throw new FusionArgsError(spawnError);
@@ -585,19 +596,37 @@ export class FusionOrchestrator {
       );
     }
 
-    const observedPanels = mergePanelObservations(
+    const observedPanels = reconcilePanelResults(
       extracted,
       snapshot.statusPayload,
       profile,
+      lifecyclePayload,
+      { allowedTrailingResults: 1 },
     );
+    if (!observedPanels.ok) {
+      return this.failActiveRun(
+        `${observedPanels.error.message} (${observedPanels.error.path})`,
+      );
+    }
     const updated = this.storePanelResults(
       active.id,
       observedPanels.outputs,
       observedPanels.failures,
     );
 
-    if (hasJudgeResult(snapshot.resultPayload, profile.panel.length)) {
-      const output = extractJudgeOutput(snapshot.resultPayload, {
+    const judgePayload =
+      hasJudgeResult(snapshot.resultPayload, profile.panel.length)
+        ? snapshot.resultPayload
+        : snapshot.statusPayload;
+    if (hasJudgeResult(judgePayload, profile.panel.length)) {
+      const lifecycleConflict = reconcileIndexedLifecycleResult(
+        snapshot.resultPayload,
+        snapshot.statusPayload,
+        profile.panel.length,
+        "judge",
+      );
+      if (lifecycleConflict) return this.failActiveRun(lifecycleConflict);
+      const output = extractJudgeOutput(judgePayload, {
         resultIndex: profile.panel.length,
       });
       if (!output.ok) return this.failActiveRun(output.error);
@@ -608,13 +637,18 @@ export class FusionOrchestrator {
             snapshot.statusPayload,
         ),
         extractRunObservation(
-          findResult(snapshot.resultPayload, profile.panel.length) ??
-            snapshot.resultPayload,
+          findResult(judgePayload, profile.panel.length) ?? judgePayload,
         ),
       );
       const observed = this.runStore.updateRun(updated.id, {
         judgeObservation,
       });
+      const callerContract =
+        observed.outputContract ?? detectCallerOutputContract(observed.prompt);
+      if (callerContract) {
+        const validation = validateCallerOutput(callerContract, output.output);
+        if (!validation.ok) return this.failActiveRun(validation.error);
+      }
       const report = renderJudgeReport({
         run: observed,
         judgeOutput: output.output,
@@ -713,11 +747,18 @@ export class FusionOrchestrator {
       );
     }
 
-    const observedPanels = mergePanelObservations(
+    const observedPanels = reconcilePanelResults(
       extracted,
       snapshot.statusPayload,
       profile,
+      lifecyclePayload,
+      { ...(stoppedPanelIndices ? { stoppedPanelIndices } : {}) },
     );
+    if (!observedPanels.ok) {
+      return this.failActiveRun(
+        `${observedPanels.error.message} (${observedPanels.error.path})`,
+      );
+    }
     const stored = this.storePanelResults(
       active.id,
       observedPanels.outputs,
@@ -875,8 +916,25 @@ export class FusionOrchestrator {
       return this.failActiveRun(lifecycleError);
     }
 
+    const lifecycleConflict = reconcileIndexedLifecycleResult(
+      snapshot.resultPayload,
+      snapshot.statusPayload,
+      0,
+      "judge",
+    );
+    if (lifecycleConflict) return this.failActiveRun(lifecycleConflict);
+
     const output = extractJudgeOutput(lifecyclePayload);
-    if (!output.ok) return this.failActiveRun(output.error);
+    if (!output.ok) {
+      const stepError = extractSubagentFailure(
+        findStepsArray(snapshot.statusPayload)[0],
+      );
+      const errors = [lifecycleError, stepError, output.error].filter(
+        (error, index, all): error is string =>
+          Boolean(error) && all.indexOf(error) === index,
+      );
+      return this.failActiveRun(errors.join(" "));
+    }
 
     // The panel and chain handlers already treat a missing profile as fatal.
     // Without the same guard here the run "succeeds" with a degraded report:
@@ -888,6 +946,13 @@ export class FusionOrchestrator {
       );
     }
 
+    const callerContract =
+      active.outputContract ?? detectCallerOutputContract(active.prompt);
+    if (callerContract) {
+      const validation = validateCallerOutput(callerContract, output.output);
+      if (!validation.ok) return this.failActiveRun(validation.error);
+    }
+
     const judgeModel = configuredJudgeModel(profile);
     const judgeObservation = mergeRunObservations(
       extractRunObservation(
@@ -1575,15 +1640,17 @@ function hasResultsArray(payload: unknown): boolean {
 }
 
 function hasJudgeResult(payload: unknown, panelCount: number): boolean {
-  return (findResultsArray(payload)?.length ?? 0) > panelCount;
+  const count =
+    findResultsArray(payload)?.length ?? findStepsArray(payload).length;
+  return count > panelCount;
 }
 
 function findResult(
   payload: unknown,
   resultIndex?: number,
 ): Record<string, unknown> | undefined {
-  const results = findResultsArray(payload);
-  if (!results || results.length === 0) return undefined;
+  const results = findResultsArray(payload) ?? findStepsArray(payload);
+  if (results.length === 0) return undefined;
   if (resultIndex !== undefined) {
     const indexed = results[resultIndex];
     return isRecord(indexed) ? indexed : undefined;
@@ -1752,56 +1819,6 @@ function extractArtifactPath(
   return undefined;
 }
 
-function mergePanelObservations(
-  result: ExtractPanelResultsSuccess,
-  statusPayload: unknown,
-  profile: FusionProfile,
-): ExtractPanelResultsSuccess {
-  const status = extractPanelResults(statusPayload, {
-    panel: profile.panel,
-    completedOnly: true,
-    limit: profile.panel.length,
-  });
-  if (!status.ok) return result;
-
-  const observations = new Map<number, PanelOutput["observation"]>();
-  for (const output of status.outputs) {
-    observations.set(output.index, output.observation);
-  }
-  for (const failure of status.failures) {
-    observations.set(failure.index, failure.observation);
-  }
-
-  return {
-    ...result,
-    outputs: result.outputs.map((output) =>
-      withMergedObservation(output, observations.get(output.index)),
-    ),
-    failures: result.failures.map((failure) =>
-      withMergedObservation(failure, observations.get(failure.index)),
-    ),
-  };
-}
-
-function withMergedObservation<T extends PanelOutput | FailedPanelSummary>(
-  item: T,
-  statusObservation: PanelOutput["observation"] | undefined,
-): T {
-  const observation = mergeRunObservations(statusObservation, item.observation);
-  return hasObservationData(observation) ? { ...item, observation } : item;
-}
-
-function hasObservationData(observation: PanelOutput["observation"]): boolean {
-  return Boolean(
-    observation &&
-    (observation.model ||
-      observation.durationMs !== undefined ||
-      observation.usage ||
-      observation.attempts ||
-      observation.providerFailures),
-  );
-}
-
 function shouldStopWhenPanelAgrees(
   profile: FusionProfile,
   outputs: readonly PanelOutput[],

package/src/panel-completion.ts

@@ -1,4 +1,12 @@
-import { renderPanelFailureReport, renderSinglePanelReport } from "./report.js";
+import {
+  detectCallerOutputContract,
+  validateCallerOutput,
+} from "./caller-contract.js";
+import {
+  renderFailureReport,
+  renderPanelFailureReport,
+  renderSinglePanelReport,
+} from "./report.js";
 import {
   appendThinkingSuffix,
   buildJudgeSpawnParams,
@@ -50,14 +58,53 @@ export function decidePanelCompletion(
     };
   }
 
-  // Under `select` every panelist answered the whole question, so a lone
-  // survivor is a complete if thin answer. Under `merge` it answered ONE facet:
-  // returning it as the answer would be wrong, not thin. Run the composer so
-  // the report names the facets nobody covered.
+  const intentionalStops =
+    input.profile.stopWhenPanelAgrees === true &&
+    input.panelOutputs.length >= 2 &&
+    input.panelFailures.length > 0 &&
+    input.panelFailures.every(
+      ({ reason }) => reason === "stopped-after-agreement",
+    );
   if (
-    input.panelOutputs.length === 1 &&
-    resolveSynthesisMode(input.profile) !== "merge"
+    input.panelOutputs.length < input.profile.panel.length &&
+    !intentionalStops
   ) {
+    const error = `Only ${input.panelOutputs.length} of ${input.profile.panel.length} fusion panelists completed successfully; ${input.panelFailures.length} panelist result(s) are also missing.`;
+    const report = renderFailureReport({
+      run: input.run,
+      error,
+      panelOutputs: input.panelOutputs,
+      failures: input.panelFailures,
+      ...withJudgeModel(judgeModel),
+      synthesis: resolveSynthesisMode(input.profile),
+      panel: input.profile.panel,
+    });
+    return { kind: "fail", error, report };
+  }
+
+  if (input.panelOutputs.length === 1) {
+    const callerContract =
+      input.run.outputContract ??
+      detectCallerOutputContract(input.run.prompt);
+    if (callerContract) {
+      const validation = validateCallerOutput(
+        callerContract,
+        input.panelOutputs[0]!.output,
+      );
+      if (!validation.ok) {
+        const report = renderFailureReport({
+          run: input.run,
+          error: validation.error,
+          panelOutputs: input.panelOutputs,
+          failures: input.panelFailures,
+          ...withJudgeModel(judgeModel),
+          synthesis: resolveSynthesisMode(input.profile),
+          panel: input.profile.panel,
+        });
+        return { kind: "fail", error: validation.error, report };
+      }
+    }
+
     const report = renderSinglePanelReport({
       run: input.run,
       output: input.panelOutputs[0]!,
@@ -75,6 +122,9 @@ export function decidePanelCompletion(
       panelOutputs: input.panelOutputs,
       failedPanelists: input.panelFailures,
       runId: input.run.id,
+      ...(input.run.outputContract
+        ? { callerContract: input.run.outputContract }
+        : {}),
     }),
     missingRunIdError: input.fallbackJudge
       ? "pi-subagents spawn did not return a fallback judge run ID."

package/src/report.ts

@@ -1,3 +1,7 @@
+import {
+  detectCallerOutputContract,
+  validateCallerOutput,
+} from "./caller-contract.js";
 import {
   buildBlindLabelMap,
   type FailedPanelSummary,
@@ -23,6 +27,7 @@ type ReportRun = Pick<
   | "panelRunId"
   | "judgeRunId"
   | "panelStopReason"
+  | "outputContract"
 > &
   Partial<Pick<FusionRun, "phase" | "createdAt" | "updatedAt">>;
 
@@ -227,6 +232,9 @@ export function renderPanelFailureReport(
 export function renderSinglePanelReport(
   input: RenderSinglePanelReportInput,
 ): string {
+  const exactOutput = validExactCallerOutput(input.run, input.output.output);
+  if (exactOutput) return exactOutput;
+
   const panelName = formatPanelName(input.output);
   const sections: ReportSection[] = [
     {
@@ -291,6 +299,15 @@ export function renderSinglePanelReport(
  * Rewrites the neutral names the judge saw back to the configured member names.
  * Longest label first so "Candidate AA" is not partly replaced by "Candidate A".
  */
+function validExactCallerOutput(
+  run: ReportRun,
+  output: string,
+): string | undefined {
+  const contract = run.outputContract ?? detectCallerOutputContract(run.prompt);
+  if (!contract) return undefined;
+  return validateCallerOutput(contract, output).ok ? output.trim() : undefined;
+}
+
 function restoreBlindLabels(
   judgeOutput: string,
   panelOutputs: readonly PanelOutput[],
@@ -317,6 +334,9 @@ function restoreBlindLabels(
 export function renderJudgeReport(input: RenderJudgeReportInput): string {
   const panelOutputs = input.panelOutputs ?? [];
   const failures = input.failures ?? [];
+  const exactOutput = validExactCallerOutput(input.run, input.judgeOutput);
+  if (exactOutput) return exactOutput;
+
   const judgeOutput = input.blindPanelLabels
     ? restoreBlindLabels(input.judgeOutput, panelOutputs, failures)
     : input.judgeOutput;

package/src/result-extract.ts

@@ -63,13 +63,19 @@ export function extractPanelResults(
 
   const outputs: PanelOutput[] = [];
   const failures: FailedPanelSummary[] = [];
+  const fallbackFailureReason = failureReason(container.payload);
   const results =
     options.limit === undefined
       ? container.results
       : container.results.slice(0, options.limit);
   for (const [index, rawResult] of results.entries()) {
     if (options.completedOnly && !isCompletedResult(rawResult)) continue;
-    const child = normalizeChildResult(rawResult, index, options);
+    const child = normalizeChildResult(
+      rawResult,
+      index,
+      options,
+      fallbackFailureReason,
+    );
     if (!child.ok) return child;
     if (child.status === "success") outputs.push(child.output);
     else failures.push(child.failure);
@@ -84,6 +90,7 @@ export function extractPanelResults(
       },
       index,
       options,
+      fallbackFailureReason,
     );
     if (!child.ok) return child;
     if (child.status === "failed") failures.push(child.failure);
@@ -197,6 +204,7 @@ function normalizeChildResult(
   rawResult: unknown,
   index: number,
   options: ExtractPanelResultsOptions,
+  fallbackFailureReason?: FailedPanelSummary["reason"],
 ):
   | { ok: true; status: "success"; output: PanelOutput }
   | { ok: true; status: "failed"; failure: FailedPanelSummary }
@@ -275,7 +283,9 @@ function normalizeChildResult(
       summary: stoppedAfterAgreement
         ? "Stopped after strong panel agreement."
         : failureSummary(rawResult, artifactPath),
-      reason: failureReason(rawResult, stoppedAfterAgreement),
+      reason:
+        failureReason(rawResult, stoppedAfterAgreement) ??
+        fallbackFailureReason,
       observation,
       artifactPath,
       sessionPath,
@@ -392,7 +402,12 @@ function failureReason(
   stoppedAfterAgreement = false,
 ): FailedPanelSummary["reason"] {
   if (stoppedAfterAgreement) return "stopped-after-agreement";
-  if (result.timedOut === true) return "timeout";
+  if (
+    result.timedOut === true ||
+    /(?:timed out|timeout)/i.test(firstNonBlankString(result.error) ?? "")
+  ) {
+    return "timeout";
+  }
   if (result.interrupted === true) return "interrupted";
   return undefined;
 }

package/src/run-builder.ts

@@ -1,3 +1,7 @@
+import {
+  callerOutputContractInstructions,
+  detectCallerOutputContract,
+} from "./caller-contract.js";
 import {
   PANEL_DECISION_CLOSE,
   PANEL_DECISION_OPEN,
@@ -8,6 +12,7 @@ import {
   memberLabel,
   panelItemLabel,
   resolveSynthesisMode,
+  type CallerOutputContract,
   THINKING_LEVELS,
   type FailedPanelSummary,
   type FusionProfile,
@@ -25,6 +30,13 @@ export const FUSION_ACCEPTANCE_DISABLED = {
 
 export type FusionAcceptanceDisabled = typeof FUSION_ACCEPTANCE_DISABLED;
 
+const DEFAULT_STAGE_TIMEOUT_MS = 900_000;
+const DEFAULT_TOOL_BUDGET: ToolBudget = {
+  soft: 8,
+  hard: 12,
+  block: "*",
+};
+
 export interface PanelSubagentTaskParams {
   agent: string;
   task: string;
@@ -34,6 +46,8 @@ export interface PanelSubagentTaskParams {
   skill: false;
   acceptance: FusionAcceptanceDisabled;
   model?: string;
+  /** Per-task cap so a panelist finalises before the workflow timeout. */
+  toolBudget: ToolBudget;
 }
 
 export interface PanelWorkflowTaskParams extends PanelSubagentTaskParams {
@@ -43,7 +57,6 @@ export interface PanelWorkflowTaskParams extends PanelSubagentTaskParams {
 export interface PanelSpawnParams {
   workflowScript: string;
   async: true;
-  clarify: false;
   context: "fresh" | "fork";
   output: true;
   outputMode: "inline";
@@ -51,22 +64,28 @@ export interface PanelSpawnParams {
   timeoutMs?: number;
 }
 
-export interface JudgeSpawnParams {
+export interface JudgeWorkflowTaskParams {
   agent: string;
   task: string;
-  async: true;
-  clarify: false;
-  context: "fresh" | "fork";
   output: true;
   outputMode: "inline";
   skill: false;
   acceptance: FusionAcceptanceDisabled;
   model?: string;
-  timeoutMs?: number;
   /** Per-task cap on judge tool calls; see `FusionProfile.judgeToolBudget`. */
   toolBudget?: ToolBudget;
 }
 
+export interface JudgeSpawnParams {
+  workflowScript: string;
+  async: true;
+  context: "fresh" | "fork";
+  output: true;
+  outputMode: "inline";
+  acceptance: FusionAcceptanceDisabled;
+  timeoutMs?: number;
+}
+
 export type { FailedPanelSummary, PanelOutput } from "./types.js";
 
 export interface BuildJudgeSpawnParamsInput {
@@ -80,6 +99,7 @@ export interface BuildJudgeSpawnParamsInput {
    * and its position bias.
    */
   runId: string;
+  callerContract?: CallerOutputContract;
 }
 
 const PANEL_OUTPUT_CONTRACT = [
@@ -147,6 +167,7 @@ export function appendThinkingSuffix(
 export function buildPanelSpawnParams(
   profile: FusionProfile,
   prompt: string,
+  callerContract?: CallerOutputContract,
 ): PanelSpawnParams {
   const concurrency = profile.concurrency ?? profile.panel.length;
   const tasks: PanelWorkflowTaskParams[] = profile.panel.map(
@@ -156,6 +177,8 @@ export function buildPanelSpawnParams(
         member,
         prompt,
         profile.stopWhenPanelAgrees === true,
+        profile.panelToolBudget ?? DEFAULT_TOOL_BUDGET,
+        callerContract,
       ),
     }),
   );
@@ -167,14 +190,11 @@ export function buildPanelSpawnParams(
       profile.stopWhenPanelAgrees === true,
     ),
     async: true,
-    clarify: false,
     context: profile.context ?? "fresh",
     output: true,
     outputMode: "inline",
     acceptance: FUSION_ACCEPTANCE_DISABLED,
-    ...(profile.timeoutMs !== undefined
-      ? { timeoutMs: profile.timeoutMs }
-      : {}),
+    timeoutMs: resolveStageTimeout(profile.panelTimeoutMs, profile.timeoutMs),
   };
 }
 
@@ -185,23 +205,28 @@ export function buildJudgeSpawnParams(
     input.profile.judge.model,
     input.profile.judge.thinking,
   );
-  return {
+  const task: JudgeWorkflowTaskParams = {
     agent: resolveSynthesisAgent(input.profile),
     task: buildJudgeTask(input),
-    async: true,
-    clarify: false,
-    context: input.profile.context ?? "fresh",
     output: true,
     outputMode: "inline",
     skill: false,
     acceptance: FUSION_ACCEPTANCE_DISABLED,
     ...(model ? { model } : {}),
-    ...(input.profile.judgeToolBudget
-      ? { toolBudget: input.profile.judgeToolBudget }
-      : {}),
-    ...(input.profile.timeoutMs !== undefined
-      ? { timeoutMs: input.profile.timeoutMs }
-      : {}),
+    toolBudget: input.profile.judgeToolBudget ?? DEFAULT_TOOL_BUDGET,
+  };
+
+  return {
+    workflowScript: `return runs.run("judge", ${JSON.stringify(task)});`,
+    async: true,
+    context: input.profile.context ?? "fresh",
+    output: true,
+    outputMode: "inline",
+    acceptance: FUSION_ACCEPTANCE_DISABLED,
+    timeoutMs: resolveStageTimeout(
+      input.profile.judgeTimeoutMs,
+      input.profile.timeoutMs,
+    ),
   };
 }
 
@@ -250,20 +275,35 @@ function buildPanelWorkflowScript(
     .join("\n");
 }
 
+function resolveStageTimeout(
+  stageTimeoutMs: number | undefined,
+  legacyTimeoutMs: number | undefined,
+): number {
+  return stageTimeoutMs ?? legacyTimeoutMs ?? DEFAULT_STAGE_TIMEOUT_MS;
+}
+
 function buildPanelTaskParams(
   member: PanelMemberConfig,
   prompt: string,
   includeDecisionRecord: boolean,
+  toolBudget: ToolBudget,
+  callerContract?: CallerOutputContract,
 ): PanelSubagentTaskParams {
   const model = appendThinkingSuffix(member.model, member.thinking);
   return {
     agent: member.agent,
-    task: buildPanelTask(member, prompt, includeDecisionRecord),
+    task: buildPanelTask(
+      member,
+      prompt,
+      includeDecisionRecord,
+      callerContract,
+    ),
     output: true,
     outputMode: "inline",
     progress: true,
     skill: false,
     acceptance: FUSION_ACCEPTANCE_DISABLED,
+    toolBudget,
     ...(model ? { model } : {}),
   };
 }
@@ -272,8 +312,11 @@ function buildPanelTask(
   member: PanelMemberConfig,
   prompt: string,
   includeDecisionRecord: boolean,
+  callerContractOverride?: CallerOutputContract,
 ): string {
   const role = member.role?.trim() || "independent analysis and critique";
+  const callerContract =
+    callerContractForPrompt(prompt, callerContractOverride);
   return [
     `Panel member: ${memberLabel(member)} (${member.id})`,
     `Role: ${role}`,
@@ -289,8 +332,10 @@ function buildPanelTask(
     "- Be concise and cite evidence when you inspect files.",
     "",
     "Output contract:",
-    ...PANEL_OUTPUT_CONTRACT,
-    ...(includeDecisionRecord
+    ...(callerContract
+      ? callerOutputContractInstructions(callerContract)
+      : PANEL_OUTPUT_CONTRACT),
+    ...(includeDecisionRecord && !callerContract
       ? [
           "",
           "Decision record:",
@@ -346,6 +391,13 @@ function formatMemberTask(member: PanelMemberConfig, prompt: string): string[] {
   ];
 }
 
+function callerContractForPrompt(
+  prompt: string,
+  explicit?: CallerOutputContract,
+): CallerOutputContract | undefined {
+  return explicit ?? detectCallerOutputContract(prompt);
+}
+
 function buildJudgeTask(input: BuildJudgeSpawnParamsInput): string {
   const sortedOutputs = [...input.panelOutputs].sort(comparePanelItems);
   const sortedFailures = [...input.failedPanelists].sort(comparePanelItems);
@@ -356,6 +408,10 @@ function buildJudgeTask(input: BuildJudgeSpawnParamsInput): string {
     ? buildBlindLabelMap([...sortedOutputs, ...sortedFailures])
     : undefined;
   const merging = resolveSynthesisMode(input.profile) === "merge";
+  const callerContract = callerContractForPrompt(
+    input.prompt,
+    input.callerContract,
+  );
   return [
     ...(merging
       ? COMPOSER_INSTRUCTIONS
@@ -389,7 +445,11 @@ function buildJudgeTask(input: BuildJudgeSpawnParamsInput): string {
     // right" wording contradicts the composer's "do not rank panelists".
     ...(merging ? [] : [...CONTESTED_CLAIMS_INSTRUCTIONS, ""]),
     "Output contract:",
-    ...(merging ? COMPOSER_OUTPUT_CONTRACT : JUDGE_OUTPUT_CONTRACT),
+    ...(callerContract
+      ? callerOutputContractInstructions(callerContract)
+      : merging
+        ? COMPOSER_OUTPUT_CONTRACT
+        : JUDGE_OUTPUT_CONTRACT),
   ].join("\n");
 }