agentic-orchestrator 0.1.6 → 0.1.7

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,
+          },
+        },
+      },
     });
   }
 }

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

@@ -5,7 +5,7 @@ export type {
   FeatureStateFrontMatter,
   FeatureStatePayload,
   RuntimeRole,
-  ToolCaller as SupervisorToolCaller
+  ToolCaller as SupervisorToolCaller,
 } from '../core/tool-caller.js';
 
 export interface AppError extends Error {
@@ -103,14 +103,29 @@ export interface FeatureOrchestrationPort {
   ensureLoaded(): Promise<void>;
   recoverFromState(): Promise<{ data: Record<string, unknown> }>;
   acquireRunLease(input: AcquireRunLeaseInput): Promise<{ data: { took_over_stale: boolean } }>;
-  updateOrchestratorSession(params: UpdateOrchestratorSessionInput): Promise<{ data: { runtime_sessions: RuntimeSessionsSnapshot } }>;
-  updateFeatureSessionAssignment(params: UpdateFeatureSessionAssignmentInput): Promise<{ data: { updated: boolean } }>;
-  pruneFeatureSessionAssignments(params: PruneFeatureSessionAssignmentsInput): Promise<{ data: { removed: string[] } }>;
+  updateOrchestratorSession(
+    params: UpdateOrchestratorSessionInput,
+  ): Promise<{ data: { runtime_sessions: RuntimeSessionsSnapshot } }>;
+  updateFeatureSessionAssignment(
+    params: UpdateFeatureSessionAssignmentInput,
+  ): Promise<{ data: { updated: boolean } }>;
+  pruneFeatureSessionAssignments(
+    params: PruneFeatureSessionAssignmentsInput,
+  ): Promise<{ data: { removed: string[] } }>;
   renewLeases(featureIds: string[]): Promise<void>;
-  renewRunLease(runId: string, ownerInstanceId: string): Promise<{ data: { lease_expires_at: string } }>;
+  renewRunLease(
+    runId: string,
+    ownerInstanceId: string,
+  ): Promise<{ data: { lease_expires_at: string } }>;
   repoDiff(featureId: string, options?: string[]): Promise<{ data: Record<string, unknown> }>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  updateState(featureId: string, expectedVersion: number | null, updater: (fm: Record<string, any>, body: string) => Promise<{ frontMatter?: Record<string, any>; body?: string }>): Promise<Record<string, unknown>>;
+  updateState(
+    featureId: string,
+    expectedVersion: number | null,
+    updater: (
+      fm: Record<string, unknown>,
+      body: string,
+    ) => Promise<{ frontMatter?: Record<string, unknown>; body?: string }>,
+  ): Promise<Record<string, unknown>>;
   checkBudget(featureId: string): Promise<BudgetCheckResult>;
 }
 

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

@@ -62,9 +62,7 @@ function readPlanVersion(value: unknown): number | null {
 function asOutputs(result: Record<string, unknown>): AnyRecord[] {
   const outputs = result.outputs;
   if (Array.isArray(outputs)) {
-    return outputs
-      .map((item) => asRecord(item))
-      .filter((item) => Object.keys(item).length > 0);
+    return outputs.map((item) => asRecord(item)).filter((item) => Object.keys(item).length > 0);
   }
   return [asRecord(result)];
 }
@@ -76,12 +74,12 @@ function makeEmptyResult(): WorkerDecisionResult {
     noteLogged: false,
     requestHandled: false,
     priorityOrder: [],
-    toolResults: []
+    toolResults: [],
   };
 }
 
 export const NOOP_WORKER_DECISION_RUNNER: WorkerDecisionRunner = {
-  execute: () => Promise.resolve(makeEmptyResult())
+  execute: () => Promise.resolve(makeEmptyResult()),
 };
 
 interface WorkerDecisionLoopDependencies {
@@ -116,8 +114,8 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       runtime_selection: {
         provider: this.provider.selection.provider,
         model: this.provider.selection.model,
-        provider_config_ref: this.provider.selection.provider_config_ref
-      }
+        provider_config_ref: this.provider.selection.provider_config_ref,
+      },
     });
 
     const outputs = asOutputs(workerOutput);
