create-principles-disciple 1.104.0 → 1.104.2

package/plugin/dist/core/signal-collector-host.js

@@ -1,337 +0,0 @@
-/**
- * SignalCollectorHost — plugin I/O 外壳 (design spec §4.2)
- *
- * 把 core 的纯逻辑 (collectSync / mapLlmResultToOutput) 接进 openclaw 运行时。
- *
- * 同步路径 (prompt.ts before_prompt_build 钩子调用,绝不阻塞):
- *   - trigger 门控 (仅 user)
- *   - Stage1 关键词快扫 (零成本)
- *   - 写 user_turns (复用 recordUserTurn)
- *   - 高精度短语命中 (high) → 直接走 STRONG 分流 (同步,纯内存)
- *   - 普通歧义词 / 未命中 → 入队异步 LLM 确认 (不阻塞)
- *
- * 异步路径 (fire-and-forget):
- *   - Stage2 LLM 确认 (后台,不阻塞 prompt hook)
- *   - LLM 不可用 → 降级:丢弃 ambiguous 候选 (不触发 STRONG,避免误判泛滥)
- *   - 按 strength 分流:STRONG → emitPainDetectedEvent (修断裂 ③);WEAK → trackFriction 累积 GFI
- *
- * 降级不静默 (rc-9):所有降级路径走 SystemLogger。
- */
-import { collectSync, mapLlmResultToOutput, buildLlmPrompt, parseLlmClassification, PiAiRuntimeAdapter, } from '@principles/core/runtime-v2';
-import { createHash } from 'node:crypto';
-import { emitPainDetectedEvent } from '../hooks/pain.js';
-import { trackFriction } from './session-tracker.js';
-import { SystemLogger } from './system-logger.js';
-import { createTraceId } from './evolution-logger.js';
-import { resolveObserverConfig } from './pd-config-loader.js';
-// ── 默认配置 / 内置 seed 词库 ─────────────────────────────────────────────────
-//
-// 注意:完整的 <stateDir>/signal_keywords.json 加载 + 旧词库合并迁移 (spec §5.1)
-// 属于另一项工作,这里先用内置 seed 保证 host 可独立工作。host 接口预留了
-// keywordStore / config 的注入点,plugin 层接入真实文件 store 时无需改逻辑。
-export const DEFAULT_SIGNAL_CONFIG = {
-    enableLlmStage: true,
-    llmTimeoutMs: 30_000,
-    promptTemplate: '',
-    strongPainScore: 70,
-    strongRateLimitPerHour: 5,
-};
-export function buildDefaultKeywordStore() {
-    const terms = {
-        // 高精度纠正短语 (命中即判 STRONG,不走 LLM)
-        '这是错的': { term: '这是错的', category: 'correction', weight: 0.9, precision: 'high', source: 'seed' },
-        '不要自作主张': { term: '不要自作主张', category: 'correction', weight: 0.9, precision: 'high', source: 'seed' },
-        '不应该这么做': { term: '不应该这么做', category: 'correction', weight: 0.9, precision: 'high', source: 'seed' },
-        // 普通歧义词 (仅作 evidence 候选,强制过 Stage2 LLM 二次确认)
-        '不对': { term: '不对', category: 'correction', weight: 0.5, precision: 'ambiguous', source: 'seed' },
-        '错了': { term: '错了', category: 'correction', weight: 0.5, precision: 'ambiguous', source: 'seed' },
-        '搞什么': { term: '搞什么', category: 'empathy', weight: 0.5, precision: 'ambiguous', source: 'seed' },
-    };
-    return { version: 1, terms };
-}
-const ONE_HOUR_MS = 60 * 60 * 1000;
-export class SignalCollectorHost {
-    wctx;
-    store;
-    config;
-    llmClassifier;
-    /** rate limit 状态:sessionId → STRONG 计数桶 */
-    rateLimit = new Map();
-    constructor(wctx, options = {}) {
-        this.wctx = wctx;
-        this.store = options.keywordStore ?? buildDefaultKeywordStore();
-        this.config = options.config ?? DEFAULT_SIGNAL_CONFIG;
-        this.llmClassifier = options.llmClassifier ?? null;
-    }
-    /**
-     * ★ 同步路径 (prompt.ts before_prompt_build 钩子里调用,绝不能阻塞)。
-     *
-     * 只做:trigger 门控 + Stage1 关键词快扫 + 写 user_turns。
-     * 高精度短语命中 (high) → 直接走 STRONG 分流 (同步,纯内存)。
-     * 普通歧义词 / 未命中 → 入队异步 LLM 确认 (不阻塞)。
-     */
-    /**
-     * 可选入参:lineage 字段(由调用方算好传入,host 不感知 trajectory 结构)。
-     * referencesAssistantTurnId 让诊断 evidence 能 JOIN 到前置 assistant turn。
-     */
-    detectSync(userMessage, sessionId, trigger, options) {
-        // 1. trigger 门控 (保留现有 trigger 门控,仅处理真实用户消息)
-        if (trigger !== 'user') {
-            return;
-        }
-        // 2. Stage1 关键词快扫 (同步,零成本)。detectedAt 由 plugin 层注入(core 不取时间,CodeRabbit #11)
-        const detectedAt = new Date().toISOString();
-        const output = collectSync(userMessage, sessionId, this.store, this.config, detectedAt);
-        // 3. 写 user_turns (复用 recordUserTurn)
-        //    correctionDetected 含义扩展:isSignal && strength=STRONG (spec §5.2)
-        const turnInput = {
-            sessionId,
-            // turnIndex 由调用方传入(基于 event.messages 的真实计数);未传则用时间戳递增避免冲突。
-            turnIndex: options?.turnIndex ?? Date.now(),
-            rawText: userMessage,
-            correctionDetected: output.isSignal && output.strength === 'STRONG',
-            correctionCue: output.matchedTerms.length > 0 ? output.matchedTerms.join(', ') : null,
-            referencesAssistantTurnId: options?.referencesAssistantTurnId ?? null,
-        };
-        try {
-            this.wctx.trajectory?.recordUserTurn?.(turnInput);
-        }
-        catch (e) {
-            SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_TRAJECTORY_FAIL', `recordUserTurn threw: ${String(e)}`);
-        }
-        // 4. 高精度短语命中 (high, STRONG) → 直接走 STRONG 分流 (同步)
-        if (output.isSignal && output.strength === 'STRONG' && output.matchedPrecision === 'high') {
-            this.routeStrong(output, sessionId);
-            return;
-        }
-        // 5. 普通歧义词 / 未命中 → 入队异步 LLM 确认 (不阻塞 prompt hook)
-        if (output.needsLlmConfirmation) {
-            const pending = {
-                output,
-                sessionId,
-                text: userMessage,
-                traceId: createTraceId(),
-            };
-            // fire-and-forget,失败不影响用户消息处理 (spec §4.2)
-            void this.detectAsyncAndRoute(pending);
-        }
-    }
-    /**
-     * ★ 异步路径 (fire-and-forget)。
-     *
-     * 1. Stage2 LLM 确认 (后台,不阻塞用户)
-     * 2. LLM 不可用 → 降级:empathy ambiguous 候选作为 WEAK 信号路由(保留旧版 GFI 累积);
-     *    correction ambiguous / 未命中候选丢弃(不触发 STRONG,避免误判泛滥)
-     * 3. 按 strength 分流:STRONG → emitPainDetectedEvent;WEAK → trackFriction 累积 GFI;none → 仅记录
-     */
-    async detectAsyncAndRoute(pending) {
-        // 1. Stage2 LLM 确认
-        let confirmed;
-        if (this.llmClassifier && this.config.enableLlmStage) {
-            let llmResult = null;
-            try {
-                llmResult = await this.llmClassifier(pending.text, this.config.promptTemplate);
-            }
-            catch (e) {
-                SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_LLM_PARSE_FAIL', `LLM classifier threw: ${String(e)}`);
-            }
-            const llmDetectedAt = new Date().toISOString();
-            if (llmResult) {
-                confirmed = mapLlmResultToOutput(llmResult, pending.text, pending.sessionId, this.config, llmDetectedAt);
-            }
-            else {
-                // LLM 返回非法结果 → 当 none 处理 (rc-1),降级不静默
-                SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_LLM_PARSE_FAIL', 'LLM returned invalid result, treating as none');
-                confirmed = mapLlmResultToOutput({ is_feedback: false, type: 'none', confidence: 1, reason: 'LLM parse failed' }, pending.text, pending.sessionId, this.config, llmDetectedAt);
-            }
-        }
-        else {
-            // LLM 不可用 → 降级:empathy ambiguous 候选作为 WEAK 信号路由(累积 GFI,不触发 STRONG)。
-            // 保留旧版 empathy keyword matcher 的 GFI 累积行为,避免 LLM 未配置(默认)时
-            // empathy 检测完全失效。correction ambiguous 候选仍然丢弃(旧版 correction cue
-            // 不触发 trackFriction,仅 recordUserTurn,已在 detectSync 中完成)。
-            if (pending.output.matchedPrecision === 'ambiguous' && pending.output.matchedTerms.length > 0) {
-                const hasEmpathyMatch = pending.output.matchedTerms.some((term) => this.store.terms[term]?.category === 'empathy');
-                if (hasEmpathyMatch) {
-                    SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_LLM_DEGRADED_WEAK', 'LLM unavailable, routing empathy ambiguous as WEAK (GFI accumulation, no STRONG trigger)');
-                    const degradedOutput = {
-                        ...pending.output,
-                        isSignal: true,
-                        type: 'empathy',
-                        strength: 'WEAK',
-                        detectionSource: 'keyword',
-                        needsLlmConfirmation: false,
-                    };
-                    this.routeWeak(degradedOutput, pending.sessionId);
-                    return;
-                }
-            }
-            SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_LLM_DEGRADED', 'LLM unavailable, dropping candidate (no STRONG trigger)');
-            return;
-        }
-        // 3. 按 strength 分流
-        if (confirmed.isSignal && confirmed.strength === 'STRONG') {
-            this.routeStrong(confirmed, pending.sessionId);
-        }
-        else if (confirmed.isSignal && confirmed.strength === 'WEAK') {
-            this.routeWeak(confirmed, pending.sessionId);
-        }
-        // none → 仅记录,无副作用
-    }
-    /**
-     * STRONG 分流 → emitPainDetectedEvent (修断裂 ③)。
-     * 带 STRONG rate limit 门控 (spec §7.2):单 session 每小时上限 strongRateLimitPerHour。
-     */
-    routeStrong(output, sessionId) {
-        if (!this.tryConsumeRateLimit(sessionId)) {
-            SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_STRONG_RATE_LIMITED', 'STRONG signal suppressed by rate limit'); // 不记录 sessionId(隐私,CodeRabbit #2)
-            return;
-        }
-        const reason = output.llmReason
-            || (output.matchedTerms.length > 0
-                ? `User correction detected: ${output.matchedTerms.join(', ')}`
-                : 'User correction detected');
-        // emitPainDetectedEvent 是 async,但同步路径不能 await (会阻塞 prompt hook)。
-        // 这里 fire-and-forget,失败 catch (不 throw,不阻断用户消息处理)。
-        void emitPainDetectedEvent(this.wctx, {
-            ts: new Date().toISOString(),
-            type: 'pain_detected',
-            data: {
-                painId: `correction_${createTraceId()}`, // 唯一 ID,避免同毫秒碰撞(CodeRabbit #3)
-                painType: 'user_frustration',
-                source: 'user_correction', // Layer 2 强信号 (spec §6.1)
-                reason,
-                score: this.config.strongPainScore, // STRONG_PAIN_SCORE 默认 70
-                sessionId,
-                agentId: 'main',
-                provenance: 'openclaw_context_bound',
-                evidence: [
-                    { sourceRef: 'signal_collector', note: output.evidence.excerpt },
-                ],
-            },
-        }, { recordObservability: true }).catch((e) => {
-            SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_EMIT_FAIL', `emitPainDetectedEvent failed: ${String(e)}`);
-        });
-    }
-    /**
-     * WEAK 分流 → trackFriction 累积 GFI + 写 evidence (维持现状,spec §3.2)。
-     *
-     * WEAK 是 Layer 3 弱信号,用较小的摩擦分(20)累积,过 highGfi 阈值(70)才触发诊断。
-     * 不用 strongPainScore(70),因为 WEAK 单条不该直接顶满 GFI。
-     */
-    routeWeak(output, sessionId) {
-        try {
-            const hash = createHash('sha256')
-                .update(`${output.evidence.detectedAt}:${sessionId}`)
-                .digest('hex')
-                .slice(0, 32);
-            trackFriction(sessionId, 20, hash, this.wctx.workspaceDir, {
-                source: 'user_empathy',
-            });
-        }
-        catch (e) {
-            SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_TRACK_FRICTION_FAIL', `trackFriction threw: ${String(e)}`);
-        }
-    }
-    /**
-     * STRONG rate limit 门控:成功消耗一个名额返回 true;超限返回 false。
-     * 窗口满一小时自动重置。
-     */
-    tryConsumeRateLimit(sessionId) {
-        const limit = this.config.strongRateLimitPerHour;
-        const now = Date.now();
-        let bucket = this.rateLimit.get(sessionId);
-        if (!bucket || now - bucket.windowStart >= ONE_HOUR_MS) {
-            bucket = { count: 0, windowStart: now };
-            this.rateLimit.set(sessionId, bucket);
-        }
-        if (bucket.count >= limit) {
-            return false;
-        }
-        bucket.count += 1;
-        return true;
-    }
-}
-/**
- * 从 .pd/config.yaml 的 signalCollector runtimeProfile 构造 SignalLlmClassifier。
- * 完成配置单轨化(spec §3.3 决策3):统一走 .pd/config.yaml,移除 empathy 的 workflows.yaml 双轨。
- *
- * 返回 null 的情况(走纯关键词降级,rc-9 不静默):
- * - feature flag signal_collector 关闭
- * - runtimeProfile 未配置 / apiKeyEnv 缺失
- * - profile 是 openclaw 类型(observer 不支持)
- *
- * 这是 Task 11 的最后一块:让本地 LLM(LMStudio)真正参与检测。
- */
-export function createSignalLlmClassifierFromConfig(wctx, logger) {
-    try {
-        const cfg = resolveObserverConfig(wctx.workspaceDir, 'signal_collector', 'signalCollector', logger);
-        if (!cfg.enabled) {
-            logger?.debug?.(`[PD:Signal] LLM classifier disabled: ${cfg.reason}`);
-            return null;
-        }
-        if (cfg.readiness !== 'not_ready' && cfg.readiness !== 'ready') {
-            // needs_setup / disabled / config_malformed → 降级
-            logger?.debug?.(`[PD:Signal] LLM classifier not ready (${cfg.readiness}): ${cfg.reason}. ${cfg.nextAction}`);
-            return null;
-        }
-        if (!cfg.provider || !cfg.model || !cfg.apiKeyEnv) {
-            logger?.debug?.(`[PD:Signal] LLM classifier missing provider/model/apiKeyEnv`);
-            return null;
-        }
-        const adapter = new PiAiRuntimeAdapter({
-            provider: cfg.provider,
-            model: cfg.model,
-            apiKeyEnv: cfg.apiKeyEnv,
-            timeoutMs: cfg.timeoutMs ?? 30_000,
-            baseUrl: cfg.baseUrl ?? undefined,
-            workspace: wctx.workspaceDir,
-        });
-        // 包装成 SignalLlmClassifier:内部调 startRun/pollRun/fetchOutput + buildLlmPrompt + parseLlmClassification
-        const classifier = async (text, _promptTemplate) => {
-            void _promptTemplate; // 用 core 的 buildLlmPrompt(标准化的),不用外部传入
-            const prompt = buildLlmPrompt(text);
-            try {
-                const handle = await adapter.startRun({
-                    agentSpec: { agentId: 'signal-collector', schemaVersion: '1' },
-                    inputPayload: { prompt },
-                    contextItems: [],
-                    timeoutMs: cfg.timeoutMs ?? 30_000,
-                });
-                let status = await adapter.pollRun(handle.runId);
-                const deadline = Date.now() + (cfg.timeoutMs ?? 30_000);
-                while (status.status === 'running' && Date.now() < deadline) {
-                    await new Promise((r) => setTimeout(r, 500));
-                    status = await adapter.pollRun(handle.runId);
-                }
-                if (status.status !== 'succeeded') {
-                    SystemLogger.log(wctx.workspaceDir, 'SIGNAL_LLM_TIMEOUT', JSON.stringify({ status: status.status }));
-                    return null;
-                }
-                const output = await adapter.fetchOutput(handle.runId);
-                const payload = output?.payload;
-                let rawOutput = '';
-                if (typeof payload === 'string') {
-                    rawOutput = payload;
-                }
-                else if (typeof payload === 'object' && payload !== null && Object.hasOwn(payload, 'output')) {
-                    const maybeOutput = payload.output;
-                    if (typeof maybeOutput === 'string') {
-                        rawOutput = maybeOutput;
-                    }
-                }
-                const parsed = parseLlmClassification(rawOutput);
-                return parsed.valid ? parsed.value : null;
-            }
-            catch (e) {
-                SystemLogger.log(wctx.workspaceDir, 'SIGNAL_LLM_FAILED', String(e).slice(0, 200));
-                return null;
-            }
-        };
-        return classifier;
-    }
-    catch (e) {
-        logger?.warn?.(`[PD:Signal] createSignalLlmClassifierFromConfig failed: ${String(e)}`);
-        return null;
-    }
-}

