agentic-orchestrator 0.1.6 → 0.1.8

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

@@ -31,7 +31,7 @@ function makeRuntimeSessions(overrides: AnyRecord = {}): AnyRecord {
     lease_expires_at: now,
     orchestrator_epoch: 0,
     feature_sessions: {},
-    ...overrides
+    ...overrides,
   };
 }
 
@@ -43,16 +43,16 @@ function makeIndex(overrides: AnyRecord = {}): AnyRecord {
     merged: [],
     locks: {
       openapi: null,
-      db_migrations: null
+      db_migrations: null,
     },
     lock_leases: {
       openapi: null,
-      db_migrations: null
+      db_migrations: null,
     },
     blocked_queue: [],
     updated_at: new Date().toISOString(),
     runtime_sessions: makeRuntimeSessions(),
-    ...overrides
+    ...overrides,
   };
 }
 
@@ -69,7 +69,7 @@ function makeRunLeaseHarness(initialIndex: AnyRecord = makeIndex()) {
       feature_sessions:
         source.feature_sessions && typeof source.feature_sessions === 'object'
           ? source.feature_sessions
-          : {}
+          : {},
     };
   };
 
@@ -77,10 +77,12 @@ function makeRunLeaseHarness(initialIndex: AnyRecord = makeIndex()) {
     makeRuntimeSessions({
       started_at: at ?? new Date().toISOString(),
       last_heartbeat_at: at ?? new Date().toISOString(),
-      lease_expires_at: at ?? new Date().toISOString()
+      lease_expires_at: at ?? new Date().toISOString(),
     }) as RuntimeSessionsSnapshot;
 
-  let runLease: RuntimeSessionsSnapshot = clone(initialIndex.runtime_sessions ?? makeRuntimeSessions());
+  let runLease: RuntimeSessionsSnapshot = clone(
+    initialIndex.runtime_sessions ?? makeRuntimeSessions(),
+  );
 
   const service = new RunLeaseService({
     runLeaseTtlSeconds: () => 30,
@@ -95,15 +97,16 @@ function makeRunLeaseHarness(initialIndex: AnyRecord = makeIndex()) {
       runLease = clone(data);
     },
     normalizeRuntimeSessions,
-    isRunLeaseFresh: (runtimeSessions: AnyRecord) => new Date(runtimeSessions.lease_expires_at).getTime() > Date.now(),
-    emptyRuntimeSessions
+    isRunLeaseFresh: (runtimeSessions: AnyRecord) =>
+      new Date(runtimeSessions.lease_expires_at).getTime() > Date.now(),
+    emptyRuntimeSessions,
   });
 
   return {
     service,
     getIndex: () => clone(index),
     getRunLease: () => clone(runLease),
-    writes
+    writes,
   };
 }
 
@@ -117,8 +120,8 @@ function makeLockPolicy(overrides: AnyRecord = {}): AnyRecord {
       initial_ms: 1,
       max_ms: 4,
       multiplier: 2,
-      jitter_ms: 0
-    }
+      jitter_ms: 0,
+    },
   };
   const lockOverrides = overrides.locks ?? {};
   return {
@@ -128,17 +131,19 @@ function makeLockPolicy(overrides: AnyRecord = {}): AnyRecord {
       ...lockOverrides,
       acquire_backoff: {
         ...lockDefaults.acquire_backoff,
-        ...(lockOverrides.acquire_backoff ?? {})
-      }
-    }
+        ...(lockOverrides.acquire_backoff ?? {}),
+      },
+    },
   };
 }
 
-async function makeLockHarness(options: {
-  policy?: AnyRecord;
-  index?: AnyRecord;
-  states?: Record<string, AnyRecord>;
-} = {}) {
+async function makeLockHarness(
+  options: {
+    policy?: AnyRecord;
+    index?: AnyRecord;
+    states?: Record<string, AnyRecord>;
+  } = {},
+) {
   let index = clone(options.index ?? makeIndex());
   const states = new Map<string, AnyRecord>(
     Object.entries(
@@ -146,15 +151,15 @@ async function makeLockHarness(options: {
         feature_a: {
           version: 1,
           status: STATUS.PLANNING,
-          locks: { held: [] }
+          locks: { held: [] },
         },
         feature_b: {
           version: 1,
           status: STATUS.PLANNING,
-          locks: { held: [] }
-        }
-      }
-    )
+          locks: { held: [] },
+        },
+      },
+    ),
   );
   const policy = makeLockPolicy(options.policy);
   const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-lock-service-'));
