principles-disciple 1.98.0 → 1.100.0

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.98.0",
+  "version": "1.100.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.98.0",
+  "version": "1.100.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",

package/src/hooks/trajectory-collector.ts

@@ -1,16 +1,14 @@
 /**
- * Trajectory Collector - 行为进化引擎 Phase 0 数据收集
- * 
- * 收集工具调用和 LLM 输出到 memory/trajectories/ 目录
- * 用于分析工具使用模式、识别原则应用案例、评估行为质量
+ * Trajectory Collector - message write trajectory recording
+ *
+ * Records message data to memory/trajectories/ JSONL files.
+ * PRI-347 removed tool_call and llm_output JSONL writers (no consumers).
+ * PRI-346 will repurpose handleBeforeMessageWrite for SQLite collection.
  */
 
 import * as fs from 'fs';
 import * as path from 'path';
 import type {
-  PluginHookAfterToolCallEvent,
-  PluginHookToolContext,
-  PluginHookLlmOutputEvent,
   PluginHookAgentContext,
   PluginHookBeforeMessageWriteEvent
 } from '../openclaw-sdk.js';
@@ -21,19 +19,16 @@ const TRAJECTORY_DIR = 'memory/trajectories/';
 // 敏感字段匹配正则
 const SENSITIVE_KEY_PATTERN = /password|token|authorization|secret|api[_-]?key|credential|cookie|session/i;
 
