principles-disciple 1.72.0 → 1.74.0

package/tests/core/file-store.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { JsonFileStore } from '../../src/core/file-store.js';
+import { safeRmDir } from '../test-utils.js';
+
+function tmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pd-filestore-test-'));
+}
+
+interface TestData {
+  count: number;
+  items: string[];
+}
+
+describe('JsonFileStore', () => {
+  let dir: string;
+  let filePath: string;
+  let store: JsonFileStore<TestData>;
+
+  beforeEach(() => {
+    dir = tmpDir();
+    filePath = path.join(dir, 'test.json');
+    store = new JsonFileStore<TestData>(filePath, () => ({ count: 0, items: [] }));
+  });
+
+  afterEach(() => {
+    safeRmDir(dir);
+  });
+
+  describe('load', () => {
+    it('returns default data when file does not exist', () => {
+      const data = store.load();
+      expect(data).toEqual({ count: 0, items: [] });
+    });
+
+    it('returns parsed JSON when file exists', () => {
+      fs.writeFileSync(filePath, JSON.stringify({ count: 42, items: ['a', 'b'] }), 'utf8');
+      const data = store.load();
+      expect(data).toEqual({ count: 42, items: ['a', 'b'] });
+    });
+
+    it('returns default data when file is empty', () => {
+      fs.writeFileSync(filePath, '', 'utf8');
+      const data = store.load();
+      expect(data).toEqual({ count: 0, items: [] });
+    });
+
+    it('returns default data when file has malformed JSON', () => {
+      fs.writeFileSync(filePath, '{broken json', 'utf8');
+      const data = store.load();
+      expect(data).toEqual({ count: 0, items: [] });
+    });
+  });
+
+  describe('save', () => {
+    it('writes data to file atomically', () => {
+      store.save({ count: 10, items: ['x'] });
+      const raw = fs.readFileSync(filePath, 'utf8');
+      expect(JSON.parse(raw)).toEqual({ count: 10, items: ['x'] });
+    });
+
+    it('overwrites existing file', () => {
+      store.save({ count: 1, items: [] });
+      store.save({ count: 2, items: ['y'] });
+      const raw = fs.readFileSync(filePath, 'utf8');
+      expect(JSON.parse(raw)).toEqual({ count: 2, items: ['y'] });
+    });
+  });
+
+  describe('mutate', () => {
+    it('performs read-modify-write and returns result', () => {
+      const result = store.mutate((d) => {
+        d.count += 5;
+        d.items.push('new');
+        return d.count;
+      });
+      expect(result).toBe(5);
+      const loaded = store.load();
+      expect(loaded.count).toBe(5);
+      expect(loaded.items).toEqual(['new']);
+    });
+
+    it('does not write when mutate function throws', () => {
+      expect(() => {
+        store.mutate(() => {
+          throw new Error('boom');
+        });
+      }).toThrow('boom');
+      const loaded = store.load();
+      expect(loaded).toEqual({ count: 0, items: [] });
+    });
+
+    it('preserves existing data across mutate calls', () => {
+      store.mutate((d) => { d.count = 1; });
+      store.mutate((d) => { d.count += 1; });
+      const loaded = store.load();
+      expect(loaded.count).toBe(2);
+    });
+  });
+});

package/tests/core/focus-history.test.ts