@@ -166,17 +171,21 @@ async function makeLockHarness(options: {
       index = clone(nextIndex);
     },
     updateState: async (featureId: string, _expectedVersion: number | null, updater: any) => {
-      const existing = states.get(featureId) ?? { version: 1, status: STATUS.PLANNING, locks: { held: [] } };
+      const existing = states.get(featureId) ?? {
+        version: 1,
+        status: STATUS.PLANNING,
+        locks: { held: [] },
+      };
       const updateResult = await updater(clone(existing), '');
       const next = {
         ...existing,
-        ...(updateResult.frontMatter ?? {})
+        ...(updateResult.frontMatter ?? {}),
       };
       states.set(featureId, next);
       return clone(next);
     },
     statePath: (featureId: string) => path.join(tmpDir, `${featureId}.state.md`),
-    getPolicySnapshot: () => policy
+    getPolicySnapshot: () => policy,
   });
 
   return {
@@ -192,7 +201,7 @@ async function makeLockHarness(options: {
       const filePath = path.join(tmpDir, `${featureId}.state.md`);
       await fs.writeFile(filePath, '---\nfeature_id: test\n---\n', 'utf8');
     },
-    cleanup: async () => await fs.rm(tmpDir, { recursive: true, force: true })
+    cleanup: async () => await fs.rm(tmpDir, { recursive: true, force: true }),
   };
 }
 
@@ -206,8 +215,8 @@ async function makeReportingHarness() {
     merged: ['feature_c'],
     locks: {
       openapi: 'feature_lock',
-      db_migrations: null
-    }
+      db_migrations: null,
+    },
   });
 
   const ensureState = async (featureId: string, frontMatter: AnyRecord) => {
@@ -221,34 +230,34 @@ async function makeReportingHarness() {
     collectAcceptedPlans: async () => clone(plans),
     getPolicySnapshot: () => ({
       exclusive_areas: ['libs/core'],
-      protected_areas: ['agentic/orchestrator']
+      protected_areas: ['config/agentic/orchestrator'],
     }),
     readIndex: async () => clone(index),
     statePath: (featureId: string) => path.join(tmpDir, featureId, 'state.md'),
     featureCostPath: (featureId: string) => path.join(tmpDir, featureId, 'cost.json'),
     readState: async (featureId: string) => ({
-      frontMatter: clone(stateMap.get(featureId) ?? {})
+      frontMatter: clone(stateMap.get(featureId) ?? {}),
     }),
     featureStateGet: async (featureId: string) => ({
       data: {
-        front_matter: clone(stateMap.get(featureId) ?? {})
-      }
+        front_matter: clone(stateMap.get(featureId) ?? {}),
+      },
     }),
     repoDiffBundle: async () => ({
       data: {
         diff_stat: '1 file changed',
         touched_files: ['src/example.ts'],
-        last_gate_summary: { overall: 'pass' }
-      }
+        last_gate_summary: { overall: 'pass' },
+      },
     }),
     qaTestIndexGet: async () => ({
       data: {
         summary: {
           required_total: 1,
-          pending_required: 0
-        }
-      }
-    })
+          pending_required: 0,
+        },
+      },
+    }),
   });
 
   return {
@@ -258,7 +267,7 @@ async function makeReportingHarness() {
       index = clone(nextIndex);
     },
     ensureState,
-    cleanup: async () => await fs.rm(tmpDir, { recursive: true, force: true })
+    cleanup: async () => await fs.rm(tmpDir, { recursive: true, force: true }),
   };
 }
 
@@ -267,7 +276,7 @@ describe('RunLeaseService', () => {
     const freshLease = makeRuntimeSessions({
       run_id: 'run:existing',
       owner_instance_id: 'owner:existing',
-      lease_expires_at: new Date(Date.now() + 60_000).toISOString()
+      lease_expires_at: new Date(Date.now() + 60_000).toISOString(),
     });
     const { service } = makeRunLeaseHarness(makeIndex({ runtime_sessions: freshLease }));
 
@@ -277,10 +286,10 @@ describe('RunLeaseService', () => {
         owner_instance_id: 'owner:new',
         provider: 'provider',
         model: 'model',
-        provider_config_ref_hash: ''
-      } as any)
+        provider_config_ref_hash: '',
+      } as any),
     ).rejects.toMatchObject({
-      normalizedResponse: { error: { code: ERROR_CODES.INVALID_ARGUMENT } }
+      normalizedResponse: { error: { code: ERROR_CODES.INVALID_ARGUMENT } },
     });
 
     await expect(
@@ -289,15 +298,15 @@ describe('RunLeaseService', () => {
         owner_instance_id: 'owner:new',
         provider: 'provider',
         model: 'model',
-        provider_config_ref_hash: ''
-      })
+        provider_config_ref_hash: '',
+      }),
     ).rejects.toMatchObject({
       normalizedResponse: {
         error: {
           code: ERROR_CODES.RUN_ALREADY_ACTIVE,
-          details: { stale: false }
-        }
-      }
+          details: { stale: false },
+        },
+      },
     });
   });
 
