agentic-orchestrator 0.1.26 → 0.1.28

package/apps/control-plane/src/supervisor/worker-decision-loop.ts

@@ -1,9 +1,15 @@
 import { TOOLS } from '../core/constants.js';
 import { ERROR_CODES } from '../core/error-codes.js';
-import type { WorkerProvider } from '../providers/providers.js';
+import type { ExecutionMode, WorkerProvider, WorkerRunInput } from '../providers/providers.js';
 import type { RuntimeRole, SupervisorToolCaller } from './types.js';
 import type { ActivityMonitorService } from '../application/services/activity-monitor-service.js';
 import { appendWorkerRuntimeEvent } from './worker-event-journal.js';
+import type {
+  CheckpointRecord,
+  CheckpointService,
+  InteractiveExecutionConfig,
+} from '../application/services/checkpoint-service.js';
+import type { WorktreeWatchdogService } from '../application/services/worktree-watchdog-service.js';
 
 type AnyRecord = Record<string, unknown>;
 const PLAN_TOP_LEVEL_KEYS = new Set([
@@ -125,6 +131,19 @@ interface WorkerDecisionLoopDependencies {
   activityMonitor?: ActivityMonitorService;
   repoRoot?: string;
   runId?: string | (() => string);
+  resolveExecutionMode?: (featureId: string, role: RuntimeRole) => Promise<ExecutionMode>;
+  resolveInteractiveConfig?: () => InteractiveExecutionConfig;
+  watchdog?: WorktreeWatchdogService;
+  checkpointService?: CheckpointService;
+  resolveWorktreePath?: (featureId: string) => string;
+  resolveRoleSessionId?: (role: RuntimeRole, featureId: string) => string | null;
+}
+
+interface InteractiveRunSummary {
+  workerOutput: Record<string, unknown>;
+  finalCheckpoint: CheckpointRecord;
+  changedFiles: string[];
+  checkpointInvalid: boolean;
 }
 
 export class WorkerDecisionLoop implements WorkerDecisionRunner {
@@ -133,6 +152,16 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
   private readonly activityMonitor: ActivityMonitorService | undefined;
   private readonly repoRoot: string | null;
   private readonly runId: string | (() => string) | null;
+  private readonly resolveExecutionModeOverride:
+    | ((featureId: string, role: RuntimeRole) => Promise<ExecutionMode>)
+    | undefined;
+  private readonly resolveInteractiveConfigOverride: (() => InteractiveExecutionConfig) | undefined;
+  private readonly watchdog: WorktreeWatchdogService | undefined;
+  private readonly checkpointService: CheckpointService | undefined;
+  private readonly resolveWorktreePath: ((featureId: string) => string) | undefined;
+  private readonly resolveRoleSessionId:
+    | ((role: RuntimeRole, featureId: string) => string | null)
+    | undefined;
 
   constructor(dependencies: WorkerDecisionLoopDependencies) {
     this.provider = dependencies.provider;
@@ -140,6 +169,12 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
     this.activityMonitor = dependencies.activityMonitor;
     this.repoRoot = dependencies.repoRoot ?? null;
     this.runId = dependencies.runId ?? null;
+    this.resolveExecutionModeOverride = dependencies.resolveExecutionMode;
+    this.resolveInteractiveConfigOverride = dependencies.resolveInteractiveConfig;
+    this.watchdog = dependencies.watchdog;
+    this.checkpointService = dependencies.checkpointService;
+    this.resolveWorktreePath = dependencies.resolveWorktreePath;
+    this.resolveRoleSessionId = dependencies.resolveRoleSessionId;
   }
 
   async execute(input: WorkerDecisionInput): Promise<WorkerDecisionResult> {
@@ -147,6 +182,27 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
     if (typeof this.provider.runWorker !== 'function') {
       return result;
     }
+    const requestedExecutionMode = await this.resolveExecutionMode(input.featureId, input.role);
+    const interactiveEligible = this.isInteractiveEligible(requestedExecutionMode, input.role);
+    const executionMode: ExecutionMode =
+      requestedExecutionMode === 'interactive' && interactiveEligible
+        ? 'interactive'
+        : 'deterministic';
+    if (requestedExecutionMode === 'interactive' && !interactiveEligible) {
+      await this.appendWorkerEvent({
+        eventType: 'interactive_fallback',
+        featureId: input.featureId,
+        role: input.role,
+        outputTypes: [],
+        patchCount: 0,
+        planSubmissionCount: 0,
+        requestCount: 0,
+        noteCount: 0,
+        valid: true,
+        errorCode: null,
+        executionMode,
+      });
+    }
     await this.appendWorkerEvent({
       eventType: 'worker_started',
       featureId: input.featureId,
@@ -158,22 +214,20 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       noteCount: 0,
       valid: true,
       errorCode: null,
+      executionMode,
     });
 
     let workerOutput: Record<string, unknown>;
+    let interactiveSummary: InteractiveRunSummary | null = null;
     try {
-      workerOutput = await this.provider.runWorker({
-        role: input.role,
-        feature_id: input.featureId,
-        context_bundle: input.contextBundle,
-        instructions: input.instructions,
-        last_tool_results: input.lastToolResults ?? [],
-        runtime_selection: {
-          provider: this.provider.selection.provider,
-          model: this.provider.selection.model,
-          provider_config_ref: this.provider.selection.provider_config_ref,
-        },
-      });
+      if (interactiveEligible) {
+        interactiveSummary = await this.runInteractiveWorker(input);
+        workerOutput = interactiveSummary.workerOutput;
+      } else {
+        workerOutput = await this.provider.runWorker(
+          this.buildRunInput(input, executionMode, undefined),
+        );
+      }
     } catch (error) {
       const typed = error as { code?: string; details?: Record<string, unknown> };
       const errorCode =
@@ -216,6 +270,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
         signal: typeof typed.details?.signal === 'string' ? typed.details.signal : null,
         exitCode:
           typeof typed.details?.exit_code === 'number' ? typed.details.exit_code : undefined,
+        executionMode,
       });
       throw error;
     }
@@ -246,7 +301,14 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       }
       if (outputType === 'PATCH') {
         patchCount += 1;
-        await this.routePatch(input, output, result);
+        if (interactiveSummary) {
+          const hasPatchPayload = Boolean(asNonEmptyString(output.unified_diff ?? output.diff));
+          if (hasPatchPayload) {
+            result.patchApplied = true;
+          }
+        } else {
+          await this.routePatch(input, output, result);
+        }
         continue;
       }
       if (outputType === 'NOTE') {
@@ -260,6 +322,18 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       }
     }
 
