agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/test/schema-date-time.spec.ts

@@ -22,14 +22,14 @@ function makeQaIndex() {
           {
             start_line: 1,
             end_line: 1,
-            change_type: 'modify'
-          }
+            change_type: 'modify',
+          },
         ],
         required_tests: ['default:fast:test'],
         status: 'pending',
-        last_run_at: '2026-02-28T12:00:00Z'
-      }
-    ]
+        last_run_at: '2026-02-28T12:00:00Z',
+      },
+    ],
   };
 }
 
@@ -44,8 +44,8 @@ describe('Schema date-time enforcement', () => {
       ...index,
       runtime_sessions: {
         ...index.runtime_sessions,
-        started_at: '2026-02-30T25:61:61Z'
-      }
+        started_at: '2026-02-30T25:61:61Z',
+      },
     };
     const startedAtValidation = await kernel.validateSchema('index.schema.json', startedAtInvalid);
     expect(startedAtValidation.valid).toBe(false);
@@ -53,9 +53,9 @@ describe('Schema date-time enforcement', () => {
       expect.arrayContaining([
         expect.objectContaining({
           keyword: 'format',
-          instancePath: '/runtime_sessions/started_at'
-        })
-      ])
+          instancePath: '/runtime_sessions/started_at',
+        }),
+      ]),
     );
 
     const leaseInvalid = {
@@ -63,9 +63,9 @@ describe('Schema date-time enforcement', () => {
       runtime_sessions: {
         ...index.runtime_sessions,
         last_heartbeat_at: 'bad-timestamp',
-        lease_expires_at: '2026-01-01 12:00:00'
+        lease_expires_at: '2026-01-01 12:00:00',
       },
-      updated_at: 'not-a-date'
+      updated_at: 'not-a-date',
     };
     const leaseValidation = await kernel.validateSchema('index.schema.json', leaseInvalid);
     expect(leaseValidation.valid).toBe(false);
@@ -73,17 +73,17 @@ describe('Schema date-time enforcement', () => {
       expect.arrayContaining([
         expect.objectContaining({
           keyword: 'format',
-          instancePath: '/runtime_sessions/last_heartbeat_at'
+          instancePath: '/runtime_sessions/last_heartbeat_at',
         }),
         expect.objectContaining({
           keyword: 'format',
-          instancePath: '/runtime_sessions/lease_expires_at'
+          instancePath: '/runtime_sessions/lease_expires_at',
         }),
         expect.objectContaining({
           keyword: 'format',
-          instancePath: '/updated_at'
-        })
-      ])
+          instancePath: '/updated_at',
+        }),
+      ]),
     );
 
     const qaInvalid = makeQaIndex();
@@ -94,9 +94,9 @@ describe('Schema date-time enforcement', () => {
       expect.arrayContaining([
         expect.objectContaining({
           keyword: 'format',
-          instancePath: '/items/0/last_run_at'
-        })
-      ])
+          instancePath: '/items/0/last_run_at',
+        }),
+      ]),
     );
 
     const qaValid = await kernel.validateSchema('qa_test_index.schema.json', makeQaIndex());
@@ -111,21 +111,29 @@ describe('Schema date-time enforcement', () => {
     await expect(
       kernel.writeIndex({
         ...index,
-        updated_at: 'invalid-datetime'
-      })
+        updated_at: 'invalid-datetime',
+      }),
     ).rejects.toMatchObject({
       normalizedResponse: {
         error: {
-          code: 'index_validation_failed'
-        }
-      }
+          code: 'index_validation_failed',
+        },
+      },
     });
 
     await writeFeatureSpec(repoRoot, 'feature_dt');
-    const init = await kernel.invoke('feature.init', { feature_id: 'feature_dt' }, { actor_type: 'orchestrator', actor_id: 'dt' });
+    const init = await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_dt' },
+      { actor_type: 'orchestrator', actor_id: 'dt' },
+    );
     expect(init.ok).toBe(true);
 
