agentic-orchestrator 0.1.6 → 0.1.8

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

@@ -9,18 +9,24 @@ type AnyRecord = Record<string, any>;
 
 type StateUpdater = (
   frontMatter: AnyRecord,
-  body: string
+  body: string,
 ) => Promise<{ frontMatter?: AnyRecord; body?: string }>;
 
 interface CollisionQueueDrivePort {
-  reDriveBlockedQueue(): Promise<{ data: { processed: number; retried: number; still_blocked: number } }>;
+  reDriveBlockedQueue(): Promise<{
+    data: { processed: number; retried: number; still_blocked: number };
+  }>;
 }
 
 export interface LockServicePort {
   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>;
   statePath(featureId: string): string;
   getPolicySnapshot(): AnyRecord;
   collisionQueueService?: CollisionQueueDrivePort;
@@ -41,7 +47,11 @@ export class LockService {
     this.port = port;
   }
 
-  async locksAcquire(resource: string | null, featureId: string | null, waitTimeoutSeconds: number | null = null) {
+  async locksAcquire(
+    resource: string | null,
+    featureId: string | null,
+    waitTimeoutSeconds: number | null = null,
+  ) {
     const policy = this.port.getPolicySnapshot();
 
     if (!resource || !policy.locks.resources.includes(resource)) {
@@ -49,8 +59,8 @@ export class LockService {
         normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'Unknown lock resource', {
           resource,
           retryable: false,
-          requires_human: true
-        })
+          requires_human: true,
+        }),
       };
     }
 
@@ -58,8 +68,8 @@ export class LockService {
       throw {
         normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'feature_id is required', {
           retryable: false,
-          requires_human: true
-        })
+          requires_human: true,
+        }),
       };
     }
 
@@ -84,12 +94,14 @@ export class LockService {
 
         if (!index.locks[resource] || index.locks[resource] === featureId) {
           const leaseId = crypto.randomUUID();
-          const expiresAt = new Date(Date.now() + policy.locks.lease_ttl_seconds * 1000).toISOString();
+          const expiresAt = new Date(
+            Date.now() + policy.locks.lease_ttl_seconds * 1000,
+          ).toISOString();
           index.locks[resource] = featureId;
           index.lock_leases[resource] = {
             holder: featureId,
             lease_id: leaseId,
-            expires_at: expiresAt
+            expires_at: expiresAt,
           };
           index.version += 1;
           index.updated_at = nowIso();
@@ -99,24 +111,24 @@ export class LockService {
             Promise.resolve({
               frontMatter: {
                 locks: {
-                  held: normalizeSet([...(frontMatter.locks?.held ?? []), resource])
-                }
+                  held: normalizeSet([...(frontMatter.locks?.held ?? []), resource]),
+                },
               },
-              body
-            })
+              body,
+            }),
           );
 
           return {
             acquired: true,
             staleReclaimed,
             lease_id: leaseId,
-            expires_at: expiresAt
+            expires_at: expiresAt,
           };
         }
 
         return {
           acquired: false,
-          holder: index.locks[resource]
+          holder: index.locks[resource],
         };
       });
 
@@ -127,14 +139,14 @@ export class LockService {
             feature_id: featureId,
             lease_id: result.lease_id,
             expires_at: result.expires_at,
-            stale_reclaimed: result.staleReclaimed
+            stale_reclaimed: result.staleReclaimed,
           },
           evidence: result.staleReclaimed
             ? {
                 code: ERROR_CODES.STALE_LOCK_RECLAIMED,
-                message: `Reclaimed stale lock for ${resource}`
+                message: `Reclaimed stale lock for ${resource}`,
               }
-            : undefined
+            : undefined,
         };
       }
 
@@ -144,8 +156,8 @@ export class LockService {
             resource,
             holder: result.holder,
             retryable: true,
-            requires_human: false
-          })
+            requires_human: false,
+          }),
         };
       }
 
@@ -154,8 +166,8 @@ export class LockService {
           normalizedResponse: fail(ERROR_CODES.LOCK_CONFLICT, 'Timed out waiting for lock', {
             resource,
             retryable: true,
-            requires_human: false
-          })
+            requires_human: false,
+          }),
         };
       }
 