+    if (interactiveSummary) {
+      result.toolResults.push({
+        checkpoint: structuredClone(interactiveSummary.finalCheckpoint),
+      });
+      if (interactiveSummary.changedFiles.length > 0) {
+        result.patchApplied = true;
+      }
+      if (interactiveSummary.checkpointInvalid) {
+        result.invalidOutput = true;
+      }
+    }
+
     const hasProgress = result.planSubmission || result.patchApplied || result.requestHandled;
     result.noProgress = !hasProgress;
 
@@ -274,6 +348,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       noteCount,
       valid: !result.invalidOutput,
       errorCode: result.invalidOutput ? ERROR_CODES.PROVIDER_OUTPUT_INVALID : null,
+      executionMode,
     });
 
     if (this.activityMonitor) {
@@ -283,6 +358,168 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
     return result;
   }
 
+  private async resolveExecutionMode(featureId: string, role: RuntimeRole): Promise<ExecutionMode> {
+    if (this.resolveExecutionModeOverride) {
+      return await this.resolveExecutionModeOverride(featureId, role);
+    }
+    return 'deterministic';
+  }
+
+  private isInteractiveEligible(executionMode: ExecutionMode, role: RuntimeRole): boolean {
+    if (executionMode !== 'interactive') {
+      return false;
+    }
+    if (role !== 'builder' && role !== 'qa') {
+      return false;
+    }
+    if (!this.repoRoot || !this.watchdog || !this.checkpointService || !this.resolveWorktreePath) {
+      return false;
+    }
+    const capabilities = this.provider.getCapabilities?.();
+    if (!capabilities) {
+      return true;
+    }
+    return capabilities.supportsInteractiveMode && capabilities.supportsWorkingDirectory;
+  }
+
+  private resolveInteractiveConfig(): InteractiveExecutionConfig {
+    if (this.resolveInteractiveConfigOverride) {
+      return this.resolveInteractiveConfigOverride();
+    }
+    return {
+      checkpointIntervalMs: 30_000,
+      watchdogPollIntervalMs: 2_000,
+      maxUncommittedChanges: 50,
+      validationOnCheckpoint: true,
+      revertOnViolation: false,
+      violationSeverity: 'warning',
+    };
+  }
+
+  private buildRunInput(
+    input: WorkerDecisionInput,
+    executionMode: ExecutionMode,
+    workingDirectory: string | undefined,
+  ): WorkerRunInput {
+    return {
+      role: input.role,
+      feature_id: input.featureId,
+      context_bundle: input.contextBundle,
+      instructions: input.instructions,
+      last_tool_results: input.lastToolResults ?? [],
+      runtime_selection: {
+        provider: this.provider.selection.provider,
+        model: this.provider.selection.model,
+        provider_config_ref: this.provider.selection.provider_config_ref,
+      },
+      execution_mode: executionMode,
+      working_directory: workingDirectory,
+      pause_resume_protocol: 'none',
+    };
+  }
+
+  private async runInteractiveWorker(input: WorkerDecisionInput): Promise<InteractiveRunSummary> {
+    if (!this.repoRoot || !this.watchdog || !this.checkpointService || !this.resolveWorktreePath) {
+      const fallbackOutput = await this.provider.runWorker(
+        this.buildRunInput(input, 'deterministic', undefined),
+      );
+      return {
+        workerOutput: fallbackOutput,
+        finalCheckpoint: this.createSyntheticCheckpoint(input.featureId),
+        changedFiles: [],
+        checkpointInvalid: false,
+      };
+    }
+
+    const interactiveConfig = this.resolveInteractiveConfig();
+    const worktreePath = this.resolveWorktreePath(input.featureId);
+    const sessionId = this.resolveRoleSessionId?.(input.role, input.featureId) ?? null;
+    await this.watchdog.startWatching({
+      featureId: input.featureId,
+      repoRoot: this.repoRoot,
+      worktreePath,
+      pollIntervalMs: interactiveConfig.watchdogPollIntervalMs,
+      maxUncommittedChanges: interactiveConfig.maxUncommittedChanges,
+    });
+
+    let latestCheckpoint: CheckpointRecord | null = null;
+    let checkpointInvalid = false;
+    let lastCheckpointAt = 0;
+    const checkpointDebounceMs = 5_000;
+    let checkpointQueue = Promise.resolve();
+
+    const enqueueCheckpoint = (
+      trigger: 'interval' | 'change_threshold' | 'final',
+    ): Promise<void> => {
+      checkpointQueue = checkpointQueue.then(async () => {
+        const now = Date.now();
+        if (trigger !== 'final' && now - lastCheckpointAt < checkpointDebounceMs) {
+          return;
+        }
+        try {
+          const checkpoint = await this.checkpointService?.createCheckpoint({
+            featureId: input.featureId,
+            sessionId,
+            trigger,
+          });
+          if (checkpoint) {
+            latestCheckpoint = checkpoint.checkpoint;
+            checkpointInvalid = checkpointInvalid || !checkpoint.valid || checkpoint.blockMerge;
+          }
+        } catch {
+          checkpointInvalid = true;
+        } finally {
+          lastCheckpointAt = Date.now();
+        }
+      });
+      checkpointQueue = checkpointQueue.catch(() => undefined);
+      return checkpointQueue;
+    };
+
+    const thresholdListener = (featureId: string): void => {
+      if (featureId !== input.featureId) {
+        return;
+      }
+      void enqueueCheckpoint('change_threshold');
+    };
+
+    this.watchdog.on('changeThreshold', thresholdListener);
+    const timer = setInterval(() => {
+      void enqueueCheckpoint('interval');
+    }, interactiveConfig.checkpointIntervalMs);
+    timer.unref?.();
+
+    try {
+      const workerOutput = await this.provider.runWorker(
+        this.buildRunInput(input, 'interactive', worktreePath),
+      );
+      await enqueueCheckpoint('final');
+      const changedFiles = latestCheckpoint?.files_changed ?? [];
+      return {
+        workerOutput,
+        finalCheckpoint: latestCheckpoint ?? this.createSyntheticCheckpoint(input.featureId),
+        changedFiles,
+        checkpointInvalid,
+      };
+    } finally {
+      clearInterval(timer);
+      this.watchdog.off('changeThreshold', thresholdListener);
+      await checkpointQueue.catch(() => undefined);
+      await this.watchdog.stopWatching(input.featureId);
+    }
+  }
+
+  private createSyntheticCheckpoint(featureId: string): CheckpointRecord {
+    return {
+      checkpoint_id: `checkpoint-synthetic-${Date.now()}`,
+      timestamp: new Date().toISOString(),
+      files_changed: [],
+      validation_status: 'skipped',
+      violations: [],
+      diff_snapshot: `.aop/features/${featureId}/checkpoints/synthetic.diff`,
+    };
+  }
+
   private async routePlanSubmission(
     input: WorkerDecisionInput,
     output: AnyRecord,
@@ -464,6 +701,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
     eventType: string;
     featureId: string;
     role: RuntimeRole;
+    executionMode?: ExecutionMode;
     outputTypes: string[];
     patchCount: number;
     planSubmissionCount: number;
@@ -492,6 +730,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       role: event.role,
       phase: 'execution',
       event_type: event.eventType,
+      execution_mode: event.executionMode ?? 'deterministic',
       output_types: event.outputTypes,
       patch_count: event.patchCount,
       plan_submission_count: event.planSubmissionCount,