-    const state = await kernel.invoke('feature.state_get', { feature_id: 'feature_dt' }, { actor_type: 'orchestrator', actor_id: 'dt' });
+    const state = await kernel.invoke(
+      'feature.state_get',
+      { feature_id: 'feature_dt' },
+      { actor_type: 'orchestrator', actor_id: 'dt' },
+    );
     expect(state.ok).toBe(true);
 
     await expect(
@@ -133,16 +141,16 @@ describe('Schema date-time enforcement', () => {
         'feature_dt',
         {
           ...state.data.front_matter,
-          last_updated: '2026-13-55T25:00:00Z'
+          last_updated: '2026-13-55T25:00:00Z',
         },
-        state.data.body
-      )
+        state.data.body,
+      ),
     ).rejects.toMatchObject({
       normalizedResponse: {
         error: {
-          code: 'state_validation_failed'
-        }
-      }
+          code: 'state_validation_failed',
+        },
+      },
     });
 
     const qaPath = path.join(repoRoot, '.aop', 'features', 'feature_dt', 'qa_test_index.json');
@@ -154,7 +162,7 @@ describe('Schema date-time enforcement', () => {
     const qaRead = await kernel.invoke(
       'qa.test_index_get',
       { feature_id: 'feature_dt' },
-      { actor_type: 'qa', actor_id: 'dt' }
+      { actor_type: 'qa', actor_id: 'dt' },
     );
     expect(qaRead.ok).toBe(false);
     expect(qaRead.error.code).toBe('internal_error');
@@ -162,9 +170,9 @@ describe('Schema date-time enforcement', () => {
       expect.arrayContaining([
         expect.objectContaining({
           keyword: 'format',
-          instancePath: '/items/0/last_run_at'
-        })
-      ])
+          instancePath: '/items/0/last_run_at',
+        }),
+      ]),
     );
   });
 });
@@ -176,7 +184,7 @@ describe('isStrictRfc3339DateTime additional branches', () => {
     const index = await kernel.readIndex();
     const result = await kernel.validateSchema('index.schema.json', {
       ...index,
-      runtime_sessions: { ...index.runtime_sessions, started_at: '2026-02-30T12:00:00Z' }
+      runtime_sessions: { ...index.runtime_sessions, started_at: '2026-02-30T12:00:00Z' },
     });
     expect(result.valid).toBe(false);
   });
@@ -187,7 +195,7 @@ describe('isStrictRfc3339DateTime additional branches', () => {
     const index = await kernel.readIndex();
     const result = await kernel.validateSchema('index.schema.json', {
       ...index,
-      runtime_sessions: { ...index.runtime_sessions, started_at: '2026-01-15T24:00:00Z' }
+      runtime_sessions: { ...index.runtime_sessions, started_at: '2026-01-15T24:00:00Z' },
     });
     expect(result.valid).toBe(false);
   });
@@ -198,7 +206,7 @@ describe('isStrictRfc3339DateTime additional branches', () => {
     const index = await kernel.readIndex();
     const result = await kernel.validateSchema('index.schema.json', {
       ...index,
-      runtime_sessions: { ...index.runtime_sessions, started_at: '2026-01-15T12:00:00+24:00' }
+      runtime_sessions: { ...index.runtime_sessions, started_at: '2026-01-15T12:00:00+24:00' },
     });
     expect(result.valid).toBe(false);
   });
@@ -209,7 +217,7 @@ describe('isStrictRfc3339DateTime additional branches', () => {
     const index = await kernel.readIndex();
     const result = await kernel.validateSchema('index.schema.json', {
       ...index,
-      runtime_sessions: { ...index.runtime_sessions, started_at: '2026-01-00T12:00:00Z' }
+      runtime_sessions: { ...index.runtime_sessions, started_at: '2026-01-00T12:00:00Z' },
     });
     expect(result.valid).toBe(false);
   });

package/apps/control-plane/test/service-retry-paths.spec.ts

