agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/src/supervisor/run-coordinator.ts

@@ -6,7 +6,7 @@ import type {
   FeatureOrchestrationPort,
   RuntimeStateReader,
   SupervisorRuntimeState,
-  SupervisorToolCaller
+  SupervisorToolCaller,
 } from './types.js';
 import { type SessionOrchestrator } from './session-orchestrator.js';
 import { type PlanningWaveExecutor } from './planning-wave-executor.js';
@@ -59,7 +59,11 @@ export class RunCoordinator {
   private readonly prMonitor: PrMonitorService | undefined;
   private readonly issueTracker: IssueTracker | undefined;
   private readonly statusCache: Map<string, string>;
-  private static readonly TERMINAL_STATUSES = new Set<string>([STATUS.MERGED, STATUS.FAILED, STATUS.PAUSED_BUDGET]);
+  private static readonly TERMINAL_STATUSES = new Set<string>([
+    STATUS.MERGED,
+    STATUS.FAILED,
+    STATUS.PAUSED_BUDGET,
+  ]);
 
   constructor(dependencies: RunCoordinatorDependencies) {
     this.kernel = dependencies.kernel;
@@ -93,7 +97,7 @@ export class RunCoordinator {
       provider: this.provider.selection.provider,
       model: this.provider.selection.model,
       provider_config_ref_hash: this.providerConfigRefHash(),
-      takeover_stale_run: this.takeoverStaleRun
+      takeover_stale_run: this.takeoverStaleRun,
     });
 
     this.state.runMetadata.took_over_stale = Boolean(leaseResult.data.took_over_stale);
@@ -109,7 +113,7 @@ export class RunCoordinator {
     await this.kernel.pruneFeatureSessionAssignments({
       run_id: this.state.runId,
       owner_instance_id: this.state.ownerInstanceId,
-      active_feature_ids: scopedFeatureIds
+      active_feature_ids: scopedFeatureIds,
     });
 
     activeFeatureIds = await this.rebalanceActiveFeatures(activeFeatureIds);
@@ -119,7 +123,10 @@ export class RunCoordinator {
         break;
       }
       await this.leaseHeartbeatService.renew();
-      activeFeatureIds = await this.applyOrchestratorPrioritization(activeFeatureIds, iteration + 1);
+      activeFeatureIds = await this.applyOrchestratorPrioritization(
+        activeFeatureIds,
+        iteration + 1,
+      );
       // N3: Check budget before waves; pause over-budget features
       activeFeatureIds = await this.pauseOverBudgetFeatures(activeFeatureIds);
       await this.planningWaveExecutor.run(activeFeatureIds);
@@ -139,8 +146,8 @@ export class RunCoordinator {
       queue_depth: this.state.queue.length,
       run_metadata: {
         ...this.state.runMetadata,
-        runtime_sessions: runtimeSessions
-      }
+        runtime_sessions: runtimeSessions,
+      },
     };
   }
 
