agentic-orchestrator 0.1.6 → 0.1.7

package/apps/control-plane/src/application/services/reactions-service.ts

@@ -1,5 +1,8 @@
 import { TOOLS } from '../../core/constants.js';
-import type { FeatureStatePayload, ToolCaller as SupervisorToolCaller } from '../../core/tool-caller.js';
+import type {
+  FeatureStatePayload,
+  ToolCaller as SupervisorToolCaller,
+} from '../../core/tool-caller.js';
 import type { NotifierService } from './notifier-service.js';
 
 export interface GateFailedReaction {
@@ -12,7 +15,12 @@ export interface GateFailedReaction {
 
 export interface ReactionsPolicy {
   gate_failed?: GateFailedReaction;
-  agent_stuck?: { enabled: boolean; action: string; idle_threshold_ms: number; escalate_after: number };
+  agent_stuck?: {
+    enabled: boolean;
+    action: string;
+    idle_threshold_ms: number;
+    escalate_after: number;
+  };
   collision_detected?: { enabled: boolean; action: string };
   ready_to_merge?: { enabled: boolean; action: string };
   changes_requested?: { enabled: boolean; action: string; escalate_after: number };
@@ -47,7 +55,7 @@ const DEFAULT_GATE_FAILED_REACTION: GateFailedReaction = {
   max_retries: 2,
   action: 'notify_only',
   escalate_after: 2,
-  retry_delay_ms: 30000
+  retry_delay_ms: 30000,
 };
 
 export class ReactionsService {
@@ -74,7 +82,11 @@ export class ReactionsService {
 
   retryDelayMs(): number {
     const reaction = this.policy.gate_failed ?? DEFAULT_GATE_FAILED_REACTION;
-    if (typeof reaction.retry_delay_ms === 'number' && Number.isFinite(reaction.retry_delay_ms) && reaction.retry_delay_ms >= 0) {
+    if (
+      typeof reaction.retry_delay_ms === 'number' &&
+      Number.isFinite(reaction.retry_delay_ms) &&
+      reaction.retry_delay_ms >= 0
+    ) {
       return Math.floor(reaction.retry_delay_ms);
     }
     return DEFAULT_GATE_FAILED_REACTION.retry_delay_ms;
@@ -82,7 +94,11 @@ export class ReactionsService {
 
   maxRetries(): number {
     const reaction = this.policy.gate_failed ?? DEFAULT_GATE_FAILED_REACTION;
-    if (typeof reaction.max_retries === 'number' && Number.isFinite(reaction.max_retries) && reaction.max_retries >= 0) {
+    if (
+      typeof reaction.max_retries === 'number' &&
+      Number.isFinite(reaction.max_retries) &&
+      reaction.max_retries >= 0
+    ) {
       return Math.floor(reaction.max_retries);
     }
     return DEFAULT_GATE_FAILED_REACTION.max_retries;
@@ -105,7 +121,7 @@ export class ReactionsService {
             .slice(-3)
             .map(
               (item) =>
-                `- attempt=${item.attempt}; gate=${item.gate_name}; exit=${item.exit_code}; at=${item.failed_at}; evidence=${item.evidence_summary || 'n/a'}`
+                `- attempt=${item.attempt}; gate=${item.gate_name}; exit=${item.exit_code}; at=${item.failed_at}; evidence=${item.evidence_summary || 'n/a'}`,
             )
             .join('\n')
         : '(none)';
@@ -121,12 +137,11 @@ export class ReactionsService {
       'Evidence:',
       ctx.evidenceSummary,
       '',
-      `Retry: ${ctx.retryCount + 1} of ${maxRetries}`
-      ,
+      `Retry: ${ctx.retryCount + 1} of ${maxRetries}`,
       `Retry delay (ms): ${delayMs}`,
       '',
       'Failure history (most recent first):',
-      failureSummary
+      failureSummary,
     ].join('\n');
   }
 
@@ -134,7 +149,7 @@ export class ReactionsService {
     const current = await this.toolCaller.callTool<FeatureStatePayload>(
       'orchestrator',
       TOOLS.FEATURE_STATE_GET,
-      { feature_id: featureId }
+      { feature_id: featureId },
     );
     await this.toolCaller.callTool('orchestrator', TOOLS.FEATURE_STATE_PATCH, {
       feature_id: featureId,
@@ -142,9 +157,9 @@ export class ReactionsService {
       patch: {
         front_matter: {
           gate_retry_count: retryCount,
-          last_retry_at: new Date().toISOString()
-        }
-      }
+          last_retry_at: new Date().toISOString(),
+        },
+      },
     });
   }
 
@@ -168,8 +183,8 @@ export class ReactionsService {
         max_retries: this.maxRetries(),
         escalate_after: (this.policy.gate_failed ?? DEFAULT_GATE_FAILED_REACTION).escalate_after,
         last_failure: ctx.failureHistory?.at(-1) ?? null,
-        failure_history: ctx.failureHistory ?? []
-      }
+        failure_history: ctx.failureHistory ?? [],
+      },
     });
   }
 }

package/apps/control-plane/src/application/services/reporting-service.ts

@@ -9,7 +9,8 @@ function normalizeSet(array: string[]): string[] {
 }
 
 function readHeldLocks(frontMatter: AnyRecord): string[] {
-  const locks = frontMatter?.locks && typeof frontMatter.locks === 'object' ? frontMatter.locks : {};
+  const locks =
+    frontMatter?.locks && typeof frontMatter.locks === 'object' ? frontMatter.locks : {};
   const held = Array.isArray(locks.held) ? locks.held : [];
   return held.filter((item: unknown): item is string => typeof item === 'string');
 }
@@ -48,14 +49,14 @@ export class ReportingService {
         const result = detectPlanCollisions(
           candidatePlan,
           [comparisonPlan],
-          this.port.getPolicySnapshot() as Parameters<typeof detectPlanCollisions>[2]
+          this.port.getPolicySnapshot() as Parameters<typeof detectPlanCollisions>[2],
         );
         if (result.hasCollisions) {
           matrix.push({
             feature_id: candidatePlan.feature_id,
             with_feature_id: comparisonPlan.feature_id,
             collisions: result.collisions,
-            fingerprint: createCollisionFingerprint(result.collisions)
+            fingerprint: createCollisionFingerprint(result.collisions),
           });
         }
       }
@@ -63,8 +64,8 @@ export class ReportingService {
 
     return {
       data: {
-        collisions: matrix
-      }
+        collisions: matrix,
+      },
     };
   }
 
@@ -74,7 +75,7 @@ export class ReportingService {
       ...index.active,
       ...index.blocked,
       ...index.merged,
-      ...Object.values(index.locks).filter(Boolean)
+      ...Object.values(index.locks).filter(Boolean),
     ]);
 
     const features = [];
@@ -85,7 +86,8 @@ export class ReportingService {
       }
       const state = await this.port.readState(featureId);
       const costData = await readJson<{ estimated_cost_usd: number; tokens_used: number }>(
-        this.port.featureCostPath(featureId), null
+        this.port.featureCostPath(featureId),
+        null,
       );
       features.push({
         feature_id: featureId,
@@ -104,15 +106,17 @@ export class ReportingService {
         activity_state: state.frontMatter.activity_state,
         activity_last_event_at: state.frontMatter.activity_last_event_at,
         activity_detected_via: state.frontMatter.activity_detected_via,
-        cost: costData ? { estimated_cost_usd: costData.estimated_cost_usd, tokens_used: costData.tokens_used } : null
+        cost: costData
+          ? { estimated_cost_usd: costData.estimated_cost_usd, tokens_used: costData.tokens_used }
+          : null,
       });
     }
 
     return {
       data: {
         index,
-        features
-      }
+        features,
+      },
     };
   }
 
