principles-disciple 1.11.0 → 1.13.0

package/tests/hooks/pain.test.ts

@@ -1,19 +1,28 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { handleAfterToolCall } from '../../src/hooks/pain';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { handleAfterToolCall } from '../../src/hooks/pain.js';
 import * as fs from 'fs';
 import * as path from 'path';
-import * as ioUtils from '../../src/utils/io';
-import { WorkspaceContext } from '../../src/core/workspace-context';
-import { EventLogService } from '../../src/core/event-log';
-import { setInjectedProbationIds, clearSession } from '../../src/core/session-tracker';
+import * as ioUtils from '../../src/utils/io.js';
+import { WorkspaceContext } from '../../src/core/workspace-context.js';
+import { EventLogService } from '../../src/core/event-log.js';
+import { setInjectedProbationIds, clearSession } from '../../src/core/session-tracker.js';
 
 vi.mock('fs');
 vi.mock('../../src/utils/io.js');
-vi.mock('../../src/core/workspace-context');
-vi.mock('../../src/core/event-log');
+vi.mock('../../src/core/evolution-engine.js', () => ({
+  recordEvolutionSuccess: vi.fn(),
+  recordEvolutionFailure: vi.fn(),
+}));
+vi.mock('../../src/core/evolution-logger.js', () => ({
+  createTraceId: vi.fn(() => 'trace-123'),
+  getEvolutionLogger: vi.fn(() => ({
+    logPainDetected: vi.fn(),
+  })),
+}));
 
 const mockEmitSync = vi.fn();
 const mockRecordProbationFeedback = vi.fn();