@@ -1,11 +1,11 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 vi.mock('../src/core/gates.js', () => ({
-  runGateMode: vi.fn()
+  runGateMode: vi.fn(),
 }));
 
 vi.mock('../src/core/git.js', () => ({
-  runGit: vi.fn()
+  runGit: vi.fn(),
 }));
 
 import { FeatureStateService } from '../src/application/services/feature-state-service.js';
@@ -29,7 +29,7 @@ function commandResult(overrides: Partial<Awaited<ReturnType<typeof runGit>>> =
     stdout: '',
     stderr: '',
     timeout: false,
-    ...overrides
+    ...overrides,
   };
 }
 
@@ -43,24 +43,25 @@ describe('Decomposition retry paths', () => {
       frontMatter: {
         feature_id: 'feature_retry',
         version: 1,
-        status: STATUS.BUILDING
+        status: STATUS.BUILDING,
       },
-      body: 'initial body'
+      body: 'initial body',
     };
 
     const service = new FeatureStateService({
-      withFeatureLock: async <T>(_featureId: string, operation: () => Promise<T>) => await operation(),
+      withFeatureLock: async <T>(_featureId: string, operation: () => Promise<T>) =>
+        await operation(),
       readState: async () => clone(state),
       writeState: async (_featureId: string, frontMatter: AnyRecord, body?: string) => {
         state.frontMatter = clone(frontMatter);
         state.body = body ?? state.body;
-      }
+      },
     });
 
     await expect(
       service.featureStatePatch('feature_retry', 0, {
-        front_matter: { status: STATUS.QA }
-      })
+        front_matter: { status: STATUS.QA },
+      }),
     ).rejects.toMatchObject({
       normalizedResponse: {
         error: {
@@ -68,22 +69,22 @@ describe('Decomposition retry paths', () => {
           details: {
             expected_version: 0,
             actual_version: 1,
-            retryable: true
-          }
-        }
-      }
+            retryable: true,
+          },
+        },
+      },
     });
 
     const retry = await service.featureStatePatch('feature_retry', 1, {
-      front_matter: { status: STATUS.QA }
+      front_matter: { status: STATUS.QA },
     });
 
     expect(retry).toMatchObject({
       data: {
         feature_id: 'feature_retry',
         version: 2,
-        status: STATUS.QA
-      }
+        status: STATUS.QA,
+      },
     });
     expect(state.frontMatter.version).toBe(2);
     expect(state.frontMatter.status).toBe(STATUS.QA);
@@ -98,11 +99,11 @@ describe('Decomposition retry paths', () => {
         gate_profile: 'default',
         gates: {
           fast: GATE_RESULT.NA,
-          full: GATE_RESULT.NA
+          full: GATE_RESULT.NA,
         },
-        evidence: {}
+        evidence: {},
       },
-      body: 'state body'
+      body: 'state body',
     };
 
     vi.mocked(runGateMode)