@@ -167,10 +179,14 @@ export class LockService {
   async locksRelease(resource: string | null, featureId: string | null) {
     if (!resource || !featureId) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.INVALID_ARGUMENT, 'resource and feature_id are required', {
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.INVALID_ARGUMENT,
+          'resource and feature_id are required',
+          {
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
@@ -179,12 +195,16 @@ export class LockService {
       const holder = index.locks[resource];
       if (holder && holder !== featureId) {
         throw {
-          normalizedResponse: fail(ERROR_CODES.LOCK_CONFLICT, 'Cannot release lock held by another feature', {
-            resource,
-            holder,
-            retryable: false,
-            requires_human: true
-          })
+          normalizedResponse: fail(
+            ERROR_CODES.LOCK_CONFLICT,
+            'Cannot release lock held by another feature',
+            {
+              resource,
+              holder,
+              retryable: false,
+              requires_human: true,
+            },
+          ),
         };
       }
 
@@ -199,16 +219,16 @@ export class LockService {
       Promise.resolve({
         frontMatter: {
           locks: {
-            held: (frontMatter.locks?.held ?? []).filter((item) => item !== resource)
-          }
+            held: (frontMatter.locks?.held ?? []).filter((item) => item !== resource),
+          },
         },
-        body
-      })
+        body,
+      }),
     );
 
     if (this.port.collisionQueueService) {
       await this.port.collisionQueueService.reDriveBlockedQueue().catch(() => ({
-        data: { processed: 0, retried: 0, still_blocked: 0 }
+        data: { processed: 0, retried: 0, still_blocked: 0 },
       }));
     }
 
@@ -216,8 +236,8 @@ export class LockService {
       data: {
         resource,
         feature_id: featureId,
-        released: true
-      }
+        released: true,
+      },
     };
   }
 
