principles-disciple 1.11.0 → 1.13.0

package/tests/core/nocturnal-artificer.test.ts

@@ -0,0 +1,241 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  parseArtificerOutput,
+  resolveArtificerTargetRule,
+  shouldRunArtificer,
+} from '../../src/core/nocturnal-artificer.js';
+import { saveLedger, type LedgerPrinciple, type LedgerRule } from '../../src/core/principle-tree-ledger.js';
+import type { NocturnalSessionSnapshot } from '../../src/core/nocturnal-trajectory-extractor.js';
+import { safeRmDir } from '../test-utils.js';
+
+function createPrinciple(overrides: Partial<LedgerPrinciple> = {}): LedgerPrinciple {
+  return {
+    id: 'P-001',
+    version: 1,
+    text: 'Use the right safety hook',
+    triggerPattern: 'gate',
+    action: 'align code fixes to the correct rule',
+    status: 'active',
+    priority: 'P1',
+    scope: 'general',
+    evaluability: 'deterministic',
+    valueScore: 0,
+    adherenceRate: 0,
+    painPreventedCount: 0,
+    derivedFromPainIds: [],
+    ruleIds: [],
+    conflictsWithPrincipleIds: [],
+    createdAt: '2026-04-08T00:00:00.000Z',
+    updatedAt: '2026-04-08T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+function createRule(overrides: Partial<LedgerRule> = {}): LedgerRule {
+  return {
+    id: 'R-001',
+    version: 1,
+    name: 'Protect destructive writes',
+    description: 'Gate write operations on risky paths.',
+    type: 'gate',
+    triggerCondition: 'write risk path',
+    enforcement: 'block',
+    action: 'require approval for risky write',
+    principleId: 'P-001',
+    status: 'implemented',
+    coverageRate: 0,
+    falsePositiveRate: 0,
+    implementationIds: [],
+    createdAt: '2026-04-08T00:00:00.000Z',
+    updatedAt: '2026-04-08T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+function createSnapshot(): NocturnalSessionSnapshot {
+  return {
+    sessionId: 'session-1',
+    startedAt: '2026-04-08T00:00:00.000Z',
+    updatedAt: '2026-04-08T00:10:00.000Z',
+    assistantTurns: [],
+    userTurns: [],
+    toolCalls: [
+      {
+        toolName: 'write',
+        outcome: 'failure',
+        filePath: 'src/risk.ts',
+        durationMs: 10,
+        exitCode: 1,
+        errorType: 'blocked',
+        errorMessage: 'risky write',
+        createdAt: '2026-04-08T00:01:00.000Z',
+      },
+    ],
+    painEvents: [
+      {
+        source: 'gate',
+        score: 0.9,
+        severity: 'high',
+        reason: 'write operation touched a risky path without approval',
+        createdAt: '2026-04-08T00:02:00.000Z',
+      },
+    ],
+    gateBlocks: [
+      {
+        toolName: 'write',
+        filePath: 'src/risk.ts',
+        reason: 'risky write requires approval',
+        planStatus: 'DRAFT',
+        createdAt: '2026-04-08T00:03:00.000Z',
+      },
+    ],
+    stats: {
+      totalAssistantTurns: 0,
+      totalToolCalls: 1,
+      totalPainEvents: 1,
+      totalGateBlocks: 1,
+      failureCount: 1,
+    },
+  };
+}
+
+describe('nocturnal-artificer', () => {
+  let tempDir: string;
+  let stateDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-artificer-'));
+    stateDir = path.join(tempDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    safeRmDir(tempDir);
+  });
+
+  it('selects the only rule for a principle without scoring ambiguity', () => {
+    saveLedger(stateDir, {
+      trainingStore: {},
+      tree: {
+        principles: {
+          'P-001': createPrinciple({ ruleIds: ['R-001'] }),
+        },
+        rules: {
+          'R-001': createRule(),
+        },
+        implementations: {},
+        metrics: {},
+        lastUpdated: '2026-04-08T00:00:00.000Z',
+      },
+    });
+
+    const resolution = resolveArtificerTargetRule(stateDir, 'P-001', createSnapshot());
+
+    expect(resolution).toMatchObject({
+      status: 'selected',
+      ruleId: 'R-001',
+      reason: 'single-rule',
+    });
+  });
+
+  it('selects the highest-signal rule when one rule has deterministic evidence', () => {
+    saveLedger(stateDir, {
+      trainingStore: {},
+      tree: {
+        principles: {
+          'P-001': createPrinciple({ ruleIds: ['R-001', 'R-002'] }),
+        },
+        rules: {
+          'R-001': createRule(),
+          'R-002': createRule({
+            id: 'R-002',
+            name: 'Protect archive deletes',
+            description: 'Require approval for delete operations.',
+            triggerCondition: 'delete archive',
+            action: 'block unreviewed delete',
+          }),
+        },
+        implementations: {},
+        metrics: {},
+        lastUpdated: '2026-04-08T00:00:00.000Z',
+      },
+    });
+
+    const resolution = resolveArtificerTargetRule(stateDir, 'P-001', createSnapshot());
+
+    expect(resolution).toMatchObject({
+      status: 'selected',
+      ruleId: 'R-001',
+      reason: 'evidence-winner',
+    });
+    expect(resolution.scores[0]?.score).toBeGreaterThan(resolution.scores[1]?.score ?? 0);
+  });
+
+  it('skips Artificer routing when multiple rules tie on the same evidence', () => {
+    saveLedger(stateDir, {
+      trainingStore: {},
+      tree: {
+        principles: {
+          'P-001': createPrinciple({ ruleIds: ['R-001', 'R-002'] }),
+        },
+        rules: {
+          'R-001': createRule({
+            name: 'Protect risky write',
+            description: 'risky write requires approval',
+            triggerCondition: 'write risky',
+            action: 'require approval for risky write',
+          }),
+          'R-002': createRule({
+            id: 'R-002',
+            name: 'Protect risky write',
+            description: 'risky write requires approval',
+            triggerCondition: 'write risky',
+            action: 'require approval for risky write',
+          }),
+        },
+        implementations: {},
+        metrics: {},
+        lastUpdated: '2026-04-08T00:00:00.000Z',
+      },
+    });
+
+    const resolution = resolveArtificerTargetRule(stateDir, 'P-001', createSnapshot());
+
+    expect(resolution).toMatchObject({
+      status: 'skip',
+      reason: 'ambiguous-target-rule',
+    });
+    expect(shouldRunArtificer(createSnapshot(), resolution)).toBe(false);
+  });
+
+  it('parses a structured code-candidate output contract with lineage metadata', () => {
+    const parsed = parseArtificerOutput(
+      JSON.stringify({
+        ruleId: 'R-001',
+        candidateSource: 'export const meta = {}; export function evaluate() {}',
+        helperUsage: ['getToolName', 'hasPlanFile'],
+        expectedDecision: 'requireApproval',
+        rationale: 'Target the risky write path guard.',
+        lineage: {
+          artifactKind: 'rule-implementation-candidate',
+          sourceSnapshotRef: 'snapshot-session-1',
+          sourcePainIds: [],
+          sourceGateBlockIds: [],
+        },
+      })
+    );
+
+    expect(parsed).toMatchObject({
+      ruleId: 'R-001',
+      implementationType: 'code',
+      helperUsage: ['getToolName', 'hasPlanFile'],
+      expectedDecision: 'requireApproval',
+      lineage: {
+        artifactKind: 'rule-implementation-candidate',
+      },
+    });
+  });
+});

package/tests/core/nocturnal-compliance-p-principles.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Tests for #216: P_* principle violation and opportunity detection
+ *
+ * Before this fix, detectOpportunity and detectViolation only handled T-01~T-09,
+ * causing all P_* principles to return false for both applicable and violated.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { detectOpportunity, detectViolation } from '../../src/core/nocturnal-compliance.js';
+import type { SessionEvents } from '../../src/core/nocturnal-compliance.js';
+
+function makeSession(overrides: Partial<SessionEvents> = {}): SessionEvents {
+  return {
+    sessionId: 'test-session',
+    toolCalls: overrides.toolCalls ?? [],
+    painSignals: overrides.painSignals ?? [],
+    gateBlocks: overrides.gateBlocks ?? [],
+    userCorrections: overrides.userCorrections ?? [],
+    planApprovals: overrides.planApprovals ?? [],
+  };
+}
+
+describe('#216: P_* principle detection', () => {
+  describe('detectOpportunity for P_* principles', () => {
+    it('returns applicable=true when session has pain signals', () => {
+      const session = makeSession({
+        painSignals: [{ source: 'tool_failure', score: 80, reason: 'write failed' }],
+      });
+      const result = detectOpportunity('P_001', session);
+      expect(result.applicable).toBe(true);
+      expect(result.reason).toContain('pain signal');
+    });
+
+    it('returns applicable=true when session has tool failures', () => {
+      const session = makeSession({
+        toolCalls: [{ toolName: 'write', filePath: 'test.txt', outcome: 'failure', errorMessage: 'disk full' }],
+      });
+      const result = detectOpportunity('P_042', session);
+      expect(result.applicable).toBe(true);
+      expect(result.reason).toContain('tool failure');
+    });
+
+    it('returns applicable=true when session has gate blocks', () => {
+      const session = makeSession({
+        gateBlocks: [{ toolName: 'bash', reason: 'high risk operation' }],
+      });
+      const result = detectOpportunity('P_065', session);
+      expect(result.applicable).toBe(true);
+      expect(result.reason).toContain('gate block');
+    });
+
+    it('returns applicable=false when session has no negative signals', () => {
+      const session = makeSession({
+        toolCalls: [{ toolName: 'read', filePath: 'test.txt', outcome: 'success' }],
+      });
+      const result = detectOpportunity('P_001', session);
+      expect(result.applicable).toBe(false);
+      expect(result.reason).toContain('no pain/tool-failure/gate-block');
+    });
+  });
+
+  describe('detectViolation for P_* principles', () => {
+    it('returns violated=true when session has high pain signals (score >= 50)', () => {
+      const session = makeSession({
+        painSignals: [{ source: 'tool_failure', score: 80, reason: 'write failed' }],
+      });
+      const result = detectViolation('P_001', session);
+      expect(result.violated).toBe(true);
+      expect(result.reason).toContain('pain signal');
+    });
+
+    it('returns violated=false when pain signals are low (score < 50)', () => {
+      const session = makeSession({
+        painSignals: [{ source: 'minor_issue', score: 30, reason: 'cosmetic' }],
+        toolCalls: [{ toolName: 'read', filePath: 'test.txt', outcome: 'success' }],
+      });
+      const result = detectViolation('P_001', session);
+      expect(result.violated).toBe(false);
+      expect(result.reason).toContain('no violation signals');
+    });
+
+    it('returns violated=true when session has tool failures', () => {
+      const session = makeSession({
+        toolCalls: [
+          { toolName: 'write', filePath: 'test.txt', outcome: 'failure', errorMessage: 'disk full' },
+        ],
+      });
+      const result = detectViolation('P_042', session);
+      expect(result.violated).toBe(true);
+      expect(result.reason).toContain('tool failure');
+    });
+
+    it('returns violated=true when session has gate blocks', () => {
+      const session = makeSession({
+        gateBlocks: [{ toolName: 'bash', reason: 'high risk operation' }],
+      });
+      const result = detectViolation('P_065', session);
+      expect(result.violated).toBe(true);
+      expect(result.reason).toContain('gate block');
+    });
+
+    it('returns violated=false for clean session with no negative signals', () => {
+      const session = makeSession({
+        toolCalls: [{ toolName: 'read', filePath: 'test.txt', outcome: 'success' }],
+      });
+      const result = detectViolation('P_001', session);
+      expect(result.violated).toBe(false);
+      expect(result.reason).toContain('no violation signals');
+    });
+  });
+
+  describe('T-* principles still work (regression check)', () => {
+    it('T-01 opportunity detected for edit operations', () => {
+      const session = makeSession({
+        toolCalls: [{ toolName: 'edit_file', filePath: 'test.ts', outcome: 'success' }],
+      });
+      const result = detectOpportunity('T-01', session);
+      expect(result.applicable).toBe(true);
+    });
+
+    it('T-01 violation detected when editing without reading first', () => {
+      const session = makeSession({
+        toolCalls: [
+          { toolName: 'edit_file', filePath: 'test.ts', outcome: 'failure', errorMessage: 'merge conflict' },
+        ],
+        painSignals: [{ source: 'test.ts edit failed', score: 70, reason: 'Did not survey structure before editing' }],
+      });
+      const result = detectViolation('T-01', session);
+      // T-01 violation: edit without prior read, with pain signal matching file or pattern
+      expect(result.violated).toBe(true);
+    });
+  });
+});

package/tests/core/nocturnal-rule-implementation-validator.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, it } from 'vitest';
+import { validateRuleImplementationCandidate } from '../../src/core/nocturnal-rule-implementation-validator.js';
+
+describe('nocturnal-rule-implementation-validator', () => {
+  it('accepts a RuleHost-compatible candidate and reports helper usage', () => {
+    const result = validateRuleImplementationCandidate(`
+      export const meta = {
+        name: 'risk-write-guard',
+        version: '1.0.0',
+        ruleId: 'R-001',
+        coversCondition: 'risky write'
+      };
+
+      export function evaluate(input, helpers) {
+        if (helpers.isRiskPath() && helpers.getToolName() === 'write') {
+          return {
+            decision: 'requireApproval',
+            matched: true,
+            reason: 'Risk path write requires approval'
+          };
+        }
+
+        return {
+          decision: 'allow',
+          matched: false,
+          reason: 'not applicable'
+        };
+      }
+    `);
+
+    expect(result.passed).toBe(true);
+    expect(result.failures).toEqual([]);
+    expect(result.helperUsage).toEqual(['isRiskPath', 'getToolName']);
+    expect(result.meta).toMatchObject({
+      ruleId: 'R-001',
+      name: 'risk-write-guard',
+    });
+  });
+
+  it('rejects forbidden APIs before compile/load checks', () => {
+    const result = validateRuleImplementationCandidate(`
+      export const meta = {
+        name: 'bad-guard',
+        version: '1.0.0',
+        ruleId: 'R-001',
+        coversCondition: 'bad'
+      };
+
+      export function evaluate() {
+        const fn = eval('1 + 1');
+        return {
+          decision: 'allow',
+          matched: false,
+          reason: String(fn)
+        };
+      }
+    `);
+
+    expect(result.passed).toBe(false);
+    expect(result.failures).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: 'forbidden-api',
+          detail: 'eval',
+        }),
+      ])
+    );
+  });
+
+  it('rejects malformed exports when meta is missing', () => {
+    const result = validateRuleImplementationCandidate(`
+      export function evaluate() {
+        return {
+          decision: 'allow',
+          matched: false,
+          reason: 'missing meta'
+        };
+      }
+    `);
+
+    expect(result.passed).toBe(false);
+    expect(result.failures).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: 'missing-meta',
+        }),
+      ])
+    );
+  });
+
+  it('rejects candidates whose evaluate result does not satisfy RuleHostResult', () => {
+    const result = validateRuleImplementationCandidate(`
+      export const meta = {
+        name: 'wrong-result-shape',
+        version: '1.0.0',
+        ruleId: 'R-001',
+        coversCondition: 'bad result'
+      };
+
+      export function evaluate() {
+        return {
+          decision: 'noop',
+          matched: 'sometimes',
+          reason: 42
+        };
+      }
+    `);
+
+    expect(result.passed).toBe(false);
+    expect(result.failures).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: 'invalid-result',
+          detail: 'decision',
+        }),
+        expect.objectContaining({
+          code: 'invalid-result',
+          detail: 'matched',
+        }),
+        expect.objectContaining({
+          code: 'invalid-result',
+          detail: 'reason',
+        }),
+      ])
+    );
+  });
+});