@@ -112,7 +113,7 @@ describe('Decomposition retry paths', () => {
         evidence_path: '/repo/.aop/features/feature_gate_retry/evidence/gate-fast-1.json',
         latest_path: '/repo/.aop/features/feature_gate_retry/evidence/latest-fast.json',
         coverage: { line: 0.7, branch: 0.72 },
-        thresholds: { coverage_line_min: 0.8, coverage_branch_min: 0.8 }
+        thresholds: { coverage_line_min: 0.8, coverage_branch_min: 0.8 },
       })
       .mockResolvedValueOnce({
         overall: 'pass',
@@ -120,7 +121,7 @@ describe('Decomposition retry paths', () => {
         evidence_path: '/repo/.aop/features/feature_gate_retry/evidence/gate-fast-2.json',
         latest_path: '/repo/.aop/features/feature_gate_retry/evidence/latest-fast.json',
         coverage: { line: 0.9, branch: 0.91 },
-        thresholds: { coverage_line_min: 0.8, coverage_branch_min: 0.8 }
+        thresholds: { coverage_line_min: 0.8, coverage_branch_min: 0.8 },
       });
 
     const service = new GateService({
@@ -129,10 +130,10 @@ describe('Decomposition retry paths', () => {
         profiles: {
           default: {
             modes: {
-              fast: [{ name: 'fast-check', cmd: ['npm', 'test'] }]
-            }
-          }
-        }
+              fast: [{ name: 'fast-check', cmd: ['npm', 'test'] }],
+            },
+          },
+        },
       }),
       getPolicySnapshot: () => ({ testing: {}, execution: {} }),
       readState: async () => clone(state),
@@ -144,14 +145,14 @@ describe('Decomposition retry paths', () => {
         state.frontMatter = {
           ...state.frontMatter,
           ...(next.frontMatter ?? {}),
-          version: state.frontMatter.version + 1
+          version: state.frontMatter.version + 1,
         };
         state.body = next.body ?? state.body;
         return clone(state.frontMatter);
       },
       worktreePath: (featureId: string) => `/repo/.worktrees/${featureId}`,
       logsPath: (featureId: string) => `/repo/.aop/features/${featureId}/logs`,
-      evidencePath: (featureId: string) => `/repo/.aop/features/${featureId}/evidence`
+      evidencePath: (featureId: string) => `/repo/.aop/features/${featureId}/evidence`,
     });
 
     await expect(service.gatesRun('feature_gate_retry', null, 'fast')).rejects.toMatchObject({
@@ -160,13 +161,13 @@ describe('Decomposition retry paths', () => {
           code: ERROR_CODES.COVERAGE_BELOW_MINIMUM,
           details: {
             retryable: true,
-            requires_human: false
-          }
+            requires_human: false,
+          },
         },
         evidence: {
-          log_path: '.aop/features/feature_gate_retry/evidence/latest-fast.json'
-        }
-      }
+          log_path: '.aop/features/feature_gate_retry/evidence/latest-fast.json',
+        },
+      },
     });
 
     expect(state.frontMatter.status).toBe(STATUS.BLOCKED);
@@ -179,7 +180,7 @@ describe('Decomposition retry paths', () => {
       feature_id: 'feature_gate_retry',
       mode: 'fast',
       overall: 'pass',
-      evidence_path: '.aop/features/feature_gate_retry/evidence/gate-fast-2.json'
+      evidence_path: '.aop/features/feature_gate_retry/evidence/gate-fast-2.json',
     });
     expect(state.frontMatter.status).toBe(STATUS.QA);
     expect(state.frontMatter.gates.fast).toBe(GATE_RESULT.PASS);
@@ -193,21 +194,21 @@ describe('Decomposition retry paths', () => {
         status: STATUS.READY_TO_MERGE,
         gates: {
           fast: GATE_RESULT.PASS,
-          full: GATE_RESULT.PASS
+          full: GATE_RESULT.PASS,
         },
         locks: {
-          held: ['openapi', 'db_migrations']
+          held: ['openapi', 'db_migrations'],
         },
-        evidence: {}
+        evidence: {},
       },
-      body: '# State'
+      body: '# State',
     };
 
     let index: AnyRecord = {
       version: 7,
       active: ['feature_merge_retry'],
       blocked: ['feature_merge_retry'],
-      merged: []
+      merged: [],
     };
 
     const locksRelease = vi.fn(async () => ({ data: { released: true } }));
@@ -241,13 +242,13 @@ describe('Decomposition retry paths', () => {
       getPolicySnapshot: () => ({
         merge_policy: {
           allowed_strategies: ['merge_commit', 'squash', 'rebase'],
-          require_user_approval: false
+          require_user_approval: false,
         },
         required_modes: ['fast'],
         required_merge_mode: 'full',
         worktree: {
-          base_branch: 'main'
-        }
+          base_branch: 'main',
+        },
       }),
       featurePath: (featureId: string) => `/repo/.aop/features/${featureId}`,
       readState: async () => clone(state),
@@ -260,7 +261,7 @@ describe('Decomposition retry paths', () => {
         state.frontMatter = {
           ...state.frontMatter,
           ...(next.frontMatter ?? {}),
-          version: state.frontMatter.version + 1
+          version: state.frontMatter.version + 1,
         };
         state.body = next.body ?? state.body;
         return clone(state.frontMatter);
@@ -270,30 +271,35 @@ describe('Decomposition retry paths', () => {
       readIndex: async () => clone(index),
       writeIndex: async (nextIndex: AnyRecord) => {
         index = clone(nextIndex);
-      }
+      },
     });
 
     await expect(
-      service.featureReadyToMerge('feature_merge_retry', 'merge retry', 'merge_commit', null)
+      service.featureReadyToMerge('feature_merge_retry', 'merge retry', 'merge_commit', null),
     ).rejects.toMatchObject({
       normalizedResponse: {
         error: {
           code: ERROR_CODES.GIT_FAILURE,
           details: {
             retryable: true,
-            requires_human: true
-          }
-        }
-      }
+            requires_human: true,
+          },
+        },
+      },
     });
 
