agentic-orchestrator 0.1.6 → 0.1.8

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

@@ -21,7 +21,7 @@ export function getUnresolvedDeps(dependsOn: string[], mergedFeatures: string[])
  */
 export function detectCircularDependency(
   startId: string,
-  getDirectDeps: (id: string) => string[]
+  getDirectDeps: (id: string) => string[],
 ): string | null {
   const visited = new Set<string>();
   const stack: string[] = [];
@@ -30,11 +30,15 @@ export function detectCircularDependency(
     if (stack.includes(id)) {
       return true; // cycle found
     }
-    if (visited.has(id)) {return false;}
+    if (visited.has(id)) {
+      return false;
+    }
     visited.add(id);
     stack.push(id);
     for (const dep of getDirectDeps(id)) {
-      if (dfs(dep)) {return true;}
+      if (dfs(dep)) {
+        return true;
+      }
     }
     stack.pop();
     return false;
@@ -50,7 +54,11 @@ export function detectCircularDependency(
 /**
  * Adds (or updates) a feature's entry in `index.dep_blocked`.
  */
-export function addToDepBlocked(index: AnyRecord, featureId: string, unresolvedDeps: string[]): void {
+export function addToDepBlocked(
+  index: AnyRecord,
+  featureId: string,
+  unresolvedDeps: string[],
+): void {
   const depBlocked: DepBlockedEntry[] = Array.isArray(index.dep_blocked) ? index.dep_blocked : [];
   const existing = depBlocked.findIndex((e) => e.feature_id === featureId);
   const entry: DepBlockedEntry = { feature_id: featureId, depends_on_unresolved: unresolvedDeps };

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

@@ -127,11 +127,13 @@ function makeEmptySummary(): FeatureDeleteSummary {
     index_updated: false,
     locks_released: [],
     blocked_queue_entries_removed: 0,
-    runtime_session_assignment_removed: false
+    runtime_session_assignment_removed: false,
   };
 }
 
-function normalizeFeatureSessions(runtimeSessions: RuntimeSessionsSnapshot): Record<string, unknown> {
+function normalizeFeatureSessions(
+  runtimeSessions: RuntimeSessionsSnapshot,
+): Record<string, unknown> {
   return runtimeSessions.feature_sessions && typeof runtimeSessions.feature_sessions === 'object'
     ? (runtimeSessions.feature_sessions as unknown as Record<string, unknown>)
     : {};
@@ -160,13 +162,16 @@ export class FeatureDeletionService {
     this.port = port;
   }
 
-  async featureDelete(featureId: string | null, options: DeleteOptions = {}): Promise<FeatureDeleteResult> {
+  async featureDelete(
+    featureId: string | null,
+    options: DeleteOptions = {},
+  ): Promise<FeatureDeleteResult> {
     if (!featureId) {
       throw {
         normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'feature_id is required', {
           retryable: false,
-          requires_human: true
-        })
+          requires_human: true,
+        }),
       };
     }
     if (!isFeatureId(featureId)) {
@@ -175,19 +180,23 @@ export class FeatureDeletionService {
           feature_id: featureId,
           expected_pattern: '^[a-z0-9_][a-z0-9_-]*$',
           retryable: false,
-          requires_human: true
-        })
+          requires_human: true,
+        }),
       };
     }
 
     const branchMode = readBranchMode(options.removeBranch);
     if (!branchMode) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'remove_branch must be one of none|safe|force', {
-          remove_branch: options.removeBranch,
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.INVALID_ARGUMENT,
+          'remove_branch must be one of none|safe|force',
+          {
+            remove_branch: options.removeBranch,
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
@@ -196,10 +205,14 @@ export class FeatureDeletionService {
     const removeWorktree = options.removeWorktree ?? true;
     if (!dryRun && !confirm) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'confirm must be true when dry_run is false', {
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.INVALID_ARGUMENT,
+          'confirm must be true when dry_run is false',
+          {
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
@@ -214,7 +227,7 @@ export class FeatureDeletionService {
       qa_test_index_json: await pathExists(path.join(featurePath, 'qa_test_index.json')),
       decisions_md: await pathExists(path.join(featurePath, 'decisions.md')),
       logs_dir: await pathExists(path.join(featurePath, 'logs')),
-      evidence_dir: await pathExists(path.join(featurePath, 'evidence'))
+      evidence_dir: await pathExists(path.join(featurePath, 'evidence')),
     };
     const featureDirExists = await pathExists(featurePath);
     const worktreeExists = await pathExists(worktreePath);
@@ -227,34 +240,40 @@ export class FeatureDeletionService {
     const runtimeSessions = await this.port.readRunLease();
     if (this.hasFreshRunLease(runtimeSessions)) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.RUN_ALREADY_ACTIVE, 'Cannot delete feature while a run lease is active', {
-          active_run_id: runtimeSessions.run_id,
-          owner_instance_id: runtimeSessions.owner_instance_id,
-          lease_expires_at: runtimeSessions.lease_expires_at,
-          stale: false,
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.RUN_ALREADY_ACTIVE,
+          'Cannot delete feature while a run lease is active',
+          {
+            active_run_id: runtimeSessions.run_id,
+            owner_instance_id: runtimeSessions.owner_instance_id,
+            lease_expires_at: runtimeSessions.lease_expires_at,
+            stale: false,
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
     const blockedQueueEntries = asStringArray(
       asArray(indexSnapshot.blocked_queue).map((entry) => {
         const record = asRecord(entry);
-        return typeof record.feature_id === 'string' && record.feature_id === featureId ? featureId : null;
-      })
+        return typeof record.feature_id === 'string' && record.feature_id === featureId
+          ? featureId
+          : null;
+      }),
     ).length;
 
     const indexMembership = {
       active: asStringArray(indexSnapshot.active).includes(featureId),
       blocked: asStringArray(indexSnapshot.blocked).includes(featureId),
-      merged: asStringArray(indexSnapshot.merged).includes(featureId)
+      merged: asStringArray(indexSnapshot.merged).includes(featureId),
     };
 
     const runtimeFeatureSessions = normalizeFeatureSessions(runtimeSessions);
     const runtimeSessionAssignmentExists = Object.prototype.hasOwnProperty.call(
       runtimeFeatureSessions,
-      featureId
+      featureId,
     );
     const indexHeldLocks = readLockResourcesFromIndex(indexSnapshot, featureId);
 
@@ -264,14 +283,14 @@ export class FeatureDeletionService {
       index_membership: indexMembership,
       locks: {
         state_held: stateHeldLocks,
-        index_held_resources: indexHeldLocks
+        index_held_resources: indexHeldLocks,
       },
       blocked_queue_entries: blockedQueueEntries,
       runtime_session_assignment_exists: runtimeSessionAssignmentExists,
       worktree_exists: worktreeExists,
       branch_exists: branchExists,
       remove_worktree: removeWorktree,
-      remove_branch: branchMode
+      remove_branch: branchMode,
     };
 
     const summary = makeEmptySummary();
@@ -281,8 +300,8 @@ export class FeatureDeletionService {
           feature_id: featureId,
           dry_run: true,
           plan,
-          summary
-        }
+          summary,
+        },
       };
     }
 
@@ -352,7 +371,8 @@ export class FeatureDeletionService {
       const featureSessions = normalizeFeatureSessions(currentRunLease);
       if (Object.prototype.hasOwnProperty.call(featureSessions, featureId)) {
         delete featureSessions[featureId];
-        currentRunLease.feature_sessions = featureSessions as RuntimeSessionsSnapshot['feature_sessions'];
+        currentRunLease.feature_sessions =
+          featureSessions as RuntimeSessionsSnapshot['feature_sessions'];
         await this.port.writeRunLease(currentRunLease);
         runtimeSessionRemoved = true;
         changed = true;
@@ -368,7 +388,7 @@ export class FeatureDeletionService {
       return {
         changed,
         blockedQueueRemoved,
-        runtimeSessionRemoved
+        runtimeSessionRemoved,
       };
     });
 
@@ -382,38 +402,54 @@ export class FeatureDeletionService {
     }
 
     if (removeWorktree && worktreeExists) {
-      const removeWorktreeResult = await runGit(repoRoot, ['worktree', 'remove', '--force', worktreePath]);
+      const removeWorktreeResult = await runGit(repoRoot, [
+        'worktree',
+        'remove',
+        '--force',
+        worktreePath,
+      ]);
       if (removeWorktreeResult.code !== 0) {
         throw {
-          normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Failed to remove feature worktree', {
-            feature_id: featureId,
-            stderr: removeWorktreeResult.stderr,
-            retryable: false,
-            requires_human: true
-          }, {
-            command: ['git', 'worktree', 'remove', '--force', worktreePath],
-            exit_code: removeWorktreeResult.code
-          })
+          normalizedResponse: fail(
+            ERROR_CODES.GIT_FAILURE,
+            'Failed to remove feature worktree',
+            {
+              feature_id: featureId,
+              stderr: removeWorktreeResult.stderr,
+              retryable: false,
+              requires_human: true,
+            },
+            {
+              command: ['git', 'worktree', 'remove', '--force', worktreePath],
+              exit_code: removeWorktreeResult.code,
+            },
+          ),
         };
       }
       summary.worktree_removed = true;
     }
 
     if (branchMode !== 'none' && branchExists) {
-      const args = branchMode === 'safe' ? ['branch', '-d', featureId] : ['branch', '-D', featureId];
+      const args =
+        branchMode === 'safe' ? ['branch', '-d', featureId] : ['branch', '-D', featureId];
       const removeBranchResult = await runGit(repoRoot, args);
       if (removeBranchResult.code !== 0) {
         throw {
-          normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Failed to remove feature branch', {
-            feature_id: featureId,
-            remove_branch: branchMode,
-            stderr: removeBranchResult.stderr,
-            retryable: false,
-            requires_human: true
-          }, {
-            command: ['git', ...args],
-            exit_code: removeBranchResult.code
-          })
+          normalizedResponse: fail(
+            ERROR_CODES.GIT_FAILURE,
+            'Failed to remove feature branch',
+            {
+              feature_id: featureId,
+              remove_branch: branchMode,
+              stderr: removeBranchResult.stderr,
+              retryable: false,
+              requires_human: true,
+            },
+            {
+              command: ['git', ...args],
+              exit_code: removeBranchResult.code,
+            },
+          ),
         };
       }
       summary.branch_removed = true;
@@ -425,8 +461,8 @@ export class FeatureDeletionService {
         dry_run: false,
         plan,
         applied: summary,
-        summary
-      }
+        summary,
+      },
     };
   }
 

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