package/plugin/dist/core/system-logger.js

@@ -1,113 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { resolvePdPath, PD_FILES } from './paths.js';
-/**
- * System Logger for Principles Disciple
- *
- * Writes critical evolutionary events to date-stamped log files:
- *   memory/logs/SYSTEM_YYYY-MM-DD.log
- *
- * Uses asynchronous writing to avoid blocking the Node.js event loop.
- * Automatically rotates to a new file at midnight.
- * Old log files are automatically cleaned up based on retention policy.
- */
-// Cache for current log file path, invalidated when date changes
-let cachedLogFile;
-let cachedLogDate;
-/**
- * Log retention: delete SYSTEM logs older than this many days.
- * Set to 0 to disable cleanup.
- */
-const LOG_RETENTION_DAYS = 7;
-/**
- * Get the system log file path for a given date.
- * Format: memory/logs/SYSTEM_YYYY-MM-DD.log
- */
-function getSystemLogPath(workspaceDir, date) {
-    const dateStr = date.toISOString().slice(0, 10); // YYYY-MM-DD
-    const logDir = path.dirname(resolvePdPath(workspaceDir, 'SYSTEM_LOG'));
-    const baseName = path.basename(PD_FILES.SYSTEM_LOG, '.log');
-    return path.join(logDir, `${baseName}_${dateStr}.log`);
-}
-/**
- * Get today's date string (YYYY-MM-DD).
- */
-function getTodayStr() {
-    return new Date().toISOString().slice(0, 10);
-}
-/**
- * Clean up old SYSTEM log files, keeping only LOG_RETENTION_DAYS.
- * Called automatically on first log write of each day.
- */
-function cleanupOldLogs(workspaceDir) {
-    if (LOG_RETENTION_DAYS <= 0)
-        return;
-    try {
-        const logDir = path.dirname(resolvePdPath(workspaceDir, 'SYSTEM_LOG'));
-        const baseName = path.basename(PD_FILES.SYSTEM_LOG, '.log');
-        const prefix = `${baseName}_`;
-        if (!fs.existsSync(logDir))
-            return;
-        const cutoffMs = Date.now() - LOG_RETENTION_DAYS * 24 * 60 * 60 * 1000;
-        const files = fs.readdirSync(logDir);
-        for (const file of files) {
-            if (!file.startsWith(prefix) || !file.endsWith('.log'))
-                continue;
-            const filePath = path.join(logDir, file);
-            const stat = fs.statSync(filePath);
-            if (stat.mtimeMs < cutoffMs) {
-                fs.unlinkSync(filePath);
-            }
-        }
-    }
-    catch {
-        // Silently fail cleanup - don't crash logging for cleanup failures
-    }
-}
-// Track if cleanup has run today
-let lastCleanupDate;
-export const SystemLogger = {
-    log(workspaceDir, eventType, message) {
-        if (!workspaceDir)
-            return;
-        try {
-            const today = getTodayStr();
-            // Check if date changed - invalidate cache and run cleanup
-            if (cachedLogDate !== today) {
-                cachedLogDate = today;
-                cachedLogFile = undefined;
-                // Run cleanup once per day when date changes
-                if (lastCleanupDate !== today) {
-                    lastCleanupDate = today;
-                    cleanupOldLogs(workspaceDir);
-                }
-            }
-            // Get or create log file path
-            if (!cachedLogFile) {
-                cachedLogFile = getSystemLogPath(workspaceDir, new Date());
-                const logDir = path.dirname(cachedLogFile);
-                if (!fs.existsSync(logDir)) {
-                    fs.mkdirSync(logDir, { recursive: true });
-                }
-            }
-            const timestamp = new Date().toISOString();
-            // Format: [YYYY-MM-DDTHH:mm:ss.sssZ] [EVENT_TYPE] Message
-            const logEntry = `[${timestamp}] [${eventType.padEnd(15)}] ${message}\n`;
-            // Use fire-and-forget async append to prevent blocking
-            fs.appendFile(cachedLogFile, logEntry, 'utf8', (_err) => {
-                // Silently drop errors (e.g. disk full) to not crash the gateway
-            });
-        }
-        catch (e) { // eslint-disable-line @typescript-eslint/no-unused-vars -- Reason: intentionally unused - silently fail if we can't setup the log
-            // Silently fail if we can't setup the log
-        }
-    },
-    /**
-     * Force refresh of the cached log file path.
-     * Call this at midnight or when the date changes to ensure proper rotation.
-     */
-    refreshCache() {
-        cachedLogDate = undefined;
-        cachedLogFile = undefined;
-    }
-};

