principles-disciple 1.72.0 → 1.74.0

package/tests/core/replay-engine.test.ts

@@ -3,75 +3,13 @@ import * as os from 'os';
 import * as path from 'path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { ReplayEngine } from '../../src/core/replay-engine.js';
-import { TrajectoryDatabase, TrajectoryRegistry } from '../../src/core/trajectory.js';
-import { registerSample } from '../../src/core/nocturnal-dataset.js';
 import { createImplementationAssetDir, getImplementationAssetRoot } from '../../src/core/code-implementation-storage.js';
-import { saveLedger, type LedgerPrinciple, type LedgerRule } from '../../src/core/principle-tree-ledger.js';
-import type { Implementation } from '../../src/types/principle-tree-schema.js';
 import { safeRmDir } from '../test-utils.js';
 
-function makePrinciple(): LedgerPrinciple {
-  return {
-    id: 'P-1',
-    version: 1,
-    text: 'Protect risky writes without READY plans',
-    triggerPattern: 'write',
-    action: 'require approval before risky write',
-    status: 'active',
-    priority: 'P1',
-    scope: 'general',
-    evaluability: 'deterministic',
-    valueScore: 0,
-    adherenceRate: 0,
-    painPreventedCount: 0,
-    derivedFromPainIds: [],
-    ruleIds: ['R-1'],
-    conflictsWithPrincipleIds: [],
-    createdAt: '2026-04-08T00:00:00.000Z',
-    updatedAt: '2026-04-08T00:00:00.000Z',
-  };
-}
-
-function makeRule(): LedgerRule {
-  return {
-    id: 'R-1',
-    version: 1,
-    name: 'Require approval for risky writes',
-    description: 'Risky write operations without a READY plan need approval.',
-    type: 'gate',
-    triggerCondition: 'tool=write',
-    enforcement: 'block',
-    action: 'require approval for risky write',
-    principleId: 'P-1',
-    status: 'implemented',
-    coverageRate: 0,
-    falsePositiveRate: 0,
-    implementationIds: ['IMPL-1'],
-    createdAt: '2026-04-08T00:00:00.000Z',
-    updatedAt: '2026-04-08T00:00:00.000Z',
-  };
-}
-
-function makeImplementation(): Implementation {
-  return {
-    id: 'IMPL-1',
-    ruleId: 'R-1',
-    type: 'code',
-    path: path.join('virtual', 'IMPL-1.js'),
-    version: '1.0.0',
-    coversCondition: 'risky write',
-    coveragePercentage: 100,
-    lifecycleState: 'candidate',
-    createdAt: '2026-04-08T00:00:00.000Z',
-    updatedAt: '2026-04-08T00:00:00.000Z',
-  };
-}
-
 describe('ReplayEngine', () => {
   let tempDir: string;
   let workspaceDir: string;
   let stateDir: string;
-  let trajectory: TrajectoryDatabase;
 
   beforeEach(() => {
     tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-replay-engine-'));
@@ -79,175 +17,149 @@ describe('ReplayEngine', () => {
     stateDir = path.join(tempDir, '.state');
     fs.mkdirSync(workspaceDir, { recursive: true });
     fs.mkdirSync(stateDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(workspaceDir, 'PROFILE.json'),
-      JSON.stringify({ risk_paths: ['src/**'] }, null, 2),
-      'utf-8',
-    );
-    trajectory = new TrajectoryDatabase({ workspaceDir });
   });
 
   afterEach(() => {
-    try {
-      trajectory.dispose();
-    } catch {
-      // Best effort cleanup.
-    }
-    try {
-      TrajectoryRegistry.dispose(workspaceDir);
-    } catch {
-      // Best effort cleanup.
-    }
     safeRmDir(tempDir);
   });
 
-  function seedLedgerAndImplementation(): void {
-    saveLedger(stateDir, {
-      trainingStore: {
-        'P-1': {
-          principleId: 'P-1',
-          evaluability: 'deterministic',
-          applicableOpportunityCount: 1,
-          observedViolationCount: 0,
-          complianceRate: 1,
-          violationTrend: 0,
-          generatedSampleCount: 0,
-          approvedSampleCount: 0,
-          includedTrainRunIds: [],
-          deployedCheckpointIds: [],
-          internalizationStatus: 'internalized',
-        },
+  it('listReports returns empty array when no replays exist', () => {
+    const engine = new ReplayEngine(workspaceDir, stateDir);
+    expect(engine.listReports('IMPL-1')).toEqual([]);
+  });
+
+  it('listReports returns persisted replay reports sorted by name descending', () => {
+    createImplementationAssetDir(stateDir, 'IMPL-1', '1.0.0');
+    const replayDir = path.join(getImplementationAssetRoot(stateDir, 'IMPL-1'), 'replays');
+    fs.mkdirSync(replayDir, { recursive: true });
+
+    const report1 = {
+      implementationId: 'IMPL-1',
+      generatedAt: '2026-04-08T00:00:00.000Z',
+      overallDecision: 'needs-review',
+      blockers: [],
+      sampleFingerprints: [],
+      replayResults: {
+        painNegative: { total: 0, passed: 0, failed: 0, details: [] },
+        successPositive: { total: 0, passed: 0, failed: 0, details: [] },
+        principleAnchor: { total: 0, passed: 0, failed: 0, details: [] },
       },
-      tree: {
-        principles: { 'P-1': makePrinciple() },
-        rules: { 'R-1': makeRule() },
-        implementations: { 'IMPL-1': makeImplementation() },
-        metrics: {},
-        lastUpdated: '2026-04-08T00:00:00.000Z',
+      evidenceSummary: {
+        evidenceStatus: 'empty',
+        totalSamples: 0,
+        classifiedCounts: { painNegative: 0, successPositive: 0, principleAnchor: 0 },
       },
-    });
-
-    createImplementationAssetDir(stateDir, 'IMPL-1', '1.0.0', {
-      entrySource: [
-        'export const meta = {',
-        '  name: "risky-write-guard",',
-        '  version: "1.0.0",',
-        '  ruleId: "R-1",',
-        '  coversCondition: "risky write",',
-        '};',
-        'export function evaluate(input, helpers) {',
-        "  if (helpers.isRiskPath() && helpers.getToolName() === 'write' && helpers.getPlanStatus() !== 'READY') {",
-        "    return { decision: 'requireApproval', matched: true, reason: 'plan required' };",
-        '  }',
-        "  return { decision: 'allow', matched: false, reason: 'not-applicable' };",
-        '}',
-      ].join('\n'),
-    });
-  }
-
-  function seedPainNegativeSample(): void {
-    trajectory.recordSession({
-      sessionId: 'session-1',
-      startedAt: '2026-04-08T00:00:00.000Z',
-    });
-    trajectory.recordToolCall({
-      sessionId: 'session-1',
-      toolName: 'write',
-      outcome: 'blocked',
-      errorMessage: 'risky write requires approval',
-      paramsJson: { filePath: 'src/app.ts' },
-      createdAt: '2026-04-08T00:01:00.000Z',
-    });
-    trajectory.recordPainEvent({
-      sessionId: 'session-1',
-      source: 'gate',
-      score: 75,
-      reason: 'risky write requires approval',
-      createdAt: '2026-04-08T00:01:01.000Z',
-    });
-    trajectory.recordGateBlock({
-      sessionId: 'session-1',
-      toolName: 'write',
-      filePath: 'src/app.ts',
-      reason: 'risky write requires approval',
-      planStatus: 'NONE',
-      createdAt: '2026-04-08T00:01:02.000Z',
-    });
-
-    const artifactPath = path.join(stateDir, 'nocturnal', 'samples', 'artifact-1.json');
-    fs.mkdirSync(path.dirname(artifactPath), { recursive: true });
-    fs.writeFileSync(
-      artifactPath,
-      JSON.stringify(
-        {
-          artifactId: 'artifact-1',
-          sessionId: 'session-1',
-          principleId: 'P-1',
-          sourceSnapshotRef: 'snapshot-session-1',
-          badDecision: 'Retried the write without checking approval requirements',
-          betterDecision: 'Check the approval requirements before writing',
-          rationale: 'Riskiest paths should not be written without a plan',
-          createdAt: '2026-04-08T00:02:00.000Z',
-        },
-        null,
-        2,
-      ),
-      'utf-8',
-    );
-
-    registerSample(
-      workspaceDir,
-      {
-        artifactId: 'artifact-1',
-        sessionId: 'session-1',
-        principleId: 'P-1',
-        sourceSnapshotRef: 'snapshot-session-1',
-        badDecision: 'Retried the write without checking approval requirements',
-        betterDecision: 'Check the approval requirements before writing',
-        rationale: 'Riskiest paths should not be written without a plan',
-        createdAt: '2026-04-08T00:02:00.000Z',
+    };
+
+    const report2 = {
+      ...report1,
+      generatedAt: '2026-04-09T00:00:00.000Z',
+      overallDecision: 'pass',
+    };
+
+    fs.writeFileSync(path.join(replayDir, '2026-04-08T00-00-00-000Z.json'), JSON.stringify(report1, null, 2), 'utf-8');
+    fs.writeFileSync(path.join(replayDir, '2026-04-09T00-00-00-000Z.json'), JSON.stringify(report2, null, 2), 'utf-8');
+
+    const engine = new ReplayEngine(workspaceDir, stateDir);
+    const reports = engine.listReports('IMPL-1');
+
+    expect(reports).toHaveLength(2);
+    expect(reports[0].overallDecision).toBe('pass');
+    expect(reports[1].overallDecision).toBe('needs-review');
+  });
+
+  it('getLatestReport returns the most recent report', () => {
+    createImplementationAssetDir(stateDir, 'IMPL-1', '1.0.0');
+    const replayDir = path.join(getImplementationAssetRoot(stateDir, 'IMPL-1'), 'replays');
+    fs.mkdirSync(replayDir, { recursive: true });
+
+    const report = {
+      implementationId: 'IMPL-1',
+      generatedAt: '2026-04-08T00:00:00.000Z',
+      overallDecision: 'pass',
+      blockers: [],
+      sampleFingerprints: [],
+      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: [] },
+      },
+      evidenceSummary: {
+        evidenceStatus: 'observed',
+        totalSamples: 1,
+        classifiedCounts: { painNegative: 1, successPositive: 0, principleAnchor: 0 },
       },
-      artifactPath,
-      null,
-      'pain-negative',
-    );
-  }
+    };
 
-  it('persists replay reports under the implementation asset root', () => {
-    seedLedgerAndImplementation();
-    seedPainNegativeSample();
+    fs.writeFileSync(path.join(replayDir, '2026-04-08T00-00-00-000Z.json'), JSON.stringify(report, null, 2), 'utf-8');
 
     const engine = new ReplayEngine(workspaceDir, stateDir);
-    const report = engine.runReplayForImplementation('IMPL-1', ['pain-negative']);
-
-    expect(report.overallDecision).toBe('pass');
-    expect(report.replayResults.painNegative.passed).toBe(1);
-    expect(report.replayResults.painNegative.failed).toBe(0);
-
-    const reportDir = path.join(
-      getImplementationAssetRoot(stateDir, 'IMPL-1'),
-      'replays',
-    );
-    expect(fs.existsSync(reportDir)).toBe(true);
-    expect(fs.readdirSync(reportDir).some((file) => file.endsWith('.json'))).toBe(true);
+    const latest = engine.getLatestReport('IMPL-1');
+
+    expect(latest).not.toBeNull();
+    expect(latest!.overallDecision).toBe('pass');
   });
 
-  it('marks empty replay evidence as needs-review instead of pass', () => {
-    seedLedgerAndImplementation();
+  it('getLatestReport returns null when no reports exist', () => {
+    const engine = new ReplayEngine(workspaceDir, stateDir);
+    expect(engine.getLatestReport('IMPL-1')).toBeNull();
+  });
+
+  it('hasPassingReport returns true when a passing report exists', () => {
+    createImplementationAssetDir(stateDir, 'IMPL-1', '1.0.0');
+    const replayDir = path.join(getImplementationAssetRoot(stateDir, 'IMPL-1'), 'replays');
+    fs.mkdirSync(replayDir, { recursive: true });
+
+    const report = {
+      implementationId: 'IMPL-1',
+      generatedAt: '2026-04-08T00:00:00.000Z',
+      overallDecision: 'pass',
+      blockers: [],
+      sampleFingerprints: [],
+      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: [] },
+      },
+      evidenceSummary: {
+        evidenceStatus: 'observed',
+        totalSamples: 1,
+        classifiedCounts: { painNegative: 1, successPositive: 0, principleAnchor: 0 },
+      },
+    };
+
+    fs.writeFileSync(path.join(replayDir, '2026-04-08T00-00-00-000Z.json'), JSON.stringify(report, null, 2), 'utf-8');
 
     const engine = new ReplayEngine(workspaceDir, stateDir);
-    const report = engine.runReplayForImplementation('IMPL-1', ['pain-negative']);
-
-    expect(report.overallDecision).toBe('needs-review');
-    expect(report.evidenceSummary).toEqual({
-      evidenceStatus: 'empty',
-      totalSamples: 0,
-      classifiedCounts: {
-        painNegative: 0,
-        successPositive: 0,
-        principleAnchor: 0,
+    expect(engine.hasPassingReport('IMPL-1')).toBe(true);
+  });
+
+  it('hasPassingReport returns false when no passing report exists', () => {
+    createImplementationAssetDir(stateDir, 'IMPL-1', '1.0.0');
+    const replayDir = path.join(getImplementationAssetRoot(stateDir, 'IMPL-1'), 'replays');
+    fs.mkdirSync(replayDir, { recursive: true });
+
+    const report = {
+      implementationId: 'IMPL-1',
+      generatedAt: '2026-04-08T00:00:00.000Z',
+      overallDecision: 'needs-review',
+      blockers: ['NO REPLAY EVIDENCE'],
+      sampleFingerprints: [],
+      replayResults: {
+        painNegative: { total: 0, passed: 0, failed: 0, details: [] },
+        successPositive: { total: 0, passed: 0, failed: 0, details: [] },
+        principleAnchor: { total: 0, passed: 0, failed: 0, details: [] },
+      },
+      evidenceSummary: {
+        evidenceStatus: 'empty',
+        totalSamples: 0,
+        classifiedCounts: { painNegative: 0, successPositive: 0, principleAnchor: 0 },
       },
-    });
-    expect(report.blockers[0]).toContain('NO REPLAY EVIDENCE');
+    };
+
+    fs.writeFileSync(path.join(replayDir, '2026-04-08T00-00-00-000Z.json'), JSON.stringify(report, null, 2), 'utf-8');
+
+    const engine = new ReplayEngine(workspaceDir, stateDir);
+    expect(engine.hasPassingReport('IMPL-1')).toBe(false);
   });
 });

package/tests/core/rule-host-helpers.test.ts

@@ -101,7 +101,7 @@ describe('createRuleHostHelpers', () => {
     const helpers = createRuleHostHelpers(makeInput({
       evolution: { epTier: 4 },
     }));
-    expect(helpers.getCurrentEpiTier()).toBe(4);
+    expect(helpers.getEpTier()).toBe(4);
   });
 
   it('all helpers should be pure functions with no side effects', () => {
@@ -115,6 +115,6 @@ describe('createRuleHostHelpers', () => {
     expect(helpers.getBashRisk()).toBe(helpers.getBashRisk());
     expect(helpers.hasPlanFile()).toBe(helpers.hasPlanFile());
     expect(helpers.getPlanStatus()).toBe(helpers.getPlanStatus());
-    expect(helpers.getCurrentEpiTier()).toBe(helpers.getCurrentEpiTier());
+    expect(helpers.getEpTier()).toBe(helpers.getEpTier());
   });
 });

package/tests/core/rule-implementation-runtime.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, it } from 'vitest';
 import { loadRuleImplementationModule } from '../../src/core/rule-implementation-runtime.js';
-import { validateRuleImplementationCandidate } from '../../src/core/nocturnal-rule-implementation-validator.js';
 
 describe('rule-implementation-runtime', () => {
   it('does not leak global mutations from loaded rule implementations into the host realm', () => {
@@ -35,30 +34,4 @@ describe('rule-implementation-runtime', () => {
 
     expect((globalThis as Record<string, unknown>).__pdRuleHostLeak).toBeUndefined();
   });
-
-  it('keeps validator execution isolated from the host global object', () => {
-    delete (globalThis as Record<string, unknown>).__pdValidatorLeak;
-
-    const result = validateRuleImplementationCandidate(`
-      globalThis.__pdValidatorLeak = 'sandbox-only';
-      export const meta = {
-        name: 'validator-leak-check',
-        version: '1.0.0',
-        ruleId: 'R-VAL',
-        coversCondition: 'validator isolation'
-      };
-
-      export function evaluate() {
-        globalThis.__pdValidatorLeak = 'still-sandboxed';
-        return {
-          decision: 'allow',
-          matched: false,
-          reason: 'ok'
-        };
-      }
-    `);
-
-    expect(result.passed).toBe(true);
-    expect((globalThis as Record<string, unknown>).__pdValidatorLeak).toBeUndefined();
-  });
 });

package/tests/core/workflow-funnel-loader.test.ts

@@ -863,4 +863,166 @@ funnels:
       expect(typeof stage1.statsField).toBe('string');
     });
   });
+
+  // ─────────────────────────────────────────────────────────────────────────────
+  // POLICY-01: Funnel and stage policy fields
+  // Extended schema: timeoutMs, successCriteria, legacyDisabled, observability
+  // ─────────────────────────────────────────────────────────────────────────────
+  describe('POLICY-01: funnel and stage policy fields', () => {
+    it('should load funnel with policy fields', () => {
+      const yamlPath = path.join(tempDir, 'workflows.yaml');
+      fs.writeFileSync(yamlPath, `
+version: "1.0"
+funnels:
+  - workflowId: "pd-runtime-v2-diagnosis"
+    policy:
+      timeoutMs: 600000
+      stageOrder: "strict"
+      legacyDisabled: false
+      observability:
+        enabled: true
+        emitEvents: ["stage_entered", "stage_exited"]
+        logLevel: "debug"
+    stages:
+      - name: "pain_detected"
+        eventType: "pain_detected"
+        eventCategory: "created"
+        statsField: "diagnostic.painDetected"
+      - name: "task_created"
+        eventType: "task_created"
+        eventCategory: "created"
+        statsField: "diagnostic.taskCreated"
+        timeoutMs: 300000
+        legacyDisabled: false
+`, 'utf-8');
+
+      const loader = new WorkflowFunnelLoader(tempDir);
+      const funnel = loader.getFunnel('pd-runtime-v2-diagnosis');
+
+      expect(funnel).toBeDefined();
+      expect(funnel!.policy).toBeDefined();
+      expect(funnel!.policy!.timeoutMs).toBe(600000);
+      expect(funnel!.policy!.stageOrder).toBe('strict');
+      expect(funnel!.policy!.legacyDisabled).toBe(false);
+      expect(funnel!.policy!.observability!.enabled).toBe(true);
+      expect(funnel!.policy!.observability!.emitEvents).toEqual(['stage_entered', 'stage_exited']);
+      expect(funnel!.policy!.observability!.logLevel).toBe('debug');
+    });
+
+    it('should load stage-level policy fields', () => {
+      const yamlPath = path.join(tempDir, 'workflows.yaml');
+      fs.writeFileSync(yamlPath, `
+version: "1.0"
+funnels:
+  - workflowId: "policy-stage-test"
+    stages:
+      - name: "custom_stage"
+        eventType: "custom_event"
+        eventCategory: "completed"
+        statsField: "test.custom"
+        timeoutMs: 900000
+        successCriteria: "artifact.committed"
+        legacyDisabled: true
+        observability:
+          enabled: false
+          emitEvents: []
+`, 'utf-8');
+
+      const loader = new WorkflowFunnelLoader(tempDir);
+      const stages = loader.getStages('policy-stage-test');
+
+      expect(stages).toHaveLength(1);
+      expect(stages[0].timeoutMs).toBe(900000);
+      expect(stages[0].successCriteria).toBe('artifact.committed');
+      expect(stages[0].legacyDisabled).toBe(true);
+      expect(stages[0].observability!.enabled).toBe(false);
+    });
+
+    it('should return stages without policy fields (backward compatible)', () => {
+      const yamlPath = path.join(tempDir, 'workflows.yaml');
+      fs.writeFileSync(yamlPath, `
+version: "1.0"
+funnels:
+  - workflowId: "backward_compat"
+    stages:
+      - name: "plain_stage"
+        eventType: "plain_event"
+        eventCategory: "completed"
+        statsField: "test.plain"
+`, 'utf-8');
+
+      const loader = new WorkflowFunnelLoader(tempDir);
+      const stages = loader.getStages('backward_compat');
+
+      expect(stages).toHaveLength(1);
+      expect(stages[0].timeoutMs).toBeUndefined();
+      expect(stages[0].successCriteria).toBeUndefined();
+      expect(stages[0].legacyDisabled).toBeUndefined();
+      expect(stages[0].observability).toBeUndefined();
+    });
+
+    it('getAllFunnelsWithPolicy returns all funnels with policy', () => {
+      const yamlPath = path.join(tempDir, 'workflows.yaml');
+      fs.writeFileSync(yamlPath, `
+version: "1.0"
+funnels:
+  - workflowId: "funnel_a"
+    policy:
+      timeoutMs: 600000
+    stages:
+      - name: "s1"
+        eventType: "e1"
+        eventCategory: "c"
+        statsField: "f.f1"
+  - workflowId: "funnel_b"
+    stages:
+      - name: "s2"
+        eventType: "e2"
+        eventCategory: "c"
+        statsField: "f.f2"
+`, 'utf-8');
+
+      const loader = new WorkflowFunnelLoader(tempDir);
+      const all = loader.getAllFunnelsWithPolicy();
+
+      expect(all.get('funnel_a')!.policy!.timeoutMs).toBe(600000);
+      expect(all.get('funnel_b')!.policy).toBeUndefined();
+    });
+
+    it('getFunnel returns undefined for unknown workflowId', () => {
+      const yamlPath = path.join(tempDir, 'workflows.yaml');
+      fs.writeFileSync(yamlPath, `
+version: "1.0"
+funnels: []
+`, 'utf-8');
+
+      const loader = new WorkflowFunnelLoader(tempDir);
+      expect(loader.getFunnel('nonexistent')).toBeUndefined();
+    });
+
+    it('getFunnel returns shallow clone (mutation isolation)', () => {
+      const yamlPath = path.join(tempDir, 'workflows.yaml');
+      fs.writeFileSync(yamlPath, `
+version: "1.0"
+funnels:
+  - workflowId: "mutation_test"
+    policy:
+      timeoutMs: 600000
+    stages:
+      - name: "stage_one"
+        eventType: "e1"
+        eventCategory: "c"
+        statsField: "f.f1"
+`, 'utf-8');
+
+      const loader = new WorkflowFunnelLoader(tempDir);
+      const funnel1 = loader.getFunnel('mutation_test')!;
+      funnel1.policy!.timeoutMs = 999;
+      funnel1.stages[0].name = 'MUTATED';
+
+      const funnel2 = loader.getFunnel('mutation_test')!;
+      expect(funnel2.policy!.timeoutMs).toBe(600000);
+      expect(funnel2.stages[0].name).toBe('stage_one');
+    });
+  });
 });

package/tests/core/workspace-context.test.ts

@@ -65,8 +65,8 @@ describe('WorkspaceContext', () => {
         
         // PROFILE is at .principles/PROFILE.json
         expect(wctx.resolve('PROFILE')).toBe(path.join(workspaceDir, '.principles', 'PROFILE.json'));
-        // PLAN is at root
-        expect(wctx.resolve('PLAN')).toBe(path.join(workspaceDir, 'PLAN.md'));
+        // THINKING_OS is at .principles/THINKING_OS.md
+        expect(wctx.resolve('THINKING_OS')).toBe(path.join(workspaceDir, '.principles', 'THINKING_OS.md'));
     });
 
     it('should support explicit disposal from cache', () => {

package/tests/core/workspace-dir-validation.test.ts

@@ -13,10 +13,17 @@ describe('validateWorkspaceDir', () => {
   it('rejects home directory and root-like paths', () => {
     expect(validateWorkspaceDir(homeDir)).toContain('home directory');
     expect(validateWorkspaceDir(`${homeDir}/`)).toContain('home directory');
-    expect(validateWorkspaceDir('/')).toContain('root or empty');
+    const slashResult = validateWorkspaceDir('/');
+    expect(slashResult && (slashResult.includes('root') || slashResult.includes('drive root'))).toBe(true);
     expect(validateWorkspaceDir('')).toContain('undefined/null');
   });
 
+  it('rejects Windows drive root paths', () => {
+    expect(validateWorkspaceDir('C:\\')).toContain('drive root');
+    expect(validateWorkspaceDir('D:\\')).toContain('drive root');
+    expect(validateWorkspaceDir('c:\\')).toContain('drive root');
+  });
+
   it('accepts normal workspace paths', () => {
     expect(validateWorkspaceDir('/home/user/projects/workspace-main')).toBeNull();
     expect(validateWorkspaceDir('/tmp/test-workspace')).toBeNull();