agentic-orchestrator 0.1.27 → 0.2.0

package/apps/control-plane/test/checkpoint-service.spec.ts

@@ -8,6 +8,7 @@ import {
   type CheckpointProviderPort,
   type CheckpointRecord,
   type InteractiveExecutionConfig,
+  type ViolationSeverity,
 } from '../src/application/services/checkpoint-service.js';
 import type { WorktreeWatchdogService } from '../src/application/services/worktree-watchdog-service.js';
 
@@ -62,6 +63,25 @@ function defaultConfig(
   };
 }
 
+function makeWatchdog(
+  changedFiles: string[],
+  options: { hasNetNewChanges?: boolean } = {},
+): WorktreeWatchdogService {
+  const hasNetNewChanges = options.hasNetNewChanges ?? changedFiles.length > 0;
+  return {
+    getChangedFiles: vi.fn(async () => changedFiles),
+    getChangeSummary: vi.fn(async () => ({
+      baselineFiles: [],
+      currentFiles: changedFiles,
+      changedFiles,
+      baselineDiffHash: 'baseline-diff-hash',
+      currentDiffHash: hasNetNewChanges ? 'current-diff-hash' : 'baseline-diff-hash',
+      hasNetNewChanges,
+    })),
+    resetChangeCount: vi.fn(),
+  } as unknown as WorktreeWatchdogService;
+}
+
 describe('CheckpointService', () => {
   it('creates a valid checkpoint and persists diff snapshot metadata', async () => {
     const repoRoot = await initGitRepo('aop-checkpoint-valid-');
@@ -70,10 +90,7 @@ describe('CheckpointService', () => {
       body: 'state body',
     };
 
-    const watchdog = {
-      getChangedFiles: vi.fn(async () => ['tracked.txt']),
-      resetChangeCount: vi.fn(),
-    } as unknown as WorktreeWatchdogService;
+    const watchdog = makeWatchdog(['tracked.txt']);
 
     const provider = {
       selection: {
@@ -158,10 +175,7 @@ describe('CheckpointService', () => {
       body: 'state body',
     };
 
-    const watchdog = {
-      getChangedFiles: vi.fn(async () => ['tracked.txt']),
-      resetChangeCount: vi.fn(),
-    } as unknown as WorktreeWatchdogService;
+    const watchdog = makeWatchdog(['tracked.txt']);
 
     const provider = {
       selection: {
@@ -248,10 +262,7 @@ describe('CheckpointService', () => {
         path.join(repoRoot, '.aop', 'features', featureId),
       worktreePathResolver: () => repoRoot,
       validateDiff: vi.fn(async () => ({ valid: true, violations: [], changed_files: [] })),
-      watchdog: {
-        getChangedFiles: vi.fn(async () => []),
-        resetChangeCount: vi.fn(),
-      } as unknown as WorktreeWatchdogService,
+      watchdog: makeWatchdog([]),
       provider: {
         selection: {
           provider: 'custom',
@@ -302,10 +313,7 @@ describe('CheckpointService', () => {
           },
         };
       }),
-      watchdog: {
-        getChangedFiles: vi.fn(async () => ['tracked.txt']),
-        resetChangeCount: vi.fn(),
-      } as unknown as WorktreeWatchdogService,
+      watchdog: makeWatchdog(['tracked.txt']),
       provider: {
         selection: {
           provider: 'custom',
@@ -347,10 +355,7 @@ describe('CheckpointService', () => {
             },
           };
         }),
-        watchdog: {
-          getChangedFiles: vi.fn(async () => ['tracked.txt']),
-          resetChangeCount: vi.fn(),
-        } as unknown as WorktreeWatchdogService,
+        watchdog: makeWatchdog(['tracked.txt']),
         provider: {
           selection: {
             provider: 'custom',
@@ -376,7 +381,956 @@ describe('CheckpointService', () => {
       });
       expect(invalid.checkpoint.validation_status).toBe('invalid');
       expect(invalid.checkpoint.violations).toEqual(['checkpoint message violation']);
-      expect(invalid.blockMerge).toBe(false);
+      expect(invalid.blockMerge).toBe(true);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('skips validation when validationOnCheckpoint is false', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-skip-config-');
+    const state: MutableState = {
+      frontMatter: { version: 1, status: 'building' },
+      body: 'state body',
+    };
+    const validateDiff = vi.fn(async () => ({
+      valid: false,
+      violations: ['should-not-run'],
+      changed_files: ['tracked.txt'],
+    }));
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff,
+      watchdog: makeWatchdog(['tracked.txt']),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig({ validationOnCheckpoint: false }),
+    });
+
+    try {
+      await fs.writeFile(path.join(repoRoot, 'tracked.txt'), 'updated\n', 'utf8');
+      const result = await service.createCheckpoint({
+        featureId: 'feature_skip_config',
+        trigger: 'final',
+      });
+      expect(result.checkpoint.validation_status).toBe('skipped');
+      expect(result.valid).toBe(true);
+      expect(result.blockMerge).toBe(false);
+      expect(validateDiff).not.toHaveBeenCalled();
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('skips validation when no diff content is present', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-empty-diff-');
+    const state: MutableState = {
+      frontMatter: { version: 1, status: 'building' },
+      body: 'state body',
+    };
+    const validateDiff = vi.fn(async () => ({
+      valid: true,
+      violations: [],
+      changed_files: [],
+    }));
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff,
+      watchdog: makeWatchdog([]),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig({ validationOnCheckpoint: true }),
+    });
+
+    try {
+      const result = await service.createCheckpoint({
+        featureId: 'feature_empty_diff',
+        trigger: 'final',
+      });
+      expect(result.checkpoint.validation_status).toBe('skipped');
+      expect(validateDiff).not.toHaveBeenCalled();
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('captures untracked files in checkpoint diffs and marks them as net new work', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-untracked-');
+    const state: MutableState = {
+      frontMatter: { version: 1, status: 'building' },
+      body: 'state body',
+    };
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff: vi.fn(async () => ({
+        valid: true,
+        violations: [],
+        changed_files: ['new-file.txt'],
+      })),
+      watchdog: makeWatchdog(['new-file.txt'], { hasNetNewChanges: true }),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig(),
+    });
+
+    try {
+      await fs.writeFile(path.join(repoRoot, 'new-file.txt'), 'hello untracked\n', 'utf8');
+
+      const result = await service.createCheckpoint({
+        featureId: 'feature_untracked_diff',
+        trigger: 'final',
+      });
+
+      expect(result.checkpoint.validation_status).toBe('valid');
+      expect(result.checkpoint.files_changed).toEqual(['new-file.txt']);
+      expect(result.checkpoint.net_new_worktree_change).toBe(true);
+      expect(result.checkpoint.diff_hash).toBeTruthy();
+      expect(result.checkpoint.diff_hash).not.toBe(
+        'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+      );
+
+      const snapshotPath = path.join(repoRoot, result.checkpoint.diff_snapshot);
+      const snapshot = await fs.readFile(snapshotPath, 'utf8');
+      expect(snapshot).toContain('new file mode 100644');
+      expect(snapshot).toContain('new-file.txt');
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('marks invalid checkpoints when validateDiff returns valid=false and notifies agent', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-invalid-return-');
+    const state: MutableState = {
+      frontMatter: { version: 1, status: 'building' },
+      body: 'state body',
+    };
+    const sendMessage = vi.fn(async () => undefined);
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff: vi.fn(async () => ({
+        valid: false,
+        violations: ['policy violation'],
+        changed_files: ['tracked.txt'],
+      })),
+      watchdog: makeWatchdog(['tracked.txt']),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+        sendMessage,
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig({ revertOnViolation: false, violationSeverity: 'warning' }),
+    });
+
+    try {
+      await fs.writeFile(path.join(repoRoot, 'tracked.txt'), 'invalid\n', 'utf8');
+      const result = await service.createCheckpoint({
+        featureId: 'feature_invalid_return',
+        sessionId: 'builder-session',
+        trigger: 'final',
+      });
+      expect(result.checkpoint.validation_status).toBe('invalid');
+      expect(result.checkpoint.violations).toEqual(['policy violation']);
+      expect(sendMessage).toHaveBeenCalledTimes(1);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('carries forward the workspace fingerprint across idle duplicate checkpoints', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-fingerprint-carry-');
+    const state: MutableState = {
+      frontMatter: { version: 1, status: 'building' },
+      body: 'state body',
+    };
+    const validateDiff = vi.fn(async () => ({
+      valid: true,
+      violations: [],
+      changed_files: ['tracked.txt'],
+    }));
+
+    const makeService = (watchdog: WorktreeWatchdogService) =>
+      new CheckpointService({
+        repoRoot,
+        featurePathResolver: (featureId: string) =>
+          path.join(repoRoot, '.aop', 'features', featureId),
+        worktreePathResolver: () => repoRoot,
+        validateDiff,
+        watchdog,
+        provider: {
+          selection: {
+            provider: 'custom',
+            model: 'local-default',
+            provider_config_env: null,
+            provider_config_ref: null,
+          },
+          runWorker: vi.fn(),
+        } as unknown as CheckpointProviderPort,
+        readState: async () => ({ frontMatter: state.frontMatter }),
+        updateState: makeUpdateState(state),
+        config: defaultConfig(),
+      });
+
+    try {
+      await fs.writeFile(path.join(repoRoot, '.gitignore'), '.aop/\n', 'utf8');
+      await runGit(repoRoot, ['add', '.gitignore']);
+      await runGit(repoRoot, ['commit', '-m', 'ignore checkpoint artifacts']);
+      await fs.writeFile(path.join(repoRoot, 'tracked.txt'), 'materialized change\n', 'utf8');
+
+      const first = await makeService(
+        makeWatchdog(['tracked.txt'], { hasNetNewChanges: true }),
+      ).createCheckpoint({
+        featureId: 'feature_fingerprint',
+        trigger: 'interval',
+      });
+
+      const second = await makeService(
+        makeWatchdog([], { hasNetNewChanges: false }),
+      ).createCheckpoint({
+        featureId: 'feature_fingerprint',
+        trigger: 'interval',
+      });
+
+      expect(first.checkpoint.validation_status).toBe('valid');
+      expect(first.checkpoint.workspace_fingerprint).toBeTruthy();
+      expect(first.checkpoint.head_sha).toBeTruthy();
+      expect(second.checkpoint.validation_status).toBe('skipped');
+      expect(second.checkpoint.net_new_worktree_change).toBe(false);
+      expect(second.checkpoint.duplicate_of_checkpoint_id).toBe(first.checkpoint.checkpoint_id);
+      expect(second.checkpoint.workspace_fingerprint).toBe(first.checkpoint.workspace_fingerprint);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('uses fallback violation message when validation throws non-object error', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-throw-string-');
+    const state: MutableState = {
+      frontMatter: { version: 1, status: 'building' },
+      body: 'state body',
+    };
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff: vi.fn(async () => {
+        throw 'boom';
+      }),
+      watchdog: makeWatchdog(['tracked.txt']),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig(),
+    });
+
+    try {
+      await fs.writeFile(path.join(repoRoot, 'tracked.txt'), 'throw\n', 'utf8');
+      const result = await service.createCheckpoint({
+        featureId: 'feature_throw',
+        sessionId: 'builder-session',
+        trigger: 'final',
+      });
+      expect(result.checkpoint.violations).toEqual(['Checkpoint validation failed']);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('falls back when violation details are not array or message is invalid', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-violation-shape-');
+    const state: MutableState = {
+      frontMatter: { version: 1, status: 'building' },
+      body: 'state body',
+    };
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff: vi.fn(async () => {
+        throw {
+          normalizedResponse: {
+            error: {
+              details: {
+                violations: 'not-an-array',
+                message: 123,
+              },
+            },
+          },
+        };
+      }),
+      watchdog: makeWatchdog(['tracked.txt']),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig(),
+    });
+
+    try {
+      await fs.writeFile(path.join(repoRoot, 'tracked.txt'), 'shape\n', 'utf8');
+      const result = await service.createCheckpoint({
+        featureId: 'feature_shape',
+        trigger: 'final',
+      });
+      expect(result.checkpoint.violations).toEqual(['Checkpoint validation failed']);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('renders unknown_path when violation entries omit path/reason', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-unknown-path-');
+    const state: MutableState = {
+      frontMatter: { version: 1, status: 'building' },
+      body: 'state body',
+    };
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff: vi.fn(async () => {
+        throw {
+          normalizedResponse: {
+            error: {
+              details: {
+                violations: [{}],
+              },
+            },
+          },
+        };
+      }),
+      watchdog: makeWatchdog(['tracked.txt']),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig(),
+    });
+
+    try {
+      await fs.writeFile(path.join(repoRoot, 'tracked.txt'), 'unknown\n', 'utf8');
+      const result = await service.createCheckpoint({
+        featureId: 'feature_unknown',
+        trigger: 'final',
+      });
+      expect(result.checkpoint.violations).toEqual(['unknown_path: constraint_violation']);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('falls back when violation entries are not objects', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-violation-null-');
+    const state: MutableState = {
+      frontMatter: { version: 1, status: 'building' },
+      body: 'state body',
+    };
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff: vi.fn(async () => {
+        throw {
+          normalizedResponse: {
+            error: {
+              details: {
+                violations: [null, 'oops'],
+              },
+            },
+          },
+        };
+      }),
+      watchdog: makeWatchdog(['tracked.txt']),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig(),
+    });
+
+    try {
+      await fs.writeFile(path.join(repoRoot, 'tracked.txt'), 'null\n', 'utf8');
+      const result = await service.createCheckpoint({
+        featureId: 'feature_null_violation',
+        trigger: 'final',
+      });
+      expect(result.checkpoint.violations).toEqual(['Checkpoint validation failed']);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('returns empty checkpoints when frontmatter is not an array', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-nonarray-');
+    const state: MutableState = {
+      frontMatter: { version: 1, checkpoints: 'nope' },
+      body: 'state body',
+    };
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff: vi.fn(async () => ({ valid: true, violations: [], changed_files: [] })),
+      watchdog: makeWatchdog([]),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig(),
+    });
+
+    try {
+      const checkpoints = await service.getCheckpoints('feature_nonarray');
+      expect(checkpoints).toEqual([]);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('normalizes checkpoint entries with mixed arrays and invalid severity', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-normalize-');
+    const state: MutableState = {
+      frontMatter: {
+        version: 1,
+        checkpoints: [
+          {
+            checkpoint_id: 'checkpoint-mixed',
+            timestamp: new Date().toISOString(),
+            files_changed: ['tracked.txt', 5, '  ', null],
+            validation_status: 'valid',
+            violations: ['bad', 3, ''],
+            severity: 'unknown',
+            diff_snapshot: '.aop/features/feature_normalize/checkpoints/checkpoint-mixed.diff',
+          },
+        ],
+      },
+      body: 'state body',
+    };
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff: vi.fn(async () => ({ valid: true, violations: [], changed_files: [] })),
+      watchdog: makeWatchdog([]),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig(),
+    });
+
+    try {
+      const checkpoints = await service.getCheckpoints('feature_normalize');
+      expect(checkpoints[0].files_changed).toEqual(['tracked.txt']);
+      expect(checkpoints[0].violations).toEqual(['bad']);
+      expect(checkpoints[0].severity).toBeUndefined();
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('returns empty arrays when files_changed or violations are not arrays', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-nonarrays-');
+    const state: MutableState = {
+      frontMatter: {
+        version: 1,
+        checkpoints: [
+          {
+            checkpoint_id: 'checkpoint-nonarray',
+            timestamp: new Date().toISOString(),
+            files_changed: null,
+            validation_status: 'valid',
+            violations: null,
+            diff_snapshot: '.aop/features/feature_nonarray/checkpoints/checkpoint.diff',
+          },
+        ],
+      },
+      body: 'state body',
+    };
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff: vi.fn(async () => ({ valid: true, violations: [], changed_files: [] })),
+      watchdog: makeWatchdog([]),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig(),
+    });
+
+    try {
+      const checkpoints = await service.getCheckpoints('feature_nonarray');
+      expect(checkpoints[0].files_changed).toEqual([]);
+      expect(checkpoints[0].violations).toEqual([]);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('skips checkpoint entries with non-string checkpoint_id values', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-bad-id-');
+    const state: MutableState = {
+      frontMatter: {
+        version: 1,
+        checkpoints: [
+          {
+            checkpoint_id: 123,
+            timestamp: new Date().toISOString(),
+            files_changed: [],
+            validation_status: 'valid',
+            violations: [],
+            diff_snapshot: '.aop/features/feature_bad_id/checkpoints/checkpoint.diff',
+          },
+        ],
+      },
+      body: 'state body',
+    };
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff: vi.fn(async () => ({ valid: true, violations: [], changed_files: [] })),
+      watchdog: makeWatchdog([]),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig(),
+    });
+
+    try {
+      const checkpoints = await service.getCheckpoints('feature_bad_id');
+      expect(checkpoints).toEqual([]);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('uses non-object histories defaults when normalizing interactive metrics', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-bad-histories-');
+    const state: MutableState = {
+      frontMatter: { version: 1, status: 'building' },
+      body: 'state body',
+    };
+    const metricsPath = path.join(repoRoot, '.aop', 'analytics', 'interactive-mode.json');
+    await fs.mkdir(path.dirname(metricsPath), { recursive: true });
+    await fs.writeFile(
+      metricsPath,
+      JSON.stringify(
+        {
+          schema_version: 1,
+          updated_at: '2026-03-06T00:00:00.000Z',
+          totals: {
+            checkpoint_count: 1,
+            valid_count: 1,
+            invalid_count: 0,
+            skipped_count: 0,
+            files_changed_total: 1,
+          },
+          histories: null,
+          latest: null,
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff: vi.fn(async () => ({
+        valid: true,
+        violations: [],
+        changed_files: ['tracked.txt'],
+      })),
+      watchdog: makeWatchdog(['tracked.txt']),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig(),
+    });
+
+    try {
+      await fs.writeFile(path.join(repoRoot, 'tracked.txt'), 'histories\n', 'utf8');
+      await service.createCheckpoint({ featureId: 'feature_histories', trigger: 'interval' });
+
+      const raw = await fs.readFile(metricsPath, 'utf8');
+      const metrics = JSON.parse(raw) as { histories: { checkpoint_latency_ms: number[] } };
+      expect(metrics.histories.checkpoint_latency_ms.length).toBe(1);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('records info and critical severities without blocking checkpoint progress', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-severity-');
+    const state: MutableState = {
+      frontMatter: { version: 1, status: 'building' },
+      body: 'state body',
+    };
+
+    const makeService = (violationSeverity: 'info' | 'critical') =>
+      new CheckpointService({
+        repoRoot,
+        featurePathResolver: (featureId: string) =>
+          path.join(repoRoot, '.aop', 'features', featureId),
+        worktreePathResolver: () => repoRoot,
+        validateDiff: vi.fn(async () => ({
+          valid: false,
+          violations: ['policy'],
+          changed_files: ['tracked.txt'],
+        })),
+        watchdog: makeWatchdog(['tracked.txt']),
+        provider: {
+          selection: {
+            provider: 'custom',
+            model: 'local-default',
+            provider_config_env: null,
+            provider_config_ref: null,
+          },
+          runWorker: vi.fn(),
+        } as unknown as CheckpointProviderPort,
+        readState: async () => ({ frontMatter: state.frontMatter }),
+        updateState: makeUpdateState(state),
+        config: defaultConfig({ violationSeverity }),
+      });
+
+    try {
+      await fs.writeFile(path.join(repoRoot, 'tracked.txt'), 'severity\n', 'utf8');
+      const infoResult = await makeService('info').createCheckpoint({
+        featureId: 'feature_severity_info',
+        trigger: 'final',
+      });
+      const criticalResult = await makeService('critical').createCheckpoint({
+        featureId: 'feature_severity_critical',
+        trigger: 'final',
+      });
+
+      expect(infoResult.blockMerge).toBe(true);
+      expect(criticalResult.blockMerge).toBe(true);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('defaults severityRank when violationSeverity is unknown', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-unknown-severity-');
+    const state: MutableState = {
+      frontMatter: { version: 1, status: 'building' },
+      body: 'state body',
+    };
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff: vi.fn(async () => ({
+        valid: false,
+        violations: ['policy'],
+        changed_files: ['tracked.txt'],
+      })),
+      watchdog: makeWatchdog(['tracked.txt']),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig({ violationSeverity: 'unknown' as ViolationSeverity }),
+    });
+
+    try {
+      await fs.writeFile(path.join(repoRoot, 'tracked.txt'), 'unknown\n', 'utf8');
+      const result = await service.createCheckpoint({
+        featureId: 'feature_unknown_severity',
+        trigger: 'final',
+      });
+      expect(result.blockMerge).toBe(true);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('retains in-flight entries when a newer gate replaces the lock', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-inflight-');
+    const state: MutableState = {
+      frontMatter: { version: 1, status: 'building' },
+      body: 'state body',
+    };
+    let service: CheckpointService | null = null;
+
+    const updateState = async (
+      featureId: string,
+      _expectedVersion: number | null,
+      updater: (
+        frontMatter: Record<string, unknown>,
+        body: string,
+      ) => Promise<{ frontMatter?: Record<string, unknown>; body?: string }>,
+    ): Promise<Record<string, unknown>> => {
+      if (service) {
+        (
+          service as unknown as { inFlightByFeature: Map<string, Promise<void>> }
+        ).inFlightByFeature.set(featureId, Promise.resolve());
+      }
+      const next = await updater(structuredClone(state.frontMatter), state.body);
+      state.frontMatter = {
+        ...state.frontMatter,
+        ...(next.frontMatter ?? {}),
+        version:
+          typeof state.frontMatter['version'] === 'number' ? state.frontMatter['version'] + 1 : 1,
+      };
+      state.body = next.body ?? state.body;
+      return state.frontMatter;
+    };
+
+    service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff: vi.fn(async () => ({
+        valid: true,
+        violations: [],
+        changed_files: ['tracked.txt'],
+      })),
+      watchdog: makeWatchdog(['tracked.txt']),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState,
+      config: defaultConfig(),
+    });
+
+    try {
+      await fs.writeFile(path.join(repoRoot, 'tracked.txt'), 'inflight\n', 'utf8');
+      await service.createCheckpoint({ featureId: 'feature_inflight', trigger: 'final' });
+      const inFlight = (service as unknown as { inFlightByFeature: Map<string, Promise<void>> })
+        .inFlightByFeature;
+      expect(inFlight.has('feature_inflight')).toBe(true);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('clamps interactive metrics histories and filters invalid history values', async () => {
+    const repoRoot = await initGitRepo('aop-checkpoint-clamp-');
+    const state: MutableState = {
+      frontMatter: { version: 1, status: 'building' },
+      body: 'state body',
+    };
+    const metricsPath = path.join(repoRoot, '.aop', 'analytics', 'interactive-mode.json');
+    await fs.mkdir(path.dirname(metricsPath), { recursive: true });
+    const longHistory = Array.from({ length: 205 }, (_, index) => index);
+    await fs.writeFile(
+      metricsPath,
+      JSON.stringify(
+        {
+          schema_version: 1,
+          updated_at: 123,
+          totals: 'invalid',
+          histories: {
+            checkpoint_latency_ms: longHistory,
+            validation_latency_ms: 'not-an-array',
+            diff_capture_latency_ms: [1, Number.NaN, 2, Infinity],
+          },
+          latest: null,
+        },
+        null,
+        2,
+      ),
+      'utf8',
+    );
+
+    const service = new CheckpointService({
+      repoRoot,
+      featurePathResolver: (featureId: string) =>
+        path.join(repoRoot, '.aop', 'features', featureId),
+      worktreePathResolver: () => repoRoot,
+      validateDiff: vi.fn(async () => ({
+        valid: true,
+        violations: [],
+        changed_files: ['tracked.txt'],
+      })),
+      watchdog: makeWatchdog(['tracked.txt']),
+      provider: {
+        selection: {
+          provider: 'custom',
+          model: 'local-default',
+          provider_config_env: null,
+          provider_config_ref: null,
+        },
+        runWorker: vi.fn(),
+      } as unknown as CheckpointProviderPort,
+      readState: async () => ({ frontMatter: state.frontMatter }),
+      updateState: makeUpdateState(state),
+      config: defaultConfig(),
+    });
+
+    try {
+      await fs.writeFile(path.join(repoRoot, 'tracked.txt'), 'clamp\n', 'utf8');
+      await service.createCheckpoint({ featureId: 'feature_clamp', trigger: 'interval' });
+
+      const metricsRaw = await fs.readFile(metricsPath, 'utf8');
+      const metrics = JSON.parse(metricsRaw) as {
+        histories: {
+          checkpoint_latency_ms: number[];
+          validation_latency_ms: number[];
+          diff_capture_latency_ms: number[];
+        };
+      };
+
+      expect(metrics.histories.checkpoint_latency_ms).toHaveLength(200);
+      expect(metrics.histories.validation_latency_ms).toHaveLength(1);
+      expect(metrics.histories.diff_capture_latency_ms.slice(0, 2)).toEqual([1, 2]);
+      expect(metrics.histories.diff_capture_latency_ms.length).toBe(3);
     } finally {
       await fs.rm(repoRoot, { recursive: true, force: true });
     }
@@ -426,10 +1380,7 @@ describe('CheckpointService', () => {
         violations: [],
         changed_files: ['tracked.txt'],
       })),
-      watchdog: {
-        getChangedFiles: vi.fn(async () => ['tracked.txt']),
-        resetChangeCount: vi.fn(),
-      } as unknown as WorktreeWatchdogService,
+      watchdog: makeWatchdog(['tracked.txt']),
       provider: {
         selection: {
           provider: 'custom',
@@ -503,10 +1454,7 @@ describe('CheckpointService', () => {
         path.join(repoRoot, '.aop', 'features', featureId),
       worktreePathResolver: () => repoRoot,
       validateDiff,
-      watchdog: {
-        getChangedFiles: vi.fn(async () => ['tracked.txt']),
-        resetChangeCount: vi.fn(),
-      } as unknown as WorktreeWatchdogService,
+      watchdog: makeWatchdog(['tracked.txt']),
       provider: {
         selection: {
           provider: 'custom',