agentic-orchestrator 0.1.0

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

@@ -0,0 +1,170 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { AopKernel } from '../src/index.js';
+import { makeTempRepo, writeFeatureSpec } from './helpers.js';
+
+let repoRoot: string;
+
+beforeEach(async () => {
+  repoRoot = await makeTempRepo(process.cwd());
+});
+
+function makeQaIndex() {
+  return {
+    feature_id: 'feature_dt',
+    version: 1,
+    source_diff_ref: 'diff-ref',
+    items: [
+      {
+        path: 'src/sample.ts',
+        hunks: [
+          {
+            start_line: 1,
+            end_line: 1,
+            change_type: 'modify'
+          }
+        ],
+        required_tests: ['default:fast:test'],
+        status: 'pending',
+        last_run_at: '2026-02-28T12:00:00Z'
+      }
+    ]
+  };
+}
+
+describe('Schema date-time enforcement', () => {
+  it('rejects malformed RFC3339 date-time values across index and QA schemas', async () => {
+    const kernel = new AopKernel(repoRoot);
+    await kernel.ensureLoaded();
+
+    const index = await kernel.readIndex();
+
+    const startedAtInvalid = {
+      ...index,
+      runtime_sessions: {
+        ...index.runtime_sessions,
+        started_at: '2026-02-30T25:61:61Z'
+      }
+    };
+    const startedAtValidation = await kernel.validateSchema('index.schema.json', startedAtInvalid);
+    expect(startedAtValidation.valid).toBe(false);
+    expect(startedAtValidation.errors).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          keyword: 'format',
+          instancePath: '/runtime_sessions/started_at'
+        })
+      ])
+    );
+
+    const leaseInvalid = {
+      ...index,
+      runtime_sessions: {
+        ...index.runtime_sessions,
+        last_heartbeat_at: 'bad-timestamp',
+        lease_expires_at: '2026-01-01 12:00:00'
+      },
+      updated_at: 'not-a-date'
+    };
+    const leaseValidation = await kernel.validateSchema('index.schema.json', leaseInvalid);
+    expect(leaseValidation.valid).toBe(false);
+    expect(leaseValidation.errors).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          keyword: 'format',
+          instancePath: '/runtime_sessions/last_heartbeat_at'
+        }),
+        expect.objectContaining({
+          keyword: 'format',
+          instancePath: '/runtime_sessions/lease_expires_at'
+        }),
+        expect.objectContaining({
+          keyword: 'format',
+          instancePath: '/updated_at'
+        })
+      ])
+    );
+
+    const qaInvalid = makeQaIndex();
+    qaInvalid.items[0].last_run_at = '2026-99-99T99:99:99Z';
+    const qaValidation = await kernel.validateSchema('qa_test_index.schema.json', qaInvalid);
+    expect(qaValidation.valid).toBe(false);
+    expect(qaValidation.errors).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          keyword: 'format',
+          instancePath: '/items/0/last_run_at'
+        })
+      ])
+    );
+
+    const qaValid = await kernel.validateSchema('qa_test_index.schema.json', makeQaIndex());
+    expect(qaValid.valid).toBe(true);
+  });
+
+  it('returns structured validation errors when malformed temporal fields are persisted', async () => {
+    const kernel = new AopKernel(repoRoot);
+    await kernel.ensureLoaded();
+
+    const index = await kernel.readIndex();
+    await expect(
+      kernel.writeIndex({
+        ...index,
+        updated_at: 'invalid-datetime'
+      })
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          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' });
+    expect(init.ok).toBe(true);
+
+    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(
+      kernel.writeState(
+        'feature_dt',
+        {
+          ...state.data.front_matter,
+          last_updated: '2026-13-55T25:00:00Z'
+        },
+        state.data.body
+      )
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: 'state_validation_failed'
+        }
+      }
+    });
+
+    const qaPath = path.join(repoRoot, '.aop', 'features', 'feature_dt', 'qa_test_index.json');
+    const malformedQa = makeQaIndex();
+    malformedQa.feature_id = 'feature_dt';
+    malformedQa.items[0].last_run_at = 'not-rfc3339';
+    await fs.writeFile(qaPath, `${JSON.stringify(malformedQa, null, 2)}\n`, 'utf8');
+
+    const qaRead = await kernel.invoke(
+      'qa.test_index_get',
+      { feature_id: 'feature_dt' },
+      { actor_type: 'qa', actor_id: 'dt' }
+    );
+    expect(qaRead.ok).toBe(false);
+    expect(qaRead.error.code).toBe('internal_error');
+    expect(qaRead.error.details?.errors).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          keyword: 'format',
+          instancePath: '/items/0/last_run_at'
+        })
+      ])
+    );
+  });
+});

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

