pi-background-tasks 2.5.0 → 2.6.0

package/src/core/durable-fs.ts

@@ -45,9 +45,13 @@ export interface DurableFileOperations {
   temporaryPath(target: string): string;
 }
 
+export interface DurableWriteOptions {
+  readonly signal?: AbortSignal | undefined;
+}
+
 export interface DurableFileWriter {
-  write(path: string, data: DurableData): Promise<void>;
-  replace(path: string, data: DurableData): Promise<void>;
+  write(path: string, data: DurableData, options?: DurableWriteOptions): Promise<void>;
+  replace(path: string, data: DurableData, options?: DurableWriteOptions): Promise<void>;
 }
 
 interface DurableErrorInput {
@@ -63,6 +67,48 @@ interface DurableErrorInput {
 interface WritableSequenceResult {
   primaryFailure: DurableFailure | undefined;
   cleanupFailures: DurableFailure[];
+  cancelled: boolean;
+}
+
+interface RenameSequenceResult {
+  error: unknown | undefined;
+  cancelled: boolean;
+}
+
+export class DurableFileCancellationError extends Error {
+  readonly code = 'durable_file_cancelled';
+  readonly path: string;
+  readonly reason: unknown;
+  readonly cleanupFailures: readonly DurableFailure[];
+  readonly targetPath: string | undefined;
+  readonly temporaryPath: string | undefined;
+  readonly renameCompleted: boolean;
+
+  constructor(input: {
+    path: string;
+    reason: unknown;
+    cleanupFailures: readonly DurableFailure[];
+    targetPath: string | undefined;
+    temporaryPath: string | undefined;
+    renameCompleted: boolean;
+  }) {
+    const reasonText = describeCause(input.reason);
+    const cleanupText =
+      input.cleanupFailures.length === 0
+        ? ''
+        : ` Cleanup failures: ${input.cleanupFailures.map(formatFailureForMessage).join('; ')}`;
+    const commitText = input.renameCompleted
+      ? ` Replacement may already be visible at ${input.targetPath ?? input.path}.`
+      : '';
+    super(`Durable file operation cancelled for ${input.path}: ${reasonText}.${commitText}${cleanupText}`);
+    this.name = 'DurableFileCancellationError';
+    this.path = input.path;
+    this.reason = input.reason;
+    this.cleanupFailures = [...input.cleanupFailures];
+    this.targetPath = input.targetPath;
+    this.temporaryPath = input.temporaryPath;
+    this.renameCompleted = input.renameCompleted;
+  }
 }
 
 export class DurableFileError extends Error {
@@ -149,20 +195,26 @@ async function writeSyncClose(
   handle: DurableWritableHandle,
   path: string,
   data: DurableData,
+  signal?: AbortSignal,
 ): Promise<WritableSequenceResult> {
   const cleanupFailures: DurableFailure[] = [];
   let primaryFailure: DurableFailure | undefined;
-  try {
-    await handle.writeFile(data);
-  } catch (error) {
-    primaryFailure = failure('write_file', path, error);
+  let cancelled = signal?.aborted === true;
+  if (!cancelled) {
+    try {
+      await handle.writeFile(data);
+    } catch (error) {
+      primaryFailure = failure('write_file', path, error);
+    }
+    cancelled = signal?.aborted === true;
   }
-  if (primaryFailure === undefined) {
+  if (primaryFailure === undefined && !cancelled) {
     try {
       await handle.sync();
     } catch (error) {
       primaryFailure = failure('sync_file', path, error);
     }
+    cancelled = signal?.aborted === true;
   }
   try {
     await handle.close();
@@ -171,7 +223,8 @@ async function writeSyncClose(
     if (primaryFailure === undefined) primaryFailure = closeFailure;
     else cleanupFailures.push(closeFailure);
   }
-  return { primaryFailure, cleanupFailures };
+  cancelled ||= signal?.aborted === true;
+  return { primaryFailure, cleanupFailures, cancelled };
 }
 
 async function syncCloseDirectory(
@@ -192,7 +245,31 @@ async function syncCloseDirectory(
     if (primaryFailure === undefined) primaryFailure = closeFailure;
     else cleanupFailures.push(closeFailure);
   }
-  return { primaryFailure, cleanupFailures };
+  return { primaryFailure, cleanupFailures, cancelled: false };
+}
+
+function cancellationReason(signal: AbortSignal): unknown {
+  return signal.reason ?? new Error('operation aborted');
+}
+
+function throwCancellation(
+  signal: AbortSignal,
+  path: string,
+  cleanupFailures: readonly DurableFailure[],
+  targetPath: string | undefined,
+  temporaryPath: string | undefined,
+  renameCompleted: boolean,
+): never {
+  const reason = cancellationReason(signal);
+  if (cleanupFailures.length === 0 && !renameCompleted && reason instanceof Error) throw reason;
+  throw new DurableFileCancellationError({
+    path,
+    reason,
+    cleanupFailures,
+    targetPath,
+    temporaryPath,
+    renameCompleted,
+  });
 }
 
 function throwDurable(
@@ -225,21 +302,34 @@ async function removeTemporary(
   }
 }
 
+function isAborted(signal: AbortSignal | undefined): boolean {
+  return signal?.aborted === true;
+}
+
 async function writeWithOperations(
   operations: DurableFileOperations,
   path: string,
   data: DurableData,
+  options: DurableWriteOptions,
 ): Promise<void> {
+  const signal = options.signal;
+  if (signal !== undefined && isAborted(signal))
+    throwCancellation(signal, path, [], path, undefined, false);
   let handle: DurableWritableHandle;
   try {
     handle = await operations.openWritable(path, 'w');
   } catch (error) {
+    if (signal !== undefined && isAborted(signal))
+      throwCancellation(signal, path, [], path, undefined, false);
     throwDurable(failure('open_file', path, error), [], path, undefined, false);
   }
-  const result = await writeSyncClose(handle, path, data);
+  const result = await writeSyncClose(handle, path, data, signal);
   if (result.primaryFailure !== undefined) {
     throwDurable(result.primaryFailure, result.cleanupFailures, path, undefined, false);
   }
+  if (result.cancelled && signal !== undefined) {
+    throwCancellation(signal, path, result.cleanupFailures, path, undefined, false);
+  }
 }
 
 async function syncDirectoryAfterRename(
@@ -265,25 +355,52 @@ async function replaceWithOperations(
   operations: DurableFileOperations,
   path: string,
   data: DurableData,
+  options: DurableWriteOptions,
 ): Promise<void> {
+  const signal = options.signal;
+  if (signal !== undefined && isAborted(signal))
+    throwCancellation(signal, path, [], path, undefined, false);
   const temporaryPath = operations.temporaryPath(path);
   let handle: DurableWritableHandle;
   try {
     handle = await operations.openWritable(temporaryPath, 'wx', 0o600);
   } catch (error) {
+    if (signal !== undefined && isAborted(signal))
+      throwCancellation(signal, temporaryPath, [], path, temporaryPath, false);
     throwDurable(failure('open_file', temporaryPath, error), [], path, temporaryPath, false);
   }
-  const writeResult = await writeSyncClose(handle, temporaryPath, data);
+  const writeResult = await writeSyncClose(handle, temporaryPath, data, signal);
   if (writeResult.primaryFailure !== undefined) {
     await removeTemporary(operations, temporaryPath, writeResult.cleanupFailures);
     throwDurable(writeResult.primaryFailure, writeResult.cleanupFailures, path, temporaryPath, false);
   }
-  const renameError = await renameWithWindowsContention(operations, temporaryPath, path);
-  if (renameError !== undefined) {
+  if (writeResult.cancelled && signal !== undefined) {
+    await removeTemporary(operations, temporaryPath, writeResult.cleanupFailures);
+    throwCancellation(
+      signal,
+      temporaryPath,
+      writeResult.cleanupFailures,
+      path,
+      temporaryPath,
+      false,
+    );
+  }
+  const renameResult = await renameWithWindowsContention(
+    operations,
+    temporaryPath,
+    path,
+    signal,
+  );
+  if (renameResult.cancelled && signal !== undefined) {
+    const cleanupFailures: DurableFailure[] = [];
+    await removeTemporary(operations, temporaryPath, cleanupFailures);
+    throwCancellation(signal, temporaryPath, cleanupFailures, path, temporaryPath, false);
+  }
+  if (renameResult.error !== undefined) {
     const cleanupFailures: DurableFailure[] = [];
     await removeTemporary(operations, temporaryPath, cleanupFailures);
     throwDurable(
-      failure('rename_file', path, renameError),
+      failure('rename_file', path, renameResult.error),
       cleanupFailures,
       path,
       temporaryPath,
@@ -291,6 +408,9 @@ async function replaceWithOperations(
     );
   }
   await syncDirectoryAfterRename(operations, path, temporaryPath);
+  if (signal !== undefined && isAborted(signal)) {
+    throwCancellation(signal, path, [], path, temporaryPath, true);
+  }
 }
 
 /**
@@ -310,9 +430,18 @@ const WINDOWS_RENAME_CONTENTION_CODES: ReadonlySet<string> = new Set([
 const WINDOWS_RENAME_ATTEMPTS = 10;
 const WINDOWS_RENAME_RETRY_DELAY_MS = 20;
 
-function delay(ms: number): Promise<void> {
+function delay(ms: number, signal?: AbortSignal): Promise<void> {
+  if (isAborted(signal)) return Promise.resolve();
   return new Promise((resolve) => {
-    setTimeout(resolve, ms);
+    const timer = setTimeout(() => {
+      signal?.removeEventListener('abort', aborted);
+      resolve();
+    }, ms);
+    const aborted = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    signal?.addEventListener('abort', aborted, { once: true });
   });
 }
 
@@ -324,31 +453,34 @@ function delay(ms: number): Promise<void> {
  * final failure is still returned and raised loudly, no alternative write path
  * is taken, and no other platform or error code is retried.
  *
- * Returns the failure cause, or undefined on success.
+ * Returns an explicit success/error/cancellation sequence result.
  */
 async function renameWithWindowsContention(
   operations: DurableFileOperations,
   temporaryPath: string,
   targetPath: string,
-): Promise<unknown> {
+  signal?: AbortSignal,
+): Promise<RenameSequenceResult> {
   const attempts = operations.platform === 'win32' ? WINDOWS_RENAME_ATTEMPTS : 1;
   let lastError: unknown;
   for (let attempt = 1; attempt <= attempts; attempt++) {
+    if (isAborted(signal)) return { error: undefined, cancelled: true };
     try {
       await operations.rename(temporaryPath, targetPath);
-      return undefined;
+      return { error: undefined, cancelled: false };
     } catch (error) {
       lastError = error;
+      if (isAborted(signal)) return { error: undefined, cancelled: true };
       const code = nativeCodeForCause(error);
       const retryable =
         operations.platform === 'win32' &&
         code !== undefined &&
         WINDOWS_RENAME_CONTENTION_CODES.has(code);
-      if (!retryable || attempt === attempts) return error;
-      await delay(WINDOWS_RENAME_RETRY_DELAY_MS * attempt);
+      if (!retryable || attempt === attempts) return { error, cancelled: false };
+      await delay(WINDOWS_RENAME_RETRY_DELAY_MS * attempt, signal);
     }
   }
-  return lastError;
+  return { error: lastError, cancelled: false };
 }
 
 function temporaryPathForTarget(target: string): string {
@@ -382,19 +514,35 @@ const defaultWriter = createDurableFileWriter(nodeOperations);
 
 export function createDurableFileWriter(operations: DurableFileOperations): DurableFileWriter {
   return {
-    async write(path: string, data: DurableData): Promise<void> {
-      await writeWithOperations(operations, path, data);
+    async write(
+      path: string,
+      data: DurableData,
+      options: DurableWriteOptions = {},
+    ): Promise<void> {
+      await writeWithOperations(operations, path, data, options);
     },
-    async replace(path: string, data: DurableData): Promise<void> {
-      await replaceWithOperations(operations, path, data);
+    async replace(
+      path: string,
+      data: DurableData,
+      options: DurableWriteOptions = {},
+    ): Promise<void> {
+      await replaceWithOperations(operations, path, data, options);
     },
   };
 }
 
-export async function writeFileDurable(path: string, data: DurableData): Promise<void> {
-  await defaultWriter.write(path, data);
+export async function writeFileDurable(
+  path: string,
+  data: DurableData,
+  options: DurableWriteOptions = {},
+): Promise<void> {
+  await defaultWriter.write(path, data, options);
 }
 
-export async function replaceFileDurable(path: string, data: DurableData): Promise<void> {
-  await defaultWriter.replace(path, data);
+export async function replaceFileDurable(
+  path: string,
+  data: DurableData,
+  options: DurableWriteOptions = {},
+): Promise<void> {
+  await defaultWriter.replace(path, data, options);
 }

package/src/core/extension-api.ts

@@ -15,6 +15,18 @@ export const BG_TERMINAL_CHANNEL = 'pi-background-tasks:terminal:v1';
 export const BG_REQUEST_SCHEMA = 'pi-background-tasks.extension-request.v1';
 export const BG_RESPONSE_SCHEMA = 'pi-background-tasks.extension-response.v1';
 export const BG_TERMINAL_SCHEMA = 'pi-background-tasks.extension-terminal.v1';
+export const BG_EXTENSION_SERVICE_CLOSED_CODE = 'pi_background_tasks_eventbus_closed';
+
+export type BackgroundTaskExtensionServiceState = 'open' | 'closed';
+
+export class BackgroundTaskExtensionServiceClosedError extends Error {
+  readonly code = BG_EXTENSION_SERVICE_CLOSED_CODE;
+
+  constructor() {
+    super('pi-background-tasks EventBus service is closed');
+    this.name = 'BackgroundTaskExtensionServiceClosedError';
+  }
+}
 
 const MAX_ERROR_CHARS = 240;
 const MAX_REQUEST_ID_CHARS = 200;
@@ -109,6 +121,7 @@ export interface BackgroundTaskExtensionTerminal {
 }
 
 export interface BackgroundTaskExtensionService {
+  readonly state: BackgroundTaskExtensionServiceState;
   publishTerminal(task: BgTaskSnapshot): void;
   close(): void;
 }
@@ -406,7 +419,7 @@ class InstalledBackgroundTaskExtensionService implements BackgroundTaskExtension
   private readonly logger: Pick<Console, 'error'>;
   private readonly seenRequestIds = new Set<string>();
   private readonly unsubscribe: () => void;
-  private closed = false;
+  private serviceState: BackgroundTaskExtensionServiceState = 'open';
 
   constructor(options: BackgroundTaskExtensionServiceOptions) {
     this.events = options.events;
@@ -419,8 +432,16 @@ class InstalledBackgroundTaskExtensionService implements BackgroundTaskExtension
     });
   }
 
+  get state(): BackgroundTaskExtensionServiceState {
+    return this.serviceState;
+  }
+
+  private isClosed(): boolean {
+    return this.serviceState === 'closed';
+  }
+
   publishTerminal(task: BgTaskSnapshot): void {
-    if (this.closed) throw new Error('pi-background-tasks EventBus service is closed');
+    if (this.serviceState === 'closed') throw new BackgroundTaskExtensionServiceClosedError();
     const terminal: BackgroundTaskExtensionTerminal = {
       schema_version: BG_TERMINAL_SCHEMA,
       task,
@@ -429,8 +450,9 @@ class InstalledBackgroundTaskExtensionService implements BackgroundTaskExtension
   }
 
   close(): void {
-    if (this.closed) return;
-    this.closed = true;
+    if (this.serviceState === 'closed') return;
+    this.serviceState = 'closed';
+    this.registry.closeTerminalPublication('publisher_closed');
     this.unsubscribe();
   }
 
@@ -459,7 +481,7 @@ class InstalledBackgroundTaskExtensionService implements BackgroundTaskExtension
         ? createTerminalPublicationGate()
         : undefined;
     try {
-      if (this.closed) throw new Error('pi-background-tasks EventBus service is closed');
+      if (this.serviceState === 'closed') throw new BackgroundTaskExtensionServiceClosedError();
       if (this.isShuttingDown() || this.registry.isShuttingDown()) {
         throw new Error('pi-background-tasks EventBus service is shutting down');
       }
@@ -467,10 +489,16 @@ class InstalledBackgroundTaskExtensionService implements BackgroundTaskExtension
       if (ctx === undefined) {
         throw new Error('pi-background-tasks EventBus service is unavailable before session_start');
       }
-      this.emitResponse(
-        successResponse(request, await this.execute(ctx, request, terminalGate?.promise)),
-      );
+      const result = await this.execute(ctx, request, terminalGate?.promise);
+      if (this.isClosed()) return;
+      if (this.isShuttingDown() || this.registry.isShuttingDown()) {
+        throw new Error('pi-background-tasks EventBus service is shutting down');
+      }
+      this.emitResponse(successResponse(request, result));
     } catch (error) {
+      // A request accepted before close may report failure, but it must never
+      // report post-close success. Requests first emitted after close remain
+      // unhandled because the listener has already been removed.
       this.emitResponse(errorResponse(request.request_id, request.operation, error));
     } finally {
       await terminalGate?.releaseAfterResponse();

package/src/core/fusion/artifacts.ts

@@ -1,7 +1,7 @@
 import { createHash, randomBytes } from 'node:crypto';
 import { chmod, mkdir } from 'node:fs/promises';
 import { basename, isAbsolute, join, relative, sep } from 'node:path';
-import { canonicalJson, sha256Buffer } from '../attested-pi-run.js';
+import { canonicalJson, sha256Buffer } from '../canonical-json.js';
 import { sanitizePathSegment } from '../common.js';
 import { replaceFileDurable } from '../durable-fs.js';
 import {
@@ -443,7 +443,9 @@ function failureArtifactClassification(
   return 'evidence_only';
 }
 
-function failureAttemptMetadata(manifest: FusionArtifactManifest): readonly FusionFailureAttemptMetadata[] {
+function failureAttemptMetadata(
+  manifest: FusionArtifactManifest,
+): readonly FusionFailureAttemptMetadata[] {
   return manifest.attempts
     .map((attempt) => ({
       stage: attempt.stage,
@@ -452,10 +454,11 @@ function failureAttemptMetadata(manifest: FusionArtifactManifest): readonly Fusi
       status: attempt.status,
       child_created: attempt.child_created,
     }))
-    .sort((left, right) =>
-      compareArtifactText(left.stage, right.stage) ||
-      (left.slot ?? 0) - (right.slot ?? 0) ||
-      left.attempt - right.attempt,
+    .sort(
+      (left, right) =>
+        compareArtifactText(left.stage, right.stage) ||
+        (left.slot ?? 0) - (right.slot ?? 0) ||
+        left.attempt - right.attempt,
     );
 }
 
@@ -470,7 +473,9 @@ export function buildFusionFailureSummary(input: {
     (input.terminalState !== 'failed' && input.terminalState !== 'cancelled') ||
     input.manifest.state !== input.terminalState
   ) {
-    throw errorForArtifact('failure summary requires a matching failed/cancelled terminal manifest');
+    throw errorForArtifact(
+      'failure summary requires a matching failed/cancelled terminal manifest',
+    );
   }
   if (input.manifest.error !== input.terminalError.message) {
     throw errorForArtifact('failure summary terminal error does not match the durable manifest');
@@ -750,10 +755,7 @@ export class FusionArtifactStore {
    * stage-output bodies.
    */
   async writeFailureSummary(summary: FusionFailureSummaryV1): Promise<FusionArtifactRef> {
-    if (
-      this.manifest.state !== 'failed' &&
-      this.manifest.state !== 'cancelled'
-    ) {
+    if (this.manifest.state !== 'failed' && this.manifest.state !== 'cancelled') {
       throw errorForArtifact('failure summary requires a failed/cancelled terminal manifest');
     }
     if (summary.terminal_state !== this.manifest.state) {
@@ -766,10 +768,7 @@ export class FusionArtifactStore {
     ) {
       throw errorForArtifact('failure summary identity does not match the terminal manifest');
     }
-    if (
-      summary.answer?.present !== false ||
-      summary.answer.reason !== 'run_did_not_commit'
-    ) {
+    if (summary.answer?.present !== false || summary.answer.reason !== 'run_did_not_commit') {
       throw errorForArtifact('failure summary must assert that no answer was committed');
     }
     if (this.manifest.error === undefined || this.manifest.artifacts['error.json'] === undefined) {
@@ -781,7 +780,9 @@ export class FusionArtifactStore {
     ) {
       throw errorForArtifact('failure summary terminal error metadata does not match the manifest');
     }
-    if (canonicalJson(summary.progress) !== canonicalJson(buildFusionRunProgress(this.snapshot()))) {
+    if (
+      canonicalJson(summary.progress) !== canonicalJson(buildFusionRunProgress(this.snapshot()))
+    ) {
       throw errorForArtifact('failure summary progress does not match the terminal manifest');
     }
     if (canonicalJson(summary.usage_so_far) !== canonicalJson(this.manifest.usage)) {

package/src/core/fusion/clean-context.ts

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { canonicalJson } from '../attested-pi-run.js';
+import { canonicalJson } from '../canonical-json.js';
 import { normalizeFusionDeclaredSources, type DeclaredFusionSourceInput } from './source-policy.js';
 import {
   FUSION_INPUT_SCHEMA_VERSION,
@@ -47,10 +47,13 @@ export function buildFusionCleanTaskCanonicalInput(
     });
   }
   if (!['investigate', 'research', 'validate'].includes(options.workflow)) {
-    throw new FusionError('clean-task fusion input is available only to investigate, research, and validate workflows', {
-      code: 'context_capture_failed',
-      childCreated: false,
-    });
+    throw new FusionError(
+      'clean-task fusion input is available only to investigate, research, and validate workflows',
+      {
+        code: 'context_capture_failed',
+        childCreated: false,
+      },
+    );
   }
   const declaredSources = normalizeFusionDeclaredSources(options.declaredSources ?? []);
   if (options.workflow === 'research' && declaredSources.length === 0) {

package/src/core/fusion/config.ts

@@ -6,6 +6,7 @@ import type { Api, Model } from '@earendil-works/pi-ai';
 import { isJsonObject, parseJsonText, type JsonObject } from '../common.js';
 import { replaceFileDurable } from '../durable-fs.js';
 import { CLAUDE_CODE_200K_SUBSCRIPTION_CONTEXT_WINDOW } from '../anthropic-attribution.js';
+import { CURRENT_MODEL_SELECTION } from './facade-contract.js';
 import {
   FUSION_MODEL_CONFIG_SCHEMA_VERSION,
   FusionError,
@@ -19,7 +20,7 @@ import {
 } from './types.js';
 
 export const FUSION_MODEL_CONFIG_FILE = 'fusion-models.json';
-export const CURRENT_MODEL_SELECTION = '$current';
+export { CURRENT_MODEL_SELECTION } from './facade-contract.js';
 
 export interface FusionModelRegistry {
   getAll(): Model<Api>[];

package/src/core/fusion/context.ts

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { canonicalJson } from '../attested-pi-run.js';
+import { canonicalJson } from '../canonical-json.js';
 import {
   projectVisibleConversationV2,
   type OmittedRunCounts,
@@ -100,11 +100,7 @@ function policyDescriptor(source: FusionSource): FusionContextPolicyDescriptor {
 }
 
 function compactOmissionCounts(counts: OmittedRunCounts): FusionProjectionOmissionCounts {
-  return [
-    counts.assistant_thinking ?? 0,
-    counts.tool_calls ?? 0,
-    counts.tool_result_texts ?? 0,
-  ];
+  return [counts.assistant_thinking ?? 0, counts.tool_calls ?? 0, counts.tool_result_texts ?? 0];
 }
 
 function expandOmissionCounts(counts: FusionProjectionOmissionCounts): OmittedRunCounts {

package/src/core/fusion/facade-contract.ts

@@ -0,0 +1,2 @@
+/** Light registration/config sentinel that must not pull the config engine into the facade. */
+export const CURRENT_MODEL_SELECTION = '$current' as const;

package/src/core/fusion/orchestrator.ts

@@ -1,5 +1,5 @@
 import { createHash, randomBytes as nodeRandomBytes } from 'node:crypto';
-import { canonicalJson } from '../attested-pi-run.js';
+import { canonicalJson } from '../canonical-json.js';
 import { parseJsonText } from '../common.js';
 import { FUSION_BUDGET_POLICY, FusionBudget } from './budget.js';
 import { assertChildOutputWithinContract } from './output-contract.js';
@@ -841,6 +841,7 @@ export class FusionOrchestrator {
       const mergePrompt = buildMergePrompt(mergeInput);
       budget.assertStagePrompt('merge', profile.mergerSystemPrompt, mergePrompt);
       input.onProgress?.({ type: 'merge_started' });
+      // Stage policy, not caller input: evaluator and merger are always reasoning-only.
       const merged = await this.runChildWithRetry(
         input,
         store,
@@ -850,7 +851,6 @@ export class FusionOrchestrator {
         profile.mergerSystemPrompt,
         mergePrompt,
         input.signal ?? new AbortController().signal,
-        // Stage policy, not caller input: evaluator and merger are always reasoning-only.
         FUSION_NO_TOOLS_CAPABILITY,
         undefined,
         'md',
@@ -1144,6 +1144,7 @@ export class FusionOrchestrator {
     const systemPrompt = repair
       ? profile.evaluationRepairSystemPrompt
       : profile.evaluatorSystemPrompt;
+    // Stage policy, not caller input: evaluator and merger are always reasoning-only.
     const result = await this.runChildWithRetry(
       input,
       store,
@@ -1153,7 +1154,6 @@ export class FusionOrchestrator {
       systemPrompt,
       prompt,
       input.signal ?? new AbortController().signal,
-      // Stage policy, not caller input: evaluator and merger are always reasoning-only.
       FUSION_NO_TOOLS_CAPABILITY,
       undefined,
       'txt',

package/src/core/fusion/prompts.ts

@@ -1,4 +1,4 @@
-import { canonicalJson } from '../attested-pi-run.js';
+import { canonicalJson } from '../canonical-json.js';
 import { FUSION_CANDIDATE_OUTPUT_CONTRACT_INSTRUCTION } from './output-contract.js';
 import {
   FUSION_EVALUATION_SCHEMA_VERSION,