principles-disciple 1.126.0 → 1.128.0

package/tests/hooks/gate-rule-host-real-pipeline.test.ts

@@ -1,190 +0,0 @@
-/**
- * PRI-437 Slice 2: Valid decisions work through public before-tool-call hook
- *
- * PURPOSE: Verify that valid RuleHost decisions (block/allow) flow correctly
- * through the real handleBeforeToolCall public hook with real SQLite activations.
- *
- * This test exercises the FULL public path:
- *   real SQLite activation → real RuleHost.evaluate() → validateRuleHostResult()
- *   → real handleBeforeToolCall() → block/allow result
- *
- * No mocking of RuleHost, SQLite, or gate internals.
- *
- * ERR risk mitigation:
- *   - ERR-024: validator is wired into the production path (verified end-to-end)
- *   - ERR-048: activation write (SQLite) connects to read (RuleHost) connects to enforcement (gate)
- *   - ERR-002: valid decisions must NOT be silently degraded
- */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { SqliteConnection, SqliteActivationStateStore } from '@principles/core/runtime-v2';
-import { handleBeforeToolCall } from '../../src/hooks/gate.js';
-import type { PluginHookBeforeToolCallEvent, PluginHookToolContext } from '../../src/openclaw-sdk.js';
-import { WorkspaceContext } from '../../src/core/workspace-context.js';
-
-// ── Test helpers ───────────────────────────────────────────────────────────
-
-const RULE_ID = 'R_TEST_GATE_002';
-const ARTIFACT_ID = 'art-gate-002';
-const ACTIVATION_ID = `act_code_${RULE_ID}`;
-
-const BLOCK_CODE = `
-function evaluate(input, helpers) {
-  var p = input.action.normalizedPath || '';
-  if (p.indexOf('/etc/') === 0 || p === '/etc') {
-    return { decision: 'block', matched: true, reason: 'GATE_BLOCK_002: system directory' };
-  }
-  return { decision: 'allow', matched: false, reason: 'Not matched' };
-}
-var meta = { name: 'gate-test-rule', version: '1', ruleId: '${RULE_ID}', coversCondition: 'all' };
-`;
-
-let tempWorkspaceDir: string;
-let tempStateDir: string;
-let sqliteConn: SqliteConnection;
-
-function setupTempDirs(): void {
-  const baseTmp = os.tmpdir();
-  tempWorkspaceDir = fs.mkdtempSync(path.join(baseTmp, 'pd-gate-real-'));
-  tempStateDir = path.join(tempWorkspaceDir, '.principles');
-  fs.mkdirSync(tempStateDir, { recursive: true });
-}
-
-function insertRuleArtifact(): void {
-  const db = sqliteConn.getDb();
-  const now = new Date().toISOString();
-  const contentJson = JSON.stringify({
-    principleId: 'P_TEST_GATE_002',
-    ruleId: RULE_ID,
-    implementationCode: BLOCK_CODE,
-    goldenTrace: {
-      traceId: 'trace-gate-002',
-      cases: [],
-      createdAt: now,
-      version: 1,
-    },
-    ruleHostGateDecision: 'accepted_shadow',
-    affectedTools: ['write_file'],
-    painReasonSummary: 'Test: block /etc writes via gate',
-  });
-
-  db.prepare(`
-    INSERT INTO pi_artifacts (artifact_id, artifact_kind, source_task_id, source_principle_id, source_rule_id, lineage_artifact_ids, validation_status, content_json, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(
-    ARTIFACT_ID,
-    'rule',
-    'task-gate-002',
-    'P_TEST_GATE_002',
-    RULE_ID,
-    '[]',
-    'validated',
-    contentJson,
-    now,
-    now,
-  );
-}
-
-async function insertActivation(): Promise<void> {
-  const store = new SqliteActivationStateStore(sqliteConn);
-  const now = new Date().toISOString();
-  await store.recordActivation({
-    activationId: ACTIVATION_ID,
-    idempotencyKey: `${ARTIFACT_ID}::code_tool_hook`,
-    artifactId: ARTIFACT_ID,
-    channel: 'code_tool_hook',
-    action: 'code_tool_hook_shadow_activate',
-    targetRef: `impl://${RULE_ID}`,
-    activatedAt: now,
-    deactivatedAt: null,
-  });
-}
-
-// ── Setup / Teardown ───────────────────────────────────────────────────────
-
-beforeEach(() => {
-  setupTempDirs();
-  WorkspaceContext.clearCache();
-  sqliteConn = new SqliteConnection(tempWorkspaceDir);
-  sqliteConn.getDb();
-});
-
-afterEach(() => {
-  WorkspaceContext.clearCache();
-  try { sqliteConn?.close(); } catch { /* best-effort */ }
-  try { fs.rmSync(tempWorkspaceDir, { recursive: true, force: true }); } catch { /* Windows */ }
-});
-
-// ── Slice 2: Valid decisions through public hook ───────────────────────────
-
-describe('PRI-437 Slice 2: Valid decisions work through public before-tool-call hook', () => {
-  it('valid block decision from SQLite activation → handleBeforeToolCall returns block result', async () => {
-    // Setup: real SQLite activation with valid blocking code
-    insertRuleArtifact();
-    await insertActivation();
-
-    // Exercise the PUBLIC hook with a real event targeting /etc/passwd
-    const event: PluginHookBeforeToolCallEvent = {
-      toolName: 'write_file',
-      params: { file_path: '/etc/passwd', content: 'malicious' },
-    };
-
-    const ctx: PluginHookToolContext = {
-      workspaceDir: tempWorkspaceDir,
-      sessionId: 'test-session-gate-002',
-      logger: { warn: () => {}, error: () => {}, info: () => {} },
-    };
-
-    const result = handleBeforeToolCall(event, ctx);
-
-    // Verify: block decision is enforced through the public hook
-    expect(result).toBeDefined();
-    expect(result?.block).toBe(true);
-    expect(result?.blockReason).toContain('GATE_BLOCK_002: system directory');
-  });
-
-  it('valid allow (no match) from SQLite activation → handleBeforeToolCall returns undefined', async () => {
-    insertRuleArtifact();
-    await insertActivation();
-
-    // Exercise the PUBLIC hook with a safe path that does NOT match the block rule
-    const event: PluginHookBeforeToolCallEvent = {
-      toolName: 'write_file',
-      params: { file_path: '/safe/project/file.txt', content: 'safe content' },
-    };
-
-    const ctx: PluginHookToolContext = {
-      workspaceDir: tempWorkspaceDir,
-      sessionId: 'test-session-gate-002',
-      logger: { warn: () => {}, error: () => {}, info: () => {} },
-    };
-
-    const result = handleBeforeToolCall(event, ctx);
-
-    // Verify: no block (allow passes through)
-    expect(result).toBeUndefined();
-  });
-
-  it('no SQLite activation → handleBeforeToolCall returns undefined (no opinion)', async () => {
-    // Artifact exists but no activation
-    insertRuleArtifact();
-
-    const event: PluginHookBeforeToolCallEvent = {
-      toolName: 'write_file',
-      params: { file_path: '/etc/passwd', content: 'malicious' },
-    };
-
-    const ctx: PluginHookToolContext = {
-      workspaceDir: tempWorkspaceDir,
-      sessionId: 'test-session-gate-002',
-      logger: { warn: () => {}, error: () => {}, info: () => {} },
-    };
-
-    const result = handleBeforeToolCall(event, ctx);
-
-    // No activation → RuleHost returns undefined → gate allows
-    expect(result).toBeUndefined();
-  });
-});