@@ -149,17 +156,22 @@ export class RunCoordinator {
     for (const featureId of activeFeatureIds) {
       const budgetCheck = await this.kernel.checkBudget(featureId);
       if (budgetCheck.over_budget) {
-        await this.kernel.updateState(featureId, null, (_fm) => Promise.resolve({
-          frontMatter: {
-            status: STATUS.PAUSED_BUDGET,
-            status_reason: `Feature paused: estimated cost $${budgetCheck.current_cost_usd.toFixed(4)} exceeds budget limit $${budgetCheck.limit_usd.toFixed(2)}`
-          }
-        }));
+        await this.kernel.updateState(featureId, null, (_fm) =>
+          Promise.resolve({
+            frontMatter: {
+              status: STATUS.PAUSED_BUDGET,
+              status_reason: `Feature paused: estimated cost $${budgetCheck.current_cost_usd.toFixed(4)} exceeds budget limit $${budgetCheck.limit_usd.toFixed(2)}`,
+            },
+          }),
+        );
         if (this.notifier) {
           await this.notifier.notify('budget_exceeded', {
             feature_id: featureId,
             message: `Budget exceeded for ${featureId}: $${budgetCheck.current_cost_usd.toFixed(4)} >= $${budgetCheck.limit_usd.toFixed(2)}`,
-            details: { current_cost_usd: budgetCheck.current_cost_usd, limit_usd: budgetCheck.limit_usd }
+            details: {
+              current_cost_usd: budgetCheck.current_cost_usd,
+              limit_usd: budgetCheck.limit_usd,
+            },
           });
         }
         await this.sessionOrchestrator.closeFeatureCluster(featureId);
@@ -169,7 +181,11 @@ export class RunCoordinator {
           await this.notifier.notify('budget_alert', {
             feature_id: featureId,
             message: `Budget alert for ${featureId}: $${budgetCheck.current_cost_usd.toFixed(4)} (${Math.round(budgetCheck.alert_threshold * 100)}% of $${budgetCheck.limit_usd.toFixed(2)})`,
-            details: { current_cost_usd: budgetCheck.current_cost_usd, limit_usd: budgetCheck.limit_usd, alert_threshold: budgetCheck.alert_threshold }
+            details: {
+              current_cost_usd: budgetCheck.current_cost_usd,
+              limit_usd: budgetCheck.limit_usd,
+              alert_threshold: budgetCheck.alert_threshold,
+            },
           });
         }
       }
@@ -190,7 +206,10 @@ export class RunCoordinator {
       survivingActiveFeatureIds.push(featureId);
     }
 
-    while (survivingActiveFeatureIds.length < this.maxActiveFeatures && this.state.queue.length > 0) {
+    while (
+      survivingActiveFeatureIds.length < this.maxActiveFeatures &&
+      this.state.queue.length > 0
+    ) {
       const nextFeature = this.state.queue.shift();
       if (!nextFeature) {
         break;
@@ -206,17 +225,20 @@ export class RunCoordinator {
       survivingActiveFeatureIds.push(nextFeature.feature_id);
     }
 
-    const activeFeatureIds = [...new Set(survivingActiveFeatureIds)].sort((a, b) => a.localeCompare(b));
-    const scopedFeatureIds = [...activeFeatureIds, ...this.state.queue.map((item) => item.feature_id)].sort((a, b) =>
-      a.localeCompare(b)
+    const activeFeatureIds = [...new Set(survivingActiveFeatureIds)].sort((a, b) =>
+      a.localeCompare(b),
     );
+    const scopedFeatureIds = [
+      ...activeFeatureIds,
+      ...this.state.queue.map((item) => item.feature_id),
+    ].sort((a, b) => a.localeCompare(b));
 
     await this.sessionOrchestrator.reconcileQueuedFeatures(this.state.queue);
     await this.sessionOrchestrator.enforceActiveFeatureInvariant(activeFeatureIds);
     await this.kernel.pruneFeatureSessionAssignments({
       run_id: this.state.runId,
       owner_instance_id: this.state.ownerInstanceId,
-      active_feature_ids: scopedFeatureIds
+      active_feature_ids: scopedFeatureIds,
     });
 
     return activeFeatureIds;
@@ -227,12 +249,16 @@ export class RunCoordinator {
   }
 
   private async readFeatureStateSnapshot(
-    featureId: string
+    featureId: string,
   ): Promise<{ status: string | null; branch: string; hasPr: boolean }> {
     try {
-      const state = await this.toolCaller.callTool<FeatureStatePayload>('orchestrator', TOOLS.FEATURE_STATE_GET, {
-        feature_id: featureId
-      });
+      const state = await this.toolCaller.callTool<FeatureStatePayload>(
+        'orchestrator',
+        TOOLS.FEATURE_STATE_GET,
+        {
+          feature_id: featureId,
+        },
+      );
       const frontMatter = RunCoordinator.asRecord(state.data.front_matter);
       const status = typeof frontMatter.status === 'string' ? frontMatter.status : null;
       const prValue = frontMatter.pr;
@@ -262,7 +288,8 @@ export class RunCoordinator {
         continue;
       }
       const prevStatus = this.statusCache.get(featureId);
-      const shouldPollPr = this.prMonitor && (newStatus === STATUS.READY_TO_MERGE || snapshot.hasPr);
+      const shouldPollPr =
+        this.prMonitor && (newStatus === STATUS.READY_TO_MERGE || snapshot.hasPr);
       if (prevStatus === newStatus && shouldPollPr) {
         await this.prMonitor.checkAndUpdate(featureId, snapshot.branch);
       }
@@ -275,12 +302,12 @@ export class RunCoordinator {
           const event = prevStatus === STATUS.PLANNING ? 'collision_detected' : 'gate_failed';
           await this.notifier.notify(event, {
             feature_id: featureId,
-            message: `Feature ${featureId} blocked (event: ${event})`
+            message: `Feature ${featureId} blocked (event: ${event})`,
           });
         } else if (newStatus === STATUS.READY_TO_MERGE) {
           await this.notifier.notify('ready_to_merge', {
             feature_id: featureId,
-            message: `Feature ${featureId} is ready to merge`
+            message: `Feature ${featureId} is ready to merge`,
           });
           if (shouldPollPr) {
             await this.prMonitor.checkAndUpdate(featureId, snapshot.branch);
@@ -288,7 +315,7 @@ export class RunCoordinator {
         } else if (newStatus === STATUS.MERGED) {
           await this.notifier.notify('feature_merged', {
             feature_id: featureId,
-            message: `Feature ${featureId} was merged`
+            message: `Feature ${featureId} was merged`,
           });
         }
       }
@@ -298,8 +325,14 @@ export class RunCoordinator {
     }
   }
 
-  private async syncIssueTrackerStatus(featureId: string, status: string, prevStatus: string | undefined): Promise<void> {
-    if (!this.issueTracker) {return;}
+  private async syncIssueTrackerStatus(
+    featureId: string,
+    status: string,
+    prevStatus: string | undefined,
+  ): Promise<void> {
+    if (!this.issueTracker) {
+      return;
+    }
     const issueId = featureId.replace(/^feature[/_]/, '');
     if (status === STATUS.PLANNING && prevStatus === undefined) {
       // Spec enrichment: fetch issue context when planning starts, store in frontmatter
@@ -310,20 +343,22 @@ export class RunCoordinator {
           title: issue.title,
           body: issue.body,
           status: issue.status,
-          url: issue.url
+          url: issue.url,
         };
         await this.kernel.updateState(featureId, null, (fm) =>
-          Promise.resolve({ frontMatter: { ...fm, issue_context: issueCtx } })
+          Promise.resolve({ frontMatter: { ...fm, issue_context: issueCtx } }),
         );
       }
     }
-    await this.issueTracker.addComment(issueId, `AOP: feature status changed to \`${status}\``).catch(() => undefined);
+    await this.issueTracker
+      .addComment(issueId, `AOP: feature status changed to \`${status}\``)
+      .catch(() => undefined);
     await this.issueTracker.updateIssueStatus(issueId, status).catch(() => undefined);
   }
 
   private async applyOrchestratorPrioritization(
     activeFeatureIds: string[],
-    iteration: number
+    iteration: number,
   ): Promise<string[]> {
     if (activeFeatureIds.length < 2) {
       return activeFeatureIds;
@@ -335,10 +370,10 @@ export class RunCoordinator {
       contextBundle: {
         iteration,
         active_feature_ids: activeFeatureIds,
-        queued_feature_ids: this.state.queue.map((item) => item.feature_id)
+        queued_feature_ids: this.state.queue.map((item) => item.feature_id),
       },
       instructions:
-        'Decide per-iteration prioritization. Emit REQUEST action=prioritize with feature_order to reprioritize active features.'
+        'Decide per-iteration prioritization. Emit REQUEST action=prioritize with feature_order to reprioritize active features.',
     });
 
     if (decision.priorityOrder.length === 0) {

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

@@ -21,7 +21,7 @@ import {
   NOTIFICATION_CHANNEL_SLOT,
   ACTIVITY_DETECTOR_SLOT,
   SCM_PROVIDER_SLOT,
-  type AdapterSlot
+  type AdapterSlot,
 } from '../application/adapters/adapter-registry.js';
 import type { ReactionsPolicy } from '../application/services/reactions-service.js';
 import type {
@@ -36,7 +36,7 @@ import type {
   SupervisorOptions,
   SupervisorRuntimeState,
   SupervisorToolCaller,
-  WorkerSessions
+  WorkerSessions,
 } from './types.js';
 
 type NamedContract = { name: string };
@@ -44,9 +44,10 @@ type NamedContract = { name: string };
 function resolveAdapterName(
   slot: AdapterSlot<NamedContract>,
   configuredValue: unknown,
-  fallback: string | null
+  fallback: string | null,
 ): string | null {
-  const configured = typeof configuredValue === 'string' && configuredValue.length > 0 ? configuredValue : null;
+  const configured =
+    typeof configuredValue === 'string' && configuredValue.length > 0 ? configuredValue : null;
   const candidate = configured ?? fallback;
   if (!candidate) {
     return null;
@@ -91,24 +92,40 @@ export class SupervisorRuntime
     kernel: SupervisorKernelPort,
     provider: WorkerProvider,
     toolClient: ToolClient,
-    options: SupervisorOptions = {}
+    options: SupervisorOptions = {},
   ) {
     this.kernel = kernel;
     this.provider = provider;
     this.toolClient = toolClient;
     this.maxActiveFeatures = options.max_active_features ?? 5;
     this.maxParallelGateRuns = this.resolveMaxParallelGateRuns(options.max_parallel_gate_runs);
-    this.maxIterationsPerPhase = this.resolveMaxIterationsPerPhase(options.max_iterations_per_phase);
+    this.maxIterationsPerPhase = this.resolveMaxIterationsPerPhase(
+      options.max_iterations_per_phase,
+    );
     this.takeoverStaleRun = Boolean(options.takeover_stale_run);
     const runId = options.run_id ?? `run:${Date.now()}`;
-    const ownerInstanceId = options.owner_instance_id ?? `supervisor:${process.pid}:${crypto.randomUUID()}`;
+    const ownerInstanceId =
+      options.owner_instance_id ?? `supervisor:${process.pid}:${crypto.randomUUID()}`;
     const adaptersConfig =
-      typeof (this.kernel as { getAdaptersConfig?: () => Record<string, unknown> }).getAdaptersConfig === 'function'
+      typeof (this.kernel as { getAdaptersConfig?: () => Record<string, unknown> })
+        .getAdaptersConfig === 'function'
         ? this.kernel.getAdaptersConfig()
         : {};
-    const notificationChannel = resolveAdapterName(NOTIFICATION_CHANNEL_SLOT, adaptersConfig['notification-channel'], null);
-    const activityDetector = resolveAdapterName(ACTIVITY_DETECTOR_SLOT, adaptersConfig['activity-detector'], 'claude-jsonl');
-    const scmProvider = resolveAdapterName(SCM_PROVIDER_SLOT, adaptersConfig['scm-provider'], 'github');
+    const notificationChannel = resolveAdapterName(
+      NOTIFICATION_CHANNEL_SLOT,
+      adaptersConfig['notification-channel'],
+      null,
+    );
+    const activityDetector = resolveAdapterName(
+      ACTIVITY_DETECTOR_SLOT,
+      adaptersConfig['activity-detector'],
+      'claude-jsonl',
+    );
+    const scmProvider = resolveAdapterName(
+      SCM_PROVIDER_SLOT,
+      adaptersConfig['scm-provider'],
+      'github',
+    );
 
     this.state = {
       runId,
@@ -124,9 +141,9 @@ export class SupervisorRuntime
         adapters: {
           notification_channel: notificationChannel,
           activity_detector: activityDetector,
-          scm_provider: scmProvider
-        }
-      }
+          scm_provider: scmProvider,
+        },
+      },
     };
 
     this.promptBundleLoader = new PromptBundleLoader(this.kernel);
@@ -136,7 +153,7 @@ export class SupervisorRuntime
       provider: this.provider,
       promptProvider: this,
       toolCaller: this,
-      state: this.state
+      state: this.state,
     });
 
     const notifier = createNotifierService(this.kernel.getPolicySnapshot(), notificationChannel);
@@ -144,7 +161,7 @@ export class SupervisorRuntime
     const reactionsService = new ReactionsService({
       toolCaller: this,
       notifier,
-      policy: reactionsPolicy
+      policy: reactionsPolicy,
     });
 
     const activityMonitor = new ActivityMonitorService({
@@ -152,7 +169,7 @@ export class SupervisorRuntime
       notifier,
       reactionsPolicy,
       idleThresholdMs: this.resolveActivityIdleThresholdMs(),
-      detectorName: activityDetector ?? 'claude-jsonl'
+      detectorName: activityDetector ?? 'claude-jsonl',
     });
 
     const prMonitor =
@@ -161,33 +178,34 @@ export class SupervisorRuntime
             toolCaller: this,
             notifier,
             reactionsPolicy,
-            ghRunner: createGhRunner()
+            ghRunner: createGhRunner(),
           })
         : undefined;
 
     const policy = this.kernel.getPolicySnapshot();
     const rawIssueTrackerConfig = policy['issue_tracker'];
-    const issueTrackerConfig = typeof rawIssueTrackerConfig === 'object' && rawIssueTrackerConfig !== null
-      ? (rawIssueTrackerConfig as { type: string; config?: Record<string, string> })
-      : undefined;
+    const issueTrackerConfig =
+      typeof rawIssueTrackerConfig === 'object' && rawIssueTrackerConfig !== null
+        ? (rawIssueTrackerConfig as { type: string; config?: Record<string, string> })
+        : undefined;
     const issueTracker = createIssueTracker(issueTrackerConfig);
 
     this.workerDecisionLoop = new WorkerDecisionLoop({
       provider: this.provider,
       toolCaller: this,
-      activityMonitor
+      activityMonitor,
     });
 
     this.planningWaveExecutor = new PlanningWaveExecutor({
       toolCaller: this,
       planGenerator: this,
-      workerDecisionRunner: this.workerDecisionLoop
+      workerDecisionRunner: this.workerDecisionLoop,
     });
 
     this.buildWaveExecutor = new BuildWaveExecutor({
       toolCaller: this,
       workerDecisionRunner: this.workerDecisionLoop,
-      reactionsService
+      reactionsService,
     });
 
     this.qaWaveExecutor = new QaWaveExecutor({
@@ -198,12 +216,12 @@ export class SupervisorRuntime
       featureClusterPatcher: this,
       state: this.state,
       workerDecisionRunner: this.workerDecisionLoop,
-      reactionsService
+      reactionsService,
     });
 
     this.leaseHeartbeatService = new LeaseHeartbeatService({
       kernel: this.kernel,
-      state: this.state
+      state: this.state,
     });
 
     this.runCoordinator = new RunCoordinator({
@@ -224,7 +242,7 @@ export class SupervisorRuntime
       workerDecisionRunner: this.workerDecisionLoop,
       notifier,
       prMonitor,
-      issueTracker
+      issueTracker,
     });
   }
 
@@ -369,7 +387,10 @@ export class SupervisorRuntime
     await this.sessionOrchestrator.enforceActiveFeatureInvariant(activeFeatureIds);
   }
 
-  async patchFeatureCluster(featureId: string, clusterPatch: Record<string, string>): Promise<void> {
+  async patchFeatureCluster(
+    featureId: string,
+    clusterPatch: Record<string, string>,
+  ): Promise<void> {
     await this.sessionOrchestrator.patchFeatureCluster(featureId, clusterPatch);
   }
 
@@ -398,7 +419,10 @@ export class SupervisorRuntime
   }
 
   async generateInitialPlan(featureId: string): Promise<Record<string, unknown>> {
-    const baseRef = await this.kernel.repoDiff(featureId, ['--stat']).then(() => 'HEAD').catch(() => 'HEAD');
+    const baseRef = await this.kernel
+      .repoDiff(featureId, ['--stat'])
+      .then(() => 'HEAD')
+      .catch(() => 'HEAD');
     return {
       feature_id: featureId,
       plan_version: 1,
@@ -409,15 +433,15 @@ export class SupervisorRuntime
       files: {
         create: [],
         modify: [],
-        delete: []
+        delete: [],
       },
       contracts: {
         openapi: 'none',
         events: 'none',
-        db: 'none'
+        db: 'none',
       },
       acceptance_criteria: ['Feature has deterministic plan and passes configured gate profile.'],
-      gate_profile: 'default'
+      gate_profile: 'default',
     };
   }
 
@@ -451,7 +475,7 @@ export class SupervisorRuntime
   async callTool<TData = Record<string, unknown>>(
     role: RuntimeRole,
     toolName: string,
-    args: Record<string, unknown>
+    args: Record<string, unknown>,
   ): Promise<{ ok: true; data: TData }> {
     const payload = withOperationIdIfRequired(toolName, args, createOperationId);
     const roleSessionId = this.resolveRoleSessionId(role, payload);
@@ -460,11 +484,11 @@ export class SupervisorRuntime
       run_id: this.state.runId,
       session_id: roleSessionId ?? `bootstrap:${role}`,
       actor_type: role,
-      actor_id: `supervisor:${role}`
+      actor_id: `supervisor:${role}`,
     });
 
     if (response.ok === false) {
-      const normalized = (response).error;
+      const normalized = response.error;
       const error = new Error(normalized.message) as AppError;
       error.code = normalized.code;
       error.details = normalized.details;

package/apps/control-plane/src/supervisor/session-orchestrator.ts

@@ -7,7 +7,7 @@ import type {
   RuntimeStateReader,
   SupervisorKernelPort,
   SupervisorRuntimeState,
-  SupervisorToolCaller
+  SupervisorToolCaller,
 } from './types.js';
 import { UNASSIGNED_SESSION_ID } from './types.js';
 
@@ -67,7 +67,7 @@ export class SessionOrchestrator {
       run_id: this.state.runId,
       owner_instance_id: this.state.ownerInstanceId,
       orchestrator_session_id: orchestratorSession.session_id,
-      increment_epoch: canReuse
+      increment_epoch: canReuse,
     });
 
     if (canReuse && candidate) {
@@ -90,8 +90,8 @@ export class SessionOrchestrator {
       const reattachResult = await Promise.race([
         this.provider.reattachSession(sessionId),
         new Promise<never>((_, reject) =>
-          setTimeout(() => reject(new Error('Reattach timeout')), timeoutMs)
-        )
+          setTimeout(() => reject(new Error('Reattach timeout')), timeoutMs),
+        ),
       ]);
       return Boolean(reattachResult?.session_id === sessionId);
     } catch (_error) {
@@ -116,14 +116,16 @@ export class SessionOrchestrator {
       metadata: {
         orphan_session_id: sessionId,
         previous_epoch: previousEpoch,
-        new_epoch: previousEpoch + 1
-      }
+        new_epoch: previousEpoch + 1,
+      },
     };
 
-    await this.toolCaller.callTool('orchestrator', TOOLS.FEATURE_LOG_APPEND, {
-      feature_id: 'global',
-      note: JSON.stringify(orphanEvent)
-    }).catch(() => ({ ok: true, data: {} }));
+    await this.toolCaller
+      .callTool('orchestrator', TOOLS.FEATURE_LOG_APPEND, {
+        feature_id: 'global',
+        note: JSON.stringify(orphanEvent),
+      })
+      .catch(() => ({ ok: true, data: {} }));
   }
 
   async cleanupOrphanWorkerSessions(scopedFeatureIds: string[]): Promise<void> {
@@ -138,7 +140,11 @@ export class SessionOrchestrator {
       }
 
       const assignment = assignments[featureId];
-      for (const sessionId of [assignment.planner_session_id, assignment.builder_session_id, assignment.qa_session_id]) {
+      for (const sessionId of [
+        assignment.planner_session_id,
+        assignment.builder_session_id,
+        assignment.qa_session_id,
+      ]) {
         if (!sessionId || sessionId === UNASSIGNED_SESSION_ID) {
           continue;
         }
@@ -159,7 +165,7 @@ export class SessionOrchestrator {
     this.state.sessionsByFeature.set(featureId, {
       planner: plannerSession.session_id,
       builder: builderSession.session_id,
-      qa: qaSession.session_id
+      qa: qaSession.session_id,
     });
 
     await this.kernel.updateFeatureSessionAssignment({
@@ -168,14 +174,14 @@ export class SessionOrchestrator {
       feature_id: featureId,
       planner_session_id: plannerSession.session_id,
       builder_session_id: builderSession.session_id,
-      qa_session_id: qaSession.session_id
+      qa_session_id: qaSession.session_id,
     });
 
     await this.patchFeatureCluster(featureId, {
       orchestrator_session_id: this.state.orchestratorSessionId ?? 'unknown',
       planner_session_id: plannerSession.session_id,
       builder_session_id: builderSession.session_id,
-      qa_session_id: qaSession.session_id
+      qa_session_id: qaSession.session_id,
     });
   }
 
@@ -204,14 +210,14 @@ export class SessionOrchestrator {
         feature_id: feature.feature_id,
         planner_session_id: UNASSIGNED_SESSION_ID,
         builder_session_id: UNASSIGNED_SESSION_ID,
-        qa_session_id: UNASSIGNED_SESSION_ID
+        qa_session_id: UNASSIGNED_SESSION_ID,
       });
 
       await this.patchFeatureCluster(feature.feature_id, {
         orchestrator_session_id: this.state.orchestratorSessionId ?? 'unknown',
         planner_session_id: UNASSIGNED_SESSION_ID,
         builder_session_id: UNASSIGNED_SESSION_ID,
-        qa_session_id: UNASSIGNED_SESSION_ID
+        qa_session_id: UNASSIGNED_SESSION_ID,
       });
     }
   }
@@ -223,9 +229,13 @@ export class SessionOrchestrator {
     }
 
     for (const featureId of [...activeFeatureIds].sort((a, b) => a.localeCompare(b))) {
-      const state = await this.toolCaller.callTool<FeatureStatePayload>('orchestrator', TOOLS.FEATURE_STATE_GET, {
-        feature_id: featureId
-      });
+      const state = await this.toolCaller.callTool<FeatureStatePayload>(
+        'orchestrator',
+        TOOLS.FEATURE_STATE_GET,
+        {
+          feature_id: featureId,
+        },
+      );
 
       const cluster = state.data.front_matter.cluster ?? {};
       if (cluster.orchestrator_session_id === orchestratorSessionId) {
@@ -239,18 +249,25 @@ export class SessionOrchestrator {
           front_matter: {
             cluster: {
               ...cluster,
-              orchestrator_session_id: orchestratorSessionId
-            }
-          }
-        }
+              orchestrator_session_id: orchestratorSessionId,
+            },
+          },
+        },
       });
     }
   }
 
-  async patchFeatureCluster(featureId: string, clusterPatch: Record<string, string>): Promise<void> {
-    const state = await this.toolCaller.callTool<FeatureStatePayload>('orchestrator', TOOLS.FEATURE_STATE_GET, {
-      feature_id: featureId
-    });
+  async patchFeatureCluster(
+    featureId: string,
+    clusterPatch: Record<string, string>,
+  ): Promise<void> {
+    const state = await this.toolCaller.callTool<FeatureStatePayload>(
+      'orchestrator',
+      TOOLS.FEATURE_STATE_GET,
+      {
+        feature_id: featureId,
+      },
+    );
 
     await this.toolCaller.callTool('orchestrator', TOOLS.FEATURE_STATE_PATCH, {
       feature_id: featureId,
@@ -259,10 +276,10 @@ export class SessionOrchestrator {
         front_matter: {
           cluster: {
             ...(state.data.front_matter.cluster ?? {}),
-            ...clusterPatch
-          }
-        }
-      }
+            ...clusterPatch,
+          },
+        },
+      },
     });
   }
 }