agentic-orchestrator 0.1.6 → 0.1.8

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

@@ -4,7 +4,11 @@ import { sortResourcesDeterministically } from '../../core/path-rules.js';
 import { ERROR_CODES } from '../../core/error-codes.js';
 import { fail } from '../../core/response.js';
 import { GATE_RESULT, STATUS } from '../../core/constants.js';
-import { getUnresolvedDeps, detectCircularDependency, addToDepBlocked } from './dependency-scheduler-service.js';
+import {
+  getUnresolvedDeps,
+  detectCircularDependency,
+  addToDepBlocked,
+} from './dependency-scheduler-service.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type AnyRecord = Record<string, any>;
@@ -15,7 +19,7 @@ type StateReadResult = {
 
 type StateUpdater = (
   frontMatter: AnyRecord,
-  body: string
+  body: string,
 ) => Promise<{ frontMatter?: AnyRecord; body?: string }>;
 
 function asArray<T = unknown>(value: unknown): T[] {
@@ -46,7 +50,11 @@ export interface PlanServicePort {
   withIndexLock<T>(operation: () => Promise<T>): Promise<T>;
   readIndex(): Promise<AnyRecord>;
   writeIndex(index: AnyRecord): Promise<void>;
-  updateState(featureId: string, expectedVersion: number | null, updater: StateUpdater): Promise<AnyRecord>;
+  updateState(
+    featureId: string,
+    expectedVersion: number | null,
+    updater: StateUpdater,
+  ): Promise<AnyRecord>;
 }
 
 export class PlanService {
@@ -61,8 +69,8 @@ export class PlanService {
     return {
       data: {
         feature_id: featureId,
-        plan
-      }
+        plan,
+      },
     };
   }
 
@@ -103,25 +111,37 @@ export class PlanService {
     const missing = required.filter((resource) => !held.has(resource));
     if (missing.length > 0) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.LOCK_NOT_HELD, 'Plan requires lock(s) that are not held', {
-          feature_id: featureId,
-          missing_resources: missing,
-          retryable: true,
-          requires_human: false,
-          suggested_next_actions: ['Acquire required locks before submitting plan']
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.LOCK_NOT_HELD,
+          'Plan requires lock(s) that are not held',
+          {
+            feature_id: featureId,
+            missing_resources: missing,
+            retryable: true,
+            requires_human: false,
+            suggested_next_actions: ['Acquire required locks before submitting plan'],
+          },
+        ),
       };
     }
   }
 