package/tests/hooks/lifecycle.test.ts

@@ -1,248 +0,0 @@
-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/message-sanitize.test.ts

@@ -1,244 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  handleBeforeMessageWrite,
-  sanitizeAssistantText,
-  sanitizeForEvidence,
-  sanitizeToolParamsForEvidence,
-  sanitizeValueForEvidence,
-  MAX_EVIDENCE_VALUE_CHARS,
-} 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();
-  });
-
-  // ── sanitizeForEvidence ──
-
-  it('binds long string values to MAX_EVIDENCE_VALUE_CHARS', () => {
-    const segment = ' data ';
-    const long = segment.repeat(100);
-    const result = sanitizeForEvidence(long);
-    expect(result).toMatch(/___TRUNCATED___$/);
-    expect(result.length).toBeLessThanOrEqual(MAX_EVIDENCE_VALUE_CHARS + 20);
-  });
-
-  it('redacts OpenAI-style secret keys (sk-*)', () => {
-    const token = 'sk-proj-' + 'a'.repeat(30);
-    const result = sanitizeForEvidence(`token is ${token}`);
-    expect(result).toContain('___REDACTED___');
-    expect(result).not.toContain(token);
-  });
-
-  it('redacts JWT-like patterns (eyJ*)', () => {
-    const jwt = 'eyJ' + 'a'.repeat(30) + '.bc';
-    const result = sanitizeForEvidence(`Bearer ${jwt}`);
-    expect(result).toContain('___REDACTED___');
-    expect(result).not.toContain(jwt);
-  });
-
-  it('redacts long base64-like strings', () => {
-    const token = 'A'.repeat(50);
-    const result = sanitizeForEvidence(`hash: ${token}`);
-    expect(result).toContain('___REDACTED___');
-    expect(result).not.toContain(token);
-  });
-
-  it('redacts GitHub PATs (ghp_*)', () => {
-    const token = 'ghp_' + 'a'.repeat(40);
-    const result = sanitizeForEvidence(token);
-    expect(result).toContain('___REDACTED___');
-  });
-
-  it('strips internal PD tags from evidence', () => {
-    const result = sanitizeForEvidence('[EMOTIONAL_DAMAGE_DETECTED:severe] something went wrong');
-    expect(result).not.toContain('EMOTIONAL_DAMAGE_DETECTED');
-    expect(result).toContain('something went wrong');
-  });
-
-  it('returns safe string for non-string values', () => {
-    expect(sanitizeForEvidence(42)).toBe('42');
-    expect(sanitizeForEvidence(null)).toBe('');
-    expect(sanitizeForEvidence(undefined)).toBe('');
-  });
-
-  it('converges absolute paths to basename when no workspaceDir', () => {
-    const result = sanitizeForEvidence('/home/user/secrets/token.json');
-    expect(result).toBe('<path:token.json>');
-  });
-
-  it('converges absolute paths to repo-relative when workspaceDir matches', () => {
-    const result = sanitizeForEvidence('/workspace/my-repo/src/index.ts', '/workspace/my-repo');
-    expect(result).toBe('src/index.ts');
-  });
-
-  // ── Path substring sanitization ──
-
-  it('replaces Windows absolute path in command with basename', () => {
-    const result = sanitizeForEvidence('cd D:\\Code\\principles && git status');
-    expect(result).not.toContain('D:\\Code\\principles');
-    expect(result).toContain('principles');
-  });
-
-  it('replaces Windows absolute path in reason with basename', () => {
-    const result = sanitizeForEvidence('error in C:\\Users\\Administrator\\secret.txt');
-    expect(result).not.toContain('C:\\Users\\Administrator');
-    expect(result).not.toContain('Administrator');
-    expect(result).toContain('secret.txt');
-  });
-
-  it('replaces POSIX absolute path in string', () => {
-    const result = sanitizeForEvidence('failed to read /home/user/project/src/config.ts');
-    expect(result).not.toContain('/home/user/project');
-    expect(result).toContain('config.ts');
-  });
-
-  it('converges workspace-internal path in string to repo-relative', () => {
-    const result = sanitizeForEvidence(
-      'edit failed on D:\\Code\\principles\\src\\index.ts',
-      'D:\\Code\\principles',
-    );
-    expect(result).not.toContain('D:\\Code\\principles');
-    expect(result).toContain('src\\index.ts');
-  });
-
-  // ── sanitizeToolParamsForEvidence ──
-
-  it('redacts long content/text/input/new_string fields', () => {
-    const params = {
-      file_path: 'src/file.ts',
-      content: ' data chunk '.repeat(60),
-      text: ' report line '.repeat(60),
-    };
-    const result = sanitizeToolParamsForEvidence(params);
-    expect(result.file_path).toBe('src/file.ts');
-    expect(result.content).toMatch(/___TRUNCATED___$/);
-    expect(result.text).toMatch(/___TRUNCATED___$/);
-    expect(result.content.length).toBeLessThan(500);
-  });
-
-  it('keeps short normal fields intact', () => {
-    const params = { file_path: 'src/index.ts', content: 'short-content', query: 'SELECT * FROM users' };
-    const result = sanitizeToolParamsForEvidence(params);
-    expect(result.file_path).toBe('src/index.ts');
-    expect(result.content).toBe('short-content');
-    expect(result.query).toBe('SELECT * FROM users');
-  });
-
-  it('redacts token-like strings inside content/text fields', () => {
-    const token = 'sk-proj-' + 'a'.repeat(30);
-    const params = { content: `key is ${token}` };
-    const result = sanitizeToolParamsForEvidence(params);
-    expect(result.content).toContain('___REDACTED___');
-    expect(result.content).not.toContain(token);
-  });
-
-  // ── edit params: nested edits array ──
-
-  it('sanitizes edit params with nested edits[].oldText/newText', () => {
-    const secretToken = 'sk-proj-' + 'a'.repeat(30);
-    const params = {
-      file_path: '/repo/src/config.ts',
-      edits: [
-        { oldText: secretToken, newText: 'safe-value' },
-        { oldText: 'const x = 1;', newText: ' data '.repeat(200) },
-      ],
-    };
-    const result = sanitizeToolParamsForEvidence(params, '/repo') as Record<string, unknown>;
-    const edits = result.edits as Array<Record<string, unknown>>;
-    // Token in oldText redacted
-    expect(edits[0].oldText).toContain('___REDACTED___');
-    expect(edits[0].oldText).not.toContain(secretToken);
-    // Short value preserved
-    expect(edits[0].newText).toBe('safe-value');
-    // Long newText truncated
-    expect(edits[1].newText).toMatch(/___TRUNCATED___$/);
-    // file_path converged to relative (workspaceDir provided)
-    expect(result.file_path).toBe('src/config.ts');
-  });
-
-  // ── command/query: token redaction ──
-
-  it('redacts tokens in command and query fields', () => {
-    const jwt = 'eyJ' + 'a'.repeat(30) + '.bc';
-    const skToken = 'sk-proj-' + 'a'.repeat(30);
-    const params = {
-      command: `curl -H "Authorization: Bearer ${jwt}" https://api.example.com`,
-      query: `SELECT * FROM users WHERE api_key = "${skToken}"`,
-    };
-    const result = sanitizeToolParamsForEvidence(params);
-    expect(result.command).toContain('___REDACTED___');
-    expect(result.command).not.toContain(jwt);
-    expect(result.query).toContain('___REDACTED___');
-    expect(result.query).not.toContain(skToken);
-  });
-
-  // ── null/array/string input: no throw ──
-
-  it('handles null input without throwing', () => {
-    expect(() => sanitizeToolParamsForEvidence(null)).not.toThrow();
-    expect(sanitizeToolParamsForEvidence(null)).toEqual({});
-  });
-
-  it('handles array input without throwing', () => {
-    const result = sanitizeToolParamsForEvidence(['a', 'b', 'c']);
-    expect(result['<array-input>']).toBeDefined();
-  });
-
-  it('handles string input without throwing', () => {
-    const result = sanitizeToolParamsForEvidence('raw string input');
-    expect(result['<string-input>']).toBeDefined();
-  });
-
-  it('handles undefined input without throwing', () => {
-    expect(sanitizeToolParamsForEvidence(undefined)).toEqual({});
-  });
-
-  it('handles number input without throwing', () => {
-    expect(sanitizeToolParamsForEvidence(42)).toEqual({});
-  });
-
-  // ── sanitizeValueForEvidence: recursive ──
-
-  it('recursively sanitizes nested objects', () => {
-    const token = 'sk-proj-' + 'a'.repeat(30);
-    const input = { a: { b: { c: token } } };
-    const result = sanitizeValueForEvidence(input) as Record<string, unknown>;
-    const nested = (result.a as Record<string, unknown>).b as Record<string, unknown>;
-    expect(nested.c).toContain('___REDACTED___');
-  });
-
-  it('respects max array items limit', () => {
-    const input = { items: Array.from({ length: 100 }, (_, i) => `item-${i}`) };
-    const result = sanitizeValueForEvidence(input) as Record<string, unknown>;
-    const items = result.items as unknown[];
-    expect(items.length).toBeLessThanOrEqual(22);
-  });
-
-  it('respects max depth limit', () => {
-    const deep: any = { a: { b: { c: { d: { e: 'too deep' } } } } };
-    const result = sanitizeValueForEvidence(deep, 0) as Record<string, unknown>;
-    const a = result.a as Record<string, unknown>;
-    const b = a.b as Record<string, unknown>;
-    const c = b.c as Record<string, unknown>;
-    const d = c.d as Record<string, unknown>;
-    expect(d.e).toBe('<max-depth>');
-  });
-});