@@ -128,8 +132,8 @@ export class ReportingService {
         diff_stat: bundle.data.diff_stat,
         touched_files: bundle.data.touched_files,
         last_gate_summary: bundle.data.last_gate_summary,
-        qa_summary: qa.data.summary
-      }
+        qa_summary: qa.data.summary,
+      },
     };
   }
 }

package/apps/control-plane/src/application/services/run-lease-service.ts

@@ -59,10 +59,14 @@ export class RunLeaseService {
   }> {
     if (!input.run_id || !input.owner_instance_id) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'run_id and owner_instance_id are required', {
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.INVALID_ARGUMENT,
+          'run_id and owner_instance_id are required',
+          {
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
@@ -76,33 +80,42 @@ export class RunLeaseService {
       const current = this.port.normalizeRuntimeSessions(await this.port.readRunLease());
       const hasLease = current.run_id !== 'none' && current.owner_instance_id !== 'none';
       const fresh = hasLease && this.port.isRunLeaseFresh(current);
-      const sameOwner = current.run_id === input.run_id && current.owner_instance_id === input.owner_instance_id;
+      const sameOwner =
+        current.run_id === input.run_id && current.owner_instance_id === input.owner_instance_id;
 
       if (fresh && !sameOwner) {
         throw {
-          normalizedResponse: fail(ERROR_CODES.RUN_ALREADY_ACTIVE, 'Another active run already owns this repository', {
-            active_run_id: current.run_id,
-            owner_instance_id: current.owner_instance_id,
-            lease_expires_at: current.lease_expires_at,
-            stale: false,
-            retryable: false,
-            requires_human: true
-          })
+          normalizedResponse: fail(
+            ERROR_CODES.RUN_ALREADY_ACTIVE,
+            'Another active run already owns this repository',
+            {
+              active_run_id: current.run_id,
+              owner_instance_id: current.owner_instance_id,
+              lease_expires_at: current.lease_expires_at,
+              stale: false,
+              retryable: false,
+              requires_human: true,
+            },
+          ),
         };
       }
 
       const staleOwnedByOther = hasLease && !fresh && !sameOwner;
       if (staleOwnedByOther && !input.takeover_stale_run) {
         throw {
-          normalizedResponse: fail(ERROR_CODES.RUN_ALREADY_ACTIVE, 'A stale run lease exists; explicit takeover is required', {
-            active_run_id: current.run_id,
-            owner_instance_id: current.owner_instance_id,
-            lease_expires_at: current.lease_expires_at,
-            stale: true,
-            requires_takeover: true,
-            retryable: false,
-            requires_human: true
-          })
+          normalizedResponse: fail(
+            ERROR_CODES.RUN_ALREADY_ACTIVE,
+            'A stale run lease exists; explicit takeover is required',
+            {
+              active_run_id: current.run_id,
+              owner_instance_id: current.owner_instance_id,
+              lease_expires_at: current.lease_expires_at,
+              stale: true,
+              requires_takeover: true,
+              retryable: false,
+              requires_human: true,
+            },
+          ),
         };
       }
 
@@ -119,7 +132,7 @@ export class RunLeaseService {
         started_at: sameOwner && current.started_at ? current.started_at : now,
         last_heartbeat_at: now,
         lease_expires_at: new Date(Date.now() + ttlMs).toISOString(),
-        orchestrator_epoch: isInitialRun ? 0 : Number(current.orchestrator_epoch ?? 0)
+        orchestrator_epoch: isInitialRun ? 0 : Number(current.orchestrator_epoch ?? 0),
       };
 
       if (!sameOwner) {
@@ -133,19 +146,26 @@ export class RunLeaseService {
         data: {
           runtime_sessions: claimed,
           took_over_stale: staleOwnedByOther,
-          reused_existing_owner: sameOwner
-        }
+          reused_existing_owner: sameOwner,
+        },
       };
     });
   }
 
-  async renewRunLease(runId: string, ownerInstanceId: string): Promise<{ data: { lease_expires_at: string } }> {
+  async renewRunLease(
+    runId: string,
+    ownerInstanceId: string,
+  ): Promise<{ data: { lease_expires_at: string } }> {
     if (!runId || !ownerInstanceId) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'runId and ownerInstanceId are required', {
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.INVALID_ARGUMENT,
+          'runId and ownerInstanceId are required',
+          {
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
@@ -154,33 +174,40 @@ export class RunLeaseService {
       const current = this.port.normalizeRuntimeSessions(await this.port.readRunLease());
       if (current.run_id !== runId || current.owner_instance_id !== ownerInstanceId) {
         throw {
-          normalizedResponse: fail(ERROR_CODES.RUN_LEASE_NOT_OWNED, 'Cannot renew a run lease not owned by this instance', {
-            run_id: runId,
-            owner_instance_id: ownerInstanceId,
-            active_run_id: current.run_id,
-            active_owner_instance_id: current.owner_instance_id,
-            retryable: false,
-            requires_human: true
-          })
+          normalizedResponse: fail(
+            ERROR_CODES.RUN_LEASE_NOT_OWNED,
+            'Cannot renew a run lease not owned by this instance',
+            {
+              run_id: runId,
+              owner_instance_id: ownerInstanceId,
+              active_run_id: current.run_id,
+              active_owner_instance_id: current.owner_instance_id,
+              retryable: false,
+              requires_human: true,
+            },
+          ),
         };
       }
 
       const updated: RuntimeSessionsSnapshot = {
         ...current,
         last_heartbeat_at: nowIso(),
-        lease_expires_at: new Date(Date.now() + ttlMs).toISOString()
+        lease_expires_at: new Date(Date.now() + ttlMs).toISOString(),
       };
       await this.port.writeRunLease(updated);
 
       return {
         data: {
-          lease_expires_at: updated.lease_expires_at
-        }
+          lease_expires_at: updated.lease_expires_at,
+        },
       };
     });
   }
 
-  async releaseRunLease(runId: string, ownerInstanceId: string): Promise<{ data: { released: boolean } }> {
+  async releaseRunLease(
+    runId: string,
+    ownerInstanceId: string,
+  ): Promise<{ data: { released: boolean } }> {
     return await this.port.withIndexLock(async () => {
       const current = this.port.normalizeRuntimeSessions(await this.port.readRunLease());
       if (current.run_id !== runId || current.owner_instance_id !== ownerInstanceId) {
@@ -201,10 +228,14 @@ export class RunLeaseService {
     const { run_id, owner_instance_id, orchestrator_session_id, increment_epoch = false } = params;
     if (!run_id || !owner_instance_id || !orchestrator_session_id) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'run_id, owner_instance_id, and orchestrator_session_id are required', {
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.INVALID_ARGUMENT,
+          'run_id, owner_instance_id, and orchestrator_session_id are required',
+          {
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
@@ -212,14 +243,18 @@ export class RunLeaseService {
       const current = this.port.normalizeRuntimeSessions(await this.port.readRunLease());
       if (current.run_id !== run_id || current.owner_instance_id !== owner_instance_id) {
         throw {
-          normalizedResponse: fail(ERROR_CODES.RUN_LEASE_NOT_OWNED, 'Cannot update orchestrator session without run ownership', {
-            run_id,
-            owner_instance_id,
-            active_run_id: current.run_id,
-            active_owner_instance_id: current.owner_instance_id,
-            retryable: false,
-            requires_human: true
-          })
+          normalizedResponse: fail(
+            ERROR_CODES.RUN_LEASE_NOT_OWNED,
+            'Cannot update orchestrator session without run ownership',
+            {
+              run_id,
+              owner_instance_id,
+              active_run_id: current.run_id,
+              active_owner_instance_id: current.owner_instance_id,
+              retryable: false,
+              requires_human: true,
+            },
+          ),
         };
       }
 
@@ -229,33 +264,46 @@ export class RunLeaseService {
       const updated: RuntimeSessionsSnapshot = {
         ...current,
         orchestrator_session_id,
-        orchestrator_epoch: nextEpoch
+        orchestrator_epoch: nextEpoch,
       };
       await this.port.writeRunLease(updated);
 
       return {
         data: {
-          runtime_sessions: updated
-        }
+          runtime_sessions: updated,
+        },
       };
     });
   }
 
-  async updateFeatureSessionAssignment(params: RuntimeFeatureSessionUpdateParams): Promise<{ data: { updated: boolean } }> {
-    const { run_id, owner_instance_id, feature_id, planner_session_id, builder_session_id, qa_session_id } = params;
+  async updateFeatureSessionAssignment(
+    params: RuntimeFeatureSessionUpdateParams,
+  ): Promise<{ data: { updated: boolean } }> {
+    const {
+      run_id,
+      owner_instance_id,
+      feature_id,
+      planner_session_id,
+      builder_session_id,
+      qa_session_id,
+    } = params;
 
     return await this.port.withIndexLock(async () => {
       const current = this.port.normalizeRuntimeSessions(await this.port.readRunLease());
       if (current.run_id !== run_id || current.owner_instance_id !== owner_instance_id) {
         throw {
-          normalizedResponse: fail(ERROR_CODES.RUN_LEASE_NOT_OWNED, 'Cannot update feature sessions without run ownership', {
-            run_id,
-            owner_instance_id,
-            active_run_id: current.run_id,
-            active_owner_instance_id: current.owner_instance_id,
-            retryable: false,
-            requires_human: true
-          })
+          normalizedResponse: fail(
+            ERROR_CODES.RUN_LEASE_NOT_OWNED,
+            'Cannot update feature sessions without run ownership',
+            {
+              run_id,
+              owner_instance_id,
+              active_run_id: current.run_id,
+              active_owner_instance_id: current.owner_instance_id,
+              retryable: false,
+              requires_human: true,
+            },
+          ),
         };
       }
 
@@ -264,32 +312,41 @@ export class RunLeaseService {
         [feature_id]: {
           planner_session_id,
           builder_session_id,
-          qa_session_id
-        }
+          qa_session_id,
+        },
       };
 
       await this.port.writeRunLease({
         ...current,
-        feature_sessions: nextFeatureSessions
+        feature_sessions: nextFeatureSessions,
       });
       return { data: { updated: true } };
     });
   }
 
-  async pruneFeatureSessionAssignments(params: PruneFeatureSessionParams): Promise<{ data: { removed: string[] } }> {
+  async pruneFeatureSessionAssignments(
+    params: PruneFeatureSessionParams,
+  ): Promise<{ data: { removed: string[] } }> {
     const active = new Set(params.active_feature_ids);
     return await this.port.withIndexLock(async () => {
       const current = this.port.normalizeRuntimeSessions(await this.port.readRunLease());
-      if (current.run_id !== params.run_id || current.owner_instance_id !== params.owner_instance_id) {
+      if (
+        current.run_id !== params.run_id ||
+        current.owner_instance_id !== params.owner_instance_id
+      ) {
         throw {
-          normalizedResponse: fail(ERROR_CODES.RUN_LEASE_NOT_OWNED, 'Cannot prune feature sessions without run ownership', {
-            run_id: params.run_id,
-            owner_instance_id: params.owner_instance_id,
-            active_run_id: current.run_id,
-            active_owner_instance_id: current.owner_instance_id,
-            retryable: false,
-            requires_human: true
-          })
+          normalizedResponse: fail(
+            ERROR_CODES.RUN_LEASE_NOT_OWNED,
+            'Cannot prune feature sessions without run ownership',
+            {
+              run_id: params.run_id,
+              owner_instance_id: params.owner_instance_id,
+              active_run_id: current.run_id,
+              active_owner_instance_id: current.owner_instance_id,
+              retryable: false,
+              requires_human: true,
+            },
+          ),
         };
       }
 
@@ -307,7 +364,7 @@ export class RunLeaseService {
       if (removed.length > 0) {
         await this.port.writeRunLease({
           ...current,
-          feature_sessions: kept
+          feature_sessions: kept,
         });
       }
 

package/apps/control-plane/src/application/tools/tool-metadata.ts

@@ -21,13 +21,13 @@ const MUTATING_TOOLS = [
   TOOLS.FEATURE_DELETE,
   TOOLS.FEATURE_SEND_MESSAGE,
   TOOLS.COST_RECORD,
-  TOOLS.PERFORMANCE_RECORD_OUTCOME
+  TOOLS.PERFORMANCE_RECORD_OUTCOME,
 ] as const;
 
 export const TOOL_BEHAVIOR_METADATA: Readonly<Record<string, ToolBehaviorMetadata>> = Object.freeze(
   Object.fromEntries(
-    MUTATING_TOOLS.map((name) => [name, { mutating: true, requires_operation_id: true }])
-  )
+    MUTATING_TOOLS.map((name) => [name, { mutating: true, requires_operation_id: true }]),
+  ),
 );
 
 export function isMutatingTool(toolName: string): boolean {
@@ -41,7 +41,7 @@ export function toolRequiresOperationId(toolName: string): boolean {
 export function withOperationIdIfRequired(
   toolName: string,
   args: Record<string, unknown>,
-  createOperationId: (toolName: string, featureId?: string) => string
+  createOperationId: (toolName: string, featureId?: string) => string,
 ): Record<string, unknown> {
   if (!toolRequiresOperationId(toolName)) {
     return { ...args };
@@ -54,6 +54,6 @@ export function withOperationIdIfRequired(
   const featureId = typeof args.feature_id === 'string' ? args.feature_id : undefined;
   return {
     ...args,
-    operation_id: createOperationId(toolName, featureId)
+    operation_id: createOperationId(toolName, featureId),
   };
 }

package/apps/control-plane/src/application/tools/tool-router.ts

@@ -5,7 +5,7 @@ export interface ToolHandlerContext {
 
 export type ToolHandler = (
   args: Record<string, unknown>,
-  context: ToolHandlerContext
+  context: ToolHandlerContext,
 ) => Promise<unknown>;
 
 export class ToolHandlerRegistry {
@@ -24,7 +24,10 @@ export class ToolRouter {
   private readonly registry: ToolHandlerRegistry;
   private readonly unknownToolHandler: (toolName: string) => Promise<unknown>;
 
-  constructor(registry: ToolHandlerRegistry, unknownToolHandler: (toolName: string) => Promise<unknown>) {
+  constructor(
+    registry: ToolHandlerRegistry,
+    unknownToolHandler: (toolName: string) => Promise<unknown>,
+  ) {
     this.registry = registry;
     this.unknownToolHandler = unknownToolHandler;
   }
@@ -32,7 +35,7 @@ export class ToolRouter {
   async route(
     toolName: string,
     args: Record<string, unknown>,
-    context: ToolHandlerContext
+    context: ToolHandlerContext,
   ): Promise<unknown> {
     const handler = this.registry.lookup(toolName);
     if (!handler) {

package/apps/control-plane/src/cli/aop.ts

@@ -7,7 +7,7 @@ import type { RuntimeContext } from './types.js';
 
 export async function main(
   argv: string[] = process.argv.slice(2),
-  runtime: RuntimeContext = { cwd: process.cwd(), env: process.env }
+  runtime: RuntimeContext = { cwd: process.cwd(), env: process.env },
 ): Promise<number> {
   return await runCli(argv, runtime);
 }
@@ -50,7 +50,7 @@ export function isDirectExecution(importMetaUrl: string, argv1: string | undefin
 export function runAsEntrypoint(
   importMetaUrl: string,
   argv1: string | undefined,
-  executeMain: () => Promise<number> = () => main()
+  executeMain: () => Promise<number> = () => main(),
 ): boolean {
   if (!isDirectExecution(importMetaUrl, argv1)) {
     return false;