-  validatePlanRevisionRules(existingPlan: AnyRecord | null, plan: AnyRecord, expectedPlanVersion: number | null = null): void {
+  validatePlanRevisionRules(
+    existingPlan: AnyRecord | null,
+    plan: AnyRecord,
+    expectedPlanVersion: number | null = null,
+  ): void {
     if (!existingPlan) {
       if (plan.plan_version !== 1 || plan.revision_of != null) {
         throw {
-          normalizedResponse: fail(ERROR_CODES.PLAN_VALIDATION_FAILED, 'Initial plan must be version 1 without revision_of', {
-            retryable: false,
-            requires_human: true
-          })
+          normalizedResponse: fail(
+            ERROR_CODES.PLAN_VALIDATION_FAILED,
+            'Initial plan must be version 1 without revision_of',
+            {
+              retryable: false,
+              requires_human: true,
+            },
+          ),
         };
       }
       return;
@@ -133,17 +153,21 @@ export class PlanService {
           expected_plan_version: expectedPlanVersion,
           actual_plan_version: existingPlan.plan_version,
           retryable: true,
-          requires_human: false
-        })
+          requires_human: false,
+        }),
       };
     }
 
     if (plan.plan_version !== expectedPlanVersion + 1 || plan.revision_of !== expectedPlanVersion) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.PLAN_VALIDATION_FAILED, 'Invalid plan revision metadata', {
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.PLAN_VALIDATION_FAILED,
+          'Invalid plan revision metadata',
+          {
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
   }
@@ -152,11 +176,15 @@ export class PlanService {
     const validation = await this.port.validateSchema('plan.schema.json', plan);
     if (!validation.valid) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.PLAN_VALIDATION_FAILED, 'plan.json failed schema validation', {
-          errors: validation.errors,
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.PLAN_VALIDATION_FAILED,
+          'plan.json failed schema validation',
+          {
+            errors: validation.errors,
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
   }
@@ -167,7 +195,7 @@ export class PlanService {
     const collisionResult = detectPlanCollisions(
       plan as Parameters<typeof detectPlanCollisions>[0],
       acceptedPlans as Parameters<typeof detectPlanCollisions>[1],
-      policy as Parameters<typeof detectPlanCollisions>[2]
+      policy as Parameters<typeof detectPlanCollisions>[2],
     );
 
     if (!collisionResult.hasCollisions) {
@@ -176,26 +204,30 @@ export class PlanService {
 
     if (policy.collision_policy === 'reject') {
       throw {
-        normalizedResponse: fail(ERROR_CODES.COLLISION_DETECTED, 'Plan collides with accepted plans', {
-          feature_id: featureId,
-          collisions: collisionResult.collisions,
-          collision_fingerprint: collisionResult.fingerprint,
-          conflicting_feature_ids: normalizeSet(
-            collisionResult.collisions.files
-              .map((x) => x.with_feature_id)
-              .concat(
-                collisionResult.collisions.areas.map((x) => x.with_feature_id),
-                collisionResult.collisions.contracts.map((x) => x.with_feature_id)
-              )
-          ),
-          retryable: false,
-          requires_human: true,
-          suggested_next_actions: [
-            'Acquire relevant lock and resubmit',
-            'Revise plan scope to avoid overlap',
-            'Create shared prerequisite feature'
-          ]
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.COLLISION_DETECTED,
+          'Plan collides with accepted plans',
+          {
+            feature_id: featureId,
+            collisions: collisionResult.collisions,
+            collision_fingerprint: collisionResult.fingerprint,
+            conflicting_feature_ids: normalizeSet(
+              collisionResult.collisions.files
+                .map((x) => x.with_feature_id)
+                .concat(
+                  collisionResult.collisions.areas.map((x) => x.with_feature_id),
+                  collisionResult.collisions.contracts.map((x) => x.with_feature_id),
+                ),
+            ),
+            retryable: false,
+            requires_human: true,
+            suggested_next_actions: [
+              'Acquire relevant lock and resubmit',
+              'Revise plan scope to avoid overlap',
+              'Create shared prerequisite feature',
+            ],
+          },
+        ),
       };
     }
 
@@ -207,10 +239,11 @@ export class PlanService {
         detected_at: nowIso(),
         collision_fingerprint: collisionResult.fingerprint,
         required_resources: await this.requiredResourcesForPlan(plan),
-        plan_snapshot: plan
+        plan_snapshot: plan,
       });
       index.blocked_queue.sort(
-        (a: AnyRecord, b: AnyRecord) => a.detected_at.localeCompare(b.detected_at) || a.feature_id.localeCompare(b.feature_id)
+        (a: AnyRecord, b: AnyRecord) =>
+          a.detected_at.localeCompare(b.detected_at) || a.feature_id.localeCompare(b.feature_id),
       );
       index.version += 1;
       index.updated_at = nowIso();
@@ -218,39 +251,53 @@ export class PlanService {
     });
 
     throw {
-      normalizedResponse: fail(ERROR_CODES.BLOCKED_BY_COLLISION_POLICY, 'Plan queued due to collision policy=block', {
-        feature_id: featureId,
-        collision_fingerprint: collisionResult.fingerprint,
-        collisions: collisionResult.collisions,
-        retryable: true,
-        requires_human: false
-      })
+      normalizedResponse: fail(
+        ERROR_CODES.BLOCKED_BY_COLLISION_POLICY,
+        'Plan queued due to collision policy=block',
+        {
+          feature_id: featureId,
+          collision_fingerprint: collisionResult.fingerprint,
+          collisions: collisionResult.collisions,
+          retryable: true,
+          requires_human: false,
+        },
+      ),
     };
   }
 
   async checkDependencies(featureId: string | null): Promise<void> {
-    if (!featureId) {return;}
+    if (!featureId) {
+      return;
+    }
     const state = await this.port.readState(featureId);
     const dependsOn: string[] = Array.isArray(state.frontMatter.depends_on)
       ? (state.frontMatter.depends_on as string[]).filter((d): d is string => typeof d === 'string')
       : [];
-    if (dependsOn.length === 0) {return;}
+    if (dependsOn.length === 0) {
+      return;
+    }
 
     // Circular detection: traverse the dependency chain
     const depsCache = new Map<string, string[]>([[featureId, dependsOn]]);
     const getDirectDeps = (id: string): string[] => {
-      if (depsCache.has(id)) {return depsCache.get(id);}
+      if (depsCache.has(id)) {
+        return depsCache.get(id);
+      }
       return [];
     };
     const cycle = detectCircularDependency(featureId, getDirectDeps);
     if (cycle) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.DEPENDENCY_CIRCULAR, `Circular dependency detected: ${cycle}`, {
-          feature_id: featureId,
-          cycle,
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.DEPENDENCY_CIRCULAR,
+          `Circular dependency detected: ${cycle}`,
+          {
+            feature_id: featureId,
+            cycle,
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
@@ -265,12 +312,16 @@ export class PlanService {
         await this.port.writeIndex(idx);
       });
       throw {
-        normalizedResponse: fail(ERROR_CODES.DEPENDENCY_UNRESOLVED, 'Plan deferred: dependencies not yet merged', {
-          feature_id: featureId,
-          depends_on_unresolved: unresolved,
-          retryable: true,
-          requires_human: false
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.DEPENDENCY_UNRESOLVED,
+          'Plan deferred: dependencies not yet merged',
+          {
+            feature_id: featureId,
+            depends_on_unresolved: unresolved,
+            retryable: true,
+            requires_human: false,
+          },
+        ),
       };
     }
   }
@@ -278,25 +329,29 @@ export class PlanService {
   async planSubmit(
     featureId: string | null,
     plan: AnyRecord | null,
-    expectedVersion: number | null = null
+    expectedVersion: number | null = null,
   ): Promise<{ data: { feature_id: string | null; accepted: boolean; plan_version: number } }> {
     if (!plan || typeof plan !== 'object') {
       throw {
         normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'plan_json is required', {
           retryable: false,
-          requires_human: true
-        })
+          requires_human: true,
+        }),
       };
     }
 
     if (plan.feature_id !== featureId) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'plan.feature_id must match feature_id', {
-          feature_id: featureId,
-          plan_feature_id: plan.feature_id,
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.INVALID_ARGUMENT,
+          'plan.feature_id must match feature_id',
+          {
+            feature_id: featureId,
+            plan_feature_id: plan.feature_id,
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
@@ -325,16 +380,16 @@ export class PlanService {
           gate_profile: plan.gate_profile,
           gates: {
             ...frontMatter.gates,
-            plan: GATE_RESULT.PASS
+            plan: GATE_RESULT.PASS,
           },
           status: nextStatus,
           collisions: {
             files: [],
             areas: [],
-            contracts: []
-          }
+            contracts: [],
+          },
         },
-        body
+        body,
       });
     });
 
@@ -342,12 +397,16 @@ export class PlanService {
       data: {
         feature_id: featureId,
         accepted: true,
-        plan_version: plan.plan_version
-      }
+        plan_version: plan.plan_version,
+      },
     };
   }
 