@@ -154,7 +152,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
   private async routePlanSubmission(
     input: WorkerDecisionInput,
     output: AnyRecord,
-    result: WorkerDecisionResult
+    result: WorkerDecisionResult,
   ): Promise<void> {
     if (input.role !== 'planner') {
       return;
@@ -172,7 +170,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
     if (existingVersion == null) {
       const response = await this.toolCaller.callTool('planner', TOOLS.PLAN_SUBMIT, {
         feature_id: input.featureId,
-        plan_json: planJson
+        plan_json: planJson,
       });
       result.toolResults.push(asRecord(response.data));
       result.planSubmission = true;
@@ -183,13 +181,17 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
     const response = await this.toolCaller.callTool('planner', TOOLS.PLAN_UPDATE, {
       feature_id: input.featureId,
       expected_plan_version: expectedPlanVersion,
-      plan_json: planJson
+      plan_json: planJson,
     });
     result.toolResults.push(asRecord(response.data));
     result.planSubmission = true;
   }
 
-  private async routePatch(input: WorkerDecisionInput, output: AnyRecord, result: WorkerDecisionResult): Promise<void> {
+  private async routePatch(
+    input: WorkerDecisionInput,
+    output: AnyRecord,
+    result: WorkerDecisionResult,
+  ): Promise<void> {
     if (input.role !== 'builder' && input.role !== 'qa') {
       return;
     }
@@ -201,18 +203,22 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
 
     const response = await this.toolCaller.callTool(input.role, TOOLS.REPO_APPLY_PATCH, {
       feature_id: input.featureId,
-      unified_diff: unifiedDiff
+      unified_diff: unifiedDiff,
     });
     result.toolResults.push(asRecord(response.data));
     result.patchApplied = true;
   }
 
-  private async routeNote(featureId: string, output: AnyRecord, result: WorkerDecisionResult): Promise<void> {
+  private async routeNote(
+    featureId: string,
+    output: AnyRecord,
+    result: WorkerDecisionResult,
+  ): Promise<void> {
     const content = asNonEmptyString(output.content) ?? JSON.stringify(output);
     try {
       const response = await this.toolCaller.callTool('orchestrator', TOOLS.FEATURE_LOG_APPEND, {
         feature_id: featureId,
-        note: content
+        note: content,
       });
       result.toolResults.push(asRecord(response.data));
       result.noteLogged = true;
@@ -221,7 +227,11 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
     }
   }
 
-  private async routeRequest(input: WorkerDecisionInput, output: AnyRecord, result: WorkerDecisionResult): Promise<void> {
+  private async routeRequest(
+    input: WorkerDecisionInput,
+    output: AnyRecord,
+    result: WorkerDecisionResult,
+  ): Promise<void> {
     const request = asRecord(output.request ?? output);
     const action = asNonEmptyString(request.action ?? request.request_type)?.toLowerCase();
     if (!action) {
@@ -244,7 +254,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       }
       const response = await this.toolCaller.callTool('orchestrator', TOOLS.LOCKS_ACQUIRE, {
         feature_id: input.featureId,
-        resources
+        resources,
       });
       result.toolResults.push(asRecord(response.data));
       result.requestHandled = true;
@@ -258,7 +268,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       }
       const response = await this.toolCaller.callTool('orchestrator', TOOLS.LOCKS_RELEASE, {
         feature_id: input.featureId,
-        resources
+        resources,
       });
       result.toolResults.push(asRecord(response.data));
       result.requestHandled = true;
@@ -267,7 +277,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
 
     if (action === 'more_context' || action === 'context_refresh') {
       const response = await this.toolCaller.callTool(input.role, TOOLS.FEATURE_GET_CONTEXT, {
-        feature_id: input.featureId
+        feature_id: input.featureId,
       });
       result.toolResults.push(asRecord(response.data));
       result.requestHandled = true;
@@ -286,7 +296,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       if (existingVersion == null) {
         const response = await this.toolCaller.callTool('planner', TOOLS.PLAN_SUBMIT, {
           feature_id: input.featureId,
-          plan_json: planJson
+          plan_json: planJson,
         });
         result.toolResults.push(asRecord(response.data));
         result.requestHandled = true;
@@ -297,7 +307,7 @@ export class WorkerDecisionLoop implements WorkerDecisionRunner {
       const response = await this.toolCaller.callTool('planner', TOOLS.PLAN_UPDATE, {
         feature_id: input.featureId,
         expected_plan_version: requestedExpectedVersion ?? existingVersion,
-        plan_json: planJson
+        plan_json: planJson,
       });
       result.toolResults.push(asRecord(response.data));
       result.requestHandled = true;

package/apps/control-plane/test/activity-monitor.spec.ts

@@ -14,7 +14,7 @@ function makeToolCaller(frontMatter: Record<string, unknown>) {
         return { ok: true, data: { front_matter: { version: 1, ...frontMatter } } };
       }
       return { ok: true, data: {} };
-    })
+    }),
   };
 }
 
@@ -27,7 +27,7 @@ describe('ActivityMonitorService', () => {
     const toolCaller = makeToolCaller({ status: 'building', last_heartbeat_at: RECENT_TIMESTAMP });
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
-      idleThresholdMs: DEFAULT_THRESHOLD
+      idleThresholdMs: DEFAULT_THRESHOLD,
     });
 
     const snapshot = await service.getActivityState('feature_a');
@@ -42,7 +42,7 @@ describe('ActivityMonitorService', () => {
     const toolCaller = makeToolCaller({ status: 'building', last_heartbeat_at: STALE_TIMESTAMP });
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
-      idleThresholdMs: DEFAULT_THRESHOLD
+      idleThresholdMs: DEFAULT_THRESHOLD,
     });
 
     const snapshot = await service.getActivityState('feature_b');
@@ -89,8 +89,13 @@ describe('ActivityMonitorService', () => {
       notifier: notifier as never,
       idleThresholdMs: DEFAULT_THRESHOLD,
       reactionsPolicy: {
-        agent_stuck: { enabled: true, action: 'notify_only', idle_threshold_ms: DEFAULT_THRESHOLD, escalate_after: 2 }
-      }
+        agent_stuck: {
+          enabled: true,
+          action: 'notify_only',
+          idle_threshold_ms: DEFAULT_THRESHOLD,
+          escalate_after: 2,
+        },
+      },
     });
 
     const stuck = await service.checkAndNotifyStuck('feature_f');
@@ -98,7 +103,7 @@ describe('ActivityMonitorService', () => {
     expect(stuck).toBe(true);
     expect(notifier.notify).toHaveBeenCalledWith(
       'agent_stuck',
-      expect.objectContaining({ feature_id: 'feature_f' })
+      expect.objectContaining({ feature_id: 'feature_f' }),
     );
   });
 
@@ -110,8 +115,13 @@ describe('ActivityMonitorService', () => {
       notifier: notifier as never,
       idleThresholdMs: DEFAULT_THRESHOLD,
       reactionsPolicy: {
-        agent_stuck: { enabled: false, action: 'notify_only', idle_threshold_ms: DEFAULT_THRESHOLD, escalate_after: 2 }
-      }
+        agent_stuck: {
+          enabled: false,
+          action: 'notify_only',
+          idle_threshold_ms: DEFAULT_THRESHOLD,
+          escalate_after: 2,
+        },
+      },
     });
 
     const stuck = await service.checkAndNotifyStuck('feature_g');