@@ -227,13 +247,15 @@ export class LockService {
     await this.port.withIndexLock(async () => {
       const index = await this.port.readIndex();
       let changed = false;
-      for (const [resource, lease] of Object.entries(index.lock_leases as Record<string, AnyRecord>)) {
+      for (const [resource, lease] of Object.entries(
+        index.lock_leases as Record<string, AnyRecord>,
+      )) {
         if (!lease || !set.has(lease.holder)) {
           continue;
         }
         index.lock_leases[resource] = {
           ...lease,
-          expires_at: new Date(Date.now() + policy.locks.lease_ttl_seconds * 1000).toISOString()
+          expires_at: new Date(Date.now() + policy.locks.lease_ttl_seconds * 1000).toISOString(),
         };
         changed = true;
       }
@@ -245,13 +267,17 @@ export class LockService {
     });
   }
 
-  async recoverFromState(): Promise<{ data: { recovered: boolean; stale_features: string[]; active: unknown } }> {
+  async recoverFromState(): Promise<{
+    data: { recovered: boolean; stale_features: string[]; active: unknown };
+  }> {
     const index = await this.port.readIndex();
     const staleFeatures: string[] = [];
 
     await this.port.withIndexLock(async () => {
       const current = await this.port.readIndex();
-      for (const [resource, lease] of Object.entries(current.lock_leases as Record<string, AnyRecord>)) {
+      for (const [resource, lease] of Object.entries(
+        current.lock_leases as Record<string, AnyRecord>,
+      )) {
         if (!lease) {
           continue;
         }
@@ -280,10 +306,10 @@ export class LockService {
         Promise.resolve({
           frontMatter: {
             status: STATUS.BLOCKED,
-            status_reason: 'Lease expired and was reclaimed'
+            status_reason: 'Lease expired and was reclaimed',
           },
-          body
-        })
+          body,
+        }),
       );
     }
 
@@ -291,8 +317,8 @@ export class LockService {
       data: {
         recovered: true,
         stale_features: normalizeSet(staleFeatures),
-        active: index.active
-      }
+        active: index.active,
+      },
     };
   }
 }

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

@@ -11,7 +11,7 @@ type AnyRecord = Record<string, any>;
 
 type StateUpdater = (
   frontMatter: AnyRecord,
-  body: string
+  body: string,
 ) => Promise<{ frontMatter?: AnyRecord; body?: string }>;
 
 function normalizeSet(array: string[]): string[] {
@@ -19,7 +19,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');
 }
@@ -38,7 +39,11 @@ export interface MergeServicePort {
   featurePath(featureId: string): string;
   readState(featureId: string): Promise<{ frontMatter: AnyRecord; body: string }>;
   worktreePath(featureId: string): string;
-  updateState(featureId: string, expectedVersion: number | null, updater: StateUpdater): Promise<AnyRecord>;
+  updateState(
+    featureId: string,
+    expectedVersion: number | null,
+    updater: StateUpdater,
+  ): Promise<AnyRecord>;
   locksRelease(resource: string, featureId: string): Promise<unknown>;
   withIndexLock<T>(operation: () => Promise<T>): Promise<T>;
   readIndex(): Promise<AnyRecord>;
@@ -56,11 +61,16 @@ export class MergeService {
     const repoRoot = this.port.getRepoRoot();
     const worktreePath = this.port.worktreePath(featureId);
 
-    const removeWorktreeResult = await runGit(repoRoot, ['worktree', 'remove', '--force', worktreePath]);
+    const removeWorktreeResult = await runGit(repoRoot, [
+      'worktree',
+      'remove',
+      '--force',
+      worktreePath,
+    ]);
     if (removeWorktreeResult.code !== 0) {
       // Best-effort cleanup; merged state must remain intact even if git cleanup fails.
       console.warn(
-        `[aop] auto-cleanup worktree removal failed for ${featureId}: ${removeWorktreeResult.stderr.trim() || `exit ${removeWorktreeResult.code}`}`
+        `[aop] auto-cleanup worktree removal failed for ${featureId}: ${removeWorktreeResult.stderr.trim() || `exit ${removeWorktreeResult.code}`}`,
       );
     }
 
@@ -68,7 +78,7 @@ export class MergeService {
     if (removeBranchResult.code !== 0) {
       // Best-effort cleanup; branch may already be removed.
       console.warn(
-        `[aop] auto-cleanup branch removal failed for ${featureId}: ${removeBranchResult.stderr.trim() || `exit ${removeBranchResult.code}`}`
+        `[aop] auto-cleanup branch removal failed for ${featureId}: ${removeBranchResult.stderr.trim() || `exit ${removeBranchResult.code}`}`,
       );
     }
 
@@ -80,7 +90,7 @@ export class MergeService {
     const timeout = setTimeout(() => {
       void this.cleanupMergedFeatureArtifacts(featureId).catch((error) => {
         console.warn(
-          `[aop] auto-cleanup failed for ${featureId}: ${error instanceof Error ? error.message : String(error)}`
+          `[aop] auto-cleanup failed for ${featureId}: ${error instanceof Error ? error.message : String(error)}`,
         );
       });
     }, delayMs);
@@ -93,7 +103,7 @@ export class MergeService {
     featureId: string,
     commitMessage: string,
     mergeStrategy: string,
-    userApprovalToken: string | null
+    userApprovalToken: string | null,
   ): Promise<{
     data: {
       feature_id: string;
@@ -109,30 +119,42 @@ export class MergeService {
 
     if (!policy.merge_policy.allowed_strategies.includes(mergeStrategy)) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.MERGE_DISABLED, 'Merge strategy is not allowed by policy', {
-          merge_strategy: mergeStrategy,
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.MERGE_DISABLED,
+          'Merge strategy is not allowed by policy',
+          {
+            merge_strategy: mergeStrategy,
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
     if (policy.merge_policy.require_user_approval && !userApprovalToken) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.USER_APPROVAL_REQUIRED, 'User approval token is required', {
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.USER_APPROVAL_REQUIRED,
+          'User approval token is required',
+          {
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
     if (state.frontMatter.status !== STATUS.READY_TO_MERGE) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.INVALID_STATUS_TRANSITION, 'Feature must be ready_to_merge before merge', {
-          current_status: state.frontMatter.status,
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.INVALID_STATUS_TRANSITION,
+          'Feature must be ready_to_merge before merge',
+          {
+            current_status: state.frontMatter.status,
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 
@@ -140,11 +162,15 @@ export class MergeService {
     for (const mode of requiredModes) {
       if (state.frontMatter.gates?.[mode] !== GATE_RESULT.PASS) {
         throw {
-          normalizedResponse: fail(ERROR_CODES.MERGE_DISABLED, 'Required gate mode has not passed', {
-            mode,
-            retryable: true,
-            requires_human: false
-          })
+          normalizedResponse: fail(
+            ERROR_CODES.MERGE_DISABLED,
+            'Required gate mode has not passed',
+            {
+              mode,
+              retryable: true,
+              requires_human: false,
+            },
+          ),
         };
       }
     }
@@ -157,19 +183,21 @@ export class MergeService {
         normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Failed to stage changes before merge', {
           stderr: commitResult.stderr,
           retryable: true,
-          requires_human: false
-        })
+          requires_human: false,
+        }),
       };
     }
 
-    const commit = await runGit(repoRoot, ['commit', '-m', commitMessage], { cwd: featureWorktree });
+    const commit = await runGit(repoRoot, ['commit', '-m', commitMessage], {
+      cwd: featureWorktree,
+    });
     if (commit.code !== 0 && !commit.stderr.includes('nothing to commit')) {
       throw {
         normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Failed to commit feature branch', {
           stderr: commit.stderr,
           retryable: true,
-          requires_human: false
-        })
+          requires_human: false,
+        }),
       };
     }
 
@@ -177,17 +205,27 @@ export class MergeService {
     const checkoutBase = await runGit(repoRoot, ['checkout', baseBranch]);
     if (checkoutBase.code !== 0) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Failed to checkout base branch for merge', {
-          stderr: checkoutBase.stderr,
-          retryable: true,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.GIT_FAILURE,
+          'Failed to checkout base branch for merge',
+          {
+            stderr: checkoutBase.stderr,
+            retryable: true,
+            requires_human: true,
+          },
+        ),
       };
     }
 
     let merge;
     if (mergeStrategy === 'merge_commit') {
-      merge = await runGit(repoRoot, ['merge', '--no-ff', featureId, '-m', `Merge feature ${featureId}`]);
+      merge = await runGit(repoRoot, [
+        'merge',
+        '--no-ff',
+        featureId,
+        '-m',
+        `Merge feature ${featureId}`,
+      ]);
     } else if (mergeStrategy === 'squash') {
       merge = await runGit(repoRoot, ['merge', '--squash', featureId]);
       if (merge.code === 0) {
@@ -200,8 +238,8 @@ export class MergeService {
           normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Rebase failed before merge', {
             stderr: rebase.stderr,
             retryable: true,
-            requires_human: true
-          })
+            requires_human: true,
+          }),
         };
       }
       merge = await runGit(repoRoot, ['merge', '--ff-only', featureId]);
@@ -212,8 +250,8 @@ export class MergeService {
         normalizedResponse: fail(ERROR_CODES.GIT_FAILURE, 'Merge failed', {
           stderr: merge.stderr,
           retryable: true,
-          requires_human: true
-        })
+          requires_human: true,
+        }),
       };
     }
 