-  async planUpdate(featureId: string | null, expectedPlanVersion: number | null, plan: AnyRecord | null) {
+  async planUpdate(
+    featureId: string | null,
+    expectedPlanVersion: number | null,
+    plan: AnyRecord | null,
+  ) {
     return await this.planSubmit(featureId, plan, expectedPlanVersion);
   }
 }

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

@@ -15,7 +15,13 @@ export interface LoadPolicyResult {
 function resolveBundledDefaultsPath(startDir: string): string | null {
   let current = path.resolve(startDir);
   while (true) {
-    const candidate = path.join(current, 'agentic', 'orchestrator', 'defaults', 'policy.defaults.yaml');
+    const candidate = path.join(
+      current,
+      'agentic',
+      'orchestrator',
+      'defaults',
+      'policy.defaults.yaml',
+    );
     if (fsSync.existsSync(candidate)) {
       return candidate;
     }
@@ -85,12 +91,12 @@ export function mergePolicy(defaults: unknown, user: unknown): unknown {
 export async function loadComposedPolicy(
   _repoRoot: string,
   policyPath: string,
-  schemaRegistry: SchemaValidator
+  schemaRegistry: SchemaValidator,
 ): Promise<LoadPolicyResult> {
   if (!BUNDLED_DEFAULTS_PATH) {
     throw new Error(
       'policy_defaults_not_found: bundled defaults artifact could not be located; ' +
-        'ensure agentic/orchestrator/defaults/policy.defaults.yaml exists in the AOP installation'
+        'ensure agentic/orchestrator/defaults/policy.defaults.yaml exists in the AOP installation',
     );
   }
 
@@ -107,7 +113,7 @@ export async function loadComposedPolicy(
     const messages = validation.errors.map((e) => e.message ?? String(e)).join('; ');
     throw new Error(
       `invalid_policy_yaml: ${messages} ` +
-        `(merged from ${policyPath} over bundled defaults; check policy.yaml for invalid overrides)`
+        `(merged from ${policyPath} over bundled defaults; check policy.yaml for invalid overrides)`,
     );
   }
 

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

@@ -1,7 +1,10 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 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';
 
 const execFileAsync = promisify(execFile);
@@ -75,7 +78,9 @@ function mapCiStatus(checks: Array<{ state: string }> | null | undefined): CiSta
   if (upper.some((s) => s === 'FAILURE' || s === 'ERROR')) {
     return 'failing';
   }
-  if (upper.some((s) => s === 'PENDING' || s === 'IN_PROGRESS' || s === 'EXPECTED' || s === 'WAITING')) {
+  if (
+    upper.some((s) => s === 'PENDING' || s === 'IN_PROGRESS' || s === 'EXPECTED' || s === 'WAITING')
+  ) {
     return 'pending';
   }
   return 'passing';
@@ -111,12 +116,20 @@ export class PrMonitorService {
   }
 
   async detectPr(featureId: string, branch: string): Promise<PrInfo | null> {
-    const candidates = [...new Set([branch, featureId, `feature/${featureId}`].map((value) => value.trim()).filter(Boolean))];
+    const candidates = [
+      ...new Set(
+        [branch, featureId, `feature/${featureId}`].map((value) => value.trim()).filter(Boolean),
+      ),
+    ];
     let parsed: GhPrViewResult | null = null;
     for (const candidate of candidates) {
       const result = await this.ghRunner([
-        'pr', 'view', '--head', candidate,
-        '--json', 'number,url,statusCheckRollup,reviewDecision,mergeable,reviewThreads'
+        'pr',
+        'view',
+        '--head',
+        candidate,
+        '--json',
+        'number,url,statusCheckRollup,reviewDecision,mergeable,reviewThreads',
       ]);
 
       if (result.exitCode !== 0 || !result.stdout.trim()) {
@@ -152,7 +165,7 @@ export class PrMonitorService {
       review_decision,
       merge_ready,
       pending_review_threads,
-      has_conflicts
+      has_conflicts,
     };
     const merge_score = this.computeMergeScore({ ...partial, merge_score: 0 });
     return { ...partial, merge_score };
@@ -162,7 +175,7 @@ export class PrMonitorService {
     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, {
@@ -178,10 +191,10 @@ export class PrMonitorService {
             merge_ready: prInfo.merge_ready,
             pending_review_threads: prInfo.pending_review_threads,
             has_conflicts: prInfo.has_conflicts,
-            merge_score: prInfo.merge_score
-          }
-        }
-      }
+            merge_score: prInfo.merge_score,
+          },
+        },
+      },
     });
   }
 
@@ -211,7 +224,13 @@ export class PrMonitorService {
       return;
     }
 
-    const reviewResult = await this.ghRunner(['pr', 'view', String(prInfo.number), '--json', 'reviews']);
+    const reviewResult = await this.ghRunner([
+      'pr',
+      'view',
+      String(prInfo.number),
+      '--json',
+      'reviews',
+    ]);
 
     let reviewBody = '';
     if (reviewResult.exitCode === 0 && reviewResult.stdout.trim()) {
@@ -226,7 +245,7 @@ export class PrMonitorService {
 
     await this.toolCaller.callTool('orchestrator', TOOLS.FEATURE_LOG_APPEND, {
       feature_id: featureId,
-      note: `PR #${prInfo.number} changes requested. Review context:\n${reviewBody}`
+      note: `PR #${prInfo.number} changes requested. Review context:\n${reviewBody}`,
     });
 
     await this.toolCaller
@@ -240,7 +259,7 @@ export class PrMonitorService {
       await this.notifier.notify('changes_requested', {
         feature_id: featureId,
         message: `PR #${prInfo.number} has changes requested for feature '${featureId}'.`,
-        details: { pr_number: prInfo.number, pr_url: prInfo.url }
+        details: { pr_number: prInfo.number, pr_url: prInfo.url },
       });
     }
   }

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

@@ -29,7 +29,7 @@ export class QaIndexService {
       feature_id: featureId,
       version: 1,
       source_diff_ref: stableHash('empty'),
-      items: []
+      items: [],
     });
 
     const validation = await this.port.validateSchema('qa_test_index.schema.json', index);
@@ -38,8 +38,8 @@ export class QaIndexService {
         normalizedResponse: fail(ERROR_CODES.INTERNAL_ERROR, 'qa_test_index file is invalid', {
           errors: validation.errors,
           retryable: false,
-          requires_human: true
-        })
+          requires_human: true,
+        }),
       };
     }
 