@@ -52,7 +52,9 @@ export class FeatureLifecycleService {
     this.port = port;
   }
 
-  async featureDiscoverSpecs(): Promise<{ data: { specs: Array<{ feature_id: string; spec_path: string }> } }> {
+  async featureDiscoverSpecs(): Promise<{
+    data: { specs: Array<{ feature_id: string; spec_path: string }> };
+  }> {
     const discovered: Array<{ feature_id: string; spec_path: string }> = [];
     const repoRoot = this.port.getRepoRoot();
     const featuresDir = this.port.getFeaturesDir();
@@ -70,7 +72,7 @@ export class FeatureLifecycleService {
       if (await pathExists(specPath)) {
         discovered.push({
           feature_id: entry.name,
-          spec_path: normalizeRepoPathForState(repoRoot, specPath)
+          spec_path: normalizeRepoPathForState(repoRoot, specPath),
         });
       }
     }
@@ -86,8 +88,8 @@ export class FeatureLifecycleService {
       throw {
         normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'feature_id is required', {
           retryable: false,
-          requires_human: true
-        })
+          requires_human: true,
+        }),
       };
     }
 
@@ -97,7 +99,11 @@ export class FeatureLifecycleService {
 
     const stateFileExists = await pathExists(this.port.statePath(featureId));
     if (!stateFileExists) {
-      const defaultState = this.port.makeDefaultState(featureId, featureId, worktreeResult.data.worktree_path_abs);
+      const defaultState = this.port.makeDefaultState(
+        featureId,
+        featureId,
+        worktreeResult.data.worktree_path_abs,
+      );
       await this.port.writeState(featureId, defaultState, '## Activity\n\nInitialized feature.\n');
     }
 
@@ -107,7 +113,7 @@ export class FeatureLifecycleService {
         feature_id: featureId,
         version: 1,
         source_diff_ref: stableHash('empty'),
-        items: []
+        items: [],
       });
     }
 