package/plugin/dist/core/thinking-models.js

@@ -1,94 +0,0 @@
-/**
- * Thinking Models — Plugin I/O Adapter (Stage 3 slim)
- *
- * Pure logic (BUILTIN_PATTERNS, BUILTIN_PATTERN_MAP, getFallbackName,
- * getFallbackDescription, deriveThinkingScenarios, types) lives in
- * @principles/core/runtime-v2/thinking-models.
- *
- * This file owns only the I/O boundary: reading THINKING_OS.md from a
- * workspace dir and merging it with the builtin patterns. It re-exports
- * the pure functions and types so existing relative imports
- * (../core/thinking-models.js) continue to resolve.
- */
-import { loadThinkingOsFromWorkspace, generateDetectionPatterns } from './thinking-os-parser.js';
-import { BUILTIN_PATTERN_MAP, getFallbackName, getFallbackDescription, } from '@principles/core/runtime-v2';
-// Re-export pure logic + types so existing imports from this module keep working.
-export { BUILTIN_PATTERN_MAP, getFallbackName, getFallbackDescription, } from '@principles/core/runtime-v2';
-export { deriveThinkingScenarios } from '@principles/core/runtime-v2';
-// ---------------------------------------------------------------------------
-// Runtime model definitions — merged from THINKING_OS.md + builtin patterns
-// ---------------------------------------------------------------------------
-let _cachedDefinitions = null;
-let _cachedWorkspace = null;
-/**
- * Load thinking model definitions dynamically from THINKING_OS.md.
- * Falls back to built-in definitions if parsing fails.
- *
- * @param workspaceDir Optional. If provided, loads from that workspace's THINKING_OS.md.
- */
-export function listThinkingModels(workspaceDir) {
-    const cacheKey = workspaceDir ?? '__global__';
-    if (_cachedDefinitions && _cachedWorkspace === cacheKey) {
-        return _cachedDefinitions.slice();
-    }
-    const models = [];
-    if (workspaceDir) {
-        // Try to load from THINKING_OS.md
-        const directives = loadThinkingOsFromWorkspace(workspaceDir);
-        if (directives.length > 0) {
-            for (const dir of directives) {
-                const builtin = BUILTIN_PATTERN_MAP.get(dir.id);
-                const patterns = builtin?.patterns ?? generateDetectionPatterns(dir.trigger);
-                if (patterns.length === 0) {
-                    console.warn(`[PD:thinking-models] No detection patterns for ${dir.id}: "${dir.trigger}"`);
-                }
-                models.push({
-                    id: dir.id,
-                    name: dir.name,
-                    description: dir.must,
-                    antiPattern: dir.forbidden || undefined,
-                    patterns,
-                    baselineScenarios: builtin?.baselineScenarios ?? [],
-                });
-            }
-            _cachedDefinitions = models;
-            _cachedWorkspace = cacheKey;
-            return models.slice();
-        }
-    }
-    // Fallback: built-in definitions
-    for (const [id, builtin] of BUILTIN_PATTERN_MAP) {
-        models.push({
-            id,
-            name: getFallbackName(id),
-            description: getFallbackDescription(id),
-            patterns: builtin.patterns,
-            baselineScenarios: builtin.baselineScenarios,
-        });
-    }
-    _cachedDefinitions = models;
-    _cachedWorkspace = cacheKey;
-    return models.slice();
-}
-export function getThinkingModel(modelId, workspaceDir) {
-    const models = listThinkingModels(workspaceDir);
-    return models.find(m => m.id === modelId);
-}
-export function detectThinkingModelMatches(text, workspaceDir) {
-    if (!text)
-        return [];
-    const models = listThinkingModels(workspaceDir);
-    const matches = [];
-    for (const model of models) {
-        for (const pattern of model.patterns) {
-            if (pattern.test(text)) {
-                matches.push({
-                    modelId: model.id,
-                    matchedPattern: pattern.source,
-                });
-                break;
-            }
-        }
-    }
-    return matches;
-}