@@ -48,8 +48,8 @@ export class QaIndexService {
       data: {
         index,
         summary: summary.summary,
-        pending_required_tests: summary.pending_by_file
-      }
+        pending_required_tests: summary.pending_by_file,
+      },
     };
   }
 
@@ -57,15 +57,15 @@ export class QaIndexService {
     featureId: string,
     expectedVersion: number | null,
     updates: unknown,
-    evidenceRefs: unknown[]
+    evidenceRefs: unknown[],
   ): Promise<{ data: { feature_id: string; version: number } }> {
     const current = await readJson(this.port.qaIndexPath(featureId), null);
     if (!current) {
       throw {
         normalizedResponse: fail(ERROR_CODES.FILE_NOT_FOUND, 'qa_test_index.json not found', {
           retryable: false,
-          requires_human: true
-        })
+          requires_human: true,
+        }),
       };
     }
 
@@ -73,16 +73,20 @@ export class QaIndexService {
       current,
       expectedVersion,
       updates as Parameters<typeof applyQaUpdates>[2],
-      evidenceRefs as Parameters<typeof applyQaUpdates>[3]
+      evidenceRefs as Parameters<typeof applyQaUpdates>[3],
     );
     const validation = await this.port.validateSchema('qa_test_index.schema.json', next);
     if (!validation.valid) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.INTERNAL_ERROR, 'qa_test_index update failed validation', {
-          errors: validation.errors,
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.INTERNAL_ERROR,
+          'qa_test_index update failed validation',
+          {
+            errors: validation.errors,
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
@@ -91,8 +95,8 @@ export class QaIndexService {
     return {
       data: {
         feature_id: featureId,
-        version: next.version
-      }
+        version: next.version,
+      },
     };
   }
 }