@@ -306,8 +315,10 @@ describe('RunLeaseService', () => {
       run_id: 'run:stale',
       owner_instance_id: 'owner:stale',
       orchestrator_session_id: 'orch:old',
-      feature_sessions: { feature_x: { planner_session_id: 'p', builder_session_id: 'b', qa_session_id: 'q' } },
-      lease_expires_at: new Date(Date.now() - 60_000).toISOString()
+      feature_sessions: {
+        feature_x: { planner_session_id: 'p', builder_session_id: 'b', qa_session_id: 'q' },
+      },
+      lease_expires_at: new Date(Date.now() - 60_000).toISOString(),
     });
     const harness = makeRunLeaseHarness(makeIndex({ runtime_sessions: staleLease }));
 
@@ -318,15 +329,15 @@ describe('RunLeaseService', () => {
         provider: 'provider',
         model: 'model',
         provider_config_ref_hash: '',
-        takeover_stale_run: false
-      })
+        takeover_stale_run: false,
+      }),
     ).rejects.toMatchObject({
       normalizedResponse: {
         error: {
           code: ERROR_CODES.RUN_ALREADY_ACTIVE,
-          details: { stale: true, requires_takeover: true }
-        }
-      }
+          details: { stale: true, requires_takeover: true },
+        },
+      },
     });
 
     const takeover = await harness.service.acquireRunLease({
@@ -335,7 +346,7 @@ describe('RunLeaseService', () => {
       provider: 'provider',
       model: 'model',
       provider_config_ref_hash: '',
-      takeover_stale_run: true
+      takeover_stale_run: true,
     });
 
     expect(takeover.data.took_over_stale).toBe(true);
@@ -354,8 +365,8 @@ describe('RunLeaseService', () => {
       lease_expires_at: '2026-01-01T00:00:30.000Z',
       feature_sessions: {
         keep_feature: { planner_session_id: 'p1', builder_session_id: 'b1', qa_session_id: 'q1' },
-        stale_feature: { planner_session_id: 'p2', builder_session_id: 'b2', qa_session_id: 'q2' }
-      }
+        stale_feature: { planner_session_id: 'p2', builder_session_id: 'b2', qa_session_id: 'q2' },
+      },
     });
     const harness = makeRunLeaseHarness(makeIndex({ runtime_sessions: initial }));
 
@@ -366,7 +377,7 @@ describe('RunLeaseService', () => {
       run_id: 'run:owner',
       owner_instance_id: 'owner:owner',
       orchestrator_session_id: 'orch:new',
-      increment_epoch: true
+      increment_epoch: true,
     });
 
     await harness.service.updateFeatureSessionAssignment({
@@ -375,13 +386,13 @@ describe('RunLeaseService', () => {
       feature_id: 'keep_feature',
       planner_session_id: 'p-next',
       builder_session_id: 'b-next',
-      qa_session_id: 'q-next'
+      qa_session_id: 'q-next',
     });
 
     const pruned = await harness.service.pruneFeatureSessionAssignments({
       run_id: 'run:owner',
       owner_instance_id: 'owner:owner',
-      active_feature_ids: ['keep_feature']
+      active_feature_ids: ['keep_feature'],
     });
     expect(pruned.data.removed).toEqual(['stale_feature']);
 
@@ -395,7 +406,7 @@ describe('RunLeaseService', () => {
       run_id: 'run:same',
       owner_instance_id: 'owner:same',
       started_at: '2026-01-01T00:00:00.000Z',
-      lease_expires_at: new Date(Date.now() + 60_000).toISOString()
+      lease_expires_at: new Date(Date.now() + 60_000).toISOString(),
     });
     const harness = makeRunLeaseHarness(makeIndex({ runtime_sessions: existing }));
 
@@ -404,17 +415,17 @@ describe('RunLeaseService', () => {
       owner_instance_id: 'owner:same',
       provider: 'provider',
       model: 'model',
-      provider_config_ref_hash: 'hash'
+      provider_config_ref_hash: 'hash',
     });
     expect(reused.data.reused_existing_owner).toBe(true);
     expect(reused.data.runtime_sessions.started_at).toBe('2026-01-01T00:00:00.000Z');
 
     await expect(harness.service.renewRunLease('', '')).rejects.toMatchObject({
-      normalizedResponse: { error: { code: ERROR_CODES.INVALID_ARGUMENT } }
+      normalizedResponse: { error: { code: ERROR_CODES.INVALID_ARGUMENT } },
     });
 
     await expect(harness.service.renewRunLease('run:other', 'owner:other')).rejects.toMatchObject({
-      normalizedResponse: { error: { code: ERROR_CODES.RUN_LEASE_NOT_OWNED } }
+      normalizedResponse: { error: { code: ERROR_CODES.RUN_LEASE_NOT_OWNED } },
     });
 
     const notReleased = await harness.service.releaseRunLease('run:other', 'owner:other');
@@ -424,10 +435,10 @@ describe('RunLeaseService', () => {
       harness.service.updateOrchestratorSession({
         run_id: '',
         owner_instance_id: 'owner:same',
-        orchestrator_session_id: ''
-      } as any)
+        orchestrator_session_id: '',
+      } as any),
     ).rejects.toMatchObject({
-      normalizedResponse: { error: { code: ERROR_CODES.INVALID_ARGUMENT } }
+      normalizedResponse: { error: { code: ERROR_CODES.INVALID_ARGUMENT } },
     });
 
     await expect(
@@ -437,20 +448,20 @@ describe('RunLeaseService', () => {
         feature_id: 'feature_a',
         planner_session_id: 'planner',
         builder_session_id: 'builder',
-        qa_session_id: 'qa'
-      })
+        qa_session_id: 'qa',
+      }),
     ).rejects.toMatchObject({
-      normalizedResponse: { error: { code: ERROR_CODES.RUN_LEASE_NOT_OWNED } }
+      normalizedResponse: { error: { code: ERROR_CODES.RUN_LEASE_NOT_OWNED } },
     });
 
     await expect(
       harness.service.pruneFeatureSessionAssignments({
         run_id: 'run:other',
         owner_instance_id: 'owner:other',
-        active_feature_ids: []
-      })
+        active_feature_ids: [],
+      }),
     ).rejects.toMatchObject({
-      normalizedResponse: { error: { code: ERROR_CODES.RUN_LEASE_NOT_OWNED } }
+      normalizedResponse: { error: { code: ERROR_CODES.RUN_LEASE_NOT_OWNED } },
     });
   });
 });
