principles-disciple 1.35.0 → 1.37.0

package/src/service/subagent-workflow/correction-observer-workflow-manager.ts

@@ -0,0 +1,246 @@
+/**
+ * CorrectionObserverWorkflowManager
+ *
+ * Workflow manager that dispatches an LLM subagent to optimize correction
+ * keywords based on recent match performance data and user feedback.
+ *
+ * Follows the established WorkflowManagerBase pattern from EmpathyObserverWorkflowManager.
+ */
+
+import type { PluginLogger } from '../../openclaw-sdk.js';
+import type {
+    SubagentWorkflowSpec,
+    WorkflowMetadata,
+    WorkflowResultContext,
+    WorkflowPersistContext,
+    WorkflowHandle,
+} from './types.js';
+import type { RuntimeDirectDriver } from './runtime-direct-driver.js';
+import { WorkflowManagerBase } from './workflow-manager-base.js';
+import { isSubagentRuntimeAvailable } from '../../utils/subagent-probe.js';
+import type {
+    CorrectionObserverPayload,
+    CorrectionObserverResult,
+} from './correction-observer-types.js';
+
+const WORKFLOW_SESSION_PREFIX = 'agent:main:subagent:workflow-correction-';
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_TTL_MS = 5 * 60 * 1000;
+
+// Prompt formatting constants
+const MAX_TRAJECTORY_MESSAGE_LENGTH = 80;
+
+// ── Options ─────────────────────────────────────────────────────────────────
+
+export interface CorrectionObserverWorkflowOptions {
+    workspaceDir: string;
+    logger: PluginLogger;
+    subagent: RuntimeDirectDriver['subagent'];
+    /** Pass api.runtime.agent.session to enable heartbeat-safe cleanup (#188) */
+    agentSession?: RuntimeDirectDriver['agentSession'];
+}
+
+// ── Helper Functions ─────────────────────────────────────────────────────────
+
+/**
+ * Extract raw assistant text from messages or assistantTexts array.
+ */
+function extractAssistantTextForSpec(messages: unknown[], assistantTexts?: string[]): string {
+    if (assistantTexts && assistantTexts.length > 0) {
+        return assistantTexts[assistantTexts.length - 1] || '';
+    }
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i] as { role?: string; content?: unknown };
+        if (msg?.role !== 'assistant') continue;
+        if (typeof msg.content === 'string') return msg.content;
+        if (Array.isArray(msg.content)) {
+            const txt = msg.content
+                .filter((part: unknown) => part && typeof part === 'object' && (part as { type?: string }).type === 'text' && typeof (part as { text?: unknown }).text === 'string')
+                .map((part: unknown) => (part as { text: string }).text)
+                .join('\n');
+            if (txt) return txt;
+        }
+    }
+    return '';
+}
+
+/**
+ * Parse correction observer JSON payload from raw text.
+ */
+function parseCorrectionObserverPayload(rawText: string): CorrectionObserverResult | null {
+    if (!rawText?.trim()) return null;
+    try {
+        return JSON.parse(rawText.trim()) as CorrectionObserverResult;
+    } catch {
+        const match = /\{[\s\S]*\}/.exec(rawText);
+        if (!match) return null;
+        try {
+            return JSON.parse(match[0]) as CorrectionObserverResult;
+        } catch {
+            return null;
+        }
+    }
+}
+
+// ── Workflow Spec ─────────────────────────────────────────────────────────────
+
+export const correctionObserverWorkflowSpec: SubagentWorkflowSpec<CorrectionObserverResult> = {
+    workflowType: 'correction_observer',
+    transport: 'runtime_direct',
+    timeoutMs: 30_000,
+    ttlMs: 300_000,
+    shouldDeleteSessionAfterFinalize: true,
+
+    buildPrompt(taskInput: unknown, _metadata: WorkflowMetadata): string {
+        const payload = taskInput as CorrectionObserverPayload;
+        const { keywordStoreSummary, recentMessages, trajectoryHistory } = payload;
+
+        const termsList = keywordStoreSummary.terms
+            .map(t => `  - term="${t.term}", weight=${t.weight}, hits=${t.hitCount}, TP=${t.truePositiveCount}, FP=${t.falsePositiveCount}`)
+            .join('\n');
+
+        const messages = recentMessages.length > 0
+            ? recentMessages.map(m => `  - ${JSON.stringify(m)}`).join('\n')
+            : '  (none)';
+
+        const trajectory = trajectoryHistory.length > 0
+            ? trajectoryHistory.map(t => `  - [${t.sessionId}] ${t.term} (${t.timestamp}): ${t.userMessage.substring(0, MAX_TRAJECTORY_MESSAGE_LENGTH)}`)
+              .join('\n')
+            : '  (none)';
+
+        return [
+            'You are a correction keyword optimizer.',
+            '',
+            '## TASK',
+            'Analyze the current correction keyword store and recent user messages.',
+            'Recommend ADD/UPDATE/REMOVE actions to improve correction cue accuracy.',
+            '',
+            '## Current Keyword Store (' + keywordStoreSummary.totalKeywords + ' terms):',
+            termsList,
+            '',
+            '## Recent User Messages (' + recentMessages.length + ' messages):',
+            messages,
+            '',
+            '## Correction Trajectory (recent confirmed corrections, D-40-08):',
+            trajectory,
+            '',
+            '## Rules:',
+            '- ADD: If a correction pattern is detected in messages but not in store',
+            '- UPDATE: If a term\'s weight should change based on TP/FP ratio',
+            '- REMOVE: If a term has 0 hits after many uses AND high false positive rate (>0.3)',
+            '- Keep reasoning concise (max 100 chars)',
+            '- Weight range: 0.1-0.9',
+            '',
+            'Return strict JSON (no markdown):',
+            '{"updated": boolean, "updates": {...}, "summary": string}',
+        ].join('\n');
+    },
+
+    async parseResult(ctx: WorkflowResultContext): Promise<CorrectionObserverResult | null> {
+        const rawText = extractAssistantTextForSpec(ctx.messages, ctx.assistantTexts);
+        return parseCorrectionObserverPayload(rawText);
+    },
+
+    async persistResult(_ctx: WorkflowPersistContext<CorrectionObserverResult>): Promise<void> {
+        // Result persistence is handled by the caller (evolution-worker.ts)
+        // which reads the result and applies keyword store updates.
+        // This spec handles only the LLM dispatch and result parsing.
+    },
+
+    shouldFinalizeOnWaitStatus(status: 'ok' | 'error' | 'timeout'): boolean {
+        return status === 'ok';
+    },
+};
+
+// ── Manager Class ─────────────────────────────────────────────────────────────
+
+export class CorrectionObserverWorkflowManager extends WorkflowManagerBase {
+    constructor(opts: CorrectionObserverWorkflowOptions) {
+        super({
+            workspaceDir: opts.workspaceDir,
+            logger: opts.logger,
+            subagent: opts.subagent,
+            agentSession: opts.agentSession,
+            workflowType: 'correction_observer',
+            sessionPrefix: WORKFLOW_SESSION_PREFIX,
+            defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
+            defaultTtlMs: DEFAULT_TTL_MS,
+        });
+    }
+
+    async startWorkflow<TResult>(
+        spec: SubagentWorkflowSpec<TResult>,
+        options: {
+            parentSessionId: string;
+            workspaceDir?: string;
+            taskInput: unknown;
+            metadata?: Record<string, unknown>;
+        }
+    ): Promise<WorkflowHandle> {
+        // Surface degrade: skip boot sessions
+        if (options.parentSessionId.startsWith('boot-')) {
+            this.logger.info(`[PD:CorrectionObserver] Skipping workflow: boot session`);
+            throw new Error(`CorrectionObserverWorkflowManager: cannot start workflow for boot session`);
+        }
+
+        // Surface degrade: check subagent runtime availability
+        if (!isSubagentRuntimeAvailable(this.driver.getSubagent())) {
+            this.logger.info(`[PD:CorrectionObserver] Skipping workflow: subagent runtime unavailable`);
+            throw new Error(`CorrectionObserverWorkflowManager: subagent runtime unavailable`);
+        }
+
+        if (spec.transport !== 'runtime_direct') {
+            throw new Error(`CorrectionObserverWorkflowManager only supports runtime_direct transport`);
+        }
+
+        return super.startWorkflow(spec, options);
+    }
+
+    /**
+     * Get the parsed workflow result for a completed workflow.
+     * Used by callers (evolution-worker.ts) to retrieve LLM optimization results
+     * after the workflow completes, so mutations can be applied to the keyword store.
+     */
+    async getWorkflowResult(workflowId: string): Promise<CorrectionObserverResult | null> {
+        const workflow = this.store.getWorkflow(workflowId);
+        if (!workflow) return null;
+
+        const result = await this.driver.getResult({ sessionKey: workflow.child_session_key, limit: 20 });
+        return correctionObserverWorkflowSpec.parseResult({
+            messages: result.messages,
+            assistantTexts: result.assistantTexts,
+            metadata: JSON.parse(workflow.metadata_json) as WorkflowMetadata,
+            waitStatus: 'ok',
+        });
+    }
+
+    // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+    protected override createWorkflowMetadata<TResult>(
+        spec: SubagentWorkflowSpec<TResult>,
+        options: {
+            parentSessionId: string;
+            workspaceDir?: string;
+            taskInput: unknown;
+            metadata?: Record<string, unknown>;
+        },
+        now: number
+    ): WorkflowMetadata {
+        return {
+            parentSessionId: options.parentSessionId,
+            workspaceDir: options.workspaceDir,
+            taskInput: options.taskInput,
+            startedAt: now,
+            workflowType: spec.workflowType,
+            ...options.metadata,
+        };
+    }
+}
+
+// ── Factory ─────────────────────────────────────────────────────────────────
+
+export function createCorrectionObserverWorkflowManager(
+    opts: CorrectionObserverWorkflowOptions
+): CorrectionObserverWorkflowManager {
+    return new CorrectionObserverWorkflowManager(opts);
+}

