agentic-orchestrator 0.1.13 → 0.1.15

package/apps/control-plane/src/supervisor/qa-wave-executor.ts

@@ -1,4 +1,5 @@
 import { GATE_RESULT, STATUS, TOOLS } from '../core/constants.js';
+import { ERROR_CODES } from '../core/error-codes.js';
 import type { WorkerProvider } from '../providers/providers.js';
 import type {
   AgentPromptProvider,
@@ -14,6 +15,11 @@ import type {
   GateRepairContext,
   ReactionsService,
 } from '../application/services/reactions-service.js';
+import type {
+  WorkerMalformedOutputAction,
+  WorkerNoProgressAction,
+  WorkerProviderMode,
+} from '../providers/worker-provider-factory.js';
 
 interface GatesRunData {
   overall?: string;
@@ -29,6 +35,10 @@ interface QaWaveExecutorDependencies {
   state: SupervisorRuntimeState;
   workerDecisionRunner?: WorkerDecisionRunner;
   reactionsService?: ReactionsService;
+  providerMode?: WorkerProviderMode;
+  noProgressLimit?: number;
+  noProgressAction?: WorkerNoProgressAction;
+  malformedOutputAction?: WorkerMalformedOutputAction;
 }
 
 function isRetryableToolError(error: unknown): boolean {
@@ -42,6 +52,13 @@ function isRetryableToolError(error: unknown): boolean {
   return (details as { retryable?: unknown }).retryable === true;
 }
 
+function asVersion(value: unknown): number | null {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    return null;
+  }
+  return Math.floor(value);
+}
+
 export class QaWaveExecutor {
   private readonly kernel: FeatureOrchestrationPort;
   private readonly provider: WorkerProvider;
@@ -51,6 +68,12 @@ export class QaWaveExecutor {
   private readonly state: SupervisorRuntimeState;
   private readonly workerDecisionRunner: WorkerDecisionRunner;
   private readonly reactionsService: ReactionsService | undefined;
+  private readonly providerMode: WorkerProviderMode;
+  private readonly noProgressLimit: number;
+  private readonly noProgressAction: WorkerNoProgressAction;
+  private readonly malformedOutputAction: WorkerMalformedOutputAction;
+  private readonly noProgressByFeature = new Map<string, number>();
+  private readonly blockedForCurrentCycle = new Set<string>();
 
   constructor(dependencies: QaWaveExecutorDependencies) {
     this.kernel = dependencies.kernel;
@@ -61,9 +84,17 @@ export class QaWaveExecutor {
     this.state = dependencies.state;
     this.workerDecisionRunner = dependencies.workerDecisionRunner ?? NOOP_WORKER_DECISION_RUNNER;
     this.reactionsService = dependencies.reactionsService;
+    this.providerMode = dependencies.providerMode ?? 'stub';
+    this.noProgressLimit =
+      typeof dependencies.noProgressLimit === 'number' && dependencies.noProgressLimit > 0
+        ? Math.floor(dependencies.noProgressLimit)
+        : 2;
+    this.noProgressAction = dependencies.noProgressAction ?? 'block_feature';
+    this.malformedOutputAction = dependencies.malformedOutputAction ?? 'block_feature';
   }
 
   async run(featureIds: string[], maxParallelGateRuns: number): Promise<void> {
+    this.blockedForCurrentCycle.clear();
     const batch: string[] = [];
     for (const featureId of featureIds) {
       const state = await this.toolCaller.callTool<FeatureStatePayload>(
@@ -83,13 +114,18 @@ export class QaWaveExecutor {
       const context = await this.toolCaller.callTool('qa', TOOLS.FEATURE_GET_CONTEXT, {
         feature_id: featureId,
       });
-      await this.workerDecisionRunner.execute({
+      const decision = await this.workerDecisionRunner.execute({
         role: 'qa',
         featureId,
         contextBundle: context.data,
         instructions:
           'Emit PATCH outputs for deterministic QA remediations, NOTE outputs for findings, and REQUEST outputs for lock/context needs.',
       });
+      const shouldSkip = await this.enforceWorkerExecutionPolicy(featureId, decision, 'qa');
+      if (shouldSkip) {
+        continue;
+      }
+      this.noProgressByFeature.delete(featureId);
 
       const stateForRetry = await this.toolCaller.callTool<FeatureStatePayload>(
         'qa',
@@ -154,12 +190,21 @@ export class QaWaveExecutor {
             failureHistory,
           };
           const repairPrompt = this.reactionsService.buildRepairPrompt(ctx);
-          await this.workerDecisionRunner.execute({
+          const repairDecision = await this.workerDecisionRunner.execute({
             role: 'qa',
             featureId,
             contextBundle: context.data,
             instructions: repairPrompt,
           });
+          const shouldSkipRepair = await this.enforceWorkerExecutionPolicy(
+            featureId,
+            repairDecision,
+            'qa',
+          );
+          if (shouldSkipRepair) {
+            break;
+          }
+          this.noProgressByFeature.delete(featureId);
 
           try {
             const retryResult = await this.toolCaller.callTool<GatesRunData>(
@@ -246,4 +291,101 @@ export class QaWaveExecutor {
       });
     }
   }
+
+  private async enforceWorkerExecutionPolicy(
+    featureId: string,
+    decision: {
+      invalidOutput: boolean;
+      noProgress: boolean;
+    },
+    phase: 'qa',
+  ): Promise<boolean> {
+    if (this.providerMode !== 'live') {
+      this.noProgressByFeature.delete(featureId);
+      return false;
+    }
+
+    if (decision.invalidOutput) {
+      await this.applyWorkerPolicyAction(
+        featureId,
+        this.malformedOutputAction,
+        ERROR_CODES.PROVIDER_OUTPUT_INVALID,
+        'QA emitted malformed worker outputs',
+        phase,
+      );
+      this.blockedForCurrentCycle.add(featureId);
+      return true;
+    }
+
+    if (!decision.noProgress) {
+      this.noProgressByFeature.delete(featureId);
+      return false;
+    }
+
+    const currentCount = (this.noProgressByFeature.get(featureId) ?? 0) + 1;
+    this.noProgressByFeature.set(featureId, currentCount);
+    this.blockedForCurrentCycle.add(featureId);
+    if (currentCount < this.noProgressLimit) {
+      return true;
+    }
+
+    await this.applyWorkerPolicyAction(
+      featureId,
+      this.noProgressAction,
+      ERROR_CODES.PROVIDER_NO_PROGRESS,
+      `QA made no actionable progress in ${currentCount} consecutive iterations`,
+      phase,
+    );
+    return true;
+  }
+
+  private async applyWorkerPolicyAction(
+    featureId: string,
+    action: WorkerNoProgressAction | WorkerMalformedOutputAction,
+    errorCode: string,
+    message: string,
+    phase: 'qa',
+  ): Promise<void> {
+    if (action === 'fail_run') {
+      const error = new Error(message) as Error & {
+        code?: string;
+        details?: Record<string, unknown>;
+      };
+      error.code = errorCode;
+      error.details = {
+        feature_id: featureId,
+        retryable: false,
+        requires_human: true,
+      };
+      throw error;
+    }
+
+    const state = await this.toolCaller.callTool<FeatureStatePayload>(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_GET,
+      {
+        feature_id: featureId,
+      },
+    );
+    const expectedVersion = asVersion(state.data.front_matter.version);
+    await this.toolCaller.callTool('orchestrator', TOOLS.FEATURE_STATE_PATCH, {
+      feature_id: featureId,
+      expected_version: expectedVersion,
+      patch: {
+        front_matter: {
+          status: STATUS.BLOCKED,
+          status_reason: `${errorCode}: ${message}`,
+        },
+      },
+    });
+    await this.toolCaller.callTool('orchestrator', TOOLS.FEATURE_LOG_APPEND, {
+      feature_id: featureId,
+      note: JSON.stringify({
+        phase,
+        decision: 'blocked',
+        error_code: errorCode,
+        reason: message,
+      }),
+    });
+  }
 }

package/apps/control-plane/src/supervisor/runtime.ts

@@ -16,6 +16,11 @@ import { ReactionsService } from '../application/services/reactions-service.js';
 import { ActivityMonitorService } from '../application/services/activity-monitor-service.js';
 import { PrMonitorService, createGhRunner } from '../application/services/pr-monitor-service.js';
 import { createIssueTracker } from '../application/services/issue-tracker-service.js';
+import {
+  resolveMalformedWorkerOutputAction,
+  resolveNoProgressAction,
+  resolveWorkerProviderRuntime,
+} from '../providers/worker-provider-factory.js';
 import {
   globalAdapterRegistry,
   NOTIFICATION_CHANNEL_SLOT,
@@ -190,23 +195,38 @@ export class SupervisorRuntime
         ? (rawIssueTrackerConfig as { type: string; config?: Record<string, string> })
         : undefined;
     const issueTracker = createIssueTracker(issueTrackerConfig);
+    const workerRuntimeConfig = resolveWorkerProviderRuntime(this.kernel.getAgentsConfig().runtime);
+    const executionPolicy =
+      policy.execution && typeof policy.execution === 'object'
+        ? (policy.execution as Record<string, unknown>)
+        : null;
 
     this.workerDecisionLoop = new WorkerDecisionLoop({
       provider: this.provider,
       toolCaller: this,
       activityMonitor,
+      repoRoot: this.kernel.getRepoRoot(),
+      runId: () => this.state.runId,
     });
 
     this.planningWaveExecutor = new PlanningWaveExecutor({
       toolCaller: this,
       planGenerator: this,
       workerDecisionRunner: this.workerDecisionLoop,
+      providerMode: this.provider.mode,
+      noProgressLimit: workerRuntimeConfig.max_consecutive_no_progress_iterations,
+      noProgressAction: resolveNoProgressAction(executionPolicy),
+      malformedOutputAction: resolveMalformedWorkerOutputAction(executionPolicy),
     });
 
     this.buildWaveExecutor = new BuildWaveExecutor({
       toolCaller: this,
       workerDecisionRunner: this.workerDecisionLoop,
       reactionsService,
+      providerMode: this.provider.mode,
+      noProgressLimit: workerRuntimeConfig.max_consecutive_no_progress_iterations,
+      noProgressAction: resolveNoProgressAction(executionPolicy),
+      malformedOutputAction: resolveMalformedWorkerOutputAction(executionPolicy),
     });
 
     this.qaWaveExecutor = new QaWaveExecutor({
@@ -218,6 +238,10 @@ export class SupervisorRuntime
       state: this.state,
       workerDecisionRunner: this.workerDecisionLoop,
       reactionsService,
+      providerMode: this.provider.mode,
+      noProgressLimit: workerRuntimeConfig.max_consecutive_no_progress_iterations,
+      noProgressAction: resolveNoProgressAction(executionPolicy),
+      malformedOutputAction: resolveMalformedWorkerOutputAction(executionPolicy),
     });
 
     this.leaseHeartbeatService = new LeaseHeartbeatService({

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

@@ -1,4 +1,7 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
 import { TOOLS } from '../core/constants.js';
+import { ERROR_CODES } from '../core/error-codes.js';
 import type { WorkerProvider } from '../providers/providers.js';
 import type { RuntimeRole, SupervisorToolCaller } from './types.js';
 import type { ActivityMonitorService } from '../application/services/activity-monitor-service.js';
@@ -18,6 +21,9 @@ export interface WorkerDecisionResult {
   patchApplied: boolean;
   noteLogged: boolean;
   requestHandled: boolean;
+  invalidOutput: boolean;
+  noProgress: boolean;
+  outputTypes: string[];
   priorityOrder: string[];
   toolResults: AnyRecord[];
 }
@@ -73,6 +79,9 @@ function makeEmptyResult(): WorkerDecisionResult {
     patchApplied: false,
     noteLogged: false,
     requestHandled: false,
+    invalidOutput: false,
+    noProgress: false,
+    outputTypes: [],
     priorityOrder: [],
     toolResults: [],
   };
@@ -86,17 +95,23 @@ interface WorkerDecisionLoopDependencies {
   provider: WorkerProvider;
   toolCaller: SupervisorToolCaller;
   activityMonitor?: ActivityMonitorService;
+  repoRoot?: string;
+  runId?: string | (() => string);
 }
 
 export class WorkerDecisionLoop implements WorkerDecisionRunner {
   private readonly provider: WorkerProvider;
   private readonly toolCaller: SupervisorToolCaller;
   private readonly activityMonitor: ActivityMonitorService | undefined;
+  private readonly repoRoot: string | null;
+  private readonly runId: string | (() => string) | null;
 
   constructor(dependencies: WorkerDecisionLoopDependencies) {
     this.provider = dependencies.provider;
     this.toolCaller = dependencies.toolCaller;
     this.activityMonitor = dependencies.activityMonitor;
+    this.repoRoot = dependencies.repoRoot ?? null;
+    this.runId = dependencies.runId ?? null;
   }
 
   async execute(input: WorkerDecisionInput): Promise<WorkerDecisionResult> {
@@ -105,43 +120,93 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       return result;
     }
 
-    const 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,
-      },
-    });
+    let workerOutput: Record<string, unknown>;
+    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,
+        },
+      });
+    } catch (error) {
+      const typed = error as { code?: string };
+      await this.appendWorkerEvent({
+        featureId: input.featureId,
+        role: input.role,
+        outputTypes: [],
+        patchCount: 0,
+        planSubmissionCount: 0,
+        requestCount: 0,
+        noteCount: 0,
+        valid: false,
+        errorCode:
+          typeof typed.code === 'string' && typed.code.length > 0
+            ? typed.code
+            : ERROR_CODES.PROVIDER_RUNTIME_UNAVAILABLE,
+      });
+      throw error;
+    }
 
     const outputs = asOutputs(workerOutput);
+    const allowedTypes = new Set(['PLAN_SUBMISSION', 'PATCH', 'NOTE', 'REQUEST']);
+    let planSubmissionCount = 0;
+    let patchCount = 0;
+    let requestCount = 0;
+    let noteCount = 0;
     for (const output of outputs) {
       const outputType = asNonEmptyString(output.type)?.toUpperCase();
       if (!outputType) {
+        result.invalidOutput = true;
+        continue;
+      }
+      result.outputTypes.push(outputType);
+      if (!allowedTypes.has(outputType)) {
+        result.invalidOutput = true;
         continue;
       }
 
       if (outputType === 'PLAN_SUBMISSION') {
+        planSubmissionCount += 1;
         await this.routePlanSubmission(input, output, result);
         continue;
       }
       if (outputType === 'PATCH') {
+        patchCount += 1;
         await this.routePatch(input, output, result);
         continue;
       }
       if (outputType === 'NOTE') {
+        noteCount += 1;
         await this.routeNote(input.featureId, output, result);
         continue;
       }
       if (outputType === 'REQUEST') {
+        requestCount += 1;
         await this.routeRequest(input, output, result);
       }
     }
 
+    const hasProgress = result.planSubmission || result.patchApplied || result.requestHandled;
+    result.noProgress = !hasProgress;
+
+    await this.appendWorkerEvent({
+      featureId: input.featureId,
+      role: input.role,
+      outputTypes: result.outputTypes,
+      patchCount,
+      planSubmissionCount,
+      requestCount,
+      noteCount,
+      valid: !result.invalidOutput,
+      errorCode: result.invalidOutput ? ERROR_CODES.PROVIDER_OUTPUT_INVALID : null,
+    });
+
     if (this.activityMonitor) {
       await this.activityMonitor.checkAndNotifyStuck(input.featureId);
     }
@@ -314,4 +379,61 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       result.planSubmission = true;
     }
   }
+
+  private resolveRunId(): string {
+    if (typeof this.runId === 'function') {
+      const value = this.runId();
+      return value && value.length > 0 ? value : `run:unknown:${Date.now()}`;
+    }
+    if (typeof this.runId === 'string' && this.runId.length > 0) {
+      return this.runId;
+    }
+    return `run:unknown:${Date.now()}`;
+  }
+
+  private sanitizeRunId(runId: string): string {
+    return runId.replace(/[^a-zA-Z0-9._:-]/g, '_');
+  }
+
+  private async appendWorkerEvent(event: {
+    featureId: string;
+    role: RuntimeRole;
+    outputTypes: string[];
+    patchCount: number;
+    planSubmissionCount: number;
+    requestCount: number;
+    noteCount: number;
+    valid: boolean;
+    errorCode: string | null;
+  }): Promise<void> {
+    if (!this.repoRoot) {
+      return;
+    }
+    const runId = this.resolveRunId();
+    const workerEventsDir = path.join(this.repoRoot, '.aop', 'runtime', 'worker-events');
+    const filePath = path.join(workerEventsDir, `${this.sanitizeRunId(runId)}.jsonl`);
+
+    const payload = {
+      ts: new Date().toISOString(),
+      run_id: runId,
+      feature_id: event.featureId,
+      role: event.role,
+      output_types: event.outputTypes,
+      patch_count: event.patchCount,
+      plan_submission_count: event.planSubmissionCount,
+      request_count: event.requestCount,
+      note_count: event.noteCount,
+      valid: event.valid,
+      error_code: event.errorCode,
+      provider: this.provider.selection.provider,
+      model: this.provider.selection.model,
+    };
+
+    try {
+      await fs.mkdir(workerEventsDir, { recursive: true });
+      await fs.appendFile(filePath, `${JSON.stringify(payload)}\n`, 'utf8');
+    } catch {
+      // Diagnostic logging is best-effort and must not alter wave behavior.
+    }
+  }
 }

package/apps/control-plane/test/cli.unit.spec.ts

@@ -97,6 +97,10 @@ vi.mock('../src/core/kernel.js', () => {
       return {};
     }
 
+    getPolicySnapshot() {
+      return {};
+    }
+
     async readIndex() {
       return await readIndexMock();
     }
@@ -124,6 +128,7 @@ vi.mock('../src/mcp/runtime-factory.js', () => ({
 
 vi.mock('../src/providers/providers.js', () => ({
   resolveProviderSelection: resolveProviderSelectionMock,
+  SUPPORTED_PROVIDERS: new Set(['codex', 'claude', 'gemini', 'custom', 'kiro-cli', 'copilot']),
   NullWorkerProvider: class NullWorkerProvider {
     selection: unknown;
 
@@ -133,6 +138,37 @@ vi.mock('../src/providers/providers.js', () => ({
   },
 }));
 
+vi.mock('../src/providers/worker-provider-factory.js', () => ({
+  DefaultWorkerProviderFactory: class DefaultWorkerProviderFactory {
+    create(input: { selection: unknown }) {
+      return {
+        mode: 'live',
+        selection: input.selection,
+        async createSession() {
+          return { session_id: 'mock-session' };
+        },
+        async reattachSession() {
+          return null;
+        },
+        async closeSession() {
+          return { closed: true };
+        },
+        async runWorker() {
+          return { outputs: [{ type: 'NOTE', content: 'mock' }] };
+        },
+      };
+    }
+  },
+  resolveWorkerProviderMode: vi.fn((_cliMode, _configuredMode, fallback) => fallback ?? 'live'),
+  resolveWorkerProviderPolicy: vi.fn(() => ({ require_live_provider_for_run: true })),
+  resolveWorkerProviderRuntime: vi.fn(() => ({
+    worker_response_timeout_ms: 120000,
+    max_consecutive_no_progress_iterations: 2,
+  })),
+  resolveMalformedWorkerOutputAction: vi.fn(() => 'block_feature'),
+  resolveNoProgressAction: vi.fn(() => 'block_feature'),
+}));
+
 vi.mock('../src/supervisor/runtime.js', () => {
   class SupervisorRuntime {
     private readonly options: unknown;

package/apps/control-plane/test/dashboard-api.integration.spec.ts

@@ -190,7 +190,7 @@ describe('dashboard api integration', () => {
         method: 'POST',
         body: JSON.stringify({ action: 'checkout', stash_changes: false }),
       }),
-      { params: { id: 'feature_checkout' } },
+      { params: Promise.resolve({ id: 'feature_checkout' }) },
     );
     const checkoutBody = (await checkoutResponse.json()) as {
       ok: boolean;
@@ -208,7 +208,7 @@ describe('dashboard api integration', () => {
         method: 'POST',
         body: JSON.stringify({ action: 'restore' }),
       }),
-      { params: { id: 'feature_checkout' } },
+      { params: Promise.resolve({ id: 'feature_checkout' }) },
     );
     const restoreBody = (await restoreResponse.json()) as {
       ok: boolean;

package/apps/control-plane/test/resume-command.spec.ts

@@ -2,10 +2,11 @@ import { describe, it, expect, vi } from 'vitest';
 
 vi.mock('../src/providers/providers.js', () => ({
   resolveProviderSelection: vi.fn(() => ({
-    provider: 'null',
+    provider: 'custom',
     model: 'none',
     provider_config_ref: null,
   })),
+  SUPPORTED_PROVIDERS: new Set(['codex', 'claude', 'gemini', 'custom', 'kiro-cli', 'copilot']),
   NullWorkerProvider: class NullWorkerProvider {
     selection: unknown;
 
@@ -27,6 +28,35 @@ vi.mock('../src/providers/providers.js', () => ({
   },
 }));
 
+vi.mock('../src/providers/worker-provider-factory.js', () => ({
+  DefaultWorkerProviderFactory: class DefaultWorkerProviderFactory {
+    create(input: { selection: unknown }) {
+      return {
+        mode: 'live',
+        selection: input.selection,
+        async createSession() {
+          return { session_id: 'mock-session' };
+        },
+        async reattachSession() {
+          return null;
+        },
+        async closeSession() {
+          return { closed: true };
+        },
+        async runWorker() {
+          return { outputs: [{ type: 'NOTE', content: 'mock' }] };
+        },
+      };
+    }
+  },
+  resolveWorkerProviderMode: vi.fn(() => 'live'),
+  resolveWorkerProviderPolicy: vi.fn(() => ({ require_live_provider_for_run: true })),
+  resolveWorkerProviderRuntime: vi.fn(() => ({
+    worker_response_timeout_ms: 120000,
+    max_consecutive_no_progress_iterations: 2,
+  })),
+}));
+
 vi.mock('../src/supervisor/runtime.js', () => ({
   SupervisorRuntime: class SupervisorRuntime {
     async start(features: unknown[]) {

package/apps/control-plane/test/worker-decision-loop.spec.ts

@@ -41,6 +41,9 @@ describe('WorkerDecisionLoop', () => {
       patchApplied: false,
       noteLogged: false,
       requestHandled: false,
+      invalidOutput: false,
+      noProgress: false,
+      outputTypes: [],
       priorityOrder: [],
       toolResults: [],
     });