-// 最大结果长度（不同于 MAX_STRING_LENGTH）
-const MAX_RESULT_LENGTH = 500;
-
 /**
  * 递归脱敏处理：遍历对象/数组，移除敏感字段值
  */
 function scrubSensitive(obj: unknown, depth = 0): unknown {
   // 防止无限递归
   if (depth > 10) return '[MAX_DEPTH]';
-  
+
   // 处理 null/undefined
   if (obj == null) return obj;
-  
+
   // 处理基本类型
   if (typeof obj !== 'object') {
     if (typeof obj === 'string' && obj.length > MAX_STRING_LENGTH) {
@@ -41,12 +36,12 @@ function scrubSensitive(obj: unknown, depth = 0): unknown {
     }
     return obj;
   }
-  
+
   // 处理数组
   if (Array.isArray(obj)) {
     return obj.map(item => scrubSensitive(item, depth + 1));
   }
-  
+
   // 处理对象
   const result: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
@@ -65,20 +60,20 @@ function scrubSensitive(obj: unknown, depth = 0): unknown {
 class AsyncWriteQueue {
   private readonly queue: (() => Promise<void>)[] = [];
   private processing = false;
-  
+
   async enqueue(task: () => Promise<void>): Promise<void> {
     this.queue.push(task);
     if (!this.processing) {
       this.processNext();
     }
   }
-  
+
   private async processNext(): Promise<void> {
     if (this.queue.length === 0) {
       this.processing = false;
       return;
     }
-    
+
     this.processing = true;
     const task = this.queue.shift();
 
@@ -92,7 +87,7 @@ class AsyncWriteQueue {
     } catch {
       // Silently fail - trajectory collection should not block main functionality
     }
-    
+
     // 处理下一个任务
     this.processNext();
   }
@@ -109,11 +104,11 @@ const dirCache = new Map<string, boolean>();
  */
 async function ensureTrajectoryDirAsync(workspaceDir: string): Promise<string> {
   const dir = path.join(workspaceDir, TRAJECTORY_DIR);
-  
+
   if (dirCache.get(dir)) {
     return dir;
   }
-  
+
   try {
     await fs.promises.mkdir(dir, { recursive: true });
     dirCache.set(dir, true);
@@ -121,7 +116,7 @@ async function ensureTrajectoryDirAsync(workspaceDir: string): Promise<string> {
     // 目录可能已存在，忽略错误
     dirCache.set(dir, true);
   }
-  
+
   return dir;
 }
 
@@ -140,7 +135,7 @@ function getTodayFilename(): string {
  */
 function writeTrajectoryRecord(workspaceDir: string, record: object): void {
   const line = JSON.stringify(record) + '\n';
-  
+
   writeQueue.enqueue(async () => {
     const dir = await ensureTrajectoryDirAsync(workspaceDir);
     const filepath = path.join(dir, getTodayFilename());
@@ -148,71 +143,12 @@ function writeTrajectoryRecord(workspaceDir: string, record: object): void {
   });
 }
 
-/**
- * 工具调用完成后的处理
- * 记录：工具名、参数、结果、错误、执行时间
- */
-export function handleAfterToolCall(
-  event: PluginHookAfterToolCallEvent,
-  ctx: PluginHookToolContext & { workspaceDir?: string }
-): void {
-  const {workspaceDir} = ctx;
-  if (!workspaceDir) return;
-
-  // 递归脱敏处理所有字段
-  const sanitizedParams = scrubSensitive(event.params);
-  const sanitizedResult = event.result == null 
-    ? null 
-    : String(scrubSensitive(event.result)).slice(0, MAX_RESULT_LENGTH);
-  const sanitizedError = event.error == null 
-    ? null 
-    : String(scrubSensitive(event.error));
-
-  writeTrajectoryRecord(workspaceDir, {
-    type: 'tool_call',
-    timestamp: new Date().toISOString(),
-    sessionId: ctx.sessionId || 'unknown',
-    toolName: event.toolName,
-    params: sanitizedParams,
-    result: sanitizedResult,
-    error: sanitizedError,
-    durationMs: event.durationMs,
-    success: !event.error,
-    runId: event.runId || null,
-    toolCallId: event.toolCallId || null
-  });
-}
-
-/**
- * LLM 输出处理
- * 记录：provider、model、输出长度、token 使用量
- */
-export function handleLlmOutput(
-  event: PluginHookLlmOutputEvent,
-  ctx: PluginHookAgentContext & { workspaceDir?: string }
-): void {
-  const {workspaceDir} = ctx;
-  if (!workspaceDir) return;
-
-  const totalTextLength = event.assistantTexts?.reduce((sum, text) => sum + (text?.length || 0), 0) || 0;
-
-  writeTrajectoryRecord(workspaceDir, {
-    type: 'llm_output',
-    timestamp: new Date().toISOString(),
-    sessionId: ctx.sessionId || 'unknown',
-    provider: event.provider,
-    model: event.model,
-    textLength: totalTextLength,
-    outputCount: event.assistantTexts?.length || 0,
-    usage: event.usage ? scrubSensitive(event.usage) : null
-  });
-}
-
 /**
  * 消息写入前的处理
  * 记录：用户/助手消息内容
+ *
+ * PRI-346 will repurpose this to write to SQLite instead of JSONL.
  */
-     
 export function handleBeforeMessageWrite(
   event: PluginHookBeforeMessageWriteEvent,
   ctx: PluginHookAgentContext & { workspaceDir?: string }
@@ -229,9 +165,6 @@ export function handleBeforeMessageWrite(
   // 提取文本内容
   let content = '';
   if (typeof msg.content === 'string') {
-     
-    // Reason: msg.content is string | ContentPart[]; destructuring would require renaming in the else branch
-     
     content = msg.content;
   } else if (Array.isArray(msg.content)) {
     content = msg.content
@@ -253,43 +186,3 @@ export function handleBeforeMessageWrite(
     agentId: event.agentId || null
   });
 }
-
-/**
- * 脱敏处理：移除敏感参数（保留旧函数签名以兼容）
- * @deprecated 使用 scrubSensitive 替代
- */
-/**
- * 轨迹汇总统计（供 cron 任务调用）
- */
-export function computeTrajectoryStats(workspaceDir: string): object {
-  const dir = path.join(workspaceDir, TRAJECTORY_DIR);
-  const todayFile = path.join(dir, getTodayFilename());
-  
-  if (!fs.existsSync(todayFile)) {
-    return { date: getTodayFilename(), totalRecords: 0, toolCalls: 0, llmOutputs: 0, messages: 0 };
-  }
-
-  const content = fs.readFileSync(todayFile, 'utf8');
-  const lines = content.split('\n').filter(line => line.trim());
-  
-  const toolCalls = lines.filter(line => {
-    try { return JSON.parse(line).type === 'tool_call'; } catch { return false; }
-  }).length;
-  
-  const llmOutputs = lines.filter(line => {
-    try { return JSON.parse(line).type === 'llm_output'; } catch { return false; }
-  }).length;
-  
-  const messages = lines.filter(line => {
-    try { return JSON.parse(line).type === 'message'; } catch { return false; }
-  }).length;
-
-  return {
-    date: getTodayFilename(),
-    totalRecords: lines.length,
-    toolCalls,
-    llmOutputs,
-    messages,
-    generatedAt: new Date().toISOString()
-  };
-}

package/src/index.ts

@@ -29,7 +29,6 @@ import { handleAfterToolCall } from './hooks/pain.js';
 import { handleBeforeReset, handleBeforeCompaction, handleAfterCompaction } from './hooks/lifecycle.js';
 import { handleLlmOutput } from './hooks/llm.js';
 import { handleSubagentEnded } from './hooks/subagent.js';
-import * as TrajectoryCollector from './hooks/trajectory-collector.js';
 import { handleInitStrategy } from './commands/strategy.js';
 import { handleBootstrapTools, handleResearchTools } from './commands/capabilities.js';
 import { handleThinkingOs } from './commands/thinking-os.js';
@@ -436,36 +435,6 @@ const plugin = {
       })
     );
 
-    // ── Hook: Trajectory Collection (Behavior Evolution Phase 0) ──
-    // Note: after_tool_call and llm_output are safe to collect
-    api.on(
-      'after_tool_call',
-      guardHook('hook:after_tool_call.trajectory', api.logger, (event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext): void => {
-        try {
-          const workspaceDir = resolveToolHookWorkspaceDirSafe(ctx, api, 'trajectory.after_tool_call');
-          if (!workspaceDir) return;
-          TrajectoryCollector.handleAfterToolCall(event, { ...ctx, workspaceDir });
-          // eslint-disable-next-line @typescript-eslint/no-unused-vars -- Reason: catch binding intentionally unused
-        } catch (_err) {
-          // Non-critical: don't log, just skip
-        }
-      })
-    );
-
-    api.on(
-      'llm_output',
-      guardHook('hook:llm_output.trajectory', api.logger, (event: PluginHookLlmOutputEvent, ctx: PluginHookAgentContext): void => {
-        try {
-          const workspaceDir = resolveToolHookWorkspaceDirSafe(ctx, api, 'trajectory.llm_output');
-          if (!workspaceDir) return;
-          TrajectoryCollector.handleLlmOutput(event, { ...ctx, workspaceDir });
-          // eslint-disable-next-line @typescript-eslint/no-unused-vars -- Reason: catch binding intentionally unused
-        } catch (_err) {
-          // Non-critical: don't log, just skip
-        }
-      })
-    );
-
     // ── Hook: Subagent Loop Closure ──
     api.on(
       'subagent_spawning',

package/tests/core/pain-diagnostic-gate.test.ts

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it } from 'vitest';
-import { evaluatePainDiagnosticGate, resetPainDiagnosticGateForTest } from '../../src/core/pain-diagnostic-gate.js';
+import { evaluatePainDiagnosticGate, resetPainDiagnosticGateForTest, isCooldownActiveForEpisode } from '../../src/core/pain-diagnostic-gate.js';
 
 describe('PainDiagnosticGate', () => {
   beforeEach(() => {
@@ -496,3 +496,119 @@ describe('PainDiagnosticGate', () => {
     }
   });
 });
+
+// ── isCooldownActiveForEpisode ─────────────────────────────────────────────────
+
+describe('isCooldownActiveForEpisode', () => {
+  beforeEach(() => {
+    resetPainDiagnosticGateForTest();
+  });
+
+  it('returns false when no diagnosis has been recorded', () => {
+    const result = isCooldownActiveForEpisode('tool_failure', 's1', 'hash-abc');
+    expect(result).toBe(false);
+  });
+
+  it('returns false when cooldownMs is 0 (disabled)', () => {
+    // Record diagnosis
+    evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 72,
+      sessionId: 's1',
+      errorHash: 'hash-abc',
+      nowMs: 1_000,
+    });
+
+    // With cooldown disabled, should always return false
+    const noCooldown = isCooldownActiveForEpisode('tool_failure', 's1', 'hash-abc', 0);
+    expect(noCooldown).toBe(false);
+  });
+
+  it('different sessionId does not share cooldown', () => {
+    // Record diagnosis for session s1
+    evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 72,
+      sessionId: 's1',
+      errorHash: 'hash-abc',
+      nowMs: 1_000,
+    });
+
+    // Check for different session s2 - should not be in cooldown
+    const differentSession = isCooldownActiveForEpisode('tool_failure', 's2', 'hash-abc');
+    expect(differentSession).toBe(false);
+  });
+
+  it('different errorHash does not share cooldown', () => {
+    // Record diagnosis for hash-abc
+    evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 72,
+      sessionId: 's1',
+      errorHash: 'hash-abc',
+      nowMs: 1_000,
+    });
+
+    // Check for different hash - should not be in cooldown
+    const differentHash = isCooldownActiveForEpisode('tool_failure', 's1', 'hash-xyz');
+    expect(differentHash).toBe(false);
+  });
+
+  it('different source does not share cooldown', () => {
+    // Record diagnosis for tool_failure
+    evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 72,
+      sessionId: 's1',
+      errorHash: 'hash-abc',
+      nowMs: 1_000,
+    });
+
+    // Check for different source dispatch_error - should not be in cooldown
+    const differentSource = isCooldownActiveForEpisode('dispatch_error', 's1', 'hash-abc');
+    expect(differentSource).toBe(false);
+  });
+
+  it('undefined sessionId uses unknown as session identifier', () => {
+    // Record diagnosis with undefined sessionId
+    evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 72,
+      errorHash: 'hash-abc',
+      nowMs: 1_000,
+    });
+
+    // Check cooldown with undefined sessionId - should not be in cooldown
+    // because evaluate used Date.now() but isCooldownActiveForEpisode uses current Date.now()
+    // and 15 seconds haven't passed
+    const undefinedSession = isCooldownActiveForEpisode('tool_failure', undefined, 'hash-abc');
+    // The episodeKey built from undefined sessionId uses 'unknown'
+    // But we can't reliably test time-based behavior without mocking Date.now()
+    // So we just verify it doesn't throw
+    expect(typeof undefinedSession).toBe('boolean');
+  });
+
+  it('episodeKey alignment: same inputs produce same cooldown state', () => {
+    // Use exact same inputs that would create an episodeKey
+    const episodeInput = {
+      source: 'manual' as const,
+      score: 100,
+      currentGfi: 0,
+      sessionId: 's-ep-test',
+      errorHash: 'hash-ep',
+      nowMs: 5_000,
+    };
+
+    // First diagnosis
+    evaluatePainDiagnosticGate(episodeInput);
+
+    // isCooldownActiveForEpisode should not throw with same inputs
+    const inCooldown = isCooldownActiveForEpisode('manual', 's-ep-test', 'hash-ep');
+    expect(typeof inCooldown).toBe('boolean');
+  });
+});

