principles-disciple 1.11.0 → 1.13.0

package/tests/core/regression-v1-9-1.test.ts

@@ -0,0 +1,265 @@
+/**
+ * Regression tests for bug fixes in v1.9.1
+ *
+ * Validates fixes for:
+ * - #208/#209: isExpectedSubagentError expanded + terminal_error classification
+ * - #212: evaluability defaults to weak_heuristic, principles are evaluable
+ * - #213: fire-and-forget Promise has .catch()
+ * - #214: sleep_reflection timeout expires nocturnal workflow
+ * - #207/#210: stateDir properly passed through WorkspaceContext
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { EvolutionReducerImpl } from '../../src/core/evolution-reducer.js';
+import {
+  listEvaluablePrinciples,
+  transitionInternalizationStatus,
+  getPrincipleState,
+} from '../../src/core/principle-training-state.js';
+import { isExpectedSubagentError } from '../../src/service/subagent-workflow/subagent-error-utils.js';
+import { WorkspaceContext } from '../../src/core/workspace-context.js';
+
+const tempDirs: string[] = [];
+
+function makeTempDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-regression-'));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ── #208/#209: isExpectedSubagentError covers daemon-mode errors ──
+
+describe('#208/#209: isExpectedSubagentError daemon-mode coverage', () => {
+  it('matches original gateway request errors', () => {
+    expect(isExpectedSubagentError('Plugin runtime subagent methods are only available during a gateway request')).toBe(true);
+    expect(isExpectedSubagentError('cannot start workflow for boot session')).toBe(true);
+    expect(isExpectedSubagentError('subagent runtime unavailable')).toBe(true);
+  });
+
+  it('matches NocturnalWorkflowManager specific error', () => {
+    expect(isExpectedSubagentError('NocturnalWorkflowManager: subagent runtime unavailable')).toBe(true);
+  });
+
+  it('matches daemon-mode connection errors', () => {
+    expect(isExpectedSubagentError('subagent is not available')).toBe(true);
+    expect(isExpectedSubagentError('gateway is not running')).toBe(true);
+    expect(isExpectedSubagentError('process isolation error: ECONNREFUSED')).toBe(true);
+    // #3 review fix: connection errors now require 'subagent' in message to reduce false positives
+    expect(isExpectedSubagentError('subagent connection refused')).toBe(true);
+    expect(isExpectedSubagentError('subagent connection reset by peer')).toBe(true);
+  });
+
+  it('does not match unrelated errors', () => {
+    expect(isExpectedSubagentError('file not found')).toBe(false);
+    expect(isExpectedSubagentError('syntax error in config')).toBe(false);
+    expect(isExpectedSubagentError('network timeout to external API')).toBe(false);
+    // #3 review fix: generic connection errors without 'subagent' should NOT match
+    expect(isExpectedSubagentError('connection refused')).toBe(false);
+    expect(isExpectedSubagentError('connection reset by peer')).toBe(false);
+  });
+});
+
+// ── #212: evaluability defaults to weak_heuristic ──
+
+describe('#212: principle evaluability and internalization status', () => {
+  it('new principle without explicit evaluability defaults to weak_heuristic', () => {
+    const workspace = makeTempDir();
+    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
+
+    const id = reducer.createPrincipleFromDiagnosis({
+      painId: 'regression-212-1',
+      painType: 'tool_failure',
+      triggerPattern: 'api call times out after 30s',
+      action: 'implement retry with exponential backoff',
+      source: 'test',
+    });
+
+    expect(id).not.toBeNull();
+    const principle = reducer.getPrincipleById(id!);
+    expect(principle).not.toBeNull();
+    expect(principle!.evaluability).toBe('weak_heuristic');
+  });
+
+  it('new principle with weak_heuristic evaluability gets needs_training status', () => {
+    const workspace = makeTempDir();
+    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
+
+    const id = reducer.createPrincipleFromDiagnosis({
+      painId: 'regression-212-2',
+      painType: 'tool_failure',
+      triggerPattern: 'database connection pool exhausted',
+      action: 'queue requests and retry with timeout',
+      source: 'test',
+    });
+
+    expect(id).not.toBeNull();
+    const trainingState = getPrincipleState(workspace, id!);
+    expect(trainingState.internalizationStatus).toBe('needs_training');
+    expect(trainingState.evaluability).toBe('weak_heuristic');
+  });
+
+  it('new principle with manual_only evaluability gets prompt_only status', () => {
+    const workspace = makeTempDir();
+    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
+
+    const id = reducer.createPrincipleFromDiagnosis({
+      painId: 'regression-212-3',
+      painType: 'user_frustration',
+      triggerPattern: 'ambiguous user intent',
+      action: 'ask clarifying questions before acting',
+      source: 'test',
+      evaluability: 'manual_only',
+    });
+
+    expect(id).not.toBeNull();
+    const trainingState = getPrincipleState(workspace, id!);
+    expect(trainingState.internalizationStatus).toBe('prompt_only');
+    expect(trainingState.evaluability).toBe('manual_only');
+  });
+
+  it('listEvaluablePrinciples includes weak_heuristic principles', () => {
+    const workspace = makeTempDir();
+    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
+
+    // Create a weak_heuristic principle (should be evaluable)
+    const id = reducer.createPrincipleFromDiagnosis({
+      painId: 'regression-212-eval-1',
+      painType: 'tool_failure',
+      triggerPattern: 'regex parse error on empty input',
+      action: 'validate input before regex processing',
+      source: 'test',
+    });
+
+    expect(id).not.toBeNull();
+    const evaluable = listEvaluablePrinciples(workspace);
+    expect(evaluable.length).toBeGreaterThan(0);
+    // Principle IDs are auto-generated (P_001, P_002...), check by the returned ID
+    expect(evaluable.some(p => p.principleId === id)).toBe(true);
+  });
+
+  it('listEvaluablePrinciples excludes manual_only + prompt_only principles', () => {
+    const workspace = makeTempDir();
+    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
+
+    // Create a manual_only principle (should NOT be evaluable)
+    reducer.createPrincipleFromDiagnosis({
+      painId: 'regression-212-noeval-1',
+      painType: 'user_frustration',
+      triggerPattern: 'user confused about feature',
+      action: 'provide contextual help',
+      source: 'test',
+      evaluability: 'manual_only',
+    });
+
+    const evaluable = listEvaluablePrinciples(workspace);
+    expect(evaluable.some(p => p.principleId.includes('regression-212-noeval'))).toBe(false);
+  });
+});
+
+// ── #212: internalization status transition mechanism ──
+
+describe('#212: internalization status transitions', () => {
+  it('transitions prompt_only → needs_training', () => {
+    const workspace = makeTempDir();
+    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
+
+    const id = reducer.createPrincipleFromDiagnosis({
+      painId: 'regression-212-transition-1',
+      painType: 'user_frustration',
+      triggerPattern: 'user error on complex form',
+      action: 'simplify form with progressive disclosure',
+      source: 'test',
+      evaluability: 'manual_only',
+    });
+
+    expect(id).not.toBeNull();
+    const before = getPrincipleState(workspace, id!);
+    expect(before.internalizationStatus).toBe('prompt_only');
+
+    transitionInternalizationStatus(workspace, id!, 'needs_training');
+    const after = getPrincipleState(workspace, id!);
+    expect(after.internalizationStatus).toBe('needs_training');
+  });
+
+  it('rejects invalid transition prompt_only → in_training', () => {
+    const workspace = makeTempDir();
+    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
+
+    const id = reducer.createPrincipleFromDiagnosis({
+      painId: 'regression-212-invalid-transition',
+      painType: 'user_frustration',
+      triggerPattern: 'user error on complex form',
+      action: 'simplify form',
+      source: 'test',
+      evaluability: 'manual_only',
+    });
+
+    expect(() => transitionInternalizationStatus(workspace, id!, 'in_training')).toThrow(
+      'Invalid transition: prompt_only → in_training'
+    );
+  });
+
+  it('transitions regressed → needs_training', () => {
+    const workspace = makeTempDir();
+    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace, stateDir: workspace });
+
+    const id = reducer.createPrincipleFromDiagnosis({
+      painId: 'regression-212-regress',
+      painType: 'tool_failure',
+      triggerPattern: 'timeout on slow endpoint',
+      action: 'add pagination and caching',
+      source: 'test',
+    });
+
+    // Transition chain: needs_training → in_training → deployed_pending_eval → regressed → needs_training
+    transitionInternalizationStatus(workspace, id!, 'in_training');
+    transitionInternalizationStatus(workspace, id!, 'deployed_pending_eval');
+
+    const before = getPrincipleState(workspace, id!);
+    expect(before.internalizationStatus).toBe('deployed_pending_eval');
+
+    // Can transition to regressed from deployed_pending_eval
+    transitionInternalizationStatus(workspace, id!, 'regressed');
+    const regressed = getPrincipleState(workspace, id!);
+    expect(regressed.internalizationStatus).toBe('regressed');
+
+    // Can transition back to needs_training from regressed
+    transitionInternalizationStatus(workspace, id!, 'needs_training');
+    const after = getPrincipleState(workspace, id!);
+    expect(after.internalizationStatus).toBe('needs_training');
+  });
+});
+
+// ── #207/#210: stateDir via WorkspaceContext ──
+
+describe('#207/#210: WorkspaceContext provides stateDir to evolutionReducer', () => {
+  it('evolutionReducer from WorkspaceContext has stateDir', () => {
+    const workspace = makeTempDir();
+    const wctx = WorkspaceContext.fromHookContext({ workspaceDir: workspace });
+
+    // The reducer should have stateDir set via WorkspaceContext
+    // We can verify by creating a principle and checking training store
+    const reducer = wctx.evolutionReducer;
+    const id = reducer.createPrincipleFromDiagnosis({
+      painId: 'regression-207-1',
+      painType: 'tool_failure',
+      triggerPattern: 'null pointer on empty list',
+      action: 'check for empty list before iteration',
+      source: 'test',
+    });
+
+    expect(id).not.toBeNull();
+    // If stateDir was properly passed, training store should have been written
+    const trainingState = getPrincipleState(workspace, id!);
+    expect(trainingState.principleId).toBe(id);
+  });
+});

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

@@ -0,0 +1,234 @@
+import * as fs from 'fs';
+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-'));
+    workspaceDir = path.join(tempDir, 'workspace');
+    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',
+        },
+      },
+      tree: {
+        principles: { 'P-1': makePrinciple() },
+        rules: { 'R-1': makeRule() },
+        implementations: { 'IMPL-1': makeImplementation() },
+        metrics: {},
+        lastUpdated: '2026-04-08T00:00:00.000Z',
+      },
+    });
+
+    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',
+      },
+      artifactPath,
+      null,
+      'pain-negative',
+    );
+  }
+
+  it('persists replay reports under the implementation asset root', () => {
+    seedLedgerAndImplementation();
+    seedPainNegativeSample();
+
+    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);
+  });
+});

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

@@ -0,0 +1,120 @@
+/**
+ * Rule Host Helpers Tests
+ *
+ * PURPOSE: Verify that the helper whitelist:
+ *   - Returns correct values from the frozen input snapshot
+ *   - Is a frozen object that cannot be mutated
+ *   - All helpers are pure functions with no side effects
+ */
+
+import { describe, it, expect } from 'vitest';
+import { createRuleHostHelpers } from '../../src/core/rule-host-helpers.js';
+import type { RuleHostInput } from '../../src/core/rule-host-types.js';
+
+function makeInput(overrides?: Partial<RuleHostInput>): RuleHostInput {
+  return {
+    action: {
+      toolName: 'write',
+      normalizedPath: 'src/test.ts',
+      paramsSummary: {},
+    },
+    workspace: {
+      isRiskPath: false,
+      planStatus: 'NONE',
+      hasPlanFile: false,
+    },
+    session: {
+      sessionId: 'session-123',
+      currentGfi: 10,
+      recentThinking: false,
+    },
+    evolution: {
+      epTier: 2,
+    },
+    derived: {
+      estimatedLineChanges: 50,
+      bashRisk: 'normal',
+    },
+    ...overrides,
+  };
+}
+
+describe('createRuleHostHelpers', () => {
+  it('should return a frozen object', () => {
+    const helpers = createRuleHostHelpers(makeInput());
+    expect(Object.isFrozen(helpers)).toBe(true);
+  });
+
+  it('should throw TypeError when attempting to mutate helpers', () => {
+    const helpers = createRuleHostHelpers(makeInput()) as Record<string, unknown>;
+    expect(() => {
+      (helpers as any).isRiskPath = () => true;
+    }).toThrow(TypeError);
+  });
+
+  it('should return correct isRiskPath from input snapshot', () => {
+    const helpers = createRuleHostHelpers(makeInput({
+      workspace: { isRiskPath: true, planStatus: 'READY', hasPlanFile: true },
+    }));
+    expect(helpers.isRiskPath()).toBe(true);
+  });
+
+  it('should return false isRiskPath by default', () => {
+    const helpers = createRuleHostHelpers(makeInput());
+    expect(helpers.isRiskPath()).toBe(false);
+  });
+
+  it('should return correct toolName from input snapshot', () => {
+    const helpers = createRuleHostHelpers(makeInput());
+    expect(helpers.getToolName()).toBe('write');
+  });
+
+  it('should return correct estimatedLineChanges from input snapshot', () => {
+    const helpers = createRuleHostHelpers(makeInput({
+      derived: { estimatedLineChanges: 200, bashRisk: 'dangerous' },
+    }));
+    expect(helpers.getEstimatedLineChanges()).toBe(200);
+  });
+
+  it('should return correct bashRisk from input snapshot', () => {
+    const helpers = createRuleHostHelpers(makeInput({
+      derived: { estimatedLineChanges: 50, bashRisk: 'safe' },
+    }));
+    expect(helpers.getBashRisk()).toBe('safe');
+  });
+
+  it('should return correct hasPlanFile from input snapshot', () => {
+    const helpers = createRuleHostHelpers(makeInput({
+      workspace: { isRiskPath: false, planStatus: 'READY', hasPlanFile: true },
+    }));
+    expect(helpers.hasPlanFile()).toBe(true);
+  });
+
+  it('should return correct planStatus from input snapshot', () => {
+    const helpers = createRuleHostHelpers(makeInput({
+      workspace: { isRiskPath: false, planStatus: 'DRAFT', hasPlanFile: true },
+    }));
+    expect(helpers.getPlanStatus()).toBe('DRAFT');
+  });
+
+  it('should return correct epTier from input snapshot', () => {
+    const helpers = createRuleHostHelpers(makeInput({
+      evolution: { epTier: 4 },
+    }));
+    expect(helpers.getCurrentEpiTier()).toBe(4);
+  });
+
+  it('all helpers should be pure functions with no side effects', () => {
+    const input = makeInput();
+    const helpers = createRuleHostHelpers(input);
+
+    // Call each helper multiple times — should always return the same value
+    expect(helpers.isRiskPath()).toBe(helpers.isRiskPath());
+    expect(helpers.getToolName()).toBe(helpers.getToolName());
+    expect(helpers.getEstimatedLineChanges()).toBe(helpers.getEstimatedLineChanges());
+    expect(helpers.getBashRisk()).toBe(helpers.getBashRisk());
+    expect(helpers.hasPlanFile()).toBe(helpers.hasPlanFile());
+    expect(helpers.getPlanStatus()).toBe(helpers.getPlanStatus());
+    expect(helpers.getCurrentEpiTier()).toBe(helpers.getCurrentEpiTier());
+  });
+});