package/plugin/dist/core/thinking-os-parser.js

@@ -1,132 +0,0 @@
-/**
- * Thinking OS XML Parser
- *
- * Parses THINKING_OS.md to extract directive definitions.
- * THINKING_OS.md is the single source of truth for thinking models.
- *
- * XML structure:
- *   <directive id="T-01" name="MAP_BEFORE_TERRITORY">
- *     <trigger>...</trigger>
- *     <must>...</must>
- *     <forbidden>...</forbidden>
- *   </directive>
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-import { resolvePdPath } from './paths.js';
-/**
- * Extract a single XML tag's text content from a string.
- */
-function extractTag(content, tagName) {
-    const regex = new RegExp(`<${tagName}>([\\s\\S]*?)</${tagName}>`, 'i');
-    const match = content.match(regex);
-    if (!match)
-        return '';
-    const raw = match[1];
-    if (!raw)
-        return '';
-    return raw.trim().replace(/\s+/g, ' ');
-}
-/**
- * Parse THINKING_OS.md content and extract all <directive> blocks.
- * Returns empty array if no directives found.
- */
-export function parseThinkingOsMd(content) {
-    const directives = [];
-    // Match all <directive ...> ... </directive> blocks
-    const directiveRegex = /<directive\s+([^>]*)>([\s\S]*?)<\/directive>/gi;
-    let _match = null;
-    while ((_match = directiveRegex.exec(content)) !== null) {
-        const attrs = _match[1];
-        const body = _match[2];
-        if (!attrs || !body)
-            continue;
-        const idMatch = /id="([^"]+)"/i.exec(attrs);
-        const nameMatch = /name="([^"]+)"/i.exec(attrs);
-        if (!idMatch)
-            continue;
-        const id = idMatch[1];
-        if (!id)
-            continue;
-        const directive = {
-            id,
-            name: nameMatch ? (nameMatch[1] ?? '') : '',
-            trigger: extractTag(body, 'trigger'),
-            must: extractTag(body, 'must'),
-            forbidden: extractTag(body, 'forbidden'),
-        };
-        directives.push(directive);
-    }
-    return directives;
-}
-/**
- * Load THINKING_OS.md from the plugin templates for a given language.
- * Falls back to the workspace THINKING_OS.md if it exists.
- */
-export function loadThinkingOsFromWorkspace(workspaceDir, language = 'zh') {
-    // Priority 1: workspace's own THINKING_OS.md
-    const workspacePath = resolvePdPath(workspaceDir, 'THINKING_OS');
-    if (fs.existsSync(workspacePath)) {
-        try {
-            const content = fs.readFileSync(workspacePath, 'utf-8');
-            const directives = parseThinkingOsMd(content);
-            if (directives.length > 0)
-                return directives;
-        }
-        catch {
-            // Fall through to template
-        }
-    }
-    // ES Module compatible __dirname (must be inside function for bundler)
-    const currentDir = path.dirname(fileURLToPath(import.meta.url));
-    // Priority 2: plugin template for the given language
-    const templatePath = path.join(path.dirname(path.dirname(path.dirname(currentDir))), 'templates', 'langs', language, 'principles', 'THINKING_OS.md');
-    if (fs.existsSync(templatePath)) {
-        try {
-            const content = fs.readFileSync(templatePath, 'utf-8');
-            return parseThinkingOsMd(content);
-        }
-        catch {
-            // Fall through to zh template
-        }
-    }
-    // Priority 3: zh template as ultimate fallback
-    const zhPath = path.join(path.dirname(path.dirname(path.dirname(currentDir))), 'templates', 'langs', 'zh', 'principles', 'THINKING_OS.md');
-    if (fs.existsSync(zhPath)) {
-        try {
-            const content = fs.readFileSync(zhPath, 'utf-8');
-            return parseThinkingOsMd(content);
-        }
-        catch {
-            return [];
-        }
-    }
-    return [];
-}
-/**
- * Extract meaningful detection keywords from a trigger string.
- * Returns an array of regex patterns.
- */
-export function generateDetectionPatterns(trigger) {
-    if (!trigger)
-        return [];
-    const patterns = [];
-    // Extract Chinese phrases: 3-8 character sequences that are meaningful
-    const chinesePattern = /[\u4e00-\u9fff]{3,8}/g;
-    const chineseMatches = trigger.match(chinesePattern) ?? [];
-    for (const phrase of chineseMatches) {
-        patterns.push(phrase);
-    }
-    // Extract English words/phrases: sequences of letters
-    const englishPattern = /[a-zA-Z]{3,20}(?:\s+[a-zA-Z]{3,20}){0,3}/g;
-    const englishMatches = trigger.match(englishPattern) ?? [];
-    for (const phrase of englishMatches) {
-        const cleaned = phrase.trim();
-        if (cleaned.length >= 3) {
-            patterns.push(cleaned);
-        }
-    }
-    // Convert to case-insensitive regexes
-    return patterns.map(p => new RegExp(p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i'));
-}

package/plugin/dist/core/trajectory-types.js

@@ -1,8 +0,0 @@
-/**
- * Trajectory database type definitions.
- *
- * PURPOSE: Track task outcomes, trust changes, and evolution progress over time.
- * USAGE: Insights, trends, and Phase 3 supporting evidence (where explicitly allowed).
- * NOT FOR: Control decisions, Phase 3 eligibility, or real-time operations.
- */
-export {};