principles-disciple 1.71.0 → 1.73.0

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

@@ -1,234 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { TrajectoryDatabase } from '../../src/core/trajectory.js';
-import { NocturnalTrajectoryExtractor } from '../../src/core/nocturnal-trajectory-extractor.js';
-import { detectViolation } from '../../src/core/nocturnal-compliance.js';
-
-function safeRmDir(dir: string): void {
-  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
-}
-
-// ─────────────────────────────────────────────────────────
-// Phase 4a: Correction rejected → pain event → nocturnal selection
-// ─────────────────────────────────────────────────────────
-describe('Phase 4a: Correction rejected integration', () => {
-  let workspaceDir: string;
-  let trajectory: TrajectoryDatabase;
-
-  beforeEach(() => {
-    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-e2e-correction-'));
-    trajectory = new TrajectoryDatabase({ workspaceDir });
-  });
-
-  afterEach(() => {
-    trajectory?.dispose();
-    safeRmDir(workspaceDir);
-  });
-
-  it('rejected correction creates a pain event with source=correction_rejected', () => {
-    // 1. Create session + correction sample
-    trajectory.recordSession({ sessionId: 'corr-session', startedAt: new Date().toISOString() });
-    const atId = trajectory.recordAssistantTurn({
-      sessionId: 'corr-session', runId: 'run-1', provider: 'local', model: 'main',
-      rawText: 'Here is my code', sanitizedText: 'Here is my code', usageJson: {}, empathySignalJson: {},
-      createdAt: new Date().toISOString(),
-    });
-    trajectory.recordUserTurn({
-      sessionId: 'corr-session', turnIndex: 1, rawText: 'This is wrong!',
-      correctionDetected: true, correctionCue: '错了',
-      referencesAssistantTurnId: atId, createdAt: new Date().toISOString(),
-    });
-    // Tool call triggers maybeCreateCorrectionSample on success
-    trajectory.recordToolCall({
-      sessionId: 'corr-session', toolName: 'read', outcome: 'success',
-      createdAt: new Date().toISOString(),
-    });
-
-    // Verify sample was created
-    const samples = trajectory.listCorrectionSamples('pending');
-    expect(samples.length).toBe(1);
-
-    // 2. Reject the sample
-    trajectory.reviewCorrectionSample(samples[0].sampleId, 'rejected', 'Bad approach');
-
-    // 3. Verify pain event was created
-    const painEvents = trajectory.listPainEventsForSession('corr-session');
-    const correctionPain = painEvents.find(e => e.source === 'correction_rejected');
-    expect(correctionPain).toBeDefined();
-    expect(correctionPain!.score).toBeGreaterThanOrEqual(0);
-    expect(correctionPain!.score).toBeLessThanOrEqual(100);
-  });
-
-  it('approved correction does NOT create a pain event', () => {
-    trajectory.recordSession({ sessionId: 'approved-session', startedAt: new Date().toISOString() });
-    const atId = trajectory.recordAssistantTurn({
-      sessionId: 'approved-session', runId: 'run-2', provider: 'local', model: 'main',
-      rawText: 'Good code', sanitizedText: 'Good code', usageJson: {}, empathySignalJson: {},
-      createdAt: new Date().toISOString(),
-    });
-    trajectory.recordUserTurn({
-      sessionId: 'approved-session', turnIndex: 1, rawText: 'Looks better',
-      correctionDetected: true, correctionCue: '改进',
-      referencesAssistantTurnId: atId, createdAt: new Date().toISOString(),
-    });
-    // Tool call triggers maybeCreateCorrectionSample on success
-    trajectory.recordToolCall({
-      sessionId: 'approved-session', toolName: 'read', outcome: 'success',
-      createdAt: new Date().toISOString(),
-    });
-
-    const samples = trajectory.listCorrectionSamples('pending');
-    expect(samples.length).toBe(1);
-
-    trajectory.reviewCorrectionSample(samples[0].sampleId, 'approved', 'Good');
-
-    const painEvents = trajectory.listPainEventsForSession('approved-session');
-    const correctionPain = painEvents.find(e => e.source === 'correction_rejected');
-    expect(correctionPain).toBeUndefined();
-  });
-});
-
-// ─────────────────────────────────────────────────────────
-// Phase 4b: Gate block + pain multi-signal test
-// ─────────────────────────────────────────────────────────
-describe('Phase 4b: Multi-signal session selection', () => {
-  let workspaceDir: string;
-  let trajectory: TrajectoryDatabase;
-
-  beforeEach(() => {
-    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-e2e-multisignal-'));
-    trajectory = new TrajectoryDatabase({ workspaceDir });
-  });
-
-  afterEach(() => {
-    trajectory?.dispose();
-    safeRmDir(workspaceDir);
-  });
-
-  it('session with more failures has higher violation density', () => {
-    // Create session A: just 1 failure
-    trajectory.recordSession({ sessionId: 'session-a-pain-only', startedAt: new Date().toISOString() });
-    const atIdA = trajectory.recordAssistantTurn({
-      sessionId: 'session-a-pain-only', runId: 'run-a', provider: 'local', model: 'main',
-      rawText: 'Code here', sanitizedText: 'Code here', usageJson: {}, empathySignalJson: {},
-      createdAt: new Date().toISOString(),
-    });
-    trajectory.recordUserTurn({
-      sessionId: 'session-a-pain-only', turnIndex: 1, rawText: '错了',
-      correctionDetected: true, correctionCue: '错了',
-      referencesAssistantTurnId: atIdA, createdAt: new Date().toISOString(),
-    });
-    trajectory.recordToolCall({
-      sessionId: 'session-a-pain-only', toolName: 'write', outcome: 'failure',
-      errorMessage: 'Write failed', errorType: 'Error', createdAt: new Date().toISOString(),
-    });
-
-    // Create session B: 2 failures
-    trajectory.recordSession({ sessionId: 'session-b-multi', startedAt: new Date().toISOString() });
-    const atIdB = trajectory.recordAssistantTurn({
-      sessionId: 'session-b-multi', runId: 'run-b', provider: 'local', model: 'main',
-      rawText: 'Code here', sanitizedText: 'Code here', usageJson: {}, empathySignalJson: {},
-      createdAt: new Date().toISOString(),
-    });
-    trajectory.recordUserTurn({
-      sessionId: 'session-b-multi', turnIndex: 1, rawText: '太复杂了',
-      correctionDetected: true, correctionCue: '太复杂了',
-      referencesAssistantTurnId: atIdB, createdAt: new Date().toISOString(),
-    });
-    trajectory.recordToolCall({
-      sessionId: 'session-b-multi', toolName: 'edit', outcome: 'failure',
-      errorMessage: 'Edit failed', errorType: 'Error', createdAt: new Date().toISOString(),
-    });
-    trajectory.recordToolCall({
-      sessionId: 'session-b-multi', toolName: 'write', outcome: 'failure',
-      errorMessage: 'Write failed too', errorType: 'Error', createdAt: new Date().toISOString(),
-    });
-
-    // Verify session B has more failure signals
-    const extractor = new NocturnalTrajectoryExtractor(trajectory);
-    const snapshotA = extractor.getNocturnalSessionSnapshot('session-a-pain-only');
-    const snapshotB = extractor.getNocturnalSessionSnapshot('session-b-multi');
-
-    expect(snapshotA).not.toBeNull();
-    expect(snapshotB).not.toBeNull();
-
-    // Session B should have more violation signals
-    const densityA = (snapshotA!.stats.failureCount ?? 0) + (snapshotA!.stats.totalPainEvents ?? 0) * 0.5;
-    const densityB = (snapshotB!.stats.failureCount ?? 0) + (snapshotB!.stats.totalPainEvents ?? 0) * 0.5;
-    expect(densityB).toBeGreaterThan(densityA);
-  });
-});
-
-// ─────────────────────────────────────────────────────────
-// Phase 4c: Boundary value test matrix
-// ─────────────────────────────────────────────────────────
-describe('Phase 4c: Boundary value tests', () => {
-  let workspaceDir: string;
-  let trajectory: TrajectoryDatabase;
-
-  beforeEach(() => {
-    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-e2e-boundary-'));
-    trajectory = new TrajectoryDatabase({ workspaceDir });
-  });
-
-  afterEach(() => {
-    trajectory?.dispose();
-    safeRmDir(workspaceDir);
-  });
-
-  it('session with correction cue is listed as candidate', () => {
-    trajectory.recordSession({ sessionId: 'single-pain', startedAt: new Date().toISOString() });
-    const atIdC = trajectory.recordAssistantTurn({
-      sessionId: 'single-pain', runId: 'run-c', provider: 'local', model: 'main',
-      rawText: 'Agent response', sanitizedText: 'Agent response', usageJson: {}, empathySignalJson: {},
-      createdAt: new Date().toISOString(),
-    });
-    trajectory.recordUserTurn({
-      sessionId: 'single-pain', turnIndex: 1, rawText: '错了',
-      correctionDetected: true, correctionCue: '错了',
-      referencesAssistantTurnId: atIdC, createdAt: new Date().toISOString(),
-    });
-
-    const extractor = new NocturnalTrajectoryExtractor(trajectory);
-    const candidates = extractor.listRecentNocturnalCandidateSessions({ limit: 10, minToolCalls: 0 });
-
-    const painCandidate = candidates.find(c => c.sessionId === 'single-pain');
-    expect(painCandidate).toBeDefined();
-  });
-
-  it('detectViolation returns violated for P_* principles with tool failure', () => {
-    trajectory.recordSession({ sessionId: 'violation-session', startedAt: new Date().toISOString() });
-    trajectory.recordAssistantTurn({
-      sessionId: 'violation-session', runId: 'run-d', provider: 'local', model: 'main',
-      rawText: 'Code', sanitizedText: 'Code', usageJson: {}, empathySignalJson: {},
-      createdAt: new Date().toISOString(),
-    });
-    trajectory.recordToolCall({
-      sessionId: 'violation-session', toolName: 'write', outcome: 'failure',
-      errorMessage: 'Failed', errorType: 'Error', createdAt: new Date().toISOString(),
-    });
-
-    const extractor = new NocturnalTrajectoryExtractor(trajectory);
-    const snapshot = extractor.getNocturnalSessionSnapshot('violation-session');
-    expect(snapshot).not.toBeNull();
-
-    // P_* principles should be violated with any failure
-    const violation = detectViolation('P_001', {
-      sessionId: 'violation-session',
-      toolCalls: snapshot!.toolCalls.map(tc => ({
-        toolName: tc.toolName, outcome: tc.outcome as 'success' | 'failure' | 'blocked',
-        errorMessage: tc.errorMessage ?? undefined,
-      })),
-      painSignals: snapshot!.painEvents.map(pe => ({
-        source: pe.source, score: pe.score, severity: pe.severity as 'mild' | 'moderate' | 'severe' | undefined,
-      })),
-      gateBlocks: [],
-      userCorrections: [],
-      planApprovals: [],
-    });
-
-    expect(violation.violated).toBe(true);
-  });
-});

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