+const mockUpdatePrincipleValueMetrics = vi.fn();
 
 describe('Post-Write Checks & Pain Hook', () => {
   const workspaceDir = '/mock/workspace';
@@ -34,6 +43,9 @@ describe('Post-Write Checks & Pain Hook', () => {
       recordToolCall: vi.fn(),
       recordPainEvent: vi.fn(),
     },
+    principleTreeLedger: {
+      updatePrincipleValueMetrics: mockUpdatePrincipleValueMetrics,
+    },
     evolutionReducer: {
       emitSync: mockEmitSync,
       recordProbationFeedback: mockRecordProbationFeedback,
@@ -49,11 +61,16 @@ describe('Post-Write Checks & Pain Hook', () => {
     vi.clearAllMocks();
     mockEmitSync.mockReset();
     mockRecordProbationFeedback.mockReset();
-    vi.mocked(WorkspaceContext.fromHookContext).mockReturnValue(mockWctx as any);
-    vi.mocked(EventLogService.get).mockReturnValue(mockEventLog as any);
+    mockUpdatePrincipleValueMetrics.mockReset();
+    vi.spyOn(WorkspaceContext, 'fromHookContext').mockReturnValue(mockWctx as any);
+    vi.spyOn(EventLogService, 'get').mockReturnValue(mockEventLog as any);
     clearSession('s-success');
   });
 
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
   it('should ignore non-write tools', () => {
     const mockCtx = { workspaceDir, sessionId: 's1' };
     const mockEvent = { toolName: 'read', params: {}, result: { exitCode: 0 }, error: undefined };
@@ -138,4 +155,51 @@ describe('Post-Write Checks & Pain Hook', () => {
     }));
   });
 
+  it('should persist matched principle valueMetrics through the locked ledger owner without raw training-state writes', () => {
+    const mockCtx = { workspaceDir, sessionId: 's-metrics', api: { logger: {} } };
+    const mockEvent = {
+      toolName: 'write',
+      params: { file_path: 'src/main.ts' },
+      error: 'Delete failed for src/main.ts',
+      result: { exitCode: 1 },
+    };
+
+    vi.mocked(ioUtils.normalizePath).mockReturnValue('src/main.ts');
+    vi.mocked(ioUtils.isRisky).mockReturnValue(false);
+    vi.mocked(ioUtils.serializeKvLines).mockReturnValue('mocked-pain-flag-content');
+    vi.mocked(fs.existsSync).mockImplementation((filePath: fs.PathLike) => {
+      const normalizedPath = String(filePath).replace(/\\/g, '/');
+      return normalizedPath.includes('.principles/PROFILE.json');
+    });
+
+    mockWctx.evolutionReducer.getActivePrinciples = vi.fn().mockReturnValue([
+      {
+        id: 'p-match',
+        trigger: 'delete src main',
+        valueMetrics: undefined,
+      },
+    ]);
+    mockWctx.evolutionReducer.getPrincipleById = vi.fn().mockReturnValue({
+      id: 'p-match',
+      trigger: 'delete src main',
+      contextTags: ['write'],
+    });
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    expect(mockUpdatePrincipleValueMetrics).toHaveBeenCalledWith(
+      'p-match',
+      expect.objectContaining({
+        painPreventedCount: 1,
+      }),
+    );
+
+    const trainingStateWrites = vi
+      .mocked(fs.writeFileSync)
+      .mock.calls
+      .filter(([targetPath]) => String(targetPath).includes('principle_training_state.json'));
+
+    expect(trainingStateWrites).toEqual([]);
+  });
+
 });

package/tests/hooks/prompt.test.ts

@@ -5,9 +5,34 @@ import { WorkspaceContext } from '../../src/core/workspace-context';
 import fs from 'fs';
 import path from 'path';
 
+const promptHookMocks = vi.hoisted(() => ({
+  empathyManagerCtor: vi.fn(),
+  startWorkflow: vi.fn(),
+  isSubagentRuntimeAvailable: vi.fn(() => false),
+}));
+
 vi.mock('fs');
 vi.mock('../../src/core/session-tracker.js');
 vi.mock('../../src/core/workspace-context.js');
+vi.mock('../../src/service/subagent-workflow/index.js', () => {
+  class MockEmpathyObserverWorkflowManager {
+    constructor(...args: unknown[]) {
+      promptHookMocks.empathyManagerCtor(...args);
+    }
+
+    startWorkflow(...args: unknown[]) {
+      return promptHookMocks.startWorkflow(...args);
+    }
+  }
+
+  return {
+    EmpathyObserverWorkflowManager: MockEmpathyObserverWorkflowManager,
+    empathyObserverWorkflowSpec: { name: 'mock-empathy-workflow' },
+  };
+});
+vi.mock('../../src/utils/subagent-probe.js', () => ({
+  isSubagentRuntimeAvailable: promptHookMocks.isSubagentRuntimeAvailable,
+}));
 
 // 🎭️Test Group: Model Resolution Functions 🎭️
 describe('resolveModelFromConfig', () => {
@@ -184,6 +209,8 @@ describe('Prompt Context Injection Hook', () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
+    promptHookMocks.startWorkflow.mockResolvedValue(undefined);
+    promptHookMocks.isSubagentRuntimeAvailable.mockReturnValue(false);
     vi.mocked(sessionTracker.getSession).mockReturnValue(undefined);
     mockWctx.evolutionReducer.getActivePrinciples.mockReturnValue([]);
     mockWctx.evolutionReducer.getProbationPrinciples.mockReturnValue([]);
@@ -226,6 +253,42 @@ describe('Prompt Context Injection Hook', () => {
     expect(mockConfig.get).toHaveBeenCalledWith('empathy_engine.enabled');
   });
 
+  it('does not start empathy workflow when subagent runtime probe fails', async () => {
+    const randomSpy = vi.spyOn(Math, 'random').mockReturnValue(0.01);
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    mockConfig.get.mockReturnValue(undefined);
+    promptHookMocks.isSubagentRuntimeAvailable.mockReturnValue(false);
+
+    await handleBeforePromptBuild({
+      messages: [{ role: 'user', content: 'hello there' }],
+    } as any, {
+      workspaceDir,
+      trigger: 'user',
+      sessionId: 'session-empathy-probe',
+      api: {
+        logger: {
+          info: vi.fn(),
+          warn: vi.fn(),
+          error: vi.fn(),
+          debug: vi.fn(),
+        },
+        runtime: {
+          subagent: {
+            run: () => {
+              throw new Error('Plugin runtime subagent methods are only available during a gateway request');
+            },
+          },
+        },
+      },
+    } as any);
+
+    expect(promptHookMocks.isSubagentRuntimeAvailable).toHaveBeenCalled();
+    expect(promptHookMocks.empathyManagerCtor).not.toHaveBeenCalled();
+    expect(promptHookMocks.startWorkflow).not.toHaveBeenCalled();
+
+    randomSpy.mockRestore();
+  });
+
   it('records latest user turn and flags explicit corrections', async () => {
   vi.mocked(fs.existsSync).mockReturnValue(false);
 
@@ -1408,4 +1471,3 @@ describe('Prompt Context Injection Hook', () => {
     });
   });
 });
-

package/tests/integration/principle-lifecycle.e2e.test.ts

@@ -0,0 +1,197 @@
+/**
+ * End-to-End Test: Principle Lifecycle
+ *
+ * Tests the complete principle lifecycle from creation to evaluation:
+ * 1. createPrincipleFromDiagnosis() → training store write
+ * 2. listEvaluablePrinciples() → returns the principle
+ * 3. executeNocturnalReflectionAsync() → full pipeline (Selector → Trinity → Arbiter → Persist)
+ *
+ * This test addresses the root causes identified in 5-WHY analysis:
+ * - #204: EvolutionReducer must write to training store
+ * - #205: NocturnalWorkflowManager must use executeNocturnalReflectionAsync
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { EvolutionReducerImpl } from '../../src/core/evolution-reducer.js';
+import { listEvaluablePrinciples, loadStore } from '../../src/core/principle-training-state.js';
+import { updateTrainingStore } from '../../src/core/principle-tree-ledger.js';
+import { PathResolver } from '../../src/core/path-resolver.js';
+
+describe('Principle Lifecycle E2E', () => {
+  let tempDir: string;
+  let workspaceDir: string;
+  let stateDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-lifecycle-test-'));
+    workspaceDir = tempDir;
+    stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+
+    // Create required directories
+    const resolver = new PathResolver({ workspaceDir });
+    const memoryDir = path.dirname(resolver.resolve('EVOLUTION_STREAM'));
+    if (!fs.existsSync(memoryDir)) {
+      fs.mkdirSync(memoryDir, { recursive: true });
+    }
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('Training Store Integration (#204)', () => {
+    it('should set needs_training for auto-evaluable principles', () => {
+      // Arrange: Create EvolutionReducer with stateDir
+      const reducer = new EvolutionReducerImpl({ workspaceDir, stateDir });
+
+      // Act: Create a principle from diagnosis with complete detectorMetadata
+      const principleId = reducer.createPrincipleFromDiagnosis({
+        painId: 'pain-001',
+        painType: 'tool_failure',
+        triggerPattern: 'file not found',
+        action: 'check file existence before access',
+        source: 'test',
+        evaluability: 'weak_heuristic',
+        detectorMetadata: {
+          applicabilityTags: ['file-operations'],
+          positiveSignals: ['file-exists-check'],
+          negativeSignals: ['file-not-found-error'],
+          toolSequenceHints: [['fs.existsSync', 'fs.readFile']],
+          confidence: 'medium',
+        },
+      });
+
+      // Assert: Principle should exist in training store with needs_training status
+      expect(principleId).not.toBeNull();
+
+      const store = loadStore(stateDir);
+      expect(store[principleId!]).toBeDefined();
+      expect(store[principleId!].evaluability).toBe('weak_heuristic');
+      expect(store[principleId!].internalizationStatus).toBe('needs_training');
+    });
+
+    it('should set prompt_only for manual_only principles', () => {
+      // Arrange: Create EvolutionReducer with stateDir
+      const reducer = new EvolutionReducerImpl({ workspaceDir, stateDir });
+
+      // Act: Create a manual_only principle
+      const principleId = reducer.createPrincipleFromDiagnosis({
+        painId: 'pain-manual',
+        painType: 'user_frustration',
+        triggerPattern: 'user is confused',
+        action: 'ask clarifying question',
+        source: 'test',
+        evaluability: 'manual_only', // Cannot be auto-evaluated
+      });
+
+      // Assert: Principle should have prompt_only status
+      expect(principleId).not.toBeNull();
+
+      const store = loadStore(stateDir);
+      expect(store[principleId!]).toBeDefined();
+      expect(store[principleId!].evaluability).toBe('manual_only');
+      expect(store[principleId!].internalizationStatus).toBe('prompt_only');
+    });
+
+    it('should list auto-evaluable principles immediately after creation', () => {
+      // Arrange: Create reducer and auto-evaluable principle
+      const reducer = new EvolutionReducerImpl({ workspaceDir, stateDir });
+      const principleId = reducer.createPrincipleFromDiagnosis({
+        painId: 'pain-auto',
+        painType: 'tool_failure',
+        triggerPattern: 'timeout exceeded',
+        action: 'implement retry with backoff',
+        source: 'test',
+        evaluability: 'deterministic',
+        detectorMetadata: {
+          applicabilityTags: ['network-operations'],
+          positiveSignals: ['retry-success'],
+          negativeSignals: ['timeout-error'],
+          toolSequenceHints: [['fetch', 'retry']],
+          confidence: 'high',
+        },
+      });
+
+      // Assert: Principle should be immediately evaluable (no status upgrade needed)
+      const evaluablePrinciples = listEvaluablePrinciples(stateDir);
+      expect(evaluablePrinciples.length).toBeGreaterThan(0);
+      expect(evaluablePrinciples.some(p => p.principleId === principleId)).toBe(true);
+    });
+
+    it('should NOT list manual_only principles as evaluable', () => {
+      // Arrange: Create reducer and manual_only principle
+      const reducer = new EvolutionReducerImpl({ workspaceDir, stateDir });
+      reducer.createPrincipleFromDiagnosis({
+        painId: 'pain-003',
+        painType: 'user_frustration',
+        triggerPattern: 'user repeated same request',
+        action: 'ask clarifying question',
+        source: 'test',
+        evaluability: 'manual_only', // Should not be evaluable
+      });
+
+      // Act: List evaluable principles
+      const evaluablePrinciples = listEvaluablePrinciples(stateDir);
+
+      // Assert: No evaluable principles (manual_only is excluded)
+      expect(evaluablePrinciples).toHaveLength(0);
+    });
+  });
+
+  describe('State Consistency', () => {
+    it('should maintain consistency across evolution.jsonl, PRINCIPLES.md, and training store', () => {
+      // Arrange
+      const reducer = new EvolutionReducerImpl({ workspaceDir, stateDir });
+
+      // Act: Create multiple principles with complete detectorMetadata
+      const ids = [
+        reducer.createPrincipleFromDiagnosis({
+          painId: 'pain-a',
+          painType: 'tool_failure',
+          triggerPattern: 'pattern a',
+          action: 'action a',
+          source: 'test',
+          evaluability: 'deterministic',
+          detectorMetadata: {
+            applicabilityTags: ['test-a'],
+            positiveSignals: ['signal-a'],
+            negativeSignals: ['neg-a'],
+            toolSequenceHints: [['tool-a']],
+            confidence: 'high',
+          },
+        }),
+        reducer.createPrincipleFromDiagnosis({
+          painId: 'pain-b',
+          painType: 'subagent_error',
+          triggerPattern: 'pattern b',
+          action: 'action b',
+          source: 'test',
+          evaluability: 'weak_heuristic',
+          detectorMetadata: {
+            applicabilityTags: ['test-b'],
+            positiveSignals: ['signal-b'],
+            negativeSignals: ['neg-b'],
+            toolSequenceHints: [['tool-b']],
+            confidence: 'medium',
+          },
+        }),
+      ];
+
+      // Assert: All should be in training store with needs_training (auto-evaluable)
+      const store = loadStore(stateDir);
+      ids.forEach(id => {
+        expect(id).not.toBeNull();
+        expect(store[id!]).toBeDefined();
+        expect(store[id!].internalizationStatus).toBe('needs_training');
+      });
+
+      // Assert: Auto-evaluable principles are immediately available
+      const evaluablePrinciples = listEvaluablePrinciples(stateDir);
+      expect(evaluablePrinciples).toHaveLength(2);
+    });
+  });
+});

package/tests/integration/tool-hooks-workspace-dir.e2e.test.ts

@@ -0,0 +1,211 @@
+/**
+ * E2E tests for tool hooks workspaceDir resolution
+ * 
+ * Verifies that after_tool_call and before_tool_call hooks
+ * correctly resolve workspaceDir and write events to the correct location.
+ * 
+ * This test addresses the bug where PluginHookToolContext lacks workspaceDir,
+ * causing events to be written to ~/.state/ instead of workspace directory.
+ */
+
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+// Mock OpenClaw API for testing
+const createMockApi = (workspaceDir: string) => ({
+  runtime: {
+    agent: {
+      resolveAgentWorkspaceDir: vi.fn().mockReturnValue(workspaceDir),
+    },
+  },
+  config: {},
+  resolvePath: vi.fn().mockReturnValue(workspaceDir),
+  logger: {
+    warn: vi.fn(),
+    error: vi.fn(),
+    info: vi.fn(),
+    debug: vi.fn(),
+  },
+  pluginConfig: {},
+});
+
+describe('E2E: Tool Hooks workspaceDir Resolution', () => {
+  const testWorkspaceDir = path.join(os.tmpdir(), 'pd-tool-hooks-e2e-test');
+  const stateDir = path.join(testWorkspaceDir, '.state');
+  const logsDir = path.join(stateDir, 'logs');
+  const eventsFile = path.join(logsDir, 'events.jsonl');
+
+  beforeAll(() => {
+    // Create test workspace structure
+    fs.mkdirSync(logsDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    // Cleanup
+    if (fs.existsSync(testWorkspaceDir)) {
+      fs.rmSync(testWorkspaceDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('Scenario 1: ctx.workspaceDir is provided (future OpenClaw fix)', () => {
+    it('should use ctx.workspaceDir directly when valid', async () => {
+      const { validateWorkspaceDir } = await import('../../src/core/workspace-dir-validation.js');
+      
+      const ctx = { 
+        workspaceDir: testWorkspaceDir, 
+        agentId: 'test-agent' 
+      };
+      
+      const result = validateWorkspaceDir(ctx.workspaceDir);
+      expect(result).toBeNull(); // Valid
+    });
+  });
+
+  describe('Scenario 2: ctx.workspaceDir is undefined (current OpenClaw behavior)', () => {
+    it('should fallback to agentId resolution', async () => {
+      const { resolveValidWorkspaceDir } = await import('../../src/core/workspace-dir-validation.js');
+      
+      const mockApi = createMockApi(testWorkspaceDir);
+      const ctx = { 
+        workspaceDir: undefined, // OpenClaw doesn't provide this
+        agentId: 'test-agent' 
+      };
+      
+      const result = resolveValidWorkspaceDir(ctx, mockApi as any, { source: 'after_tool_call' });
+      
+      expect(result).toBe(testWorkspaceDir);
+      expect(mockApi.runtime.agent.resolveAgentWorkspaceDir).toHaveBeenCalledWith(mockApi.config, 'test-agent');
+    });
+
+    it('should fallback to resolvePath when agentId is also undefined', async () => {
+      const { resolveValidWorkspaceDir } = await import('../../src/core/workspace-dir-validation.js');
+      
+      const mockApi = createMockApi(testWorkspaceDir);
+      const ctx = { 
+        workspaceDir: undefined,
+        agentId: undefined 
+      };
+      
+      const result = resolveValidWorkspaceDir(ctx, mockApi as any, { source: 'after_tool_call' });
+      
+      expect(result).toBe(testWorkspaceDir);
+      expect(mockApi.resolvePath).toHaveBeenCalledWith('.');
+    });
+  });
+
+  describe('Scenario 3: Events are written to correct location', () => {
+    it('should create events.jsonl in workspace directory with correct content', () => {
+      // Simulate event being written
+      const testEvent = {
+        ts: new Date().toISOString(),
+        type: 'hook_execution',
+        category: 'success',
+        data: { hook: 'after_tool_call' },
+      };
+      
+      fs.appendFileSync(eventsFile, JSON.stringify(testEvent) + '\n', 'utf-8');
+      
+      // Verify file exists in workspace directory
+      expect(fs.existsSync(eventsFile)).toBe(true);
+      
+      // Verify content contains the expected hook
+      const content = fs.readFileSync(eventsFile, 'utf-8');
+      const lines = content.trim().split('\n');
+      const lastLine = JSON.parse(lines[lines.length - 1]);
+      expect(lastLine.data.hook).toBe('after_tool_call');
+      
+      // Verify the path is NOT directly under home directory
+      // (it should be under a workspace subdirectory)
+      const homeDir = os.homedir();
+      const normalizedPath = path.normalize(eventsFile);
+      // Events file should not be directly at ~/.state/logs/events.jsonl
+      const directHomeEventsFile = path.join(homeDir, '.state', 'logs', 'events.jsonl');
+      // If it happens to be the same path, that's a problem
+      if (normalizedPath === path.normalize(directHomeEventsFile)) {
+        throw new Error('Events file is being written to ~/.state/ instead of workspace directory!');
+      }
+    });
+  });
+
+  describe('Scenario 4: Warning is logged when workspaceDir resolution fails', () => {
+    it('should warn when falling back to resolvePath with invalid result', async () => {
+      const { resolveValidWorkspaceDir } = await import('../../src/core/workspace-dir-validation.js');
+      
+      const mockApi = createMockApi(os.homedir()); // resolvePath returns home dir
+      mockApi.runtime.agent.resolveAgentWorkspaceDir.mockReturnValue(os.homedir()); // agentId also returns home
+      
+      const warningMessages: string[] = [];
+      const onWarning = (msg: string) => warningMessages.push(msg);
+      
+      const ctx = { workspaceDir: undefined, agentId: 'test-agent' };
+      
+      const result = resolveValidWorkspaceDir(ctx, mockApi as any, { 
+        source: 'test',
+        onWarning,
+      });
+      
+      // Should have warnings about invalid paths
+      expect(warningMessages.length).toBeGreaterThan(0);
+      expect(warningMessages.some(m => m.includes('FINAL FALLBACK') || m.includes('invalid'))).toBe(true);
+    });
+  });
+});
+
+describe('E2E: EventLog flushImmediately', () => {
+  const testWorkspaceDir = path.join(os.tmpdir(), 'pd-eventlog-flush-test');
+  const stateDir = path.join(testWorkspaceDir, '.state');
+  const logsDir = path.join(stateDir, 'logs');
+  const eventsFile = path.join(logsDir, 'events.jsonl');
+
+  beforeAll(() => {
+    fs.mkdirSync(logsDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    if (fs.existsSync(testWorkspaceDir)) {
+      fs.rmSync(testWorkspaceDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should flush events immediately when flushImmediately is true', async () => {
+    const { EventLog } = await import('../../src/core/event-log.js');
+    
+    const eventLog = new EventLog(stateDir);
+    
+    // Write with flushImmediately
+    eventLog.recordHookExecution({ hook: 'after_tool_call' }, { flushImmediately: true });
+    
+    // File should exist immediately (not waiting for buffer or timer)
+    expect(fs.existsSync(eventsFile)).toBe(true);
+    
+    // Content should be there
+    const content = fs.readFileSync(eventsFile, 'utf-8');
+    expect(content).toContain('after_tool_call');
+    
+    eventLog.flush();
+  });
+
+  it('should not flush immediately when flushImmediately is false or omitted', async () => {
+    const { EventLog } = await import('../../src/core/event-log.js');
+    
+    // Clean up
+    if (fs.existsSync(eventsFile)) {
+      fs.unlinkSync(eventsFile);
+    }
+    
+    const eventLog = new EventLog(stateDir);
+    
+    // Write without flushImmediately
+    eventLog.recordHookExecution({ hook: 'before_tool_call' });
+    
+    // File might not exist yet (depends on buffer)
+    // But after manual flush, it should be there
+    eventLog.flush();
+    
+    expect(fs.existsSync(eventsFile)).toBe(true);
+    const content = fs.readFileSync(eventsFile, 'utf-8');
+    expect(content).toContain('before_tool_call');
+  });
+});