principles-disciple 1.72.0 → 1.74.0

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

@@ -67,6 +67,7 @@ describe('ModelTrainingRegistry registerTrainingRun', () => {
 
   it('registers a new training run', () => {
     const run = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-abc123',
       exportId: 'export-001',
@@ -87,6 +88,7 @@ describe('ModelTrainingRegistry registerTrainingRun', () => {
 
   it('persists the run to disk', () => {
     const run = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'claude-3',
       datasetFingerprint: 'sha256-def456',
       exportId: 'export-002',
@@ -102,6 +104,7 @@ describe('ModelTrainingRegistry registerTrainingRun', () => {
 
   it('generates unique trainRunIds', () => {
     const run1 = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-abc',
       exportId: 'e1',
@@ -109,6 +112,7 @@ describe('ModelTrainingRegistry registerTrainingRun', () => {
       configFingerprint: 'c1',
     });
     const run2 = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-def',
       exportId: 'e2',
@@ -130,6 +134,7 @@ describe('ModelTrainingRegistry run status transitions', () => {
   beforeEach(() => {
     tmpDir = makeTmpDir();
     runId = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-abc',
       exportId: 'exp-1',
@@ -186,6 +191,7 @@ describe('ModelTrainingRegistry run status transitions', () => {
     // BeforeEach already created runId as pending
     // Create run2 (also pending by default)
     const run2 = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-def',
       exportId: 'exp-2',
@@ -208,6 +214,7 @@ describe('ModelTrainingRegistry run status transitions', () => {
   it('listTrainingRuns filters by targetModelFamily', () => {
     // Register gpt-4 and claude-3 runs using the tmpDir from beforeEach
     const gpt4Run = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-a',
       exportId: 'e1',
@@ -215,6 +222,7 @@ describe('ModelTrainingRegistry run status transitions', () => {
       configFingerprint: 'c1',
     });
     registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'claude-3',
       datasetFingerprint: 'sha256-b',
       exportId: 'e2',
@@ -244,6 +252,7 @@ describe('ModelTrainingRegistry registerCheckpoint', () => {
   beforeEach(() => {
     tmpDir = makeTmpDir();
     runId = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-abc',
       exportId: 'exp-1',
@@ -345,6 +354,7 @@ describe('ModelTrainingRegistry attachEvalSummary', () => {
   beforeEach(() => {
     tmpDir = makeTmpDir();
     const run = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-abc',
       exportId: 'exp-1',
@@ -464,6 +474,7 @@ describe('ModelTrainingRegistry deployability gating', () => {
   beforeEach(() => {
     tmpDir = makeTmpDir();
     const run = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-abc',
       exportId: 'exp-1',
@@ -614,6 +625,7 @@ describe('ModelTrainingRegistry deployability gating', () => {
   it('listDeployableCheckpoints returns only deployable checkpoints', () => {
     // Create another run and checkpoint
     const run2 = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-def',
       exportId: 'exp-2',
@@ -661,6 +673,7 @@ describe('ModelTrainingRegistry lineage tracing', () => {
   beforeEach(() => {
     tmpDir = makeTmpDir();
     const run = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-full',
       exportId: 'exp-full',
@@ -743,6 +756,7 @@ describe('ModelTrainingRegistry stats', () => {
 
   it('counts runs in each status', () => {
     const run1 = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-a',
       exportId: 'e1',
@@ -750,6 +764,7 @@ describe('ModelTrainingRegistry stats', () => {
       configFingerprint: 'c1',
     });
     const run2 = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-b',
       exportId: 'e2',
@@ -757,6 +772,7 @@ describe('ModelTrainingRegistry stats', () => {
       configFingerprint: 'c1',
     });
     const run3 = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-c',
       exportId: 'e3',
@@ -779,6 +795,7 @@ describe('ModelTrainingRegistry stats', () => {
 
   it('counts passing vs failing evals', () => {
     const run = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-abc',
       exportId: 'exp-1',
@@ -838,6 +855,7 @@ describe('ModelTrainingRegistry persistence', () => {
 
   it('getFullRegistry returns all record types', () => {
     const run = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-abc',
       exportId: 'exp-1',
@@ -870,6 +888,7 @@ describe('ModelTrainingRegistry persistence', () => {
   it('registry persists across module re-invocations', () => {
     // This test verifies the registry is written to disk
     const run = registerTrainingRun(tmpDir, {
+      experimentId: 'mock-experiment-id',
       targetModelFamily: 'gpt-4',
       datasetFingerprint: 'sha256-abc',
       exportId: 'exp-1',

package/tests/core/observability.test.ts

@@ -187,7 +187,6 @@ describe('calculateBaselines', () => {
 
     // Create a trajectory DB with pain events
     const dbPath = path.join(tmpDir, 'trajectory.db');
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
     const Database = require('better-sqlite3');
     const db = new Database(dbPath);
     db.exec(`

package/tests/core/pain-diagnostic-gate.test.ts

@@ -0,0 +1,498 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { evaluatePainDiagnosticGate, resetPainDiagnosticGateForTest } from '../../src/core/pain-diagnostic-gate.js';
+
+describe('PainDiagnosticGate', () => {
+  beforeEach(() => {
+    resetPainDiagnosticGateForTest();
+  });
+
+  it('lets manual pain bypass automatic thresholds', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'manual',
+      score: 1,
+      currentGfi: 0,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'manual',
+    });
+  });
+
+  it('does not diagnose ordinary low-signal tool failures', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 15,
+      consecutiveErrors: 1,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: false,
+      reason: 'below_gate',
+    });
+  });
+
+  it('diagnoses repeated same failures', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 50,
+      consecutiveErrors: 4,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'repeated_failure',
+    });
+  });
+
+  it('diagnoses high GFI episodes', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 72,
+      consecutiveErrors: 2,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'high_gfi',
+    });
+  });
+
+  it('requires stronger score for generic semantic pain', () => {
+    const low = evaluatePainDiagnosticGate({
+      source: 'semantic',
+      score: 45,
+      currentGfi: 0,
+      sessionId: 's1',
+    });
+    const high = evaluatePainDiagnosticGate({
+      source: 'semantic',
+      score: 60,
+      currentGfi: 0,
+      sessionId: 's2',
+    });
+
+    expect(low.shouldDiagnose).toBe(false);
+    expect(high).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'semantic_pain',
+    });
+  });
+
+  it('deduplicates repeated diagnosis within cooldown', () => {
+    const input = {
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 72,
+      sessionId: 's1',
+      errorHash: 'same',
+      nowMs: 1_000,
+    };
+
+    expect(evaluatePainDiagnosticGate(input).shouldDiagnose).toBe(true);
+    expect(evaluatePainDiagnosticGate({ ...input, nowMs: 2_000 })).toMatchObject({
+      shouldDiagnose: false,
+      reason: 'cooldown',
+    });
+  });
+
+  it('diagnoses subagent_error when score >= painTrigger', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'subagent_error',
+      score: 40,
+      currentGfi: 0,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'subagent_error',
+    });
+  });
+
+  it('skips subagent_error when score < painTrigger', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'subagent_error',
+      score: 39,
+      currentGfi: 0,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: false,
+      reason: 'below_gate',
+    });
+  });
+
+  it('diagnoses llm_paralysis when score >= painTrigger', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'llm_paralysis',
+      score: 40,
+      currentGfi: 0,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'llm_paralysis',
+    });
+  });
+
+  it('diagnoses risky_high_score when isRisky=true and score >= highSeverity', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 70,
+      currentGfi: 0,
+      isRisky: true,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'risky_high_score',
+    });
+  });
+
+  it('skips risky_high_score when isRisky=true but score < highSeverity', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 69,
+      currentGfi: 0,
+      isRisky: true,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: false,
+      reason: 'below_gate',
+    });
+  });
+
+  it('diagnoses user_empathy when score >= semanticPain threshold', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'user_empathy',
+      score: 60,
+      currentGfi: 0,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'semantic_pain',
+    });
+  });
+
+  it('uses custom threshold overrides', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 60,
+      consecutiveErrors: 2,
+      sessionId: 's1',
+      thresholds: {
+        painTrigger: 40,
+        highSeverity: 70,
+        highGfi: 55,
+        repeatedFailure: 4,
+        semanticPain: 60,
+      },
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'high_gfi',
+    });
+  });
+
+  it('handles exact threshold boundary (score === painTrigger)', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'subagent_error',
+      score: 40,
+      currentGfi: 0,
+      sessionId: 's1',
+      thresholds: { painTrigger: 40 },
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'subagent_error',
+    });
+  });
+
+  it('normalizes llm_ prefixed sources (non-paralysis) to semantic', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'llm_confusion',
+      score: 60,
+      currentGfi: 0,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'semantic_pain',
+    });
+  });
+
+  it('llm_paralysis is NOT normalized to semantic', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'llm_paralysis',
+      score: 40,
+      currentGfi: 0,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'llm_paralysis',
+    });
+  });
+
+  it('skips llm_paralysis when score < painTrigger', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'llm_paralysis',
+      score: 39,
+      currentGfi: 0,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: false,
+      reason: 'below_gate',
+    });
+  });
+
+  it('diagnoses llm_paralysis with score 45 (new config default, PRI-274)', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'llm_paralysis',
+      score: 45,
+      currentGfi: 0,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'llm_paralysis',
+    });
+  });
+
+  it('cooldownMs=0 disables cooldown (allows re-diagnosis)', () => {
+    const input = {
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 72,
+      sessionId: 's1',
+      errorHash: 'same',
+      nowMs: 1_000,
+      cooldownMs: 0,
+    };
+
+    expect(evaluatePainDiagnosticGate(input).shouldDiagnose).toBe(true);
+    expect(evaluatePainDiagnosticGate({ ...input, nowMs: 2_000 }).shouldDiagnose).toBe(true);
+  });
+
+  it('treats NaN score as 0 (below gate)', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: NaN,
+      currentGfi: 72,
+      consecutiveErrors: 4,
+      sessionId: 's1',
+    });
+
+    expect(decision.shouldDiagnose).toBe(true);
+    expect(decision.reason).toBe('repeated_failure');
+  });
+
+  it('treats NaN currentGfi as 0', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: NaN,
+      consecutiveErrors: 1,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: false,
+      reason: 'below_gate',
+    });
+  });
+
+  it('treats Infinity score as finite for gate evaluation', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: Infinity,
+      currentGfi: 0,
+      isRisky: true,
+      sessionId: 's1',
+    });
+
+    expect(decision.shouldDiagnose).toBe(false);
+  });
+
+  it('treats NaN consecutiveErrors as 0', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 50,
+      consecutiveErrors: NaN,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: false,
+      reason: 'below_gate',
+    });
+  });
+
+  it('episodeKey includes sessionId, source, and errorHash', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'manual',
+      score: 1,
+      currentGfi: 0,
+      sessionId: 's-ep',
+      errorHash: 'hash-abc',
+    });
+
+    expect(decision.episodeKey).toContain('s-ep');
+    expect(decision.episodeKey).toContain('manual');
+    expect(decision.episodeKey).toContain('hash-abc');
+  });
+
+  it('episodeKey uses "unknown" when sessionId missing', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'manual',
+      score: 1,
+      currentGfi: 0,
+    });
+
+    expect(decision.episodeKey).toContain('unknown');
+  });
+
+  it('episodeKey uses "no-hash" when errorHash missing', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'manual',
+      score: 1,
+      currentGfi: 0,
+      sessionId: 's1',
+    });
+
+    expect(decision.episodeKey).toContain('no-hash');
+  });
+
+  it('manual pain is still subject to cooldown', () => {
+    const input = {
+      source: 'manual',
+      score: 100,
+      currentGfi: 0,
+      sessionId: 's1',
+      nowMs: 1_000,
+    };
+
+    const first = evaluatePainDiagnosticGate(input);
+    expect(first.shouldDiagnose).toBe(true);
+
+    const second = evaluatePainDiagnosticGate({ ...input, nowMs: 2_000 });
+    expect(second).toMatchObject({
+      shouldDiagnose: false,
+      reason: 'cooldown',
+    });
+  });
+
+  it('different errorHash produces different episodeKey (no cooldown cross-contamination)', () => {
+    const base = {
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 72,
+      sessionId: 's1',
+      nowMs: 1_000,
+    };
+
+    expect(evaluatePainDiagnosticGate({ ...base, errorHash: 'hash-a' }).shouldDiagnose).toBe(true);
+    expect(evaluatePainDiagnosticGate({ ...base, errorHash: 'hash-b', nowMs: 2_000 }).shouldDiagnose).toBe(true);
+  });
+
+  it('highGfi defaults to max(highSeverity, painTrigger+30)', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 72,
+      consecutiveErrors: 1,
+      sessionId: 's1',
+      thresholds: {
+        painTrigger: 40,
+        highSeverity: 70,
+      },
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'high_gfi',
+    });
+  });
+
+  it('gate_block source falls through to below_gate when score below painTrigger', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'gate_blocked',
+      score: 10,
+      currentGfi: 5,
+      consecutiveErrors: 0,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: false,
+      reason: 'below_gate',
+    });
+  });
+
+  it('diagnoses gate_blocked when score >= painTrigger (PRI-274)', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'gate_blocked',
+      score: 45,
+      currentGfi: 0,
+      consecutiveErrors: 0,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'gate_blocked',
+    });
+  });
+
+  it('skips gate_blocked when score < painTrigger', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'gate_blocked',
+      score: 39,
+      currentGfi: 0,
+      consecutiveErrors: 0,
+      sessionId: 's1',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: false,
+      reason: 'below_gate',
+    });
+  });
+
+  it('returns detail string in every decision', () => {
+    const cases = [
+      { source: 'manual' as const, score: 1, currentGfi: 0 },
+      { source: 'tool_failure' as const, score: 10, currentGfi: 5, consecutiveErrors: 0 },
+    ];
+
+    for (const input of cases) {
+      const decision = evaluatePainDiagnosticGate({ ...input, sessionId: 's1' });
+      expect(typeof decision.detail).toBe('string');
+      expect(decision.detail.length).toBeGreaterThan(0);
+    }
+  });
+});

package/tests/core/pain.test.ts

@@ -4,7 +4,6 @@ import * as path from 'path';
 import {
   computePainScore,
   painSeverityLabel,
-  writePainFlag,
   readPainFlagData,
   buildPainFlag,
   validatePainFlag,

package/tests/core/path-resolver.test.ts

@@ -20,7 +20,7 @@ describe('PathResolver', () => {
         const { PathResolver } = await import('../../src/core/path-resolver.js');
         const resolver = new PathResolver({ workspaceDir: '/test/workspace' });
         
-        const requiredKeys = ['PROFILE', 'PLAN', 'AGENT_SCORECARD', 'PAIN_FLAG', 'EVOLUTION_QUEUE', 'THINKING_OS', 'THINKING_OS_USAGE', 'THINKING_OS_CANDIDATES'];
+        const requiredKeys = ['PROFILE', 'AGENT_SCORECARD', 'PAIN_FLAG', 'EVOLUTION_QUEUE', 'THINKING_OS', 'THINKING_OS_USAGE', 'THINKING_OS_CANDIDATES'];
         
         for (const key of requiredKeys) {
             expect(() => resolver.resolve(key)).not.toThrow();

package/tests/core/paths-refactor.test.ts

@@ -1,9 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { planStatus } from '../../src/utils/io.js';
 import { resolvePdPath } from '../../src/core/paths.js';
-import * as fs from 'fs';
-
-vi.mock('fs');
 
 describe('Path Anchoring Integration', () => {
     const workspaceDir = '/mock/workspace';
@@ -17,26 +13,8 @@ describe('Path Anchoring Integration', () => {
         expect(resolvePdPath(workspaceDir, 'PROFILE')).toBe(expected);
     });
 
-    it('should resolve PLAN.md at the project root', () => {
-        const expected = '/mock/workspace/PLAN.md';
-        expect(resolvePdPath(workspaceDir, 'PLAN')).toBe(expected);
-    });
-
     it('should resolve AGENT_SCORECARD.json inside .state/', () => {
         const expected = '/mock/workspace/.state/AGENT_SCORECARD.json';
         expect(resolvePdPath(workspaceDir, 'AGENT_SCORECARD')).toBe(expected);
     });
-
-    it('planStatus should look for PLAN.md in the root', () => {
-        const rootPlanPath = '/mock/workspace/PLAN.md';
-        vi.mocked(fs.existsSync).mockImplementation((p) => p === rootPlanPath);
-        vi.mocked(fs.readFileSync).mockReturnValue('STATUS: READY');
-
-        const status = planStatus(workspaceDir);
-        
-        expect(status).toBe('READY');
-        expect(fs.existsSync).toHaveBeenCalledWith(rootPlanPath);
-        // Verify it does NOT look in docs/
-        expect(fs.existsSync).not.toHaveBeenCalledWith(expect.stringContaining('docs/PLAN.md'));
-    });
 });