@@ -1,357 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  validateExecutability,
-  validateForApproval,
-  type BoundedAction,
-} from '../../src/core/nocturnal-executability.js';
-
-describe('Nocturnal Executability', () => {
-
-  // -------------------------------------------------------------------------
-  // Tests: validateExecutability — valid bounded actions
-  // -------------------------------------------------------------------------
-
-  describe('validateExecutability — valid bounded actions', () => {
-    it('accepts "Read the file before editing"', () => {
-      const result = validateExecutability({
-        badDecision: 'Edited a file without reading it first',
-        betterDecision: 'Read the file before editing to understand its current structure',
-      });
-      expect(result.executable).toBe(true);
-      expect(result.boundedAction).toBeDefined();
-      expect(result.boundedAction?.verb.toLowerCase()).toBe('read');
-    });
-
-    it('accepts "Check the error message and verify preconditions"', () => {
-      const result = validateExecutability({
-        badDecision: 'Retried without checking error',
-        betterDecision: 'Check the error message and verify preconditions before retrying',
-      });
-      expect(result.executable).toBe(true);
-      expect(result.boundedAction?.verb.toLowerCase()).toBe('check');
-    });
-
-    it('accepts "Verify the current state of the repository"', () => {
-      const result = validateExecutability({
-        badDecision: 'Committed without checking status',
-        betterDecision: 'Verify the current state of the repository before committing',
-      });
-      expect(result.executable).toBe(true);
-      expect(result.boundedAction?.verb.toLowerCase()).toBe('verify');
-    });
-
-    it('accepts "Edit the config file to add the missing setting"', () => {
-      const result = validateExecutability({
-        badDecision: 'Changed settings without knowing current values',
-        betterDecision: 'Edit the config file to add the missing setting',
-      });
-      expect(result.executable).toBe(true);
-      expect(result.boundedAction?.verb.toLowerCase()).toBe('edit');
-    });
-
-    it('accepts "Search the codebase for similar patterns"', () => {
-      const result = validateExecutability({
-        badDecision: 'Wrote duplicate code',
-        betterDecision: 'Search the codebase for similar patterns before implementing new code',
-      });
-      expect(result.executable).toBe(true);
-      expect(result.boundedAction?.verb.toLowerCase()).toBe('search');
-    });
-
-    it('accepts "Look at the file to understand its structure"', () => {
-      const result = validateExecutability({
-        badDecision: 'Made changes without understanding the code',
-        betterDecision: 'Look at the file to understand its structure before modifying it',
-      });
-      expect(result.executable).toBe(true);
-      expect(result.boundedAction?.verb.toLowerCase()).toBe('look');
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Tests: validateExecutability — vague verbs
-  // -------------------------------------------------------------------------
-
-  describe('validateExecutability — vague verbs', () => {
-    const vagueVerbTests = [
-      { text: 'Understand the error before proceeding', expectedFail: true },
-      { text: 'Learn from the failure and adjust', expectedFail: true },
-      { text: 'Improve the error handling approach', expectedFail: true },
-      { text: 'Fix the issue by checking preconditions', expectedFail: true }, // "fix" is vague
-      { text: 'Handle errors more gracefully', expectedFail: true },
-      { text: 'Be more careful with edge cases', expectedFail: true },
-      { text: 'Ensure the code is correct', expectedFail: true },
-      { text: 'Consider reading the documentation', expectedFail: true },
-      { text: 'Think about the root cause', expectedFail: true },
-      { text: 'Reflect on the failure', expectedFail: true },
-      { text: 'Review the error carefully', expectedFail: true }, // borderline but rejected by our list
-    ];
-
-    vagueVerbTests.forEach(({ text, expectedFail }) => {
-      it(`"${text}" → ${expectedFail ? 'rejected' : 'accepted'}`, () => {
-        const result = validateExecutability({
-          badDecision: 'Made a mistake',
-          betterDecision: text,
-        });
-        if (expectedFail) {
-          expect(result.executable).toBe(false);
-          expect(result.failures.some(f => f.reason.includes('vague verb'))).toBe(true);
-        } else {
-          expect(result.executable).toBe(true);
-        }
-      });
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Tests: validateExecutability — hollow patterns
-  // -------------------------------------------------------------------------
-
-  describe('validateExecutability — hollow patterns', () => {
-    const hollowTests = [
-      { text: 'Always be careful when editing files', expectedFail: true },
-      { text: 'Be mindful of potential conflicts', expectedFail: true },
-      { text: "Don't rush into making changes", expectedFail: true },
-      { text: 'Take your time with complex tasks', expectedFail: true },
-      { text: 'Be patient and verify your work', expectedFail: true },
-      { text: 'Be more careful next time', expectedFail: true },
-      { text: 'Work smarter, not harder', expectedFail: true },
-      { text: 'Follow best practices for error handling', expectedFail: true },
-      { text: 'Read the documentation before proceeding', expectedFail: false }, // not hollow
-    ];
-
-    hollowTests.forEach(({ text, expectedFail }) => {
-      it(`"${text}" → ${expectedFail ? 'rejected (hollow)' : 'accepted'}`, () => {
-        const result = validateExecutability({
-          badDecision: 'Made an error',
-          betterDecision: text,
-        });
-        if (expectedFail) {
-          expect(result.executable).toBe(false);
-          expect(result.failures.some(f => f.reason.includes('hollow'))).toBe(true);
-        } else {
-          expect(result.executable).toBe(true);
-        }
-      });
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Tests: validateExecutability — too generic
-  // -------------------------------------------------------------------------
-
-  describe('validateExecutability — too generic', () => {
-    it('rejects text that is too short', () => {
-      const result = validateExecutability({
-        badDecision: 'Made a mistake',
-        betterDecision: 'Be better',
-      });
-      expect(result.executable).toBe(false);
-      expect(result.failures.some(f => f.reason.includes('too generic'))).toBe(true);
-    });
-
-    it('rejects purely negative constraints', () => {
-      const result = validateExecutability({
-        badDecision: 'Did not check the error',
-        betterDecision: 'Do not make the same mistake again',
-      });
-      expect(result.executable).toBe(false);
-      expect(result.failures.some(f => f.reason.includes('too generic'))).toBe(true);
-    });
-
-    it('accepts a concrete action with target', () => {
-      const result = validateExecutability({
-        badDecision: 'Edited without reading',
-        betterDecision: 'Read src/main.ts to understand the current structure before editing',
-      });
-      expect(result.executable).toBe(true);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Tests: validateExecutability — non-existent operations
-  // -------------------------------------------------------------------------
-
-  describe('validateExecutability — non-existent operations', () => {
-    it('rejects "rewrite the entire codebase"', () => {
-      const result = validateExecutability({
-        badDecision: 'Made changes poorly',
-        betterDecision: 'Rewrite the entire codebase to fix the architecture',
-      });
-      expect(result.executable).toBe(false);
-      expect(result.failures.some(f => f.reason.includes('too broad'))).toBe(true);
-    });
-
-    it('rejects "redesign the whole system"', () => {
-      const result = validateExecutability({
-        badDecision: 'System design was flawed',
-        betterDecision: 'Redesign the whole system from scratch',
-      });
-      expect(result.executable).toBe(false);
-      expect(result.failures.some(f => f.reason.includes('too broad'))).toBe(true);
-    });
-
-    it('rejects "restart from scratch"', () => {
-      const result = validateExecutability({
-        badDecision: 'Initial approach was wrong',
-        betterDecision: 'Restart from scratch with a new plan',
-      });
-      expect(result.executable).toBe(false);
-      expect(result.failures.some(f => f.reason.includes('too broad'))).toBe(true);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Tests: validateExecutability — badDecision hollow check
-  // -------------------------------------------------------------------------
-
-  describe('validateExecutability — badDecision checks', () => {
-    it('rejects hollow badDecision pattern', () => {
-      const result = validateExecutability({
-        badDecision: 'Always be careful and mindful of your actions',
-        betterDecision: 'Read the file before editing',
-      });
-      // The hollow check applies to badDecision too
-      expect(result.executable).toBe(false);
-      expect(result.failures.some(f => f.field === 'badDecision')).toBe(true);
-    });
-
-    it('accepts specific badDecision', () => {
-      const result = validateExecutability({
-        badDecision: 'Edited a file without reading it first, causing a merge conflict',
-        betterDecision: 'Read the file before editing to check for conflicts',
-      });
-      expect(result.executable).toBe(true);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Tests: validateForApproval — combined arbiter + executability
-  // -------------------------------------------------------------------------
-
-  describe('validateForApproval — combined check', () => {
-    function makeValidArtifact(overrides: Record<string, unknown> = {}): string {
-      return JSON.stringify({
-        artifactId: 'a1b2c3d4-e5f6-7890-abcd-ef1234567890',
-        sessionId: 'session-abc123',
-        principleId: 'T-08',
-        sourceSnapshotRef: 'snapshot-001',
-        badDecision: 'After bash command failed, immediately retried without diagnosing the root cause',
-        betterDecision: 'Check the error message and verify preconditions before retrying a failed bash command',
-        rationale: 'Treating each failure as a signal to diagnose rather than blindly retry prevents repeated failures and respects the cost of each action',
-        createdAt: '2026-03-27T12:00:00.000Z',
-        ...overrides,
-      });
-    }
-
-    it('approves a valid artifact that passes both arbiter and executability', () => {
-      const json = makeValidArtifact();
-      const result = validateForApproval(json);
-      expect(result.approved).toBe(true);
-      expect(result.artifact).toBeDefined();
-      expect(result.failures).toHaveLength(0);
-    });
-
-    it('rejects artifact with invalid JSON', () => {
-      const result = validateForApproval('not json');
-      expect(result.approved).toBe(false);
-      expect(result.failures.some(f => f.includes('parse'))).toBe(true);
-    });
-
-    it('rejects artifact with missing principleId', () => {
-      const json = makeValidArtifact({ principleId: undefined });
-      const result = validateForApproval(json);
-      expect(result.approved).toBe(false);
-    });
-
-    it('rejects artifact with cross-validation mismatch', () => {
-      const json = makeValidArtifact({ principleId: 'T-08' });
-      const result = validateForApproval(json, { expectedPrincipleId: 'T-01' });
-      expect(result.approved).toBe(false);
-      expect(result.failures.some(f => f.includes('mismatch'))).toBe(true);
-    });
-
-    it('rejects artifact with vague verb in betterDecision', () => {
-      const json = makeValidArtifact({ betterDecision: 'Understand the error first' });
-      const result = validateForApproval(json);
-      expect(result.approved).toBe(false);
-      expect(result.failures.some(f => f.includes('vague verb'))).toBe(true);
-    });
-
-    it('rejects artifact with hollow pattern in betterDecision', () => {
-      const json = makeValidArtifact({ betterDecision: 'Always be careful when proceeding' });
-      const result = validateForApproval(json);
-      expect(result.approved).toBe(false);
-      expect(result.failures.some(f => f.includes('hollow'))).toBe(true);
-    });
-
-    it('rejects artifact with invalid: true', () => {
-      const json = makeValidArtifact({ invalid: true, reason: 'no violation found' });
-      const result = validateForApproval(json);
-      expect(result.approved).toBe(false);
-    });
-
-    it('returns boundedAction in approved artifact', () => {
-      const json = makeValidArtifact();
-      const result = validateForApproval(json);
-      expect(result.approved).toBe(true);
-      expect(result.artifact?.boundedAction).toBeDefined();
-      expect(result.artifact?.boundedAction?.verb.toLowerCase()).toBe('check');
-    });
-
-    it('passes when cross-validation matches', () => {
-      const json = makeValidArtifact({ principleId: 'T-08', sessionId: 'session-xyz' });
-      const result = validateForApproval(json, {
-        expectedPrincipleId: 'T-08',
-        expectedSessionId: 'session-xyz',
-      });
-      expect(result.approved).toBe(true);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Tests: bounded action parsing
-  // -------------------------------------------------------------------------
-
-  describe('bounded action parsing', () => {
-    it('extracts verb and target from "Read the file"', () => {
-      const result = validateExecutability({
-        badDecision: 'Did not read',
-        betterDecision: 'Read the file before proceeding',
-      });
-      expect(result.executable).toBe(true);
-      expect(result.boundedAction?.verb.toLowerCase()).toBe('read');
-      // The boundedPattern captures (?:word\s+){0,4} after first word, so target = "file before proceeding"
-      expect(result.boundedAction?.target).toBe('file before proceeding');
-    });
-
-    it('extracts verb and target from "Check X first"', () => {
-      const result = validateExecutability({
-        badDecision: 'Did not check',
-        betterDecision: 'Check the error message first',
-      });
-      expect(result.executable).toBe(true);
-      expect(result.boundedAction?.verb.toLowerCase()).toBe('check');
-      // "Check the error message first" → verb="check", target="error message first"
-      expect(result.boundedAction?.target).toBe('error message first');
-    });
-
-    it('includes fullText in bounded action', () => {
-      const result = validateExecutability({
-        badDecision: 'Made a mistake',
-        betterDecision: 'Verify the preconditions before running the command',
-      });
-      expect(result.executable).toBe(true);
-      expect(result.boundedAction?.fullText.toLowerCase()).toContain('verify');
-    });
-
-    it('returns executable: false without boundedAction when all checks fail', () => {
-      const result = validateExecutability({
-        badDecision: 'Made a mistake',
-        betterDecision: 'Be better next time',
-      });
-      expect(result.executable).toBe(false);
-      expect(result.boundedAction).toBeUndefined();
-    });
-  });
-});