@@ -122,13 +132,13 @@ describe('ActivityMonitorService', () => {
 
   it('GIVEN formatForStatus called WHEN state is idle THEN string includes idle', () => {
     const service = new ActivityMonitorService({
-      toolCaller: { callTool: vi.fn() } as never
+      toolCaller: { callTool: vi.fn() } as never,
     });
     const snapshot: ActivitySnapshot = {
       featureId: 'feature_h',
       state: 'idle',
       lastEventAt: new Date(Date.now() - 10 * 60_000).toISOString(),
-      detectedVia: 'jsonl'
+      detectedVia: 'jsonl',
     };
 
     const str = service.formatForStatus(snapshot);
@@ -138,13 +148,13 @@ describe('ActivityMonitorService', () => {
 
   it('GIVEN formatForStatus called WHEN state has no timestamp THEN returns state name', () => {
     const service = new ActivityMonitorService({
-      toolCaller: { callTool: vi.fn() } as never
+      toolCaller: { callTool: vi.fn() } as never,
     });
     const snapshot: ActivitySnapshot = {
       featureId: 'feature_i',
       state: 'unknown',
       lastEventAt: null,
-      detectedVia: 'unknown'
+      detectedVia: 'unknown',
     };
 
     const str = service.formatForStatus(snapshot);
@@ -160,8 +170,13 @@ describe('ActivityMonitorService', () => {
       notifier: notifier as never,
       idleThresholdMs: DEFAULT_THRESHOLD,
       reactionsPolicy: {
-        agent_stuck: { enabled: true, action: 'notify_only', idle_threshold_ms: DEFAULT_THRESHOLD, escalate_after: 2 }
-      }
+        agent_stuck: {
+          enabled: true,
+          action: 'notify_only',
+          idle_threshold_ms: DEFAULT_THRESHOLD,
+          escalate_after: 2,
+        },
+      },
     });
 
     const stuck = await service.checkAndNotifyStuck('feature_j');
@@ -174,7 +189,7 @@ describe('ActivityMonitorService', () => {
     const toolCaller = makeToolCaller({ status: 'building', last_run_at: RECENT_TIMESTAMP });
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
-      detectorName: 'codex-rpc'
+      detectorName: 'codex-rpc',
     });
 
     const snapshot = await service.getActivityState('feature_codex');
@@ -188,10 +203,10 @@ describe('ActivityMonitorService', () => {
     const toolCaller = makeToolCaller({
       status: 'building',
       status_reason: 'waiting_input:user_confirmation',
-      last_heartbeat_at: RECENT_TIMESTAMP
+      last_heartbeat_at: RECENT_TIMESTAMP,
     });
     const service = new ActivityMonitorService({
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const snapshot = await service.getActivityState('feature_wait');
@@ -202,7 +217,7 @@ describe('ActivityMonitorService', () => {
   it('GIVEN_checkAndNotifyStuck_WHEN_snapshot_changes_THEN_activity_snapshot_persisted_to_state', async () => {
     const toolCaller = makeToolCaller({ status: 'building', last_heartbeat_at: STALE_TIMESTAMP });
     const service = new ActivityMonitorService({
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     await service.checkAndNotifyStuck('feature_patch');
@@ -215,10 +230,10 @@ describe('ActivityMonitorService', () => {
         patch: expect.objectContaining({
           front_matter: expect.objectContaining({
             activity_state: 'idle',
-            activity_detected_via: 'jsonl'
-          })
-        })
-      })
+            activity_detected_via: 'jsonl',
+          }),
+        }),
+      }),
     );
   });
 });
@@ -230,7 +245,7 @@ describe('ActivityMonitorService detectedVia and resolveLastEvent branches', ()
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
       detectorName: 'codex-rpc',
-      operationLedger
+      operationLedger,
     });
     const snapshot = await service.getActivityState('feature_ledger');
     expect(snapshot.detectedVia).toBe('ledger');
@@ -240,7 +255,7 @@ describe('ActivityMonitorService detectedVia and resolveLastEvent branches', ()
     const toolCaller = makeToolCaller({ status: 'building', last_heartbeat_at: RECENT_TIMESTAMP });
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
-      detectorName: 'process-heuristic'
+      detectorName: 'process-heuristic',
     });
     const snapshot = await service.getActivityState('feature_proc');
     expect(snapshot.detectedVia).toBe('process');
@@ -252,17 +267,21 @@ describe('ActivityMonitorService detectedVia and resolveLastEvent branches', ()
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
       detectorName: 'codex-rpc',
-      operationLedger
+      operationLedger,
     });
     const snapshot = await service.getActivityState('feature_norpc');
     expect(snapshot.detectedVia).toBe('process');
   });
 
   it('GIVEN_process_heuristic_with_last_run_at_WHEN_getActivityState_THEN_uses_last_run_at', async () => {
-    const toolCaller = makeToolCaller({ status: 'building', last_run_at: RECENT_TIMESTAMP, last_heartbeat_at: undefined });
+    const toolCaller = makeToolCaller({
+      status: 'building',
+      last_run_at: RECENT_TIMESTAMP,
+      last_heartbeat_at: undefined,
+    });
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
-      detectorName: 'process-heuristic'
+      detectorName: 'process-heuristic',
     });
     const snapshot = await service.getActivityState('feature_run_at');
     expect(snapshot.lastEventAt).toBe(RECENT_TIMESTAMP);
@@ -272,7 +291,7 @@ describe('ActivityMonitorService detectedVia and resolveLastEvent branches', ()
     const toolCaller = makeToolCaller({ status: 'building', last_heartbeat_at: RECENT_TIMESTAMP });
     const service = new ActivityMonitorService({
       toolCaller: toolCaller as never,
-      detectorName: 'some-unknown-detector'
+      detectorName: 'some-unknown-detector',
     });
     const snapshot = await service.getActivityState('feature_unknown_detector');
     expect(snapshot.detectedVia).toBe('unknown');
@@ -282,10 +301,15 @@ describe('ActivityMonitorService detectedVia and resolveLastEvent branches', ()
     const toolCaller = {
       callTool: vi.fn(async (_role: string, toolName: string) => {
         if (toolName === TOOLS.FEATURE_STATE_GET) {
-          return { ok: true, data: { front_matter: { version: 1, status: 'building', last_heartbeat_at: STALE_TIMESTAMP } } };
+          return {
+            ok: true,
+            data: {
+              front_matter: { version: 1, status: 'building', last_heartbeat_at: STALE_TIMESTAMP },
+            },
+          };
         }
         throw new Error('patch failed');
-      })
+      }),
     };
     const service = new ActivityMonitorService({ toolCaller: toolCaller as never });
     // Should not throw even when persistSnapshot fails - still returns stuck status

package/apps/control-plane/test/adapter-registry.spec.ts

@@ -3,7 +3,7 @@ import {
   DefaultAdapterRegistry,
   AGENT_PROVIDER_SLOT,
   globalAdapterRegistry,
-  REGISTERED_PROVIDER_NAMES
+  REGISTERED_PROVIDER_NAMES,
 } from '../src/application/adapters/adapter-registry.js';
 import { SUPPORTED_PROVIDERS } from '../src/providers/providers.js';
 import { ERROR_CODES } from '../src/core/error-codes.js';
@@ -47,7 +47,7 @@ describe('DefaultAdapterRegistry', () => {
       const registry = new DefaultAdapterRegistry();
       const slot = { name: 'compute-slot' };
       registry.register(slot, { slot: 'compute-slot', name: 'fast' }, (config) => ({
-        speed: (config as { speed: number }).speed
+        speed: (config as { speed: number }).speed,
       }));
       const result = registry.resolve(slot, 'fast', { speed: 100 });
       expect(result).toEqual({ speed: 100 });
@@ -59,7 +59,7 @@ describe('DefaultAdapterRegistry', () => {
       const registry = new DefaultAdapterRegistry();
       const slot = { name: 'missing-slot' };
       expect(() => registry.resolve(slot, 'ghost', {})).toThrowError(
-        expect.objectContaining({ code: ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER })
+        expect.objectContaining({ code: ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER }),
       );
     });
 
@@ -74,7 +74,7 @@ describe('DefaultAdapterRegistry', () => {
       }
       expect((caught as { details: Record<string, unknown> }).details).toMatchObject({
         slot: 'missing-slot',
-        name: 'ghost'
+        name: 'ghost',
       });
     });
   });