package/tests/core/pd-task-store.test.ts

@@ -0,0 +1,126 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import {
+  readTasks,
+  writeTasks,
+  initTaskMeta,
+  updateSyncMeta,
+} from '../../src/core/pd-task-store.js';
+import type { PDTaskSpec } from '../../src/core/pd-task-types.js';
+
+const TEST_TASK: PDTaskSpec = {
+  id: 'test-task',
+  name: 'PD Test Task',
+  description: 'A test task',
+  enabled: true,
+  version: '1.0.0',
+  schedule: { kind: 'every', everyMs: 3600000 },
+  execution: { promptTemplate: 'test', timeoutSeconds: 60 },
+  delivery: { mode: 'none' },
+};
+
+describe('PDTaskStore', () => {
+  const tmpDir = path.join(os.tmpdir(), `pd-task-store-test-${Date.now()}-${Math.random()}`);
+  const stateDir = path.join(tmpDir, '.state');
+
+  beforeEach(() => {
+    fs.mkdirSync(stateDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('readTasks', () => {
+    it('should return empty array when file does not exist', () => {
+      const tasks = readTasks(tmpDir);
+      expect(tasks).toEqual([]);
+    });
+
+    it('should return empty array for invalid JSON', () => {
+      const filePath = path.join(stateDir, 'pd_tasks.json');
+      fs.writeFileSync(filePath, 'not valid json', 'utf-8');
+      const tasks = readTasks(tmpDir);
+      expect(tasks).toEqual([]);
+    });
+
+    it('should return empty array for non-array JSON', () => {
+      const filePath = path.join(stateDir, 'pd_tasks.json');
+      fs.writeFileSync(filePath, JSON.stringify({ version: 1 }), 'utf-8');
+      const tasks = readTasks(tmpDir);
+      expect(tasks).toEqual([]);
+    });
+
+    it('should read and parse valid task array', () => {
+      const filePath = path.join(stateDir, 'pd_tasks.json');
+      const tasks = [TEST_TASK];
+      fs.writeFileSync(filePath, JSON.stringify(tasks), 'utf-8');
+      const result = readTasks(tmpDir);
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('test-task');
+    });
+  });
+
+  describe('writeTasks', () => {
+    it('should create .state directory if missing', async () => {
+      const newDir = path.join(tmpDir, 'new-workspace');
+      await writeTasks(newDir, [TEST_TASK]);
+      const newStateDir = path.join(newDir, '.state');
+      expect(fs.existsSync(newStateDir)).toBe(true);
+    });
+
+    it('should write tasks to pd_tasks.json', async () => {
+      await writeTasks(tmpDir, [TEST_TASK]);
+      const filePath = path.join(stateDir, 'pd_tasks.json');
+      expect(fs.existsSync(filePath)).toBe(true);
+      const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      expect(content).toHaveLength(1);
+      expect(content[0].id).toBe('test-task');
+    });
+
+    it('should use atomic write (tmp + rename)', async () => {
+      await writeTasks(tmpDir, [TEST_TASK]);
+      const filePath = path.join(stateDir, 'pd_tasks.json');
+      const tmpFile = filePath + '.tmp';
+      expect(fs.existsSync(tmpFile)).toBe(false);
+    });
+  });
+
+  describe('initTaskMeta', () => {
+    it('should initialize meta if missing', () => {
+      const task = { ...TEST_TASK };
+      const result = initTaskMeta(task);
+      expect(result.meta).toBeDefined();
+      expect(result.meta!.createdAtMs).toBeDefined();
+    });
+
+    it('should preserve existing meta', () => {
+      const task = {
+        ...TEST_TASK,
+        meta: { createdAtMs: 1000, autoDisabled: true },
+      };
+      const result = initTaskMeta(task);
+      expect(result.meta!.createdAtMs).toBe(1000);
+      expect(result.meta!.autoDisabled).toBe(true);
+    });
+  });
+
+  describe('updateSyncMeta', () => {
+    it('should update sync metadata', () => {
+      const task = { ...TEST_TASK };
+      const result = updateSyncMeta(task, 'ok', 'job-123');
+      expect(result.meta!.lastSyncedAtMs).toBeDefined();
+      expect(result.meta!.lastSyncStatus).toBe('ok');
+      expect(result.meta!.lastSyncedJobId).toBe('job-123');
+    });
+
+    it('should record error for failed sync', () => {
+      const task = { ...TEST_TASK };
+      const result = updateSyncMeta(task, 'error', undefined, 'Lock timeout');
+      expect(result.meta!.lastSyncStatus).toBe('error');
+      expect(result.meta!.lastSyncError).toBe('Lock timeout');
+    });
+  });
+});