pi-background-tasks 0.7.7 → 0.9.0

package/src/core/fusion/orchestrator.ts

@@ -13,10 +13,6 @@ import {
 } from './evaluation.js';
 import { FusionChildRunError, runPiChild, type RunPiChildOptions } from './pi-child.js';
 import {
-  FUSION_CANDIDATE_SYSTEM_PROMPT,
-  FUSION_EVALUATION_REPAIR_SYSTEM_PROMPT,
-  FUSION_EVALUATOR_SYSTEM_PROMPT,
-  FUSION_MERGER_SYSTEM_PROMPT,
   buildBlindEvaluationInput,
   buildCandidatePrompt,
   buildEvaluationPrompt,
@@ -26,11 +22,18 @@ import {
   type AnonymousFusionCandidate,
 } from './prompts.js';
 import {
+  FUSION_BRAINSTORM_WORKFLOW,
+  resolveWorkflowCapability,
+  type FusionWorkflowProfile,
+} from './workflows.js';
+import {
+  FUSION_DEFAULT_CAPABILITY,
   FUSION_RESULT_SCHEMA_VERSION,
   FusionError,
   addFusionUsage,
   createEmptyFusionUsage,
   type FusionCalibrationViolation,
+  type FusionCapability,
   type FusionCanonicalInputV3,
   type FusionCandidateId,
   type FusionContextOmissionLedgerV2,
@@ -62,6 +65,9 @@ export interface FusionWorkflowInput {
   contextLedger: FusionContextOmissionLedgerV2;
   config: FusionModelConfigV1;
   models: ResolvedFusionModels;
+  candidateCapability?: FusionCapability | undefined;
+  /** Stage framing and capability policy. Defaults to the brainstorm workflow. */
+  profile?: FusionWorkflowProfile | undefined;
   signal?: AbortSignal | undefined;
   onProgress?: FusionProgressSink | undefined;
 }
@@ -179,21 +185,25 @@ function childOptions(
   model: ResolvedFusionModel,
   stage: FusionStage,
   attempt: number,
+  capability: FusionCapability,
   systemPrompt: string,
   userPrompt: string,
   signal: AbortSignal,
   slot?: CandidateSlot,
+  toolCallLogPath?: string,
 ): RunPiChildOptions {
   const out: RunPiChildOptions = {
     stage,
     attempt,
     cwd: input.cwd,
     model,
+    capability,
     systemPrompt,
     userPrompt,
     signal,
   };
   if (slot !== undefined) out.slot = slot;
+  if (toolCallLogPath !== undefined) out.toolCallLogPath = toolCallLogPath;
   return out;
 }
 
@@ -324,11 +334,22 @@ export class FusionOrchestrator {
   }
 
   async run(input: FusionWorkflowInput): Promise<FusionRunResult> {
+    const profile = input.profile ?? FUSION_BRAINSTORM_WORKFLOW;
+    // Workflow policy, not caller input: a fixed-capability workflow rejects each
+    // other capability here, before a single child exists, rather than silently
+    // substituting its own and running a review that never read the code.
+    const candidateCapability = resolveWorkflowCapability(profile, input.candidateCapability);
     const storeOptions: CreateFusionArtifactStoreOptions = {
       cwd: input.cwd,
+      profile,
       source: input.source,
       config: input.config,
       models: input.models,
+      capabilities: {
+        candidate: candidateCapability,
+        evaluation: FUSION_DEFAULT_CAPABILITY,
+        merge: FUSION_DEFAULT_CAPABILITY,
+      },
     };
     if (input.sessionId !== undefined) storeOptions.sessionId = input.sessionId;
     if (this.now !== undefined) storeOptions.now = this.now;
@@ -344,6 +365,8 @@ export class FusionOrchestrator {
       const budget = new FusionBudget(
         input.models,
         input.canonicalInput.conversation_projection.policy.id,
+        candidateCapability,
+        profile,
       );
       const budgetPlan = budget.plan(input.canonicalInput);
       await store.writeBudgetPlan(budgetPlan);
@@ -363,6 +386,8 @@ export class FusionOrchestrator {
         usage,
         budget,
         calibrationWarnings,
+        profile,
+        candidateCapability,
       );
       await store.transition('candidates_complete');
       input.onProgress?.({ type: 'state', state: 'candidates_complete' });
@@ -381,6 +406,7 @@ export class FusionOrchestrator {
         blindInput,
         budget,
         calibrationWarnings,
+        profile,
       );
       await store.writeEvaluationJson(evaluation);
       await store.transition('evaluation_complete');
@@ -390,7 +416,7 @@ export class FusionOrchestrator {
       input.onProgress?.({ type: 'state', state: 'merging' });
       const mergeInput = buildMergeInput(input.canonicalInput, shuffled.candidates, evaluation);
       const mergePrompt = buildMergePrompt(mergeInput);
-      budget.assertStagePrompt('merge', FUSION_MERGER_SYSTEM_PROMPT, mergePrompt);
+      budget.assertStagePrompt('merge', profile.mergerSystemPrompt, mergePrompt);
       input.onProgress?.({ type: 'merge_started' });
       const merged = await this.runChildWithRetry(
         input,
@@ -398,9 +424,11 @@ export class FusionOrchestrator {
         usage,
         input.models.merger,
         'merge',
-        FUSION_MERGER_SYSTEM_PROMPT,
+        profile.mergerSystemPrompt,
         mergePrompt,
         input.signal ?? new AbortController().signal,
+        // Stage policy, not caller input: evaluator and merger are always reasoning-only.
+        FUSION_DEFAULT_CAPABILITY,
         undefined,
         'md',
       );
@@ -412,7 +440,7 @@ export class FusionOrchestrator {
         budget,
         calibrationWarnings,
         'merge',
-        FUSION_MERGER_SYSTEM_PROMPT,
+        profile.mergerSystemPrompt,
         mergePrompt,
         merged,
       );
@@ -426,6 +454,7 @@ export class FusionOrchestrator {
         details: {
           schema_version: FUSION_RESULT_SCHEMA_VERSION,
           run_id: store.runId,
+          workflow: profile.id,
           source: input.source,
           status: 'completed',
           artifact_dir: store.artifactDir,
@@ -480,14 +509,17 @@ export class FusionOrchestrator {
     usage: FusionUsage,
     budget: FusionBudget,
     calibrationWarnings: FusionCalibrationViolation[],
+    profile: FusionWorkflowProfile,
+    candidateCapability: FusionCapability,
   ): Promise<readonly CandidateResult[]> {
     const controller = new AbortController();
     const abortListener = () => controller.abort();
     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] as const) {
-      budget.assertStagePrompt('candidate', FUSION_CANDIDATE_SYSTEM_PROMPT, prompt, slot);
+      budget.assertStagePrompt('candidate', systemPrompt, prompt, slot);
     }
     let primaryError: unknown;
     let completed = 0;
@@ -507,9 +539,10 @@ export class FusionOrchestrator {
           usage,
           model,
           'candidate',
-          FUSION_CANDIDATE_SYSTEM_PROMPT,
+          systemPrompt,
           prompt,
           controller.signal,
+          candidateCapability,
           slot,
           'md',
         ).then(async (result) => {
@@ -520,7 +553,7 @@ export class FusionOrchestrator {
             budget,
             calibrationWarnings,
             'candidate',
-            FUSION_CANDIDATE_SYSTEM_PROMPT,
+            systemPrompt,
             prompt,
             result,
             slot,
@@ -562,9 +595,10 @@ export class FusionOrchestrator {
     blindInput: Parameters<typeof buildEvaluationPrompt>[0],
     budget: FusionBudget,
     calibrationWarnings: FusionCalibrationViolation[],
+    profile: FusionWorkflowProfile,
   ): Promise<FusionEvaluationV1> {
     const firstPrompt = buildEvaluationPrompt(blindInput);
-    budget.assertStagePrompt('evaluation', FUSION_EVALUATOR_SYSTEM_PROMPT, firstPrompt);
+    budget.assertStagePrompt('evaluation', profile.evaluatorSystemPrompt, firstPrompt);
     const first = await this.runEvaluationAttempt(
       input,
       store,
@@ -574,6 +608,7 @@ export class FusionOrchestrator {
       firstPrompt,
       1,
       false,
+      profile,
     );
     if (first.evaluation !== undefined) return first.evaluation;
     const errors = boundedEvaluationErrors(first.errors);
@@ -586,7 +621,7 @@ export class FusionOrchestrator {
     });
     budget.assertStagePrompt(
       'evaluation_repair',
-      FUSION_EVALUATION_REPAIR_SYSTEM_PROMPT,
+      profile.evaluationRepairSystemPrompt,
       repairPrompt,
     );
     const second = await this.runEvaluationAttempt(
@@ -598,6 +633,7 @@ export class FusionOrchestrator {
       repairPrompt,
       2,
       true,
+      profile,
     );
     if (second.evaluation !== undefined) return second.evaluation;
     throw new FusionError(
@@ -619,11 +655,12 @@ export class FusionOrchestrator {
     prompt: string,
     attempt: 1 | 2,
     repair: boolean,
+    profile: FusionWorkflowProfile,
   ): Promise<EvaluationAttemptResult> {
     input.onProgress?.({ type: 'evaluation_started', attempt, repair });
     const systemPrompt = repair
-      ? FUSION_EVALUATION_REPAIR_SYSTEM_PROMPT
-      : FUSION_EVALUATOR_SYSTEM_PROMPT;
+      ? profile.evaluationRepairSystemPrompt
+      : profile.evaluatorSystemPrompt;
     const result = await this.runChildWithRetry(
       input,
       store,
@@ -633,6 +670,8 @@ export class FusionOrchestrator {
       systemPrompt,
       prompt,
       input.signal ?? new AbortController().signal,
+      // Stage policy, not caller input: evaluator and merger are always reasoning-only.
+      FUSION_DEFAULT_CAPABILITY,
       undefined,
       'txt',
       attempt,
@@ -700,6 +739,7 @@ export class FusionOrchestrator {
     systemPrompt: string,
     userPrompt: string,
     signal: AbortSignal,
+    capability: FusionCapability,
     slot: CandidateSlot | undefined,
     responseKind: 'md' | 'txt',
     fixedAttempt?: 1 | 2,
@@ -709,9 +749,24 @@ export class FusionOrchestrator {
       if (stage === 'candidate' && slot !== undefined) {
         input.onProgress?.({ type: 'candidate_started', slot, attempt: logicalAttempt });
       }
+      const toolCallLogPath =
+        capability !== 'reason'
+          ? store.childToolCallLogPath(stage, slot, logicalAttempt)
+          : undefined;
       try {
         return await this.childRunner(
-          childOptions(input, model, stage, logicalAttempt, systemPrompt, userPrompt, signal, slot),
+          childOptions(
+            input,
+            model,
+            stage,
+            logicalAttempt,
+            capability,
+            systemPrompt,
+            userPrompt,
+            signal,
+            slot,
+            toolCallLogPath,
+          ),
         );
       } catch (error) {
         if (!signal.aborted && retryableSpawn(error, launchTry) && launchTry === 1) continue;