@@ -472,11 +483,11 @@ describe('LockService', () => {
     cleanups.push(harness.cleanup);
 
     await expect(harness.service.locksAcquire('missing', 'feature_a')).rejects.toMatchObject({
-      normalizedResponse: { error: { code: ERROR_CODES.INVALID_ARGUMENT } }
+      normalizedResponse: { error: { code: ERROR_CODES.INVALID_ARGUMENT } },
     });
 
     await expect(harness.service.locksAcquire('openapi', null)).rejects.toMatchObject({
-      normalizedResponse: { error: { code: ERROR_CODES.INVALID_ARGUMENT } }
+      normalizedResponse: { error: { code: ERROR_CODES.INVALID_ARGUMENT } },
     });
 
     const acquired = await harness.service.locksAcquire('openapi', 'feature_a');
@@ -484,7 +495,7 @@ describe('LockService', () => {
     expect(harness.getState('feature_a').locks.held).toContain('openapi');
 
     await expect(harness.service.locksRelease('openapi', 'feature_b')).rejects.toMatchObject({
-      normalizedResponse: { error: { code: ERROR_CODES.LOCK_CONFLICT } }
+      normalizedResponse: { error: { code: ERROR_CODES.LOCK_CONFLICT } },
     });
 
     const released = await harness.service.locksRelease('openapi', 'feature_a');
@@ -497,29 +508,29 @@ describe('LockService', () => {
       active: ['feature_a'],
       locks: {
         openapi: 'feature_old',
-        db_migrations: 'feature_b'
+        db_migrations: 'feature_b',
       },
       lock_leases: {
         openapi: {
           holder: 'feature_old',
           lease_id: 'lease-old',
-          expires_at: new Date(Date.now() - 60_000).toISOString()
+          expires_at: new Date(Date.now() - 60_000).toISOString(),
         },
         db_migrations: {
           holder: 'feature_b',
           lease_id: 'lease-b',
-          expires_at: new Date(Date.now() + 60_000).toISOString()
-        }
-      }
+          expires_at: new Date(Date.now() + 60_000).toISOString(),
+        },
+      },
     });
     const harness = await makeLockHarness({
       index: staleIndex,
       policy: {
         locks: {
           acquire_behavior: 'wait',
-          default_wait_timeout_seconds: 1
-        }
-      }
+          default_wait_timeout_seconds: 1,
+        },
+      },
     });
     cleanups.push(harness.cleanup);
 