@@ -124,8 +130,8 @@ export class FeatureLifecycleService {
       data: {
         feature_id: featureId,
         initialized: true,
-        worktree_path: normalizeRepoPathForState(repoRoot, worktreeResult.data.worktree_path_abs)
-      }
+        worktree_path: normalizeRepoPathForState(repoRoot, worktreeResult.data.worktree_path_abs),
+      },
     };
   }
 
@@ -152,15 +158,15 @@ export class FeatureLifecycleService {
         state: state.data,
         plan: plan.data.plan,
         qa_test_index: qaIndex.data,
-        latest_evidence: evidence.data?.latest ?? null
-      }
+        latest_evidence: evidence.data?.latest ?? null,
+      },
     };
   }
 
   async featureLogAppend(
     featureId: string,
     note: string,
-    context: FeatureContext
+    context: FeatureContext,
   ): Promise<{ data: { feature_id: string; appended: boolean; log_path: string } }> {
     const repoRoot = this.port.getRepoRoot();
     const logPath = this.port.decisionsPath(featureId);
@@ -170,8 +176,8 @@ export class FeatureLifecycleService {
       data: {
         feature_id: featureId,
         appended: true,
-        log_path: normalizeRepoPathForState(repoRoot, logPath)
-      }
+        log_path: normalizeRepoPathForState(repoRoot, logPath),
+      },
     };
   }
 }

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