-    const retry = await service.featureReadyToMerge('feature_merge_retry', 'merge retry', 'merge_commit', null);
+    const retry = await service.featureReadyToMerge(
+      'feature_merge_retry',
+      'merge retry',
+      'merge_commit',
+      null,
+    );
 
     expect(retry.data).toMatchObject({
       feature_id: 'feature_merge_retry',
       merge_sha: 'abc123',
       merge_strategy: 'merge_commit',
-      status: STATUS.MERGED
+      status: STATUS.MERGED,
     });
     expect(state.frontMatter.status).toBe(STATUS.MERGED);
     expect(state.frontMatter.version).toBe(5);
@@ -306,30 +312,44 @@ describe('Decomposition retry paths', () => {
 
 describe('FeatureStateService branch coverage', () => {
   it('GIVEN_frontMatter_with_non_numeric_version_WHEN_updateState_called_THEN_version_starts_from_1', async () => {
-    const state = { frontMatter: { feature_id: 'f1', status: STATUS.PLANNING, version: 'not-a-number' as unknown as number }, body: '' };
+    const state = {
+      frontMatter: {
+        feature_id: 'f1',
+        status: STATUS.PLANNING,
+        version: 'not-a-number' as unknown as number,
+      },
+      body: '',
+    };
     const service = new FeatureStateService({
       withFeatureLock: async <T>(_id: string, op: () => Promise<T>) => await op(),
       readState: async () => ({ ...state }),
-      writeState: async (_id: string, fm: Record<string, unknown>) => { state.frontMatter = fm as typeof state.frontMatter; }
+      writeState: async (_id: string, fm: Record<string, unknown>) => {
+        state.frontMatter = fm as typeof state.frontMatter;
+      },
     });
 
-    const result = await service.featureStatePatch('f1', null, { front_matter: { status: STATUS.PLANNING } });
+    const result = await service.featureStatePatch('f1', null, {
+      front_matter: { status: STATUS.PLANNING },
+    });
     // version should be 0 (non-numeric read) + 1 = 1
     expect(result.data.version).toBe(1);
   });
 
   it('GIVEN_illegal_status_transition_WHEN_updateState_called_THEN_throws_INVALID_STATUS_TRANSITION', async () => {
-    const state = { frontMatter: { feature_id: 'f1', status: STATUS.MERGED, version: 1 }, body: '' };
+    const state = {
+      frontMatter: { feature_id: 'f1', status: STATUS.MERGED, version: 1 },
+      body: '',
+    };
     const service = new FeatureStateService({
       withFeatureLock: async <T>(_id: string, op: () => Promise<T>) => await op(),
       readState: async () => ({ ...state }),
-      writeState: vi.fn()
+      writeState: vi.fn(),
     });
 
     await expect(
-      service.featureStatePatch('f1', null, { front_matter: { status: STATUS.PLANNING } })
+      service.featureStatePatch('f1', null, { front_matter: { status: STATUS.PLANNING } }),
     ).rejects.toMatchObject({
-      normalizedResponse: { error: { code: ERROR_CODES.INVALID_STATUS_TRANSITION } }
+      normalizedResponse: { error: { code: ERROR_CODES.INVALID_STATUS_TRANSITION } },
     });
   });
 });