@@ -537,7 +548,7 @@ describe('LockService', () => {
     expiredSnapshot.lock_leases.openapi = {
       holder: 'feature_a',
       lease_id: 'lease-stale',
-      expires_at: new Date(Date.now() - 60_000).toISOString()
+      expires_at: new Date(Date.now() - 60_000).toISOString(),
     };
     harness.setIndex(expiredSnapshot);
 
@@ -552,28 +563,28 @@ describe('LockService', () => {
     const harness = await makeLockHarness({
       policy: {
         locks: {
-          acquire_behavior: 'fail'
-        }
+          acquire_behavior: 'fail',
+        },
       },
       index: makeIndex({
         locks: {
           openapi: 'feature_other',
-          db_migrations: null
+          db_migrations: null,
         },
         lock_leases: {
           openapi: {
             holder: 'feature_other',
             lease_id: 'lease-1',
-            expires_at: new Date(Date.now() + 60_000).toISOString()
+            expires_at: new Date(Date.now() + 60_000).toISOString(),
           },
-          db_migrations: null
-        }
-      })
+          db_migrations: null,
+        },
+      }),
     });
     cleanups.push(harness.cleanup);
 
     await expect(harness.service.locksAcquire('openapi', 'feature_a')).rejects.toMatchObject({
-      normalizedResponse: { error: { code: ERROR_CODES.LOCK_CONFLICT } }
+      normalizedResponse: { error: { code: ERROR_CODES.LOCK_CONFLICT } },
     });
   });
 
@@ -582,38 +593,38 @@ describe('LockService', () => {
       policy: {
         locks: {
           acquire_behavior: undefined,
-          default_wait_timeout_seconds: 0
-        }
+          default_wait_timeout_seconds: 0,
+        },
       },
       states: {
         feature_a: {
           version: 1,
-          status: STATUS.PLANNING
-        }
+          status: STATUS.PLANNING,
+        },
       },
       index: makeIndex({
         locks: {
           openapi: 'feature_other',
-          db_migrations: null
+          db_migrations: null,
         },
         lock_leases: {
           openapi: {
             holder: 'feature_other',
             lease_id: 'lease-wait',
-            expires_at: new Date(Date.now() + 60_000).toISOString()
+            expires_at: new Date(Date.now() + 60_000).toISOString(),
           },
-          db_migrations: null
-        }
-      })
+          db_migrations: null,
+        },
+      }),
     });
     cleanups.push(harness.cleanup);
 
     await expect(harness.service.locksAcquire('openapi', 'feature_a', 0)).rejects.toMatchObject({
-      normalizedResponse: { error: { code: ERROR_CODES.LOCK_CONFLICT } }
+      normalizedResponse: { error: { code: ERROR_CODES.LOCK_CONFLICT } },
     });
 
     await expect(harness.service.locksRelease(null, null)).rejects.toMatchObject({
-      normalizedResponse: { error: { code: ERROR_CODES.INVALID_ARGUMENT } }
+      normalizedResponse: { error: { code: ERROR_CODES.INVALID_ARGUMENT } },
     });
 
     await harness.service.locksRelease('db_migrations', 'feature_a');
