principles-disciple 1.126.0 → 1.128.0

package/{src/core/system-logger.ts → dist/core/system-logger.js}

@@ -1,7 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { resolvePdPath, PD_FILES } from './paths.js';
-
 /**
  * System Logger for Principles Disciple
  *
@@ -12,76 +11,67 @@ import { resolvePdPath, PD_FILES } from './paths.js';
  * 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: string | undefined;
-let cachedLogDate: string | undefined;
-
+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: string, date: Date): string {
+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(): string {
+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: string): void {
-    if (LOG_RETENTION_DAYS <= 0) return;
-
+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;
-
+        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;
-
+            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 {
+    }
+    catch {
         // Silently fail cleanup - don't crash logging for cleanup failures
     }
 }
-
 // Track if cleanup has run today
-let lastCleanupDate: string | undefined;
-
+let lastCleanupDate;
 export const SystemLogger = {
-    log(workspaceDir: string | undefined, eventType: string, message: string): void {
-        if (!workspaceDir) return;
-
+    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;
@@ -92,7 +82,6 @@ export const SystemLogger = {
                     cleanupOldLogs(workspaceDir);
                 }
             }
-
             // Get or create log file path
             if (!cachedLogFile) {
                 cachedLogFile = getSystemLogPath(workspaceDir, new Date());
@@ -101,26 +90,23 @@ export const SystemLogger = {
                     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
+        }
+        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(): void {
+    refreshCache() {
         cachedLogDate = undefined;
         cachedLogFile = undefined;
     }

package/dist/core/thinking-models.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Thinking Models — Detection Engine
+ *
+ * Core principle metadata (id, name, description) comes from the
+ * Core Principle Registry in @principles/core/runtime-v2.
+ * Detection patterns are carefully tuned regexes that match AI output text.
+ *
+ * Flow:
+ *   Core Principle Registry (authority) → id, name, description
+ *   BUILTIN_PATTERNS (engine) → detection regexes per model id
+ *   THINKING_MODELS (merged) → full definitions with patterns
+ */
+export interface ThinkingModelDefinition {
+    id: string;
+    name: string;
+    description: string;
+    antiPattern?: string;
+    patterns: RegExp[];
+    baselineScenarios: string[];
+}
+export interface ThinkingModelMatch {
+    modelId: string;
+    matchedPattern: string;
+}
+export interface ThinkingScenarioContext {
+    recentToolCalls?: {
+        toolName: string;
+        outcome: 'success' | 'failure' | 'blocked';
+        errorType?: string | null;
+    }[];
+    recentPainEvents?: {
+        source: string;
+        score: number;
+    }[];
+    recentGateBlocks?: {
+        toolName: string;
+        reason: string;
+    }[];
+    recentUserCorrections?: {
+        correctionCue?: string | null;
+    }[];
+    recentPrincipleEvents?: {
+        eventType: string;
+        principleId?: string | 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 declare function listThinkingModels(workspaceDir?: string): ThinkingModelDefinition[];
+/**
+ * Clear the cached model definitions.
+ * Call this when THINKING_OS.md changes.
+ */
+export declare function clearThinkingModelCache(): void;
+export declare function getThinkingModel(modelId: string, workspaceDir?: string): ThinkingModelDefinition | undefined;
+export declare function detectThinkingModelMatches(text: string, workspaceDir?: string): ThinkingModelMatch[];
+/**
+ * Get all model definitions for display purposes (no patterns).
+ */
+export declare function getThinkingModelDefinitions(workspaceDir?: string): {
+    modelId: string;
+    name: string;
+    description: string;
+    antiPattern?: string;
+}[];
+export declare function deriveThinkingScenarios(modelId: string, context: ThinkingScenarioContext): string[];

package/dist/core/thinking-models.js

@@ -0,0 +1,300 @@
+/**
+ * Thinking Models — Detection Engine
+ *
+ * Core principle metadata (id, name, description) comes from the
+ * Core Principle Registry in @principles/core/runtime-v2.
+ * Detection patterns are carefully tuned regexes that match AI output text.
+ *
+ * Flow:
+ *   Core Principle Registry (authority) → id, name, description
+ *   BUILTIN_PATTERNS (engine) → detection regexes per model id
+ *   THINKING_MODELS (merged) → full definitions with patterns
+ */
+import { loadThinkingOsFromWorkspace, generateDetectionPatterns } from './thinking-os-parser.js';
+import { CORE_PRINCIPLES } from '@principles/core/runtime-v2';
+const BUILTIN_PATTERNS = [
+    {
+        id: 'T-01',
+        patterns: [
+            // Thinking process language (AI reasoning output)
+            /let me (first )?(understand|map|outline|survey|review the (structure|architecture|dependencies))/i,
+            /before (changing|editing|touching) anything/i,
+            /让我先(梳理|理解|看看|盘点).*(结构|架构|依赖|全貌)/i,
+            /在执行任何.*/i,
+            // Decision directive language (nocturnal artifact betterDecision)
+            /review (the |)(docs|architecture|structure|requirements|constraints|dependencies|authorization)/i,
+            /read (the |)(docs|architecture|requirements|constraints|logs?|error|stack)/i,
+            /check (the |)(docs|architecture|source|authorization|requirements|error)/i,
+            /understand (the |)(structure|architecture|requirements|constraints|full (context|picture))/i,
+            /first (to|and|,) (verify|check|review|read|understand|confirm|diagnose)/i,
+            /(verify|check|review|read|confirm) .+ first/i,
+        ],
+        baselineScenarios: ['exploration', 'discovery'],
+    },
+    {
+        id: 'T-02',
+        patterns: [
+            // Thinking process language
+            /(type|test|contract|schema|interface) (constraint|requirement|check|validation)/i,
+            /(必须|需要).*(遵守|符合|满足).*(类型|测试|契约|接口|规范)/i,
+            // Decision directive language
+            /(trust|follow|respect|adhere to|meet) (the |)(constraint|requirement|contract|interface|specification|schema|type)/i,
+            /(check|verify|validate|ensure) (the |)(constraint|requirement|contract|interface|specification|type|schema)/i,
+        ],
+        baselineScenarios: ['constraint-check', 'contract-verification'],
+    },
+    {
+        id: 'T-03',
+        patterns: [
+            // Thinking process language
+            /based on (the |this )?(evidence|logs?|output|error|stack trace|test result)/i,
+            /let me (check|verify|confirm|read|look at) (the |)(actual|source|code|file|log)/i,
+            /根据(日志|证据|输出|报错|堆栈|测试结果)/i,
+            // Decision directive language (evidence-based decision)
+            /(verify|check|confirm) (the |)(error|error code|error message|actual|evidence|logs?|output|stack)/i,
+            /(error|failure) (logs?|output|stack trace|message|code) (before|then)/i,
+            /(look at|read) (the |)(error|logs?|output|stack|actual|evidence|file|code)/i,
+        ],
+        baselineScenarios: ['evidence-gathering', 'verification'],
+    },
+    {
+        id: 'T-04',
+        patterns: [
+            // Thinking process language
+            /this (is|would be) (irreversible|destructive|permanent|not easily undone)/i,
+            /(reversible|can be undone|safely roll back)/i,
+            /(不可逆|破坏性|无法回滚|可以回滚|安全撤销)/i,
+            // Decision directive language
+            /(irreversible|destructive|permanent|high impact) (action|change|operation)/i,
+            /(must be|need to be|should be) (reviewed|confirmed|verified|checked) (first|before)/i,
+            /(get|obtain|ask for) (confirmation|authorization|approval|permission) (first|before)/i,
+        ],
+        baselineScenarios: ['risk-management', 'reversibility'],
+    },
+    {
+        id: 'T-05',
+        patterns: [
+            // Thinking process language
+            /we (must|should) (not|never|avoid|prevent|ensure we don't)/i,
+            /(critical|important) (not to|that we don't|to avoid)/i,
+            /(绝不能|必须避免|不可|禁止|确保不会)/i,
+            // Decision directive language
+            /(must|should|need to) (not |never |avoid )?(check|verify|review|read|confirm|ask)/i,
+            /(safety|safe) (check|gate|checklist|guard)/i,
+        ],
+        baselineScenarios: ['guardrails', 'safety-rails'],
+    },
+    {
+        id: 'T-06',
+        patterns: [
+            // Thinking process language
+            /(simpl(er|est|ify)|minimal|straightforward|lean) (approach|solution|fix|implementation)/i,
+            /(simple is better|keep it simple|no need to over)/i,
+            /(最简|更简单|精简|没必要过度设计)/i,
+            // Decision directive language
+            /(minimal|smallest|narrowest) (change|modification|impact|approach)/i,
+            /(only|just) (change|modify|touch|edit|affect) (the |what)/i,
+        ],
+        baselineScenarios: ['simplification', 'pragmatism'],
+    },
+    {
+        id: 'T-07',
+        patterns: [
+            // Thinking process language
+            /(minimal|smallest|narrowest|least) (change|diff|modification|impact)/i,
+            /only (change|modify|touch|edit) (the |what)/i,
+            /(最小改动|最小变更|只改|只动必要部分)/i,
+            // Decision directive language
+            /(limit|narrow) (the |)(change|impact|scope|blast radius)/i,
+        ],
+        baselineScenarios: ['minimal-diff', 'blast-radius-control'],
+    },
+    {
+        id: 'T-08',
+        patterns: [
+            // Thinking process language
+            /this (error|failure|issue) (tells us|indicates|signals|suggests|means)/i,
+            /let me (stop|pause|step back|reconsider|rethink)/i,
+            /这个(错误|失败|问题).*(说明|意味着|提示)/i,
+            /让我(停下|暂停|退一步|重新考虑|重新审视)/i,
+            // Decision directive language
+            /(diagnose|analyze|investigate) (the |)(root |)(cause|reason|error|failure) (first|before)/i,
+            /(understand|diagnose|analyze) (the |)(error|failure|issue|problem) (first|before)/i,
+        ],
+        baselineScenarios: ['reflection', 'pain-response'],
+    },
+    {
+        id: 'T-09',
+        patterns: [
+            // Thinking process language
+            /(break|split|decompose|divide) (this |the task |it )?(into|down)/i,
+            /(step 1|first,? (we|i|let's)|phase 1)/i,
+            /(拆分|分解|分步|分阶段|第一步)/i,
+            // Decision directive language
+            /(break|split|decompose|divide) (the |)(task|problem|action) (into|into steps)/i,
+        ],
+        baselineScenarios: ['decomposition', 'phased-execution'],
+    },
+    {
+        id: 'T-10',
+        patterns: [
+            // Thinking process language
+            /let me (write|save|record|note down|document)/i,
+            /memory.*scratchpad|write.*plan\.md|write.*memory|memory.*persist/i,
+            /(让我.*写入|写入.*memory|记录.*scratchpad)/i,
+            // Decision directive language
+            /(write|save|record|note) (the |)(conclusion|decision|plan|next step) (to|in) (file|plan\.md|scratchpad)/i,
+        ],
+        baselineScenarios: ['memory-persistence', 'state-externalization'],
+    },
+];
+const BUILTIN_PATTERN_MAP = new Map(BUILTIN_PATTERNS.map((p) => [p.id, p]));
+// Fallback name/description lookup — delegates to Core Principle Registry
+function getFallbackName(id) {
+    const entry = CORE_PRINCIPLES.find(p => p.id === id);
+    return entry?.name ?? id;
+}
+function getFallbackDescription(id) {
+    const entry = CORE_PRINCIPLES.find(p => p.id === id);
+    return entry?.statement ?? '';
+}
+// ---------------------------------------------------------------------------
+// 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 bp of BUILTIN_PATTERNS) {
+        models.push({
+            id: bp.id,
+            name: getFallbackName(bp.id),
+            description: getFallbackDescription(bp.id),
+            patterns: bp.patterns,
+            baselineScenarios: bp.baselineScenarios,
+        });
+    }
+    _cachedDefinitions = models;
+    _cachedWorkspace = cacheKey;
+    return models.slice();
+}
+/**
+ * Clear the cached model definitions.
+ * Call this when THINKING_OS.md changes.
+ */
+export function clearThinkingModelCache() {
+    _cachedDefinitions = null;
+    _cachedWorkspace = null;
+}
+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;
+}
+/**
+ * Get all model definitions for display purposes (no patterns).
+ */
+export function getThinkingModelDefinitions(workspaceDir) {
+    return listThinkingModels(workspaceDir).map(m => ({
+        modelId: m.id,
+        name: m.id + ': ' + m.name,
+        description: m.description,
+        antiPattern: m.antiPattern,
+    }));
+}
+export function deriveThinkingScenarios(modelId, context) {
+    const scenarios = new Set(getThinkingModel(modelId)?.baselineScenarios ?? []);
+    if ((context.recentToolCalls ?? []).some((call) => call.outcome === 'failure')) {
+        scenarios.add('after-tool-failure');
+    }
+    // after-recovery: success that follows a failure (not just any success)
+    const calls = context.recentToolCalls ?? [];
+    const hasFailure = calls.some((call) => call.outcome === 'failure');
+    const hasSuccess = calls.some((call) => call.outcome === 'success');
+    if (hasFailure && hasSuccess) {
+        scenarios.add('after-recovery');
+    }
+    if ((context.recentToolCalls ?? []).some((call) => call.outcome === 'blocked')) {
+        scenarios.add('blocked-execution');
+    }
+    if ((context.recentToolCalls ?? []).some((call) => Boolean(call.errorType))) {
+        scenarios.add('incident-response');
+    }
+    if ((context.recentPainEvents ?? []).length > 0) {
+        scenarios.add('user-friction');
+    }
+    if ((context.recentGateBlocks ?? []).length > 0) {
+        scenarios.add('gate-block');
+    }
+    if ((context.recentUserCorrections ?? []).length > 0) {
+        scenarios.add('user-correction');
+    }
+    if ((context.recentPrincipleEvents ?? []).length > 0) {
+        scenarios.add('principle-feedback');
+    }
+    if (modelId === 'T-03') {
+        scenarios.add('root-cause-analysis');
+    }
+    if (modelId === 'T-04' || modelId === 'T-05') {
+        scenarios.add('risk-review');
+    }
+    if (modelId === 'T-08') {
+        scenarios.add('reflection-loop');
+    }
+    if (modelId === 'T-09') {
+        scenarios.add('task-planning');
+    }
+    return Array.from(scenarios);
+}

package/dist/core/thinking-os-parser.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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>
+ */
+export interface ThinkingOsDirective {
+    id: string;
+    name: string;
+    trigger: string;
+    must: string;
+    forbidden: string;
+}
+/**
+ * Parse THINKING_OS.md content and extract all <directive> blocks.
+ * Returns empty array if no directives found.
+ */
+export declare function parseThinkingOsMd(content: string): ThinkingOsDirective[];
+/**
+ * Load THINKING_OS.md from the plugin templates for a given language.
+ * Falls back to the workspace THINKING_OS.md if it exists.
+ */
+export declare function loadThinkingOsFromWorkspace(workspaceDir: string, language?: string): ThinkingOsDirective[];
+/**
+ * Extract meaningful detection keywords from a trigger string.
+ * Returns an array of regex patterns.
+ */
+export declare function generateDetectionPatterns(trigger: string): RegExp[];

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

@@ -0,0 +1,123 @@
+/**
+ * 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 '';
+    return match[1].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, body] = _match;
+        const idMatch = /id="([^"]+)"/i.exec(attrs);
+        const nameMatch = /name="([^"]+)"/i.exec(attrs);
+        if (!idMatch)
+            continue;
+        const directive = {
+            id: idMatch[1],
+            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'));
+}