package/tests/core/surface-guard.test.ts

@@ -93,8 +93,8 @@ describe('surface-guard', () => {
     });
 
     it('allows override for quiet surface', () => {
-      const result = isSurfaceEnabled('hook:after_tool_call.trajectory', {
-        'hook:after_tool_call.trajectory': true,
+      const result = isSurfaceEnabled('hook:subagent_spawning', {
+        'hook:subagent_spawning': true,
       });
       expect(result.enabled).toBe(true);
     });
@@ -308,15 +308,13 @@ describe('surface-guard', () => {
       }
     });
 
-    it('trajectory hook disabledReason is opt-in and ADR-anchored (PRI-298)', () => {
-      const trajectory = PLUGIN_SURFACE_REGISTRY.find(
-        s => s.id === 'hook:after_tool_call.trajectory',
+    it('subagent hook disabledReason is opt-in and ADR-anchored (PRI-298)', () => {
+      const subagent = PLUGIN_SURFACE_REGISTRY.find(
+        s => s.id === 'hook:subagent_spawning',
       );
-      expect(trajectory?.disabledReason).toBeDefined();
-      const reason = trajectory!.disabledReason!.toLowerCase();
+      expect(subagent?.disabledReason).toBeDefined();
+      const reason = subagent!.disabledReason!.toLowerCase();
       // Quiet hook copy is opt-in / opt-out anchored on a real ADR section
-      // (no MVP-phase residue, no promise of a feature-flag override that
-      // the production guard path does not actually consume — chatgpt P2).
       expect(reason).toContain('opt-in');
       expect(reason).toContain('default off');
       expect(reason).toMatch(/adr-?0014/);

package/tests/evolution-worker-slimming.test.ts

@@ -139,8 +139,6 @@ describe('PRI-294: Surface registry coverage audit', () => {
     'hook:before_tool_call',
     'hook:after_tool_call',
     'hook:llm_output',
-    'hook:after_tool_call.trajectory',
-    'hook:llm_output.trajectory',
     'hook:subagent_spawning',
     'hook:subagent_ended',
     'hook:before_reset',
@@ -257,8 +255,6 @@ describe('PRI-294: MVP core hooks enabled, non-core disabled', () => {
   ];
 
   const QUIET_HOOKS = [
-    'hook:after_tool_call.trajectory',
-    'hook:llm_output.trajectory',
     'hook:subagent_spawning',
     'hook:subagent_ended',
     'hook:before_reset',

package/tests/hooks/trajectory-evidence.test.ts

@@ -0,0 +1,194 @@
+/**
+ * Trajectory Evidence Builder Tests — PRI-326
+ *
+ * Tests the pure data extraction function buildTrajectoryEvidence
+ * which reads from trajectory DB, sanitizes, and returns evidence entries.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { buildTrajectoryEvidence } from '../../src/hooks/trajectory-evidence.js';
+import type { WorkspaceContext } from '../../src/core/workspace-context.js';
+import type { TrajectoryDatabase } from '../../src/core/trajectory.js';
+
+// Mock sanitizeAssistantText to avoid testing message-sanitize here
+vi.mock('../../src/hooks/message-sanitize.js', () => ({
+  sanitizeAssistantText: vi.fn((text: string) => text),
+}));
+
+describe('buildTrajectoryEvidence', () => {
+  let mockTrajectory: Partial<TrajectoryDatabase>;
+  let mockWctx: Partial<WorkspaceContext>;
+
+  beforeEach(() => {
+    mockTrajectory = {
+      listUserTurnsForSession: vi.fn(),
+      listAssistantTurns: vi.fn(),
+    };
+    mockWctx = {
+      trajectory: mockTrajectory as TrajectoryDatabase,
+      workspaceDir: '/test/workspace',
+    };
+  });
+
+  it('returns unavailable evidence when trajectory is not available', () => {
+    mockWctx.trajectory = undefined;
+    const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'unknown');
+    expect(result).toHaveLength(1);
+    expect(result[0].sourceRef).toBe('owner_message:unavailable');
+    expect(result[0].note).toContain('no_trajectory_db');
+  });
+
+  it('returns unavailable evidence when sessionId is unknown', () => {
+    const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'unknown');
+    expect(result).toHaveLength(1);
+    expect(result[0].sourceRef).toBe('owner_message:unavailable');
+    expect(result[0].note).toContain('unknown_session');
+  });
+
+  it('returns last correction owner message as evidence', () => {
+    const mockUserTurn = {
+      createdAt: '2024-01-15T10:00:00Z',
+      correctionDetected: true,
+      rawExcerpt: 'Please fix this bug',
+    };
+    vi.mocked(mockTrajectory.listUserTurnsForSession!).mockReturnValue([mockUserTurn as any]);
+    vi.mocked(mockTrajectory.listAssistantTurns!).mockReturnValue([]);
+
+    const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'session-123');
+
+    expect(result).toHaveLength(1);
+    expect(result[0].sourceRef).toContain('owner_message:');
+    expect(result[0].note).toBe('Please fix this bug');
+  });
+
+  it('handles trajectory listUserTurnsForSession throwing an error gracefully', () => {
+    vi.mocked(mockTrajectory.listUserTurnsForSession!).mockImplementation(() => {
+      throw new Error('Database error');
+    });
+    vi.mocked(mockTrajectory.listAssistantTurns!).mockReturnValue([]);
+
+    const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'session-123');
+
+    expect(result).toHaveLength(1);
+    expect(result[0].sourceRef).toBe('owner_message:unavailable');
+    expect(result[0].note).toContain('trajectory_user_turns_unavailable');
+    expect(result[0].note).toContain('Database error');
+  });
+
+  it('returns recent assistant turns as evidence', () => {
+    const mockUserTurn = {
+      createdAt: '2024-01-15T10:00:00Z',
+      correctionDetected: false,
+      rawExcerpt: '',
+    };
+    const mockAssistantTurns = [
+      { createdAt: '2024-01-15T09:58:00Z', sanitizedText: 'Turn 1' },
+      { createdAt: '2024-01-15T09:59:00Z', sanitizedText: 'Turn 2' },
+      { createdAt: '2024-01-15T10:00:00Z', sanitizedText: 'Turn 3' },
+    ];
+    vi.mocked(mockTrajectory.listUserTurnsForSession!).mockReturnValue([mockUserTurn as any]);
+    vi.mocked(mockTrajectory.listAssistantTurns!).mockReturnValue(mockAssistantTurns as any);
+
+    const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'session-123');
+
+    // Should have the last 3 assistant turns (MAX is 3 from core constants)
+    expect(result.length).toBeGreaterThan(0);
+    expect(result.some(e => e.note === 'Turn 3')).toBe(true);
+  });
+
+  it('handles trajectory listAssistantTurns throwing an error gracefully', () => {
+    const mockUserTurn = {
+      createdAt: '2024-01-15T10:00:00Z',
+      correctionDetected: true,
+      rawExcerpt: 'Last correction',
+    };
+    vi.mocked(mockTrajectory.listUserTurnsForSession!).mockReturnValue([mockUserTurn as any]);
+    vi.mocked(mockTrajectory.listAssistantTurns!).mockImplementation(() => {
+      throw new Error('Trajectory DB error');
+    });
+
+    const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'session-123');
+
+    // Should have owner message plus error entry
+    expect(result.length).toBeGreaterThanOrEqual(1);
+    expect(result[0].sourceRef).toContain('owner_message:');
+  });
+
+  it('returns empty trajectory notice when no user corrections or assistant turns', () => {
+    vi.mocked(mockTrajectory.listUserTurnsForSession!).mockReturnValue([]);
+    vi.mocked(mockTrajectory.listAssistantTurns!).mockReturnValue([]);
+
+    const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'session-123');
+
+    expect(result).toHaveLength(1);
+    expect(result[0].sourceRef).toBe('trajectory:empty');
+    expect(result[0].note).toContain('trajectory_available_but_empty');
+  });
+
+  it('respects MAX_EVIDENCE_ENTRIES limit', () => {
+    // Create many user turns with corrections
+    const manyUserTurns = Array.from({ length: 10 }, (_, i) => ({
+      createdAt: `2024-01-15T${String(i).padStart(2, '0')}:00:00Z`,
+      correctionDetected: true,
+      rawExcerpt: `Correction ${i}`,
+    }));
+    vi.mocked(mockTrajectory.listUserTurnsForSession!).mockReturnValue(manyUserTurns as any);
+    vi.mocked(mockTrajectory.listAssistantTurns!).mockReturnValue([]);
+
+    const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'session-123');
+
+    // MAX_EVIDENCE_ENTRIES from core is 5, so should be capped
+    expect(result.length).toBeLessThanOrEqual(5);
+  });
+
+  it('uses last correction turn (most recent) when multiple corrections exist', () => {
+    const olderCorrection = {
+      createdAt: '2024-01-15T09:00:00Z',
+      correctionDetected: true,
+      rawExcerpt: 'Older correction',
+    };
+    const newerCorrection = {
+      createdAt: '2024-01-15T10:00:00Z',
+      correctionDetected: true,
+      rawExcerpt: 'Newer correction',
+    };
+    vi.mocked(mockTrajectory.listUserTurnsForSession!).mockReturnValue([olderCorrection, newerCorrection] as any);
+    vi.mocked(mockTrajectory.listAssistantTurns!).mockReturnValue([]);
+
+    const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'session-123');
+
+    // Should use the newer correction (last in reverse order)
+    expect(result[0].note).toBe('Newer correction');
+  });
+
+  it('sanitizes owner message text', () => {
+    const mockUserTurn = {
+      createdAt: '2024-01-15T10:00:00Z',
+      correctionDetected: true,
+      rawExcerpt: 'Text with [EMOTIONAL_DAMAGE_DETECTED:mild] internal tags',
+    };
+    vi.mocked(mockTrajectory.listUserTurnsForSession!).mockReturnValue([mockUserTurn] as any);
+    vi.mocked(mockTrajectory.listAssistantTurns!).mockReturnValue([]);
+
+    const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'session-123');
+
+    // The mock sanitizeAssistantText returns text as-is
+    expect(result[0].note).toContain('Text with [EMOTIONAL_DAMAGE_DETECTED:mild] internal tags');
+  });
+
+  it('truncates long notes to MAX_EVIDENCE_NOTE_CHARS', () => {
+    const longText = 'A'.repeat(10000);
+    const mockUserTurn = {
+      createdAt: '2024-01-15T10:00:00Z',
+      correctionDetected: true,
+      rawExcerpt: longText,
+    };
+    vi.mocked(mockTrajectory.listUserTurnsForSession!).mockReturnValue([mockUserTurn] as any);
+    vi.mocked(mockTrajectory.listAssistantTurns!).mockReturnValue([]);
+
+    const result = buildTrajectoryEvidence(mockWctx as WorkspaceContext, 'session-123');
+
+    // Note should be truncated to MAX_EVIDENCE_NOTE_CHARS (1000 from core)
+    expect(result[0].note.length).toBeLessThanOrEqual(1000);
+  });
+});

package/tests/integration/mvp-surface-registry-guard.test.ts

@@ -186,18 +186,16 @@ describe('MVP Surface Registry Guard (PRI-289)', () => {
       }
     });
 
-    it('after_tool_call has two registrations: core + trajectory', () => {
+    it('after_tool_call has one registration: core only', () => {
       const afterToolCallRegs = registrations.filter(r => r.event === 'after_tool_call');
-      expect(afterToolCallRegs.length).toBe(2);
+      expect(afterToolCallRegs.length).toBe(1);
       expect(afterToolCallRegs[0].surfaceId).toBe('hook:after_tool_call');
-      expect(afterToolCallRegs[1].surfaceId).toBe('hook:after_tool_call.trajectory');
     });
 
-    it('llm_output has two registrations: core + trajectory', () => {
+    it('llm_output has one registration: core only', () => {
       const llmOutputRegs = registrations.filter(r => r.event === 'llm_output');
-      expect(llmOutputRegs.length).toBe(2);
+      expect(llmOutputRegs.length).toBe(1);
       expect(llmOutputRegs[0].surfaceId).toBe('hook:llm_output');
-      expect(llmOutputRegs[1].surfaceId).toBe('hook:llm_output.trajectory');
     });
 
     it('total api.on registrations with guardHook match registry hook count', () => {
@@ -375,14 +373,14 @@ describe('MVP Surface Registry Guard (PRI-289)', () => {
 
     it('isSurfaceEnabled returns false for quiet surfaces by default', async () => {
       const { isSurfaceEnabled } = await import('../../src/core/surface-guard.js');
-      const result = isSurfaceEnabled('hook:after_tool_call.trajectory');
+      const result = isSurfaceEnabled('hook:subagent_spawning');
       expect(result.enabled).toBe(false);
       expect(result.reason).toBeDefined();
     });
 
     it('isSurfaceEnabled allows quiet surfaces with explicit override', async () => {
       const { isSurfaceEnabled } = await import('../../src/core/surface-guard.js');
-      const result = isSurfaceEnabled('hook:after_tool_call.trajectory', { 'hook:after_tool_call.trajectory': true });
+      const result = isSurfaceEnabled('hook:subagent_spawning', { 'hook:subagent_spawning': true });
       expect(result.enabled).toBe(true);
     });