@@ -0,0 +1,305 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('../src/core/gates.js', () => ({
+  runGateMode: vi.fn()
+}));
+
+vi.mock('../src/core/git.js', () => ({
+  runGit: vi.fn()
+}));
+
+import { FeatureStateService } from '../src/application/services/feature-state-service.js';
+import { GateService } from '../src/application/services/gate-service.js';
+import { MergeService } from '../src/application/services/merge-service.js';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { GATE_RESULT, STATUS } from '../src/core/constants.js';
+import { runGateMode } from '../src/core/gates.js';
+import { runGit } from '../src/core/git.js';
+
+type AnyRecord = Record<string, any>;
+
+function clone<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+function commandResult(overrides: Partial<Awaited<ReturnType<typeof runGit>>> = {}) {
+  return {
+    code: 0,
+    signal: null,
+    stdout: '',
+    stderr: '',
+    timeout: false,
+    ...overrides
+  };
+}
+
+describe('Decomposition retry paths', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('retries FeatureStateService patch after version_conflict with normalized envelope parity', async () => {
+    const state: { frontMatter: AnyRecord; body: string } = {
+      frontMatter: {
+        feature_id: 'feature_retry',
+        version: 1,
+        status: STATUS.BUILDING
+      },
+      body: 'initial body'
+    };
+
+    const service = new FeatureStateService({
+      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 }
+      })
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.VERSION_CONFLICT,
+          details: {
+            expected_version: 0,
+            actual_version: 1,
+            retryable: true
+          }
+        }
+      }
+    });
+
+    const retry = await service.featureStatePatch('feature_retry', 1, {
+      front_matter: { status: STATUS.QA }
+    });
+
+    expect(retry).toMatchObject({
+      data: {
+        feature_id: 'feature_retry',
+        version: 2,
+        status: STATUS.QA
+      }
+    });
+    expect(state.frontMatter.version).toBe(2);
+    expect(state.frontMatter.status).toBe(STATUS.QA);
+  });
+
+  it('retries GateService fast mode after transient coverage failure and preserves MCP-style failure envelope', async () => {
+    const state = {
+      frontMatter: {
+        feature_id: 'feature_gate_retry',
+        version: 10,
+        status: STATUS.BUILDING,
+        gate_profile: 'default',
+        gates: {
+          fast: GATE_RESULT.NA,
+          full: GATE_RESULT.NA
+        },
+        evidence: {}
+      },
+      body: 'state body'
+    };
+
+    vi.mocked(runGateMode)
+      .mockResolvedValueOnce({
+        overall: 'fail',
+        coverage_status: 'fail',
+        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 }
+      })
+      .mockResolvedValueOnce({
+        overall: 'pass',
+        coverage_status: 'pass',
+        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 }
+      });
+
+    const service = new GateService({
+      getRepoRoot: () => '/repo',
+      getGatesConfig: () => ({
+        profiles: {
+          default: {
+            modes: {
+              fast: [{ name: 'fast-check', cmd: ['npm', 'test'] }]
+            }
+          }
+        }
+      }),
+      getPolicySnapshot: () => ({ testing: {}, execution: {} }),
+      readState: async () => clone(state),
+      updateState: async (_featureId: string, expectedVersion: number | null, updater: any) => {
+        if (expectedVersion != null && expectedVersion !== state.frontMatter.version) {
+          throw new Error('unexpected_version_mismatch');
+        }
+        const next = await updater(clone(state.frontMatter), state.body);
+        state.frontMatter = {
+          ...state.frontMatter,
+          ...(next.frontMatter ?? {}),
+          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`
+    });
+
+    await expect(service.gatesRun('feature_gate_retry', null, 'fast')).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.COVERAGE_BELOW_MINIMUM,
+          details: {
+            retryable: true,
+            requires_human: false
+          }
+        },
+        evidence: {
+          log_path: '.aop/features/feature_gate_retry/evidence/latest-fast.json'
+        }
+      }
+    });
+
+    expect(state.frontMatter.status).toBe(STATUS.BLOCKED);
+    expect(state.frontMatter.gates.fast).toBe(GATE_RESULT.FAIL);
+
+    state.frontMatter.status = STATUS.BUILDING;
+    const retry = await service.gatesRun('feature_gate_retry', null, 'fast');
+
+    expect(retry.data).toMatchObject({
+      feature_id: 'feature_gate_retry',
+      mode: 'fast',
+      overall: 'pass',
+      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);
+  });
+
+  it('retries MergeService after transient git merge failure and succeeds without duplicate side effects', async () => {
+    const state = {
+      frontMatter: {
+        feature_id: 'feature_merge_retry',
+        version: 4,
+        status: STATUS.READY_TO_MERGE,
+        gates: {
+          fast: GATE_RESULT.PASS,
+          full: GATE_RESULT.PASS
+        },
+        locks: {
+          held: ['openapi', 'db_migrations']
+        },
+        evidence: {}
+      },
+      body: '# State'
+    };
+
+    let index: AnyRecord = {
+      version: 7,
+      active: ['feature_merge_retry'],
+      blocked: ['feature_merge_retry'],
+      merged: []
+    };
+
+    const locksRelease = vi.fn(async () => ({ data: { released: true } }));
+    let mergeAttempt = 0;
+
+    vi.mocked(runGit).mockImplementation(async (_repoRoot: string, args: string[]) => {
+      if (args[0] === 'add') {
+        return commandResult();
+      }
+      if (args[0] === 'commit') {
+        return commandResult({ code: 1, stderr: 'nothing to commit' });
+      }
+      if (args[0] === 'checkout') {
+        return commandResult();
+      }
+      if (args[0] === 'merge' && args[1] === '--no-ff') {
+        mergeAttempt += 1;
+        if (mergeAttempt === 1) {
+          return commandResult({ code: 1, stderr: 'merge conflict' });
+        }
+        return commandResult();
+      }
+      if (args[0] === 'rev-parse') {
+        return commandResult({ stdout: 'abc123\n' });
+      }
+      return commandResult();
+    });
+
+    const service = new MergeService({
+      getRepoRoot: () => '/repo',
+      getPolicySnapshot: () => ({
+        merge_policy: {
+          allowed_strategies: ['merge_commit', 'squash', 'rebase'],
+          require_user_approval: false
+        },
+        required_modes: ['fast'],
+        required_merge_mode: 'full',
+        worktree: {
+          base_branch: 'main'
+        }
+      }),
+      featurePath: (featureId: string) => `/repo/.aop/features/${featureId}`,
+      readState: async () => clone(state),
+      worktreePath: (featureId: string) => `/repo/.worktrees/${featureId}`,
+      updateState: async (_featureId: string, expectedVersion: number | null, updater: any) => {
+        if (expectedVersion != null && expectedVersion !== state.frontMatter.version) {
+          throw new Error('unexpected_version_mismatch');
+        }
+        const next = await updater(clone(state.frontMatter), state.body);
+        state.frontMatter = {
+          ...state.frontMatter,
+          ...(next.frontMatter ?? {}),
+          version: state.frontMatter.version + 1
+        };
+        state.body = next.body ?? state.body;
+        return clone(state.frontMatter);
+      },
+      locksRelease,
+      withIndexLock: async <T>(operation: () => Promise<T>) => await operation(),
+      readIndex: async () => clone(index),
+      writeIndex: async (nextIndex: AnyRecord) => {
+        index = clone(nextIndex);
+      }
+    });
+
+    await expect(
+      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
+          }
+        }
+      }
+    });
+
+    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
+    });
+    expect(state.frontMatter.status).toBe(STATUS.MERGED);
+    expect(state.frontMatter.version).toBe(5);
+    expect(locksRelease).toHaveBeenCalledTimes(2);
+    expect(index.active).toEqual([]);
+    expect(index.blocked).toEqual([]);
+    expect(index.merged).toEqual(['feature_merge_retry']);
+  });
+});