@@ -7,7 +7,7 @@ import {
   cleanupHistory,
   getHistoryVersions,
   extractSummary,
-  // 工作记忆相关函数
+  cleanupStaleInfo,
   extractWorkingMemory,
   parseWorkingMemorySection,
   mergeWorkingMemory,
@@ -25,6 +25,11 @@ vi.mock('fs', () => ({
   writeFileSync: vi.fn(),
   statSync: vi.fn(),
   unlinkSync: vi.fn(),
+  promises: {
+    readdir: vi.fn(),
+    stat: vi.fn(),
+    readFile: vi.fn(),
+  }
 }));
 
 describe('focus-history', () => {
@@ -164,30 +169,83 @@ describe('focus-history', () => {
   });
 
   describe('getHistoryVersions', () => {
-    it('should return empty array if no history', () => {
-      vi.mocked(fs.existsSync).mockReturnValue(false);
+    it('should return empty array if no history', async () => {
+      const err = new Error('ENOENT: no such file or directory') as NodeJS.ErrnoException;
+      err.code = 'ENOENT';
+      vi.mocked(fs.promises.readdir).mockRejectedValue(err);
 
-      const result = getHistoryVersions(mockFocusPath, 3);
+      const result = await getHistoryVersions(mockFocusPath, 3);
 
       expect(result).toEqual([]);
     });
 
-    it('should return history versions sorted by mtime', () => {
+    it('should return history versions sorted by mtime', async () => {
       vi.mocked(fs.existsSync).mockReturnValue(true);
-      vi.mocked(fs.readdirSync).mockReturnValue([
+      // fs.promises.readdir mock
+      vi.mocked(fs.promises.readdir).mockResolvedValue([
         'CURRENT_FOCUS.v1.2026-03-10.md',
         'CURRENT_FOCUS.v2.2026-03-11.md',
       ] as any);
-      vi.mocked(fs.statSync)
-        .mockReturnValueOnce({ mtime: new Date('2026-03-10') } as any)
-        .mockReturnValueOnce({ mtime: new Date('2026-03-11') } as any);
-      vi.mocked(fs.readFileSync).mockReturnValue('history content');
+      // fs.promises.stat mock
+      vi.mocked(fs.promises.stat)
+        .mockResolvedValueOnce({ mtime: new Date('2026-03-10') } as any)
+        .mockResolvedValueOnce({ mtime: new Date('2026-03-11') } as any);
+      // fs.promises.readFile mock
+      vi.mocked(fs.promises.readFile).mockResolvedValue('history content');
 
-      const result = getHistoryVersions(mockFocusPath, 3);
+      const result = await getHistoryVersions(mockFocusPath, 3);
 
       expect(result.length).toBe(2);
       expect(result[0]).toBe('history content');
     });
+
+    it('should return empty array if readdir throws ENOENT', async () => {
+      const err = new Error('ENOENT') as NodeJS.ErrnoException;
+      err.code = 'ENOENT';
+      vi.mocked(fs.promises.readdir).mockRejectedValue(err);
+
+      const result = await getHistoryVersions(mockFocusPath, 3);
+
+      expect(result).toEqual([]);
+    });
+
+    it('should handle partial stat failures', async () => {
+      vi.mocked(fs.promises.readdir).mockResolvedValue([
+        'CURRENT_FOCUS.v1.md',
+        'CURRENT_FOCUS.v2.md',
+      ] as any);
+
+      // First fails, second succeeds
+      vi.mocked(fs.promises.stat)
+        .mockRejectedValueOnce(new Error('Deleted'))
+        .mockResolvedValueOnce({ mtime: new Date() } as any);
+
+      vi.mocked(fs.promises.readFile).mockResolvedValue('content');
+
+      const result = await getHistoryVersions(mockFocusPath, 3);
+
+      expect(result.length).toBe(1);
+      expect(result[0]).toBe('content');
+    });
+
+    it('should handle partial readFile failures', async () => {
+      vi.mocked(fs.promises.readdir).mockResolvedValue([
+        'CURRENT_FOCUS.v1.md',
+        'CURRENT_FOCUS.v2.md',
+      ] as any);
+
+      vi.mocked(fs.promises.stat).mockResolvedValue({ mtime: new Date() } as any);
+
+      // First fails, second succeeds
+      vi.mocked(fs.promises.readFile)
+        .mockRejectedValueOnce(new Error('Read error'))
+        .mockResolvedValueOnce('content v2');
+
+      const result = await getHistoryVersions(mockFocusPath, 3);
+
+      expect(result.length).toBe(1);
+      expect(result[0]).toBe('content v2');
+    });
   });
 
   describe('extractSummary', () => {
@@ -567,6 +625,140 @@ ${Array.from({ length: 40 }, (_, i) => `| Item ${i + 1} | Value ${i + 1} |`).joi
     });
   });
 
+  describe('cleanupStaleInfo', () => {
+    it('should filter stale file artifacts when workspaceDir is provided', () => {
+      const content = `# 🎯 CURRENT_FOCUS
+
+## 🧠 Working Memory
+
+| 文件路径 | 操作 | 描述 |
+|----------|------|------|
+| \`src/exists.ts\` | modified | exists |
+| \`src/missing.ts\` | modified | missing |
+| \`src/also-missing.ts\` | modified | also missing |
+
+### ➡️ 下一步行动
+
+1. Next action`;
+
+      vi.mocked(fs.existsSync).mockImplementation((p: any) => {
+        const path = String(p);
+        return path.includes('exists');
+      });
+
+      const result = cleanupStaleInfo(content, '/workspace');
+
+      expect(result).toContain('exists.ts');
+      expect(result).not.toContain('missing.ts');
+      expect(result).not.toContain('also-missing.ts');
+    });
+
+    it('should keep table state after skipping a missing file row', () => {
+      const content = `# 🎯 CURRENT_FOCUS
+
+## 🧠 Working Memory
+
+| 文件路径 | 操作 | 描述 |
+|----------|------|------|
+| \`src/stale-a.ts\` | modified | stale |
+| \`src/stale-b.ts\` | modified | stale |
+| \`src/valid.ts\` | modified | valid |
+
+### ➡️ 下一步行动
+
+1. Action`;
+
+      vi.mocked(fs.existsSync).mockImplementation((p: any) => {
+        const path = String(p);
+        return path.includes('valid');
+      });
+
+      const result = cleanupStaleInfo(content, '/workspace');
+
+      expect(result).toContain('valid.ts');
+      expect(result).not.toContain('stale-a.ts');
+      expect(result).not.toContain('stale-b.ts');
+      expect(result).toContain('### ➡️ 下一步行动');
+    });
+
+    it('should preserve table header when filtering artifacts', () => {
+      const content = `# 🎯 CURRENT_FOCUS
+
+## 🧠 Working Memory
+
+| 文件路径 | 操作 | 描述 |
+|----------|------|------|
+| \`src/stale.ts\` | modified | stale |
+
+### ➡️ 下一步行动
+
+1. Action`;
+
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+
+      const result = cleanupStaleInfo(content, '/workspace');
+
+      expect(result).toContain('| 文件路径 | 操作 | 描述 |');
+      expect(result).not.toContain('stale.ts');
+      expect(result).toContain('### ➡️ 下一步行动');
+    });
+  });
+
+  describe('cleanupStaleInfo I/O integration (autoCompressFocus prefilter path)', () => {
+    it('should filter stale artifacts when workspaceDir is provided', () => {
+      const focusContent = `# 🎯 CURRENT_FOCUS
+
+**版本**: v3
+**更新**: 2026-01-01
+
+## 🔄 当前任务
+
+${Array.from({ length: 150 }, (_, i) => `- [x] Task ${i + 1}`).join('\n')}
+
+## 🧠 Working Memory
+
+| 文件路径 | 操作 | 描述 |
+|----------|------|------|
+| \`src/missing-a.ts\` | modified | stale |
+| \`src/existing.ts\` | modified | valid |
+| \`src/missing-b.ts\` | modified | stale |
+
+### ➡️ 下一步行动
+
+1. Next action`;
+
+      vi.spyOn(fs, 'existsSync').mockImplementation((p: unknown) => {
+        const s = String(p);
+        if (s.includes('existing')) return true;
+        return false;
+      });
+
+      const result = cleanupStaleInfo(focusContent, '/workspace');
+
+      expect(result).toContain('existing.ts');
+      expect(result).not.toContain('missing-a.ts');
+      expect(result).not.toContain('missing-b.ts');
+    });
+
+    it('should not filter when workspaceDir is omitted', () => {
+      const focusContent = `# 🎯 CURRENT_FOCUS
+
+## 🧠 Working Memory
+
+| 文件路径 | 操作 | 描述 |
+|----------|------|------|
+| \`src/stale.ts\` | modified | stale |
+
+### ➡️ 下一步行动
+
+1. Action`;
+
+      const result = cleanupStaleInfo(focusContent);
+
+      expect(result).toContain('stale.ts');
+    });
+  });
+
   // ============================================================================
   // 端到端测试：压缩时文件路径落盘
   // ============================================================================

package/tests/core/merge-gate-audit.test.ts

@@ -6,30 +6,9 @@ import {
   formatMergeGateAuditReport,
   runMergeGateAudit,
 } from '../../src/core/merge-gate-audit.js';
-import type { NocturnalArtifact } from '../../src/core/nocturnal-arbiter.js';
-import {
-  registerSample,
-  updateReviewStatus,
-} from '../../src/core/nocturnal-dataset.js';
-import { appendArtifactLineageRecord } from '../../src/core/nocturnal-artifact-lineage.js';
-import { exportORPOSamples } from '../../src/core/nocturnal-export.js';
 import { createImplementationAssetDir, getImplementationAssetRoot } from '../../src/core/code-implementation-storage.js';
 import { safeRmDir } from '../test-utils.js';
 
-function makeArtifact(overrides: Partial<NocturnalArtifact> = {}): NocturnalArtifact {
-  return {
-    artifactId: 'artifact-1',
-    sessionId: 'session-1',
-    principleId: 'T-08',
-    sourceSnapshotRef: 'snapshot-1',
-    badDecision: 'Retried without checking state',
-    betterDecision: 'Inspect state before retrying',
-    rationale: 'Evidence first.',
-    createdAt: '2026-04-12T09:00:00.000Z',
-    ...overrides,
-  };
-}
-
 describe('merge-gate-audit', () => {
   let tempDir: string;
   let workspaceDir: string;
@@ -47,50 +26,13 @@ describe('merge-gate-audit', () => {
     safeRmDir(tempDir);
   });
 
-  function registerApprovedArtifact(artifactId = 'artifact-1'): string {
-    const artifact = makeArtifact({ artifactId });
-    const artifactPath = path.join(
-      workspaceDir,
-      '.state',
-      'nocturnal',
-      'samples',
-      `${artifactId}.json`,
-    );
-    fs.mkdirSync(path.dirname(artifactPath), { recursive: true });
-    fs.writeFileSync(artifactPath, JSON.stringify(artifact, null, 2), 'utf-8');
-
-    const record = registerSample(workspaceDir, artifact, artifactPath, 'gpt-4').record;
-    updateReviewStatus(
-      workspaceDir,
-      record.sampleFingerprint,
-      'approved_for_training',
-      'approved for merge gate audit',
-    );
-
-    appendArtifactLineageRecord(workspaceDir, {
-      artifactKind: 'behavioral-sample',
-      artifactId: record.artifactId,
-      principleId: record.principleId,
-      ruleId: null,
-      sessionId: record.sessionId,
-      sourceSnapshotRef: record.sourceSnapshotRef,
-      sourcePainIds: ['pain-1'],
-      sourceGateBlockIds: ['gate-1'],
-      storagePath: artifactPath,
-      implementationId: null,
-      createdAt: record.createdAt,
-    });
-
-    return record.sampleFingerprint;
-  }
-
   it('returns defer when audit surfaces are not populated yet', () => {
     const report = runMergeGateAudit(workspaceDir, stateDir);
 
     expect(report.overallStatus).toBe('defer');
     expect(report.checks.find((check) => check.id === 'pain_flag_path_contract')?.status).toBe('pass');
     expect(report.checks.find((check) => check.id === 'queue_path_contract')?.status).toBe('pass');
-    expect(report.checks.find((check) => check.id === 'runtime_adapter_contract')?.status).toBe('pass');
+    expect(report.checks.find((check) => check.id === 'replay_evidence_integrity')?.status).toBe('defer');
     expect(report.counts.defer).toBeGreaterThan(0);
   });
 
@@ -129,115 +71,6 @@ describe('merge-gate-audit', () => {
     expect(replayCheck?.status).toBe('block');
   });
 
-  it('passes populated dataset, lineage, export, and replay evidence surfaces', () => {
-    registerApprovedArtifact('artifact-pass');
-    const exportResult = exportORPOSamples(workspaceDir, 'gpt-4');
-    expect(exportResult.success).toBe(true);
-
-    createImplementationAssetDir(stateDir, 'IMPL-1', '1.0.0');
-    const replayDir = path.join(getImplementationAssetRoot(stateDir, 'IMPL-1'), 'replays');
-    fs.mkdirSync(replayDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(replayDir, 'good-report.json'),
-      JSON.stringify(
-        {
-          overallDecision: 'pass',
-          replayResults: {
-            painNegative: { total: 1, passed: 1, failed: 0, details: [] },
-            successPositive: { total: 0, passed: 0, failed: 0, details: [] },
-            principleAnchor: { total: 0, passed: 0, failed: 0, details: [] },
-          },
-          blockers: [],
-          generatedAt: '2026-04-12T09:00:00.000Z',
-          implementationId: 'IMPL-1',
-          sampleFingerprints: ['sample-1'],
-          evidenceSummary: {
-            evidenceStatus: 'observed',
-            totalSamples: 1,
-            classifiedCounts: {
-              painNegative: 1,
-              successPositive: 0,
-              principleAnchor: 0,
-            },
-          },
-        },
-        null,
-        2,
-      ),
-      'utf-8',
-    );
-
-    const report = runMergeGateAudit(workspaceDir, stateDir);
-
-    expect(report.overallStatus).toBe('pass');
-    expect(report.counts.block).toBe(0);
-    expect(report.counts.defer).toBe(0);
-    expect(formatMergeGateAuditReport(report)).toContain('Overall Status: PASS');
-  });
-
-  it('blocks when dataset artifacts are missing', () => {
-    const artifactPath = path.join(
-      workspaceDir,
-      '.state',
-      'nocturnal',
-      'samples',
-      'artifact-missing.json',
-    );
-    fs.mkdirSync(path.dirname(artifactPath), { recursive: true });
-    const artifact = makeArtifact({ artifactId: 'artifact-missing' });
-    fs.writeFileSync(artifactPath, JSON.stringify(artifact, null, 2), 'utf-8');
-
-    const record = registerSample(workspaceDir, artifact, artifactPath, 'gpt-4').record;
-    updateReviewStatus(workspaceDir, record.sampleFingerprint, 'approved_for_training', 'approved');
-
-    // Append lineage pointing to a real file (so lineage passes)
-    appendArtifactLineageRecord(workspaceDir, {
-      artifactKind: 'behavioral-sample',
-      artifactId: record.artifactId,
-      principleId: record.principleId,
-      ruleId: null,
-      sessionId: record.sessionId,
-      sourceSnapshotRef: record.sourceSnapshotRef,
-      sourcePainIds: [],
-      sourceGateBlockIds: [],
-      storagePath: artifactPath,
-      implementationId: null,
-      createdAt: record.createdAt,
-    });
-
-    // Delete the artifact to simulate a missing file
-    fs.unlinkSync(artifactPath);
-
-    const report = runMergeGateAudit(workspaceDir, stateDir);
-    const datasetCheck = report.checks.find((c) => c.id === 'dataset_artifact_integrity');
-
-    expect(report.overallStatus).toBe('block');
-    expect(datasetCheck?.status).toBe('block');
-  });
-
-  it('blocks when artifact lineage storage paths are missing', () => {
-    const badPath = path.join(workspaceDir, '.state', 'nocturnal', 'samples', 'nonexistent.json');
-    appendArtifactLineageRecord(workspaceDir, {
-      artifactKind: 'behavioral-sample',
-      artifactId: 'lineage-missing',
-      principleId: 'T-08',
-      ruleId: null,
-      sessionId: 'session-1',
-      sourceSnapshotRef: 'snap-1',
-      sourcePainIds: [],
-      sourceGateBlockIds: [],
-      storagePath: badPath,
-      implementationId: null,
-      createdAt: new Date().toISOString(),
-    });
-
-    const report = runMergeGateAudit(workspaceDir, stateDir);
-    const lineageCheck = report.checks.find((c) => c.id === 'artifact_lineage_integrity');
-
-    expect(report.overallStatus).toBe('block');
-    expect(lineageCheck?.status).toBe('block');
-  });
-
   it('blocks when replay reports are malformed', () => {
     createImplementationAssetDir(stateDir, 'IMPL-BAD', '1.0.0');
     const replayDir = path.join(getImplementationAssetRoot(stateDir, 'IMPL-BAD'), 'replays');
@@ -268,7 +101,7 @@ describe('merge-gate-audit', () => {
         blockers: [],
         generatedAt: '2026-04-12T09:00:00.000Z',
         implementationId: 'IMPL-NOEVID',
-        evidenceSummary: { evidenceStatus: 'observed' }, // missing totalSamples
+        evidenceSummary: { evidenceStatus: 'observed' },
       }),
       'utf-8',
     );

package/tests/core/migration.test.ts

@@ -18,25 +18,25 @@ describe('Directory Structure Migration', () => {
         vi.clearAllMocks();
     });
 
-    it('should move non-security files from docs/ to new locations', () => {
-        const legacyPlan = path.join(workspaceDir, 'docs', 'PLAN.md');
-        const newPlan = '/mock/workspace/PLAN.md';
+    it('should move THINKING_OS.md from docs/ to .principles/', () => {
+        const legacyThinkingOs = path.join(workspaceDir, 'docs', 'THINKING_OS.md');
+        const newThinkingOs = '/mock/workspace/.principles/THINKING_OS.md';
 
         vi.mocked(fs.existsSync).mockImplementation((p) => {
             const pathStr = p.toString();
             if (pathStr === path.join(workspaceDir, 'docs')) return true;
-            if (pathStr === legacyPlan) return true;
+            if (pathStr === legacyThinkingOs) return true;
             // Destination directories don't exist yet
             if (pathStr === path.join(workspaceDir, '.principles')) return false;
             // Destination files don't exist yet
-            if (pathStr === newPlan) return false;
+            if (pathStr === newThinkingOs) return false;
             return false;
         });
 
         migrateDirectoryStructure(mockApi, workspaceDir);
 
-        // Verify it moved PLAN.md to root
-        expect(fs.renameSync).toHaveBeenCalledWith(legacyPlan, newPlan);
+        // Verify it moved THINKING_OS.md to .principles/
+        expect(fs.renameSync).toHaveBeenCalledWith(legacyThinkingOs, newThinkingOs);
 
         expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining('Successfully migrated'));
     });

package/tests/core/model-deployment-registry.test.ts

@@ -66,6 +66,7 @@ function rmdir(dir: string): void {
  */
 function setupDeployableReaderCheckpoint(tmpDir: string): { runId: string; checkpointId: string } {
   const run = registerTrainingRun(tmpDir, {
+    experimentId: 'mock-experiment-id',
     targetModelFamily: 'claude-reader-latest',
     datasetFingerprint: 'sha256-reader-001',
     exportId: 'export-reader',
@@ -108,6 +109,7 @@ function setupDeployableReaderCheckpoint(tmpDir: string): { runId: string; check
  */
 function setupDeployableEditorCheckpoint(tmpDir: string): { runId: string; checkpointId: string } {
   const run = registerTrainingRun(tmpDir, {
+    experimentId: 'mock-experiment-id',
     targetModelFamily: 'gpt-editor-v4',
     datasetFingerprint: 'sha256-editor-001',
     exportId: 'export-editor',
@@ -149,6 +151,7 @@ function setupDeployableEditorCheckpoint(tmpDir: string): { runId: string; check
  */
 function setupNonDeployableCheckpoint(tmpDir: string): { runId: string; checkpointId: string } {
   const run = registerTrainingRun(tmpDir, {
+    experimentId: 'mock-experiment-id',
     targetModelFamily: 'claude-reader-latest',
     datasetFingerprint: 'sha256-abc',
     exportId: 'export-abc',
@@ -280,6 +283,7 @@ describe('ModelDeploymentRegistry bindCheckpointToWorkerProfile', () => {
 
     // Set up a second reader checkpoint
     const run2 = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'claude-reader-latest',
       datasetFingerprint: 'sha256-reader-002',
       exportId: 'export-reader-2',
@@ -564,6 +568,7 @@ describe('ModelDeploymentRegistry rollbackDeployment', () => {
 
     // Set up ck2
     const run2 = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'claude-reader-latest',
       datasetFingerprint: 'sha256-reader-002',
       exportId: 'export-reader-2',
@@ -619,8 +624,8 @@ describe('ModelDeploymentRegistry rollbackDeployment', () => {
 
   it('rollback fails when previous checkpoint no longer exists', () => {
     const { checkpointId: ck1 } = setupDeployableReaderCheckpoint(tmpDir);
-
     const run2 = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'claude-reader-latest',
       datasetFingerprint: 'sha256-reader-002',
       exportId: 'export-reader-2',
@@ -677,6 +682,7 @@ describe('ModelDeploymentRegistry rollbackDeployment', () => {
     const { checkpointId: ck1 } = setupDeployableReaderCheckpoint(tmpDir);
 
     const run2 = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'claude-reader-latest',
       datasetFingerprint: 'sha256-reader-002',
       exportId: 'export-reader-2',