@@ -642,14 +653,14 @@ describe('ReportingService', () => {
         feature_id: 'feature_a',
         files: { modify: ['src/shared.ts'] },
         allowed_areas: ['libs/core'],
-        contracts: { openapi: 'none', events: 'none', db: 'none' }
+        contracts: { openapi: 'none', events: 'none', db: 'none' },
       },
       {
         feature_id: 'feature_b',
         files: { create: ['src/shared.ts'] },
         allowed_areas: ['libs/core/module'],
-        contracts: { openapi: 'none', events: 'none', db: 'none' }
-      }
+        contracts: { openapi: 'none', events: 'none', db: 'none' },
+      },
     );
 
     await harness.ensureState('feature_a', {
@@ -657,14 +668,14 @@ describe('ReportingService', () => {
       locks: { held: ['openapi'] },
       gate_profile: 'default',
       gates: { plan: 'pass' },
-      last_updated: '2026-01-01T00:00:00.000Z'
+      last_updated: '2026-01-01T00:00:00.000Z',
     });
     await harness.ensureState('feature_lock', {
       status: STATUS.BLOCKED,
       locks: { held: [] },
       gate_profile: 'default',
       gates: { plan: 'na' },
-      last_updated: '2026-01-02T00:00:00.000Z'
+      last_updated: '2026-01-02T00:00:00.000Z',
     });
 
     const collisions = await harness.service.collisionsScan();
@@ -673,7 +684,10 @@ describe('ReportingService', () => {
     expect(typeof collisions.data.collisions[0].fingerprint).toBe('string');
 
     const dashboard = await harness.service.reportDashboard();
-    expect(dashboard.data.features.map((item: AnyRecord) => item.feature_id)).toEqual(['feature_a', 'feature_lock']);
+    expect(dashboard.data.features.map((item: AnyRecord) => item.feature_id)).toEqual([
+      'feature_a',
+      'feature_lock',
+    ]);
   });
 
   it('aggregates feature summary from state, diff bundle, and qa index', async () => {
@@ -682,14 +696,14 @@ describe('ReportingService', () => {
     await harness.ensureState('feature_summary', {
       status: STATUS.QA,
       gates: { full: 'pass' },
-      locks: { held: [] }
+      locks: { held: [] },
     });
     harness.setIndex(
       makeIndex({
         active: ['feature_summary'],
         blocked: [],
-        merged: []
-      })
+        merged: [],
+      }),
     );
 
     const summary = await harness.service.reportFeatureSummary('feature_summary');
@@ -706,7 +720,9 @@ describe('ReportingService worktree_branch coverage', () => {
   afterEach(async () => {
     while (cleanups.length > 0) {
       const cleanup = cleanups.pop();
-      if (cleanup) {await cleanup();}
+      if (cleanup) {
+        await cleanup();
+      }
     }
   });
 
@@ -720,7 +736,7 @@ describe('ReportingService worktree_branch coverage', () => {
       locks: { held: [] },
       gate_profile: 'default',
       gates: { plan: 'pass' },
-      last_updated: '2026-01-01T00:00:00.000Z'
+      last_updated: '2026-01-01T00:00:00.000Z',
     });
 
     const dashboard = await harness.service.reportDashboard();
@@ -735,7 +751,9 @@ describe('LockService sleep branch coverage', () => {
   afterEach(async () => {
     while (cleanups.length > 0) {
       const cleanup = cleanups.pop();
-      if (cleanup) {await cleanup();}
+      if (cleanup) {
+        await cleanup();
+      }
     }
     vi.useRealTimers();
   });
@@ -752,12 +770,12 @@ describe('LockService sleep branch coverage', () => {
             initial_ms: 0,
             max_ms: 0,
             multiplier: 1,
-            jitter_ms: 0
-          }
-        }
+            jitter_ms: 0,
+          },
+        },
       },
       states: {
-        feature_a: { version: 1, status: STATUS.PLANNING, locks: { held: [] } }
+        feature_a: { version: 1, status: STATUS.PLANNING, locks: { held: [] } },
       },
       index: makeIndex({
         locks: { openapi: 'feature_other', db_migrations: null },
@@ -765,11 +783,11 @@ describe('LockService sleep branch coverage', () => {
           openapi: {
             holder: 'feature_other',
             lease_id: 'lease-sleep-test',
-            expires_at: new Date(Date.now() + 60_000).toISOString()
+            expires_at: new Date(Date.now() + 60_000).toISOString(),
           },
-          db_migrations: null
-        }
-      })
+          db_migrations: null,
+        },
+      }),
     });
     cleanups.push(harness.cleanup);
 
@@ -780,7 +798,7 @@ describe('LockService sleep branch coverage', () => {
     vi.advanceTimersByTime(15_000);
 
     await expect(acquirePromise).rejects.toMatchObject({
-      normalizedResponse: { error: { code: ERROR_CODES.LOCK_CONFLICT } }
+      normalizedResponse: { error: { code: ERROR_CODES.LOCK_CONFLICT } },
     });
   });
 });