agentic-orchestrator 0.1.6 → 0.1.7

package/apps/control-plane/src/providers/providers.ts

@@ -52,7 +52,7 @@ function parseAgentConfigJson(raw: string, source: 'cli' | 'env'): Record<string
       reason: 'Invalid agent config JSON',
       source,
       value: raw,
-      parse_error: error instanceof Error ? error.message : String(error)
+      parse_error: error instanceof Error ? error.message : String(error),
     });
   }
 
@@ -60,7 +60,7 @@ function parseAgentConfigJson(raw: string, source: 'cli' | 'env'): Record<string
     throw invalidAgentConfigError({
       reason: 'Agent config JSON must be an object',
       source,
-      value: raw
+      value: raw,
     });
   }
 
@@ -69,7 +69,7 @@ function parseAgentConfigJson(raw: string, source: 'cli' | 'env'): Record<string
 
 function resolveConfiguredAgentConfig(
   provider: string,
-  runtime: ResolveSelectionRuntimeConfig
+  runtime: ResolveSelectionRuntimeConfig,
 ): Record<string, unknown> | null {
   if (!runtime) {
     return null;
@@ -93,16 +93,10 @@ export type ProviderSelectionResolver = (input: ResolveSelectionInput) => Provid
 
 export const resolveProviderSelection: ProviderSelectionResolver = ({ cli, env, agentsConfig }) => {
   const provider =
-    cli.agent_provider ||
-    env.AOP_AGENT_PROVIDER ||
-    agentsConfig?.runtime?.default_provider ||
-    null;
+    cli.agent_provider || env.AOP_AGENT_PROVIDER || agentsConfig?.runtime?.default_provider || null;
 
   const model =
-    cli.agent_model ||
-    env.AOP_AGENT_MODEL ||
-    agentsConfig?.runtime?.default_model ||
-    null;
+    cli.agent_model || env.AOP_AGENT_MODEL || agentsConfig?.runtime?.default_model || null;
 
   const providerConfigEnv =
     cli.provider_config_env ||
@@ -123,15 +117,12 @@ export const resolveProviderSelection: ProviderSelectionResolver = ({ cli, env,
     throw error;
   }
 
-  if (
-    AUTH_REQUIRED_PROVIDERS.has(provider) &&
-    (!providerConfigEnv || !env[providerConfigEnv])
-  ) {
+  if (AUTH_REQUIRED_PROVIDERS.has(provider) && (!providerConfigEnv || !env[providerConfigEnv])) {
     const error = new Error(ERROR_CODES.PROVIDER_AUTH_MISSING) as AppError;
     error.code = ERROR_CODES.PROVIDER_AUTH_MISSING;
     error.details = {
       provider,
-      provider_config_env: providerConfigEnv
+      provider_config_env: providerConfigEnv,
     };
     throw error;
   }
@@ -149,8 +140,8 @@ export const resolveProviderSelection: ProviderSelectionResolver = ({ cli, env,
     provider,
     model: model ?? `${provider}-default`,
     provider_config_env: providerConfigEnv,
-    provider_config_ref: providerConfigEnv ? env[providerConfigEnv] ?? null : null,
-    agent_config: agentConfig
+    provider_config_ref: providerConfigEnv ? (env[providerConfigEnv] ?? null) : null,
+    agent_config: agentConfig,
   };
 };
 
@@ -163,7 +154,11 @@ export interface WorkerSession {
 
 export interface WorkerProvider {
   selection: ProviderSelection;
-  createSession(role: string, featureId: string, systemPrompt: string | null): Promise<WorkerSession>;
+  createSession(
+    role: string,
+    featureId: string,
+    systemPrompt: string | null,
+  ): Promise<WorkerSession>;
   reattachSession(sessionId: string): Promise<WorkerSession | null>;
   closeSession(sessionId: string): Promise<{ closed: true }>;
   runWorker(input: {
@@ -197,23 +192,31 @@ export interface ProviderCommandRunnerOptions {
 }
 
 export interface ProviderCommandRunner {
-  run(command: string, args: string[], options?: ProviderCommandRunnerOptions): Promise<ProviderCommandResult>;
+  run(
+    command: string,
+    args: string[],
+    options?: ProviderCommandRunnerOptions,
+  ): Promise<ProviderCommandResult>;
 }
 
 export class NodeProviderCommandRunner implements ProviderCommandRunner {
-  async run(command: string, args: string[], options: ProviderCommandRunnerOptions = {}): Promise<ProviderCommandResult> {
+  async run(
+    command: string,
+    args: string[],
+    options: ProviderCommandRunnerOptions = {},
+  ): Promise<ProviderCommandResult> {
     return await new Promise<ProviderCommandResult>((resolve) => {
       let child;
       try {
         child = spawn(command, args, {
           env: options.env,
-          stdio: options.interactive ? 'inherit' : ['pipe', 'pipe', 'pipe']
+          stdio: options.interactive ? 'inherit' : ['pipe', 'pipe', 'pipe'],
         });
       } catch {
         resolve({
           exitCode: 127,
           signal: null,
-          errorCode: 'ENOENT'
+          errorCode: 'ENOENT',
         });
         return;
       }
@@ -244,7 +247,7 @@ export class NodeProviderCommandRunner implements ProviderCommandRunner {
         resolve({
           exitCode: code ?? (spawnErrorCode === 'ENOENT' ? 127 : 1),
           signal,
-          errorCode: spawnErrorCode
+          errorCode: spawnErrorCode,
         });
       });
     });
@@ -276,7 +279,7 @@ function readStringArray(value: unknown): string[] | null {
 function resolveTemplateFromAgentConfig(
   agentConfig: Record<string, unknown> | null | undefined,
   kind: 'attach' | 'send',
-  fallback: ProviderCommandTemplate | undefined
+  fallback: ProviderCommandTemplate | undefined,
 ): ProviderCommandTemplate | undefined {
   const nested = agentConfig?.[kind];
   const nestedRecord = isPlainObject(nested) ? nested : null;
@@ -307,24 +310,34 @@ function resolveProviderCommands(selection: ProviderSelection): ProviderCliComma
   const defaults: Record<string, ProviderCliCommands> = {
     codex: {
       attach: { command: 'codex', args: ['chat', '--session', '{session_id}'] },
-      send: { command: 'codex', args: ['chat', '--session', '{session_id}', '--message', '{message}'] }
+      send: {
+        command: 'codex',
+        args: ['chat', '--session', '{session_id}', '--message', '{message}'],
+      },
     },
     claude: {
       attach: { command: 'claude-code', args: ['chat', '--session', '{session_id}'] },
-      send: { command: 'claude-code', args: ['chat', '--session', '{session_id}', '--message', '{message}'] }
-    }
+      send: {
+        command: 'claude-code',
+        args: ['chat', '--session', '{session_id}', '--message', '{message}'],
+      },
+    },
   };
 
   const defaultsForProvider = defaults[selection.provider] ?? {};
   return {
-    attach: resolveTemplateFromAgentConfig(selection.agent_config, 'attach', defaultsForProvider.attach),
-    send: resolveTemplateFromAgentConfig(selection.agent_config, 'send', defaultsForProvider.send)
+    attach: resolveTemplateFromAgentConfig(
+      selection.agent_config,
+      'attach',
+      defaultsForProvider.attach,
+    ),
+    send: resolveTemplateFromAgentConfig(selection.agent_config, 'send', defaultsForProvider.send),
   };
 }
 
 function applyCommandArgsTemplate(
   args: string[],
-  values: { sessionId: string; message?: string }
+  values: { sessionId: string; message?: string },
 ): string[] {
   return args.map((arg) => {
     if (arg === '{session_id}') {
@@ -341,7 +354,7 @@ function commandFailureError(
   provider: string,
   capability: 'attach' | 'send',
   details: Record<string, unknown>,
-  code: string
+  code: string,
 ): AppError {
   const error = new Error(`${provider} provider ${capability} failed`) as AppError;
   error.code = code;
@@ -374,17 +387,21 @@ export class NullWorkerProvider implements WorkerProvider {
       this.getSessionInfo = (sessionId: string) =>
         Promise.resolve({
           active: Boolean(sessionId) && sessionId !== 'unknown' && sessionId !== 'unassigned',
-          provider: this.selection.provider
+          provider: this.selection.provider,
         });
     }
   }
 
-  createSession(role: string, featureId: string, systemPrompt: string | null): Promise<WorkerSession> {
+  createSession(
+    role: string,
+    featureId: string,
+    systemPrompt: string | null,
+  ): Promise<WorkerSession> {
     return Promise.resolve({
       session_id: `${role}-${featureId}-${crypto.randomUUID()}`,
       role,
       feature_id: featureId,
-      system_prompt_loaded: Boolean(systemPrompt)
+      system_prompt_loaded: Boolean(systemPrompt),
     });
   }
   reattachSession(sessionId: string): Promise<WorkerSession | null> {
@@ -395,7 +412,7 @@ export class NullWorkerProvider implements WorkerProvider {
       session_id: sessionId,
       role: 'orchestrator',
       feature_id: 'global',
-      system_prompt_loaded: false
+      system_prompt_loaded: false,
     });
   }
   closeSession(_sessionId: string): Promise<{ closed: true }> {
@@ -405,7 +422,7 @@ export class NullWorkerProvider implements WorkerProvider {
   runWorker({
     role,
     feature_id,
-    context_bundle
+    context_bundle,
   }: {
     role: string;
     feature_id: string;
@@ -421,9 +438,7 @@ export class NullWorkerProvider implements WorkerProvider {
     if (role === 'planner') {
       const state = context_bundle?.state;
       const frontMatter =
-        state && typeof state === 'object'
-          ? (state as Record<string, unknown>).front_matter
-          : null;
+        state && typeof state === 'object' ? (state as Record<string, unknown>).front_matter : null;
       const status =
         frontMatter && typeof frontMatter === 'object'
           ? (frontMatter as Record<string, unknown>).status
@@ -432,32 +447,36 @@ export class NullWorkerProvider implements WorkerProvider {
         type: 'NOTE',
         content: `Planner session active for ${feature_id}.`,
         context_snapshot: {
-          status: typeof status === 'string' ? status : 'unknown'
-        }
+          status: typeof status === 'string' ? status : 'unknown',
+        },
       });
     }
 
     return Promise.resolve({
       type: 'NOTE',
-      content: `${role} session active for ${feature_id}.`
+      content: `${role} session active for ${feature_id}.`,
     });
   }
 
-  private async executeCommand(kind: 'attach' | 'send', sessionId: string, message?: string): Promise<void> {
+  private async executeCommand(
+    kind: 'attach' | 'send',
+    sessionId: string,
+    message?: string,
+  ): Promise<void> {
     const template = kind === 'attach' ? this.commands.attach : this.commands.send;
     if (!template) {
       throw commandFailureError(
         this.selection.provider,
         kind,
         { reason: `Provider ${this.selection.provider} does not support ${kind}` },
-        ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER
+        ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER,
       );
     }
 
     const args = applyCommandArgsTemplate(template.args, { sessionId, message });
     const result = await this.commandRunner.run(template.command, args, {
       interactive: kind === 'attach',
-      timeoutMs: kind === 'send' ? 15_000 : undefined
+      timeoutMs: kind === 'send' ? 15_000 : undefined,
     });
 
     if (result.exitCode === 0) {
@@ -469,10 +488,15 @@ export class NullWorkerProvider implements WorkerProvider {
       args,
       exit_code: result.exitCode,
       signal: result.signal,
-      error_code: result.errorCode
+      error_code: result.errorCode,
     };
     if (result.exitCode === 127 || result.errorCode === 'ENOENT') {
-      throw commandFailureError(this.selection.provider, kind, details, ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER);
+      throw commandFailureError(
+        this.selection.provider,
+        kind,
+        details,
+        ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER,
+      );
     }
     throw commandFailureError(this.selection.provider, kind, details, ERROR_CODES.INTERNAL_ERROR);
   }

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

@@ -1,7 +1,10 @@
 import { GATE_RESULT, STATUS, TOOLS } from '../core/constants.js';
 import type { FeatureStatePayload, SupervisorToolCaller } from './types.js';
 import { NOOP_WORKER_DECISION_RUNNER, type WorkerDecisionRunner } from './worker-decision-loop.js';
-import type { GateRepairContext, ReactionsService } from '../application/services/reactions-service.js';
+import type {
+  GateRepairContext,
+  ReactionsService,
+} from '../application/services/reactions-service.js';
 
 interface GatesRunData {
   overall?: string;
@@ -28,9 +31,13 @@ export class BuildWaveExecutor {
   async run(featureIds: string[], maxParallelGateRuns: number): Promise<void> {
     const batch: string[] = [];
     for (const featureId of featureIds) {
-      const state = await this.toolCaller.callTool<FeatureStatePayload>('builder', TOOLS.FEATURE_STATE_GET, {
-        feature_id: featureId
-      });
+      const state = await this.toolCaller.callTool<FeatureStatePayload>(
+        'builder',
+        TOOLS.FEATURE_STATE_GET,
+        {
+          feature_id: featureId,
+        },
+      );
 
       if (state.data.front_matter.status === STATUS.BUILDING) {
         batch.push(featureId);
@@ -40,21 +47,25 @@ export class BuildWaveExecutor {
     const selected = batch.slice(0, maxParallelGateRuns);
     for (const featureId of selected) {
       const context = await this.toolCaller.callTool('builder', TOOLS.FEATURE_GET_CONTEXT, {
-        feature_id: featureId
+        feature_id: featureId,
       });
       await this.workerDecisionRunner.execute({
         role: 'builder',
         featureId,
         contextBundle: context.data,
         instructions:
-          'Emit PATCH outputs for code changes, NOTE outputs for progress context, and REQUEST outputs for lock/context needs.'
+          'Emit PATCH outputs for code changes, NOTE outputs for progress context, and REQUEST outputs for lock/context needs.',
       });
     }
 
     const executing = selected.map(async (featureId) => {
-      const stateForRetry = await this.toolCaller.callTool<FeatureStatePayload>('builder', TOOLS.FEATURE_STATE_GET, {
-        feature_id: featureId
-      });
+      const stateForRetry = await this.toolCaller.callTool<FeatureStatePayload>(
+        'builder',
+        TOOLS.FEATURE_STATE_GET,
+        {
+          feature_id: featureId,
+        },
+      );
       const initialRetryCount = stateForRetry.data.front_matter.gate_retry_count ?? 0;
 
       let gateOverall: string;
@@ -64,11 +75,15 @@ export class BuildWaveExecutor {
       const failureHistory: GateRepairContext['failureHistory'] = [];
 
       try {
-        const gateResult = await this.toolCaller.callTool<GatesRunData>('builder', TOOLS.GATES_RUN, {
-          feature_id: featureId,
-          profile: null,
-          mode: 'fast'
-        });
+        const gateResult = await this.toolCaller.callTool<GatesRunData>(
+          'builder',
+          TOOLS.GATES_RUN,
+          {
+            feature_id: featureId,
+            profile: null,
+            mode: 'fast',
+          },
+        );
         gateOverall = gateResult.data.overall ?? GATE_RESULT.PASS;
         gateExitCode = gateOverall === GATE_RESULT.FAIL ? 1 : 0;
         gateEvidencePath = gateResult.data.evidence_path ?? '';
@@ -87,13 +102,13 @@ export class BuildWaveExecutor {
           evidence_summary: gateEvidencePath,
           logs_excerpt: gateLogs.slice(0, 800),
           failed_at: new Date().toISOString(),
-          retry_delay_ms: this.reactionsService?.retryDelayMs()
+          retry_delay_ms: this.reactionsService?.retryDelayMs(),
         });
       }
 
       if (this.reactionsService && gateOverall === GATE_RESULT.FAIL) {
         const context = await this.toolCaller.callTool('builder', TOOLS.FEATURE_GET_CONTEXT, {
-          feature_id: featureId
+          feature_id: featureId,
         });
         let retryCount = initialRetryCount;
         const retryDelayMs = this.reactionsService.retryDelayMs();
@@ -109,22 +124,26 @@ export class BuildWaveExecutor {
             logs: gateLogs,
             evidenceSummary: gateEvidencePath,
             retryCount,
-            failureHistory
+            failureHistory,
           };
           const repairPrompt = this.reactionsService.buildRepairPrompt(ctx);
           await this.workerDecisionRunner.execute({
             role: 'builder',
             featureId,
             contextBundle: context.data,
-            instructions: repairPrompt
+            instructions: repairPrompt,
           });
 
           try {
-            const retryResult = await this.toolCaller.callTool<GatesRunData>('builder', TOOLS.GATES_RUN, {
-              feature_id: featureId,
-              profile: null,
-              mode: 'fast'
-            });
+            const retryResult = await this.toolCaller.callTool<GatesRunData>(
+              'builder',
+              TOOLS.GATES_RUN,
+              {
+                feature_id: featureId,
+                profile: null,
+                mode: 'fast',
+              },
+            );
             gateOverall = retryResult.data.overall ?? GATE_RESULT.PASS;
             gateExitCode = gateOverall === GATE_RESULT.FAIL ? 1 : 0;
             gateEvidencePath = retryResult.data.evidence_path ?? gateEvidencePath;
@@ -147,7 +166,7 @@ export class BuildWaveExecutor {
               evidence_summary: gateEvidencePath,
               logs_excerpt: gateLogs.slice(0, 800),
               failed_at: new Date().toISOString(),
-              retry_delay_ms: retryDelayMs
+              retry_delay_ms: retryDelayMs,
             });
           }
 
@@ -164,7 +183,7 @@ export class BuildWaveExecutor {
             logs: gateLogs,
             evidenceSummary: gateEvidencePath,
             retryCount,
-            failureHistory
+            failureHistory,
           };
           await this.reactionsService.notifyEscalation(featureId, escalateCtx);
         }

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

@@ -1,9 +1,5 @@
 import { STATUS, TOOLS } from '../core/constants.js';
-import type {
-  FeatureContextPayload,
-  InitialPlanGenerator,
-  SupervisorToolCaller
-} from './types.js';
+import type { FeatureContextPayload, InitialPlanGenerator, SupervisorToolCaller } from './types.js';
 import { NOOP_WORKER_DECISION_RUNNER, type WorkerDecisionRunner } from './worker-decision-loop.js';
 
 type AnyRecord = Record<string, unknown>;
@@ -78,7 +74,7 @@ function deriveEdgeCaseChecklist(specText: string): string[] {
   const checklist = [
     'Edge-case: boundary values and size limits are covered.',
     'Edge-case: negative-path input validation and error handling are covered.',
-    'Edge-case: dependency failure and retry behavior are covered.'
+    'Edge-case: dependency failure and retry behavior are covered.',
   ];
 
   const normalizedSpec = specText.toLowerCase();
@@ -123,9 +119,13 @@ export class PlanningWaveExecutor {
 
   async run(featureIds: string[]): Promise<void> {
     for (const featureId of featureIds) {
-      const context = await this.toolCaller.callTool<FeatureContextPayload>('planner', TOOLS.FEATURE_GET_CONTEXT, {
-        feature_id: featureId
-      });
+      const context = await this.toolCaller.callTool<FeatureContextPayload>(
+        'planner',
+        TOOLS.FEATURE_GET_CONTEXT,
+        {
+          feature_id: featureId,
+        },
+      );
 
       const state = context.data.state.front_matter;
       if (state.status !== STATUS.PLANNING && state.status !== STATUS.BLOCKED) {
@@ -138,7 +138,7 @@ export class PlanningWaveExecutor {
         featureId,
         contextBundle: asRecord(context.data),
         instructions:
-          'Review feature context and emit PLAN_SUBMISSION/REQUEST/NOTE outputs to advance planning deterministically.'
+          'Review feature context and emit PLAN_SUBMISSION/REQUEST/NOTE outputs to advance planning deterministically.',
       });
 
       if (decision.planSubmission || existingPlan) {
@@ -148,16 +148,20 @@ export class PlanningWaveExecutor {
       const plan = await this.planGenerator.generateInitialPlan(featureId);
       await this.toolCaller.callTool('planner', TOOLS.PLAN_SUBMIT, {
         feature_id: featureId,
-        plan_json: plan
+        plan_json: plan,
       });
     }
   }
 
   async runPostQaReconciliation(featureIds: string[], iteration: number): Promise<void> {
     for (const featureId of featureIds) {
-      const context = await this.toolCaller.callTool<FeatureContextPayload>('planner', TOOLS.FEATURE_GET_CONTEXT, {
-        feature_id: featureId
-      });
+      const context = await this.toolCaller.callTool<FeatureContextPayload>(
+        'planner',
+        TOOLS.FEATURE_GET_CONTEXT,
+        {
+          feature_id: featureId,
+        },
+      );
 
       const frontMatter = asRecord(asRecord(context.data.state).front_matter);
       const status = readStatus(frontMatter.status);
@@ -172,7 +176,7 @@ export class PlanningWaveExecutor {
           iteration,
           decision: 'no_update',
           reasons: ['missing_plan'],
-          status
+          status,
         });
         continue;
       }
@@ -184,7 +188,7 @@ export class PlanningWaveExecutor {
           iteration,
           decision: 'no_update',
           reasons: ['existing_plan_version_invalid'],
-          status
+          status,
         });
         continue;
       }
@@ -199,7 +203,7 @@ export class PlanningWaveExecutor {
           reasons: decision.reasons,
           qa_summary: decision.qaSummary,
           latest_gate_overall: decision.latestGateOverall,
-          edge_case_checklist: decision.edgeCaseChecklist
+          edge_case_checklist: decision.edgeCaseChecklist,
         });
         continue;
       }
@@ -208,7 +212,7 @@ export class PlanningWaveExecutor {
       await this.toolCaller.callTool('planner', TOOLS.PLAN_UPDATE, {
         feature_id: featureId,
         expected_plan_version: planVersion,
-        plan_json: nextPlan
+        plan_json: nextPlan,
       });
 
       await this.appendDecisionLog(featureId, {
@@ -222,7 +226,7 @@ export class PlanningWaveExecutor {
         reasons: decision.reasons,
         qa_summary: decision.qaSummary,
         latest_gate_overall: decision.latestGateOverall,
-        edge_case_checklist: decision.edgeCaseChecklist
+        edge_case_checklist: decision.edgeCaseChecklist,
       });
     }
   }
@@ -230,7 +234,7 @@ export class PlanningWaveExecutor {
   private evaluateReconciliationDecision(
     context: FeatureContextPayload,
     plan: AnyRecord,
-    status: string
+    status: string,
   ): ReconciliationDecision {
     const acceptanceCriteria = asStringArray(plan.acceptance_criteria);
     const riskItems = asStringArray(plan.risk);
@@ -240,9 +244,10 @@ export class PlanningWaveExecutor {
     const pending = readCount(qaSummary, 'pending');
     const failed = readCount(qaSummary, 'failed');
     const running = readCount(qaSummary, 'running');
-    const latestGateOverall = typeof asRecord(context.latest_evidence).overall === 'string'
-      ? String(asRecord(context.latest_evidence).overall)
-      : null;
+    const latestGateOverall =
+      typeof asRecord(context.latest_evidence).overall === 'string'
+        ? String(asRecord(context.latest_evidence).overall)
+        : null;
 
     const reasons: string[] = [];
     const acceptanceCriteriaAdditions: string[] = [];
@@ -251,16 +256,17 @@ export class PlanningWaveExecutor {
     if (missingEdgeCases.length > 0) {
       reasons.push(`edge_case_checklist_missing:${missingEdgeCases.length}`);
       acceptanceCriteriaAdditions.push(
-        'Planner edge-case checklist has been reviewed and incorporated into the execution plan.'
+        'Planner edge-case checklist has been reviewed and incorporated into the execution plan.',
       );
     }
 
-    const hasQaSignals = status === STATUS.BLOCKED || failed > 0 || pending > 0 || latestGateOverall === 'fail';
+    const hasQaSignals =
+      status === STATUS.BLOCKED || failed > 0 || pending > 0 || latestGateOverall === 'fail';
     const qaCheckpoint = `Planner reconciliation checkpoint [status=${status};failed=${failed};pending=${pending};latest=${latestGateOverall ?? 'unknown'}]`;
     if (hasQaSignals && !acceptanceCriteria.includes(qaCheckpoint)) {
       reasons.push(`qa_signals_detected:${status}:failed=${failed}:pending=${pending}`);
       acceptanceCriteriaAdditions.push(
-        'Reconcile QA/gate findings against plan scope and apply corrective updates before merge.'
+        'Reconcile QA/gate findings against plan scope and apply corrective updates before merge.',
       );
       acceptanceCriteriaAdditions.push(qaCheckpoint);
     }
@@ -274,9 +280,9 @@ export class PlanningWaveExecutor {
         qaSummary: {
           pending,
           failed,
-          running
+          running,
         },
-        latestGateOverall
+        latestGateOverall,
       };
     }
 
@@ -288,13 +294,17 @@ export class PlanningWaveExecutor {
       qaSummary: {
         pending,
         failed,
-        running
+        running,
       },
-      latestGateOverall
+      latestGateOverall,
     };
   }
 
-  private buildUpdatedPlan(plan: AnyRecord, planVersion: number, decision: ReconciliationDecision): AnyRecord {
+  private buildUpdatedPlan(
+    plan: AnyRecord,
+    planVersion: number,
+    decision: ReconciliationDecision,
+  ): AnyRecord {
     const nextPlan = structuredClone(plan);
     const acceptanceCriteria = asStringArray(nextPlan.acceptance_criteria);
     const riskItems = asStringArray(nextPlan.risk);
@@ -302,7 +312,10 @@ export class PlanningWaveExecutor {
     nextPlan.plan_version = planVersion + 1;
     nextPlan.revision_of = planVersion;
     nextPlan.revision_reason = decision.reasons.join('; ');
-    nextPlan.acceptance_criteria = normalizeList([...acceptanceCriteria, ...decision.acceptanceCriteriaAdditions]);
+    nextPlan.acceptance_criteria = normalizeList([
+      ...acceptanceCriteria,
+      ...decision.acceptanceCriteriaAdditions,
+    ]);
     nextPlan.risk = normalizeList([...riskItems, ...decision.edgeCaseChecklist]);
     return nextPlan;
   }
@@ -310,7 +323,7 @@ export class PlanningWaveExecutor {
   private async appendDecisionLog(featureId: string, note: AnyRecord): Promise<void> {
     await this.toolCaller.callTool('orchestrator', TOOLS.FEATURE_LOG_APPEND, {
       feature_id: featureId,
-      note: JSON.stringify(note)
+      note: JSON.stringify(note),
     });
   }
 }

package/apps/control-plane/src/supervisor/prompt-bundle-loader.ts

@@ -23,7 +23,7 @@ export class PromptBundleLoader implements AgentPromptProvider {
     const prompts: PromptBundle = {
       planner: null,
       builder: null,
-      qa: null
+      qa: null,
     };
 
     for (const role of ['planner', 'builder', 'qa'] as const) {