@@ -14,7 +14,7 @@ type StateReadResult = {
 
 type StateUpdater = (
   frontMatter: AnyRecord,
-  body: string
+  body: string,
 ) => Promise<{ frontMatter?: AnyRecord; body?: string }>;
 
 const LEGAL_TRANSITIONS = {
@@ -24,7 +24,7 @@ const LEGAL_TRANSITIONS = {
   [STATUS.READY_TO_MERGE]: [STATUS.MERGED, STATUS.BLOCKED, STATUS.READY_TO_MERGE],
   [STATUS.BLOCKED]: [STATUS.PLANNING, STATUS.BUILDING, STATUS.QA, STATUS.BLOCKED],
   [STATUS.MERGED]: [STATUS.MERGED],
-  [STATUS.FAILED]: [STATUS.FAILED, STATUS.BLOCKED]
+  [STATUS.FAILED]: [STATUS.FAILED, STATUS.BLOCKED],
 };
 
 function isTransitionLegal(from: string, to: string): boolean {
@@ -53,7 +53,11 @@ export class FeatureStateService {
     this.port = port;
   }
 
-  async updateState(featureId: string, expectedVersion: number | null, updater: StateUpdater): Promise<AnyRecord> {
+  async updateState(
+    featureId: string,
+    expectedVersion: number | null,
+    updater: StateUpdater,
+  ): Promise<AnyRecord> {
     return await this.port.withFeatureLock(featureId, async () => {
       const current = await this.port.readState(featureId);
       if (expectedVersion != null && current.frontMatter.version !== expectedVersion) {
@@ -62,8 +66,8 @@ export class FeatureStateService {
             expected_version: expectedVersion,
             actual_version: current.frontMatter.version,
             retryable: true,
-            requires_human: false
-          })
+            requires_human: false,
+          }),
         };
       }
 
@@ -72,17 +76,21 @@ export class FeatureStateService {
         ...current.frontMatter,
         ...next.frontMatter,
         version: readVersion(current.frontMatter) + 1,
-        last_updated: nowIso()
+        last_updated: nowIso(),
       };
 
       if (!isTransitionLegal(current.frontMatter.status, merged.status)) {
         throw {
-          normalizedResponse: fail(ERROR_CODES.INVALID_STATUS_TRANSITION, 'illegal state status transition', {
-            from: current.frontMatter.status,
-            to: merged.status,
-            retryable: false,
-            requires_human: true
-          })
+          normalizedResponse: fail(
+            ERROR_CODES.INVALID_STATUS_TRANSITION,
+            'illegal state status transition',
+            {
+              from: current.frontMatter.status,
+              to: merged.status,
+              retryable: false,
+              requires_human: true,
+            },
+          ),
         };
       }
 
@@ -91,26 +99,28 @@ export class FeatureStateService {
     });
   }
 
-  async featureStateGet(featureId: string): Promise<{ data: { front_matter: AnyRecord; body: string } }> {
+  async featureStateGet(
+    featureId: string,
+  ): Promise<{ data: { front_matter: AnyRecord; body: string } }> {
     const state = await this.port.readState(featureId);
     return {
       data: {
         front_matter: state.frontMatter,
-        body: state.body
-      }
+        body: state.body,
+      },
     };
   }
 
   async featureStatePatch(
     featureId: string,
     expectedVersion: number | null,
-    patch: AnyRecord | null | undefined
+    patch: AnyRecord | null | undefined,
   ): Promise<{ data: { feature_id: string; version: number; status: string } }> {
     const updated = await this.updateState(featureId, expectedVersion, (frontMatter, body) => {
       const nextFront = { ...frontMatter, ...(patch?.front_matter ?? {}) };
       return Promise.resolve({
         frontMatter: nextFront,
-        body: patch?.body ?? body
+        body: patch?.body ?? body,
       });
     });
 
@@ -118,8 +128,8 @@ export class FeatureStateService {
       data: {
         feature_id: featureId,
         version: updated.version,
-        status: updated.status
-      }
+        status: updated.status,
+      },
     };
   }
 }

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

@@ -4,9 +4,14 @@ export interface InterpolationContext {
   worktree_path?: string;
 }
 
-export function interpolateGateCommands(commands: string[], context: InterpolationContext): string[] {
+export function interpolateGateCommands(
+  commands: string[],
+  context: InterpolationContext,
+): string[] {
   return commands.map((token) =>
-    token.replaceAll('{base_branch}', context.base_branch).replaceAll('{feature_id}', context.feature_id)
+    token
+      .replaceAll('{base_branch}', context.base_branch)
+      .replaceAll('{feature_id}', context.feature_id),
   );
 }