@@ -87,7 +87,7 @@ describe('DefaultAdapterRegistry', () => {
       registry.register(slot, { slot: 'multi-slot', name: 'b' }, () => 'b');
       registry.register(slot, { slot: 'multi-slot', name: 'c' }, () => 'c');
       expect(registry.list('multi-slot').map((m) => m.name)).toEqual(
-        expect.arrayContaining(['a', 'b', 'c'])
+        expect.arrayContaining(['a', 'b', 'c']),
       );
     });
   });

package/apps/control-plane/test/aop.spec.ts

@@ -6,7 +6,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { runCli } from '../src/interfaces/cli/bootstrap.js';
 
 vi.mock('../src/interfaces/cli/bootstrap.js', () => ({
-  runCli: vi.fn()
+  runCli: vi.fn(),
 }));
 
 const ORIGINAL_ARGV = [...process.argv];
@@ -33,7 +33,7 @@ describe('aop.ts entrypoint', () => {
 
     const runtime = {
       cwd: '/tmp/custom-repo',
-      env: { NODE_ENV: 'test' } as NodeJS.ProcessEnv
+      env: { NODE_ENV: 'test' } as NodeJS.ProcessEnv,
     };
     const exitCode = await main(['status'], runtime);
 
@@ -51,7 +51,7 @@ describe('aop.ts entrypoint', () => {
     expect(exitCode).toBe(0);
     expect(runCli).toHaveBeenCalledWith(['resume'], {
       cwd: process.cwd(),
-      env: process.env
+      env: process.env,
     });
   });
 
@@ -132,7 +132,7 @@ describe('aop.ts entrypoint', () => {
     expect(process.exitCode).toBe(17);
     expect(runCli).toHaveBeenCalledWith(['status'], {
       cwd: process.cwd(),
-      env: process.env
+      env: process.env,
     });
   });
 });