@@ -229,11 +267,11 @@ export class MergeService {
             ...(frontMatter.evidence ?? {}),
             merge_sha: mergeSha,
             merge_strategy: mergeStrategy,
-            merge_at: nowIso()
-          }
+            merge_at: nowIso(),
+          },
         },
-        body: `${body}\n\n## Merge\n\nMerged at ${nowIso()} as ${mergeSha}.\n`
-      })
+        body: `${body}\n\n## Merge\n\nMerged at ${nowIso()} as ${mergeSha}.\n`,
+      }),
     );
 
     const heldLocks = [...readHeldLocks(state.frontMatter)];
@@ -248,7 +286,9 @@ export class MergeService {
       index.merged = normalizeSet([...asArray<string>(index.merged), featureId]);
 
       const blockedQueue = asArray<AnyRecord>(index.blocked_queue);
-      index.blocked_queue = blockedQueue.filter((entry) => asRecord(entry).feature_id !== featureId);
+      index.blocked_queue = blockedQueue.filter(
+        (entry) => asRecord(entry).feature_id !== featureId,
+      );
 
       const locks = asRecord(index.locks);
       for (const [resource, holder] of Object.entries(locks)) {
@@ -285,7 +325,8 @@ export class MergeService {
     const cleanupPolicy = asRecord(policy.cleanup);
     const autoAfterMerge = cleanupPolicy.auto_after_merge === true;
     const gracePeriodSeconds =
-      typeof cleanupPolicy.grace_period_seconds === 'number' && Number.isFinite(cleanupPolicy.grace_period_seconds)
+      typeof cleanupPolicy.grace_period_seconds === 'number' &&
+      Number.isFinite(cleanupPolicy.grace_period_seconds)
         ? cleanupPolicy.grace_period_seconds
         : 3600;
     const shouldCleanupNow = autoAfterMerge && gracePeriodSeconds <= 0;
@@ -303,8 +344,8 @@ export class MergeService {
         merge_strategy: mergeStrategy,
         status: STATUS.MERGED,
         retained_for_cleanup: !shouldCleanupNow,
-        cleanup_grace_period_seconds: gracePeriodSeconds
-      }
+        cleanup_grace_period_seconds: gracePeriodSeconds,
+      },
     };
   }
 }