principles-disciple 1.8.1 → 1.8.2

package/tests/hooks/lifecycle.test.ts

@@ -0,0 +1,248 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { handleBeforeReset, handleBeforeCompaction, extractPainFromSessionFile } from '../../src/hooks/lifecycle';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { Readable } from 'stream';
+
+vi.mock('fs');
+
+describe('Lifecycle Hooks', () => {
+  const workspaceDir = '/mock/workspace';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('handleBeforeReset', () => {
+    it('should append summary to MEMORY.md if pain points exist', async () => {
+      const mockEvent = {
+        messages: [
+          { role: 'user', content: 'hello' },
+          { role: 'assistant', content: 'error: something went wrong' }
+        ],
+        reason: 'Manual reset'
+      };
+
+      await handleBeforeReset(mockEvent, { workspaceDir });
+
+      expect(fs.appendFileSync).toHaveBeenCalled();
+      const callArgs = vi.mocked(fs.appendFileSync).mock.calls[0];
+      expect(callArgs[0]).toContain('MEMORY.md');
+      expect(callArgs[1]).toContain('Session Reset Summary');
+      expect(callArgs[1]).toContain('1 potential pain point(s)');
+    });
+
+    it('should not write if no pain points are found', async () => {
+      const mockEvent = {
+        messages: [{ role: 'assistant', content: 'all good' }]
+      };
+      await handleBeforeReset(mockEvent, { workspaceDir });
+      expect(fs.appendFileSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('handleBeforeCompaction', () => {
+    it('should write checkpoint to CHECKPOINT.md', async () => {
+      const mockEvent = { messageCount: 50 };
+      await handleBeforeCompaction(mockEvent, { workspaceDir });
+      expect(fs.appendFileSync).toHaveBeenCalled();
+      const callArgs = vi.mocked(fs.appendFileSync).mock.calls[0];
+      expect(callArgs[0]).toContain(path.join('memory'));
+      expect(callArgs[1]).toContain('Pre-Compaction Checkpoint');
+    });
+  });
+
+  describe('extractPainFromSessionFile', () => {
+    const tempSessionFile = path.join(os.tmpdir(), 'test_session.jsonl');
+
+    beforeEach(() => {
+      // Create memory directories so our test can write to them without erroring
+      const dailyLogDir = path.join(workspaceDir, 'memory');
+      const painLogDir = path.join(dailyLogDir, 'pain');
+      fs.mkdirSync(painLogDir, { recursive: true });
+    });
+
+    afterEach(() => {
+      // Clean up the temp jsonl
+      if (fs.existsSync(tempSessionFile)) fs.unlinkSync(tempSessionFile);
+    });
+
+    it('should extract FATAL INTERCEPT from openclawAbort', async () => {
+      const loggerMock = { info: vi.fn(), debug: vi.fn(), warn: vi.fn(), error: vi.fn() };
+
+      const jsonlContent = [
+        JSON.stringify({ role: 'user', content: 'Do something' }),
+        JSON.stringify({
+          role: 'assistant',
+          content: 'I will modify the file directly',
+          openclawAbort: { aborted: true, origin: 'rpc', runId: 'test-run-123' }
+        })
+      ].join('\n') + '\n';
+
+      // Temporarily mock fs.existsSync true strictly for our file, and unmock createReadStream
+      vi.mocked(fs.existsSync).mockImplementation((p: any) => p === tempSessionFile || String(p).includes('memory'));
+      vi.spyOn(fs, 'createReadStream').mockImplementation((...args: any[]) => {
+        // We use actual fs for reading our temp file which we write actually unmocked below
+        return Readable.from([jsonlContent]) as any;
+      });
+
+      await extractPainFromSessionFile(tempSessionFile, { workspaceDir, logger: loggerMock });
+
+      expect(loggerMock.info).toHaveBeenCalledWith(expect.stringContaining('Detected hard-abort snapshot (runId: test-run-123)'));
+      expect(fs.appendFileSync).toHaveBeenCalled();
+
+      // Check that what was appended to MEMORY contains FATAL INTERCEPT
+      const calls = vi.mocked(fs.appendFileSync).mock.calls;
+      const memoryWrite = calls.find((call: any) => String(call[0]).endsWith('.md') && !String(call[0]).includes('confusion_samples'));
+      expect(memoryWrite).toBeDefined();
+      expect(memoryWrite![1]).toContain('[FATAL INTERCEPT]');
+      expect(memoryWrite![1]).toContain('I will modify the file directly');
+    });
+
+    it('should extract COGNITIVE OVERLOAD from oversized placeholder', async () => {
+      const loggerMock = { info: vi.fn(), debug: vi.fn(), warn: vi.fn(), error: vi.fn() };
+
+      const jsonlContent = [
+        JSON.stringify({
+          role: 'assistant',
+          content: 'Reading massive file',
+          __openclaw: { truncated: true, reason: 'oversized' }
+        })
+      ].join('\n') + '\n';
+
+      vi.mocked(fs.existsSync).mockImplementation((p: any) => p === tempSessionFile || String(p).includes('memory'));
+      vi.spyOn(fs, 'createReadStream').mockImplementation((...args: any[]) => {
+        return Readable.from([jsonlContent]) as any;
+      });
+
+      await extractPainFromSessionFile(tempSessionFile, { workspaceDir, logger: loggerMock });
+
+      expect(loggerMock.info).toHaveBeenCalledWith(expect.stringContaining('Detected oversized data truncation placeholder'));
+
+      const calls = vi.mocked(fs.appendFileSync).mock.calls;
+      const memoryWrite = calls.find((call: any) => String(call[0]).endsWith('.md') && !String(call[0]).includes('confusion_samples'));
+      expect(memoryWrite).toBeDefined();
+      expect(memoryWrite![1]).toContain('[COGNITIVE OVERLOAD]');
+    });
+
+    it('should fallback to semantic guessing for i am sorry', async () => {
+      const loggerMock = { info: vi.fn(), debug: vi.fn(), warn: vi.fn(), error: vi.fn() };
+
+      const jsonlContent = [
+        JSON.stringify({
+          role: 'assistant',
+          content: 'I\'m sorry, but I\'m still getting an error.'
+        })
+      ].join('\n') + '\n';
+
+      vi.mocked(fs.existsSync).mockImplementation((p: any) => p === tempSessionFile || String(p).includes('memory'));
+      vi.spyOn(fs, 'createReadStream').mockImplementation((...args: any[]) => {
+        return Readable.from([jsonlContent]) as any;
+      });
+
+      await extractPainFromSessionFile(tempSessionFile, { workspaceDir, logger: loggerMock });
+
+      expect(loggerMock.debug).toHaveBeenCalledWith(expect.stringContaining('Detected semantic confusion string'));
+
+      const calls = vi.mocked(fs.appendFileSync).mock.calls;
+      const memoryWrite = calls.find((call: any) => String(call[0]).endsWith('.md') && !String(call[0]).includes('confusion_samples'));
+      expect(memoryWrite).toBeDefined();
+      expect(memoryWrite![1]).toContain('I\'m sorry, but I\'m still getting');
+    });
+
+    it('should ignore openclawAbort when aborted is false', async () => {
+      const loggerMock = { info: vi.fn(), debug: vi.fn(), warn: vi.fn(), error: vi.fn() };
+      const jsonlContent = [
+        JSON.stringify({
+          role: 'assistant',
+          content: 'Normal message',
+          openclawAbort: { aborted: false, origin: 'rpc', runId: 'test-run-456' }
+        })
+      ].join('\n') + '\n';
+
+      vi.mocked(fs.existsSync).mockImplementation((p: any) => p === tempSessionFile || String(p).includes('memory'));
+      vi.spyOn(fs, 'createReadStream').mockImplementation((...args: any[]) => {
+        return Readable.from([jsonlContent]) as any;
+      });
+
+      await extractPainFromSessionFile(tempSessionFile, { workspaceDir, logger: loggerMock } as any);
+
+      const calls = vi.mocked(fs.appendFileSync).mock.calls;
+      const memoryWrite = calls.find((call: any) => String(call[0]).endsWith('.md') && !String(call[0]).includes('confusion_samples'));
+      expect(memoryWrite).toBeUndefined();
+    });
+
+    it('should ignore __openclaw when truncated is false or reason is not oversized', async () => {
+      const loggerMock = { info: vi.fn(), debug: vi.fn(), warn: vi.fn(), error: vi.fn() };
+      const jsonlContent = [
+        JSON.stringify({
+          role: 'assistant',
+          content: 'Normal message',
+          __openclaw: { truncated: false, reason: 'oversized' }
+        }),
+        JSON.stringify({
+          role: 'assistant',
+          content: 'Normal message 2',
+          __openclaw: { truncated: true, reason: 'other_reason' }
+        })
+      ].join('\n') + '\n';
+
+      vi.mocked(fs.existsSync).mockImplementation((p: any) => p === tempSessionFile || String(p).includes('memory'));
+      vi.spyOn(fs, 'createReadStream').mockImplementation((...args: any[]) => {
+        return Readable.from([jsonlContent]) as any;
+      });
+
+      await extractPainFromSessionFile(tempSessionFile, { workspaceDir, logger: loggerMock } as any);
+
+      const calls = vi.mocked(fs.appendFileSync).mock.calls;
+      const memoryWrite = calls.find((call: any) => String(call[0]).endsWith('.md') && !String(call[0]).includes('confusion_samples'));
+      expect(memoryWrite).toBeUndefined();
+    });
+
+    it('should return early if workspaceDir is not available', async () => {
+      const loggerMock = { info: vi.fn(), debug: vi.fn(), warn: vi.fn(), error: vi.fn() };
+      vi.spyOn(fs, 'createReadStream');
+
+      await extractPainFromSessionFile(tempSessionFile, { logger: loggerMock } as any);
+
+      expect(fs.createReadStream).not.toHaveBeenCalled();
+    });
+
+    it('should log debug and return early if sessionFile does not exist', async () => {
+      const loggerMock = { info: vi.fn(), debug: vi.fn(), warn: vi.fn(), error: vi.fn() };
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+      vi.spyOn(fs, 'createReadStream');
+
+      await extractPainFromSessionFile('fake_file.jsonl', { workspaceDir, logger: loggerMock } as any);
+
+      expect(loggerMock.debug).toHaveBeenCalledWith(expect.stringContaining('Session file not found: fake_file.jsonl'));
+      expect(fs.createReadStream).not.toHaveBeenCalled();
+    });
+
+    it('should handle corrupted jsonl lines gracefully without throwing', async () => {
+      const loggerMock = { info: vi.fn(), debug: vi.fn(), warn: vi.fn(), error: vi.fn() };
+      const jsonlContent = [
+        '{ invalid json ',
+        JSON.stringify({ role: 'user', content: 'Normal' }),
+        'also invalid json'
+      ].join('\n') + '\n';
+
+      vi.mocked(fs.existsSync).mockImplementation((p: any) => p === tempSessionFile || String(p).includes('memory'));
+      vi.spyOn(fs, 'createReadStream').mockImplementation((...args: any[]) => {
+        return Readable.from([jsonlContent]) as any;
+      });
+
+      // Execute without throwing
+      await extractPainFromSessionFile(tempSessionFile, { workspaceDir, logger: loggerMock } as any);
+
+      const calls = vi.mocked(fs.appendFileSync).mock.calls;
+      const memoryWrite = calls.find((call: any) => String(call[0]).endsWith('.md') && !String(call[0]).includes('confusion_samples'));
+      expect(memoryWrite).toBeUndefined();
+    });
+  });
+});

package/tests/hooks/llm.test.ts

@@ -0,0 +1,308 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { handleLlmOutput, extractEmpathySignal, isEmpathyAuditPayload } from '../../src/hooks/llm';
+import * as painFlags from '../../src/core/pain';
+import * as sessionTracker from '../../src/core/session-tracker';
+import { ControlUiDatabase } from '../../src/core/control-ui-db';
+import { DetectionService } from '../../src/core/detection-service';
+import { WorkspaceContext } from '../../src/core/workspace-context';
+import fs from 'fs';
+import path from 'path';
+
+vi.mock('fs');
+vi.mock('../../src/core/pain', () => ({
+    writePainFlag: vi.fn(),
+}));
+vi.mock('../../src/core/control-ui-db');
+vi.mock('../../src/core/detection-service');
+vi.mock('../../src/core/workspace-context');
+
+describe('LLM Cognitive Distress Hook', () => {
+    const workspaceDir = '/mock/workspace';
+    const sessionId = 'test-session-auth';
+
+    const mockConfig = {
+        get: vi.fn((key) => {
+            if (key === 'thresholds.stuck_loops_trigger') return 3;
+            if (key === 'thresholds.cognitive_paralysis_input') return 4000;
+            if (key === 'scores.paralysis') return 40;
+            if (key === 'thresholds.pain_trigger') return 30;
+            if (key === 'scores.default_confusion') return 35;
+            if (key === 'empathy_engine.enabled') return true;
+            if (key === 'empathy_engine.dedupe_window_ms') return 60000;
+            if (key === 'empathy_engine.penalties.mild') return 10;
+            if (key === 'empathy_engine.penalties.moderate') return 25;
+            if (key === 'empathy_engine.penalties.severe') return 40;
+            if (key === 'empathy_engine.rate_limit.max_per_turn') return 40;
+            if (key === 'empathy_engine.rate_limit.max_per_hour') return 120;
+            if (key === 'empathy_engine.model_calibration') return { 'test/test': 0.5 };
+            return undefined;
+        })
+    };
+
+    const mockEventLog = {
+        recordRuleMatch: vi.fn(),
+        recordPainSignal: vi.fn(),
+    };
+    const mockControlUiDb = {
+        getRecentThinkingContext: vi.fn().mockReturnValue({
+            toolCalls: [{ toolName: 'edit', outcome: 'failure', errorType: 'EACCES' }],
+            painEvents: [{ source: 'user_empathy', score: 13 }],
+            gateBlocks: [],
+            userCorrections: [],
+            principleEvents: [],
+        }),
+        recordThinkingModelEvent: vi.fn(),
+        dispose: vi.fn(),
+    };
+
+    const mockWctx = {
+        workspaceDir,
+        stateDir: '/mock/workspace/.state',
+        config: mockConfig,
+        eventLog: mockEventLog,
+        trajectory: {
+            recordAssistantTurn: vi.fn().mockReturnValue(101),
+            recordPainEvent: vi.fn(),
+        },
+        resolve: vi.fn().mockImplementation((key) => {
+            if (key === 'THINKING_OS_USAGE') return path.join(workspaceDir, '.state', 'thinking_os_usage.json');
+            return '';
+        }),
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        sessionTracker.clearSession(sessionId);
+        vi.mocked(WorkspaceContext.fromHookContext).mockReturnValue(mockWctx as any);
+        vi.mocked(ControlUiDatabase).mockImplementation(function MockControlUiDatabase() {
+            return mockControlUiDb as any;
+        } as any);
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    it('should detect confusion patterns via detection funnel (L1)', () => {
+        const mockFunnel = {
+            detect: vi.fn().mockReturnValue({
+                detected: true,
+                severity: 35,
+                ruleId: 'P_CONFUSION_EN',
+                source: 'l1_exact'
+            })
+        };
+        vi.mocked(DetectionService.get).mockReturnValue(mockFunnel as any);
+
+        const mockEvent = {
+            runId: 'r1',
+            sessionId,
+            provider: 'test',
+            assistantTexts: ['I am currently struggling to figure out why this test is failing.'],
+        };
+
+        handleLlmOutput(mockEvent as any, { workspaceDir, sessionId } as any);
+
+        expect(painFlags.writePainFlag).toHaveBeenCalledWith(
+            workspaceDir,
+            expect.objectContaining({
+                source: 'llm_p_confusion_en',
+                score: '35',
+                reason: expect.stringContaining('P_CONFUSION_EN')
+            })
+        );
+    });
+
+    it('should track Thinking OS mental model usage when signal is detected', () => {
+        const mockFunnel = {
+            detect: vi.fn().mockReturnValue({ detected: false, source: 'l3_async_queued' })
+        };
+        vi.mocked(DetectionService.get).mockReturnValue(mockFunnel as any);
+
+        const mockEvent = {
+            runId: 'r1',
+            sessionId,
+            provider: 'test',
+            model: 'test',
+            assistantTexts: ["According to Occam's Razor, the simplest approach is best."],
+        };
+
+        const usageLogPath = path.join(workspaceDir, '.state', 'thinking_os_usage.json');
+
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+        const mockWrite = vi.fn();
+        vi.mocked(fs.writeFileSync).mockImplementation(mockWrite);
+
+        handleLlmOutput(mockEvent as any, { workspaceDir, sessionId } as any);
+
+        expect(mockWrite).toHaveBeenCalledWith(
+            usageLogPath,
+            expect.stringContaining('"T-06": 1'),
+            'utf8'
+        );
+        expect(mockControlUiDb.recordThinkingModelEvent).toHaveBeenCalledWith(
+            expect.objectContaining({
+                modelId: 'T-06',
+                assistantTurnId: expect.any(Number),
+            })
+        );
+    });
+
+    it('should parse structured empathy signal', () => {
+        const result = extractEmpathySignal('<empathy signal="damage" severity="severe" confidence="0.75" reason="ignored constraints"/>');
+        expect(result).toEqual(expect.objectContaining({
+            detected: true,
+            severity: 'severe',
+            confidence: 0.75,
+            mode: 'structured'
+        }));
+    });
+
+
+    it('should reject legacy empathy tag when embedded in regular assistant text', () => {
+        const result = extractEmpathySignal('User asked me to print [EMOTIONAL_DAMAGE_DETECTED:severe], so I echoed it.');
+        expect(result).toEqual(expect.objectContaining({
+            detected: false
+        }));
+    });
+
+    it('should NOT produce user_empathy from empathy JSON in main model output (Path 1 disabled)', () => {
+        vi.spyOn(sessionTracker, 'trackFriction').mockImplementation(() => ({ currentGfi: 0 } as any));
+        const mockFunnel = { detect: vi.fn().mockReturnValue({ detected: false, source: 'l3_async_queued' }) };
+        vi.mocked(DetectionService.get).mockReturnValue(mockFunnel as any);
+
+        const mockEvent = {
+            runId: 'r1',
+            sessionId,
+            provider: 'test',
+            model: 'test',
+            assistantTexts: ['[EMOTIONAL_DAMAGE_DETECTED:moderate]'],
+        };
+
+        handleLlmOutput(mockEvent as any, { workspaceDir, sessionId } as any);
+
+        expect(sessionTracker.trackFriction).not.toHaveBeenCalledWith(
+            sessionId,
+            expect.anything(),
+            expect.stringContaining('user_empathy'),
+            expect.anything(),
+            expect.anything()
+        );
+    });
+
+    it('should NOT produce user_empathy from structured empathy tag in main model output', () => {
+        vi.spyOn(sessionTracker, 'trackFriction').mockImplementation(() => ({ currentGfi: 0 } as any));
+        const mockFunnel = { detect: vi.fn().mockReturnValue({ detected: false, source: 'l3_async_queued' }) };
+        vi.mocked(DetectionService.get).mockReturnValue(mockFunnel as any);
+
+        const event = {
+            runId: 'same-run',
+            sessionId,
+            provider: 'test',
+            model: 'test',
+            assistantTexts: ['<empathy signal="damage" severity="severe" confidence="1" reason="reason-a"/>'],
+        };
+
+        handleLlmOutput(event as any, { workspaceDir, sessionId } as any);
+
+        expect(sessionTracker.trackFriction).not.toHaveBeenCalledWith(
+            sessionId,
+            expect.anything(),
+            expect.stringContaining('user_empathy'),
+            expect.anything(),
+            expect.anything()
+        );
+    });
+
+    it('should filter empathy audit payloads before detection to prevent rule_match pollution', () => {
+        const mockFunnel = {
+            detect: vi.fn().mockReturnValue({ detected: false, source: 'l3_async_queued' })
+        };
+        vi.mocked(DetectionService.get).mockReturnValue(mockFunnel as any);
+
+        const mockEvent = {
+            runId: 'r1',
+            sessionId,
+            provider: 'test',
+            assistantTexts: ['{"damageDetected": true, "severity": "moderate", "confidence": 0.8, "reason": "frustration"}'],
+        };
+
+        handleLlmOutput(mockEvent as any, { workspaceDir, sessionId } as any);
+
+        expect(mockFunnel.detect).toHaveBeenCalledWith('');
+    });
+
+    it('should continue pain processing when trajectory persistence fails', () => {
+        const mockFunnel = {
+            detect: vi.fn().mockReturnValue({
+                detected: true,
+                severity: 35,
+                ruleId: 'P_CONFUSION_EN',
+                source: 'l1_exact'
+            })
+        };
+        vi.mocked(DetectionService.get).mockReturnValue(mockFunnel as any);
+        mockWctx.trajectory.recordAssistantTurn.mockImplementation(() => {
+            throw new Error('db offline');
+        });
+
+        const logger = {
+            warn: vi.fn(),
+            info: vi.fn(),
+            error: vi.fn(),
+            debug: vi.fn(),
+        };
+
+        handleLlmOutput({
+            runId: 'r-fail',
+            sessionId,
+            provider: 'test',
+            model: 'test',
+            assistantTexts: ['I am currently struggling to figure out why this test is failing.'],
+        } as any, { workspaceDir, sessionId, logger } as any);
+
+        expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('Failed to persist assistant turn'));
+        expect(painFlags.writePainFlag).toHaveBeenCalledWith(
+            workspaceDir,
+            expect.objectContaining({
+                source: 'llm_p_confusion_en',
+                score: '35',
+            })
+        );
+        expect(mockEventLog.recordPainSignal).toHaveBeenCalledWith(
+            sessionId,
+            expect.objectContaining({
+                source: 'llm_p_confusion_en',
+                score: 35,
+            })
+        );
+    });
+
+    it('should rollback only the empathy slice when rollback tag is emitted', () => {
+        vi.spyOn(sessionTracker, 'resetFriction').mockImplementation(() => ({ currentGfi: 10 } as any));
+        const mockFunnel = { detect: vi.fn().mockReturnValue({ detected: false, source: 'l3_async_queued' }) };
+        vi.mocked(DetectionService.get).mockReturnValue(mockFunnel as any);
+        (mockEventLog as any).getLastEmpathyEventId = vi.fn().mockReturnValue('emp_rollback_1');
+        (mockEventLog as any).rollbackEmpathyEvent = vi.fn().mockReturnValue(13);
+
+        handleLlmOutput({
+            runId: 'r-rollback',
+            sessionId,
+            provider: 'test',
+            model: 'test',
+            assistantTexts: ['[EMPATHY_ROLLBACK_REQUEST]'],
+        } as any, { workspaceDir, sessionId } as any);
+
+        expect(mockEventLog.getLastEmpathyEventId).toHaveBeenCalledWith(sessionId);
+        expect(mockEventLog.rollbackEmpathyEvent).toHaveBeenCalledWith(
+            'emp_rollback_1',
+            sessionId,
+            'Natural language rollback request detected',
+            'natural_language'
+        );
+        expect(sessionTracker.resetFriction).toHaveBeenCalledWith(sessionId, workspaceDir, {
+            source: 'user_empathy',
+            amount: 13,
+        });
+    });
+});

package/tests/hooks/message-sanitize.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { handleBeforeMessageWrite, sanitizeAssistantText } from '../../src/hooks/message-sanitize';
+
+describe('message-sanitize hook', () => {
+  it('removes empathy control tags from assistant text', () => {
+    const text = '抱歉 [EMOTIONAL_DAMAGE_DETECTED:moderate]\n<empathy signal="damage" severity="moderate"/>\n继续处理';
+    expect(sanitizeAssistantText(text)).toBe('抱歉\n\n继续处理');
+  });
+
+  it('returns modified message for assistant role', () => {
+    const result = handleBeforeMessageWrite({
+      message: {
+        role: 'assistant',
+        content: 'hello [EMOTIONAL_DAMAGE_DETECTED] world'
+      }
+    } as any);
+
+    expect(result).toEqual({
+      message: {
+        role: 'assistant',
+        content: 'hello  world'
+      }
+    });
+  });
+
+  it('ignores non-assistant messages', () => {
+    const result = handleBeforeMessageWrite({
+      message: {
+        role: 'user',
+        content: '[EMOTIONAL_DAMAGE_DETECTED]'
+      }
+    } as any);
+
+    expect(result).toBeUndefined();
+  });
+});