package/src/service/subagent-workflow/index.ts

@@ -65,3 +65,16 @@ export type {
     WorkflowEventRow,
     WorkflowDebugSummary,
 } from './types.js';
+
+export {
+    CorrectionObserverWorkflowManager,
+    createCorrectionObserverWorkflowManager,
+    correctionObserverWorkflowSpec,
+    type CorrectionObserverWorkflowOptions,
+} from './correction-observer-workflow-manager.js';
+
+export type {
+    CorrectionObserverPayload,
+    CorrectionObserverResult,
+    CorrectionObserverWorkflowSpec,
+} from './correction-observer-types.js';

package/src/service/subagent-workflow/workflow-manager-base.ts

@@ -303,6 +303,7 @@ export abstract class WorkflowManagerBase implements WorkflowManager {
                 await this.notifyWaitResult(workflowId, 'error', errMsg);
             }
         }, 100);
+        timeout.unref(); // Don't keep process alive for wait poll
 
         this.activeWorkflows.set(workflowId, timeout);
     }

package/tests/core/correction-cue-learner.test.ts

@@ -0,0 +1,345 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import * as path from 'path';
+import * as os from 'os';
+import {
+  CorrectionCueLearner,
+  loadCorrectionKeywordStore,
+  saveCorrectionKeywordStore,
+  _resetCorrectionCueCache,
+  _resetCorrectionCueLearnerInstance,
+} from '../../src/core/correction-cue-learner.js';
+import {
+  CORRECTION_SEED_KEYWORDS,
+  MAX_CORRECTION_KEYWORDS,
+} from '../../src/core/correction-types.js';
+
+// ── Mock fs (hoisted — vi.mock runs before imports) ──────────────────────────
+
+vi.mock('fs', () => ({
+  existsSync: vi.fn(() => false),
+  readFileSync: vi.fn(() => ''),
+  writeFileSync: vi.fn(),
+  renameSync: vi.fn(),
+  mkdirSync: vi.fn(),
+}));
+
+import * as fs from 'fs';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function tempDir(): string {
+  return path.join(os.tmpdir(), `correction-cue-test-${Date.now()}-${Math.random()}`);
+}
+
+// ── Test setup: reset module-level cache and singleton between tests ─────────
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  _resetCorrectionCueCache();
+  _resetCorrectionCueLearnerInstance();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CORR-01: Seed keywords
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe('CORR-01: Seed keywords', () => {
+  it('should create store with 16 seed keywords on first load', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    const dir = tempDir();
+    const store = loadCorrectionKeywordStore(dir);
+    expect(store.keywords).toHaveLength(16);
+    expect(store.version).toBe(1);
+  });
+
+  it('should set source=seed and non-empty addedAt for all seed keywords', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    const dir = tempDir();
+    const store = loadCorrectionKeywordStore(dir);
+    for (const kw of store.keywords) {
+      expect(kw.source).toBe('seed');
+      expect(kw.addedAt).not.toBe('');
+      expect(kw.addedAt).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+    }
+  });
+
+  it('should have all 16 exact terms from CORRECTION_SEED_KEYWORDS', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    const dir = tempDir();
+    const store = loadCorrectionKeywordStore(dir);
+    const terms = store.keywords.map((k) => k.term);
+    for (const seed of CORRECTION_SEED_KEYWORDS) {
+      expect(terms).toContain(seed.term);
+    }
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CORR-03: Atomic write
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe('CORR-03: Atomic write', () => {
+  it('should write to .tmp file before rename', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(
+      JSON.stringify({ keywords: CORRECTION_SEED_KEYWORDS.map((k) => ({ ...k, addedAt: '2026-01-01T00:00:00Z' })), version: 1 })
+    );
+
+    const dir = tempDir();
+    const store = {
+      keywords: CORRECTION_SEED_KEYWORDS.map((k) => ({ ...k, addedAt: '2026-01-01T00:00:00Z' })),
+      version: 1,
+      lastOptimizedAt: '2026-01-01T00:00:00Z',
+    };
+    saveCorrectionKeywordStore(dir, store);
+
+    const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0];
+    const tmpPath = writeCall[0] as string;
+    expect(tmpPath).toMatch(/\.tmp$/);
+  });
+
+  it('should rename from tmp path to final path after write', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(
+      JSON.stringify({ keywords: CORRECTION_SEED_KEYWORDS.map((k) => ({ ...k, addedAt: '2026-01-01T00:00:00Z' })), version: 1 })
+    );
+
+    const dir = tempDir();
+    const store = {
+      keywords: CORRECTION_SEED_KEYWORDS.map((k) => ({ ...k, addedAt: '2026-01-01T00:00:00Z' })),
+      version: 1,
+      lastOptimizedAt: '2026-01-01T00:00:00Z',
+    };
+    saveCorrectionKeywordStore(dir, store);
+
+    const renameCalls = vi.mocked(fs.renameSync).mock.calls;
+    expect(renameCalls).toHaveLength(1);
+    const [from, to] = renameCalls[0];
+    expect(from).toMatch(/\.tmp$/);
+    expect(to).not.toMatch(/\.tmp$/);
+  });
+
+  it('should call mkdirSync with recursive:true before writing', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(
+      JSON.stringify({ keywords: CORRECTION_SEED_KEYWORDS.map((k) => ({ ...k, addedAt: '2026-01-01T00:00:00Z' })), version: 1 })
+    );
+
+    const dir = tempDir();
+    const store = {
+      keywords: CORRECTION_SEED_KEYWORDS.map((k) => ({ ...k, addedAt: '2026-01-01T00:00:00Z' })),
+      version: 1,
+      lastOptimizedAt: '2026-01-01T00:00:00Z',
+    };
+    saveCorrectionKeywordStore(dir, store);
+
+    expect(vi.mocked(fs.mkdirSync)).toHaveBeenCalledWith(dir, { recursive: true });
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CORR-04: Cache invalidation
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe('CORR-04: Cache invalidation', () => {
+  it('should invalidate cache after save so next load re-reads from disk', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(
+      JSON.stringify({
+        keywords: CORRECTION_SEED_KEYWORDS.map((k) => ({ ...k, addedAt: '2026-01-01T00:00:00Z' })),
+        version: 1,
+      })
+    );
+
+    const dir = tempDir();
+    loadCorrectionKeywordStore(dir);
+    expect(vi.mocked(fs.readFileSync)).toHaveBeenCalled();
+
+    const store = loadCorrectionKeywordStore(dir);
+    saveCorrectionKeywordStore(dir, store);
+
+    // After save, cache is null — next load must re-read. Verify by changing
+    // the mock return and confirming the new data is picked up.
+    vi.mocked(fs.readFileSync).mockClear();
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ keywords: [], version: 1 }));
+
+    const store2 = loadCorrectionKeywordStore(dir);
+    expect(vi.mocked(fs.readFileSync)).toHaveBeenCalled();
+    expect(store2.keywords).toHaveLength(0); // proves re-read happened
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CORR-05: 200-term limit
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe('CORR-05: 200-term limit', () => {
+  it('should throw when adding keyword beyond 200 terms', () => {
+    const keywords = Array.from({ length: 200 }, (_, i) => ({
+      term: `keyword-${i}`,
+      weight: 0.5,
+      source: 'seed' as const,
+      addedAt: '2026-01-01T00:00:00Z',
+    }));
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ keywords, version: 1 }));
+
+    const dir = tempDir();
+    const learner = new CorrectionCueLearner(dir);
+    expect(learner.getStore().keywords).toHaveLength(200);
+
+    expect(() => learner.add({ term: 'new-keyword', weight: 0.5, source: 'user' })).toThrow(
+      'Correction keyword store limit reached (200 terms)'
+    );
+  });
+
+  it('should allow add when at 199 terms', () => {
+    const keywords = Array.from({ length: 199 }, (_, i) => ({
+      term: `keyword-${i}`,
+      weight: 0.5,
+      source: 'seed' as const,
+      addedAt: '2026-01-01T00:00:00Z',
+    }));
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ keywords, version: 1 }));
+
+    const dir = tempDir();
+    const learner = new CorrectionCueLearner(dir);
+    expect(learner.getStore().keywords).toHaveLength(199);
+
+    expect(() => learner.add({ term: 'new-keyword', weight: 0.5, source: 'user' })).not.toThrow();
+  });
+
+  it('should not modify store when add fails due to limit', () => {
+    const keywords = Array.from({ length: 200 }, (_, i) => ({
+      term: `keyword-${i}`,
+      weight: 0.5,
+      source: 'seed' as const,
+      addedAt: '2026-01-01T00:00:00Z',
+    }));
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ keywords, version: 1 }));
+
+    const dir = tempDir();
+    const learner = new CorrectionCueLearner(dir);
+    try {
+      learner.add({ term: 'new-keyword', weight: 0.5, source: 'user' });
+    } catch {
+      // expected
+    }
+
+    expect(learner.getStore().keywords).toHaveLength(200);
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CORR-11: Equivalence to detectCorrectionCue
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe('CORR-11: Equivalence to detectCorrectionCue', () => {
+  beforeEach(() => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+  });
+
+  /**
+   * Reference implementation using find() — first match wins (same as detectCorrectionCue).
+   */
+  function detectCorrectionCueLegacy(text: string): string | null {
+    const normalized = text.trim().toLowerCase().replace(/[.,!?;:，。！？；：]/g, '');
+    const cues = CORRECTION_SEED_KEYWORDS.map((k) => k.term);
+    return cues.find((cue) => normalized.includes(cue)) ?? null;
+  }
+
+  /**
+   * Tests using first-match semantics: find() returns the FIRST keyword in the
+   * array whose term appears in the normalized text, not the longest match.
+   *
+   * Order of CORRECTION_SEED_KEYWORDS array (first 8 Chinese):
+   *   '不是这个', '不对', '错了', '搞错了', '理解错了', '你理解错了', '重新来', '再试一次'
+   *
+   * So "我搞错了" → "错了" is found first (index 2) before "搞错了" (index 3).
+   * "你理解错了" → "错了" is found first (index 2) before "理解错了" (index 4) and "你理解错了" (index 5).
+   */
+  it.each([
+    // Chinese cases — note: first match wins
+    ['不是这个', '不是这个'],       // exact match
+    ['你不对啊', '不对'],          // first match is '不对' (index 1)
+    ['错了！', '错了'],            // exact match (index 2)
+    ['我搞错了', '错了'],          // '错了' appears first in array (index 2 < index 3)
+    ['你理解错了', '错了'],         // '错了' appears first in array (index 2 < index 4)
+    ['重新来一遍', '重新来'],       // exact match
+    ['再试一次行不行', '再试一次'],  // exact match
+    // English cases
+    ['you are wrong', 'you are wrong'],  // exact match
+    ['wrong file', 'wrong file'],        // exact match
+    ['not this one', 'not this'],        // exact match
+    ['redo it', 'redo'],                 // exact match (index 11)
+    ['try again', 'try again'],           // exact match (index 12)
+    ['do it again', 'again'],             // 'again' is index 13
+    ['please redo', 'redo'],              // 'redo' found first (index 11 < index 14)
+    ['please try again', 'try again'],    // 'try again' found first (index 12 < index 15)
+  ])('should match "%s" → "%s"', (text, expected) => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    const dir = tempDir();
+    const learner = new CorrectionCueLearner(dir);
+    const result = learner.match(text);
+    expect(result.matched).toBe(true);
+    expect(result.matchedTerms).toContain(expected);
+    expect(result.score).toBeGreaterThan(0);
+  });
+
+  it('should produce same result as legacy detectCorrectionCue for varied inputs', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    const dir = tempDir();
+    const learner = new CorrectionCueLearner(dir);
+
+    const cases = [
+      '这个可以，没问题',
+      '不对，应该是这样',
+      '你再试试这个方法',
+      'nothing wrong here',
+      'please be careful',
+      'can you try again?',
+      'I think you are wrong about this',
+    ];
+
+    for (const text of cases) {
+      const legacyResult = detectCorrectionCueLegacy(text);
+      const learnerResult = learner.match(text);
+
+      if (legacyResult !== null) {
+        expect(learnerResult.matched).toBe(true);
+        expect(learnerResult.matchedTerms).toContain(legacyResult);
+        expect(learnerResult.score).toBeGreaterThan(0);
+      } else {
+        expect(learnerResult.matched).toBe(false);
+        expect(learnerResult.matchedTerms).toEqual([]);
+      }
+    }
+  });
+
+  it('should match regardless of surrounding punctuation', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    const dir = tempDir();
+    const learner = new CorrectionCueLearner(dir);
+
+    const variations = ['不对', '不对!', '不对?', '。不对', '不对。', '  不对  ', '不对啊'];
+    for (const text of variations) {
+      const result = learner.match(text);
+      expect(result.matched).toBe(true);
+      expect(result.matchedTerms).toContain('不对');
+    }
+  });
+
+  it('should return positive score when matched, 0 when not matched', () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    const dir = tempDir();
+    const learner = new CorrectionCueLearner(dir);
+    expect(learner.match('不是这个').score).toBeGreaterThan(0);
+    expect(learner.match('这个可以').score).toBe(0);
+  });
+
+  it('should export MAX_CORRECTION_KEYWORDS = 200', () => {
+    expect(MAX_CORRECTION_KEYWORDS).toBe(200);
+  });
+});