principles-disciple 1.12.0 → 1.13.0

package/src/core/principle-tree-migration.ts

@@ -0,0 +1,195 @@
+/**
+ * Principle Tree Migration — Migrates trainingStore to tree.principles
+ *
+ * This migration handles the Phase 11 gap: existing principles in trainingStore
+ * were never written to tree.principles, blocking the Rule/Implementation layer.
+ *
+ * Usage:
+ *   - Called automatically by migratePrincipleTree() during plugin initialization
+ *   - Or run manually: node scripts/migrate-principle-tree.mjs <workspace-dir>
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  loadLedger,
+  createPrinciple,
+  type LedgerPrinciple,
+} from './principle-tree-ledger.js';
+import type { LegacyPrincipleTrainingState } from './principle-tree-ledger.js';
+import { SystemLogger } from './system-logger.js';
+
+export interface PrincipleTreeMigrationResult {
+  migratedCount: number;
+  skippedCount: number;
+  errorCount: number;
+  details: Array<{
+    principleId: string;
+    status: 'migrated' | 'skipped' | 'error';
+    reason?: string;
+  }>;
+}
+
+/**
+ * Check if migration is needed by comparing trainingStore and tree.principles
+ */
+export function needsMigration(stateDir: string): boolean {
+  const ledger = loadLedger(stateDir);
+  const trainingStoreCount = Object.keys(ledger.trainingStore).length;
+  const treePrinciplesCount = Object.keys(ledger.tree.principles).length;
+
+  // Migration needed if trainingStore has more principles than tree.principles
+  return trainingStoreCount > treePrinciplesCount;
+}
+
+/**
+ * Create a minimal LedgerPrinciple from LegacyPrincipleTrainingState
+ */
+function trainingStateToTreePrinciple(
+  principleId: string,
+  state: LegacyPrincipleTrainingState,
+  now: string
+): LedgerPrinciple {
+  return {
+    id: principleId,
+    version: 1,
+    text: `Principle ${principleId}`, // Minimal text, will be enriched from PRINCIPLES.md if available
+    triggerPattern: '', // Unknown from legacy data
+    action: '', // Unknown from legacy data
+    status: mapInternalizationStatusToPrincipleStatus(state.internalizationStatus),
+    priority: 'P1', // Default priority
+    scope: 'general',
+    evaluability: state.evaluability,
+    valueScore: 0,
+    adherenceRate: state.complianceRate * 100, // Convert 0-1 to 0-100
+    painPreventedCount: 0,
+    derivedFromPainIds: [],
+    ruleIds: [],
+    conflictsWithPrincipleIds: [],
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+/**
+ * Map internalization status to principle status
+ */
+function mapInternalizationStatusToPrincipleStatus(
+  status: LegacyPrincipleTrainingState['internalizationStatus']
+): 'candidate' | 'active' | 'deprecated' {
+  switch (status) {
+    case 'internalized':
+    case 'deployed_pending_eval':
+      return 'active';
+    case 'regressed':
+    case 'needs_training':
+      return 'candidate';
+    case 'prompt_only':
+    case 'in_training':
+      return 'candidate';
+    default:
+      return 'candidate';
+  }
+}
+
+/**
+ * Migrate trainingStore principles to tree.principles
+ *
+ * This function is idempotent: it only migrates principles that don't exist
+ * in tree.principles yet.
+ */
+export function migratePrincipleTree(
+  stateDir: string,
+  workspaceDir?: string
+): PrincipleTreeMigrationResult {
+  const result: PrincipleTreeMigrationResult = {
+    migratedCount: 0,
+    skippedCount: 0,
+    errorCount: 0,
+    details: [],
+  };
+
+  try {
+    const ledger = loadLedger(stateDir);
+    const now = new Date().toISOString();
+
+    for (const [principleId, state] of Object.entries(ledger.trainingStore)) {
+      // Skip if already exists in tree.principles
+      if (ledger.tree.principles[principleId]) {
+        result.skippedCount++;
+        result.details.push({
+          principleId,
+          status: 'skipped',
+          reason: 'Already exists in tree.principles',
+        });
+        continue;
+      }
+
+      try {
+        const treePrinciple = trainingStateToTreePrinciple(principleId, state, now);
+        createPrinciple(stateDir, treePrinciple);
+
+        result.migratedCount++;
+        result.details.push({
+          principleId,
+          status: 'migrated',
+        });
+
+        if (workspaceDir) {
+          SystemLogger.log(
+            workspaceDir,
+            'PRINCIPLE_TREE_MIGRATED',
+            `Migrated ${principleId} from trainingStore to tree.principles`
+          );
+        }
+      } catch (err) {
+        result.errorCount++;
+        result.details.push({
+          principleId,
+          status: 'error',
+          reason: String(err),
+        });
+
+        if (workspaceDir) {
+          SystemLogger.log(
+            workspaceDir,
+            'PRINCIPLE_TREE_MIGRATION_ERROR',
+            `Failed to migrate ${principleId}: ${String(err)}`
+          );
+        }
+      }
+    }
+
+    if (workspaceDir && result.migratedCount > 0) {
+      SystemLogger.log(
+        workspaceDir,
+        'PRINCIPLE_TREE_MIGRATION_COMPLETE',
+        `Migrated ${result.migratedCount} principles to tree.principles (${result.skippedCount} skipped, ${result.errorCount} errors)`
+      );
+    }
+  } catch (err) {
+    if (workspaceDir) {
+      SystemLogger.log(
+        workspaceDir,
+        'PRINCIPLE_TREE_MIGRATION_FAILED',
+        `Migration failed: ${String(err)}`
+      );
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Run migration if needed (called during plugin initialization)
+ */
+export function runMigrationIfNeeded(
+  stateDir: string,
+  workspaceDir?: string
+): PrincipleTreeMigrationResult | null {
+  if (!needsMigration(stateDir)) {
+    return null;
+  }
+
+  return migratePrincipleTree(stateDir, workspaceDir);
+}

package/src/core/thinking-os-parser.ts

@@ -4,7 +4,7 @@
  * Parses THINKING_OS.md to extract directive definitions.
  * THINKING_OS.md is the single source of truth for thinking models.
  *
- * XML structure:
+ * Required XML structure:
  *   <directive id="T-01" name="MAP_BEFORE_TERRITORY">
  *     <trigger>...</trigger>
  *     <must>...</must>
@@ -37,47 +37,42 @@ function extractTag(content: string, tagName: string): string {
 
 /**
  * Parse THINKING_OS.md content and extract all <directive> blocks.
- * Returns empty array if no directives found.
+ * Returns empty array if no XML directives found.
  */
 export function parseThinkingOsMd(content: string): ThinkingOsDirective[] {
   const directives: ThinkingOsDirective[] = [];
-
-  // Match all <directive ...> ... </directive> blocks
   const directiveRegex = /<directive\s+([^>]*)>([\s\S]*?)<\/directive>/gi;
-  /* eslint-disable @typescript-eslint/init-declarations, @typescript-eslint/no-use-before-define, @typescript-eslint/prefer-destructuring, no-useless-assignment, @typescript-eslint/no-unused-vars */
+   
   let match: RegExpExecArray | null = null;
 
   while ((match = directiveRegex.exec(content)) !== null) {
-    const [, attrs, body] = match;
-
-    const idMatch = /id="([^"]+)"/i.exec(attrs);
-    const nameMatch = /name="([^"]+)"/i.exec(attrs);
-
+    const attrs = match[1];
+    const body = match[2];
+    const idMatch = attrs.match(/id="([^"]+)"/i);
+    const nameMatch = attrs.match(/name="([^"]+)"/i);
     if (!idMatch) continue;
 
-    const directive: ThinkingOsDirective = {
+    directives.push({
       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.
+ * Load THINKING_OS.md from the workspace.
+ * Falls back to plugin templates if workspace file doesn't exist or has no XML directives.
  */
 export function loadThinkingOsFromWorkspace(
   workspaceDir: string,
   language = 'zh',
 ): ThinkingOsDirective[] {
-  // Priority 1: workspace's own THINKING_OS.md
+  // Priority 1: workspace THINKING_OS.md
   const workspacePath = resolvePdPath(workspaceDir, 'THINKING_OS');
   if (fs.existsSync(workspacePath)) {
     try {
@@ -89,39 +84,21 @@ export function loadThinkingOsFromWorkspace(
     }
   }
 
-  // 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)) {
+  const templatePath = resolveTemplatePath(language);
+  if (templatePath) {
     try {
       const content = fs.readFileSync(templatePath, 'utf-8');
-      return parseThinkingOsMd(content);
+      const directives = parseThinkingOsMd(content);
+      if (directives.length > 0) return directives;
     } 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)) {
+  const zhPath = resolveTemplatePath('zh');
+  if (zhPath) {
     try {
       const content = fs.readFileSync(zhPath, 'utf-8');
       return parseThinkingOsMd(content);
@@ -133,6 +110,22 @@ export function loadThinkingOsFromWorkspace(
   return [];
 }
 
+/**
+ * Resolve the THINKING_OS.md template path for a given language.
+ */
+function resolveTemplatePath(language: string): string | null {
+  const currentDir = path.dirname(fileURLToPath(import.meta.url));
+  const templatePath = path.join(
+    path.dirname(path.dirname(path.dirname(currentDir))),
+    'templates',
+    'langs',
+    language,
+    'principles',
+    'THINKING_OS.md',
+  );
+  return fs.existsSync(templatePath) ? templatePath : null;
+}
+
 /**
  * Extract meaningful detection keywords from a trigger string.
  * Returns an array of regex patterns.
@@ -142,14 +135,14 @@ export function generateDetectionPatterns(trigger: string): RegExp[] {
 
   const patterns: string[] = [];
 
-  // Extract Chinese phrases: 3-8 character sequences that are meaningful
+  // Extract Chinese phrases: 3-8 character sequences
   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
+  // Extract English words/phrases
   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) {
@@ -159,6 +152,5 @@ export function generateDetectionPatterns(trigger: string): RegExp[] {
     }
   }
 
-  // Convert to case-insensitive regexes
   return patterns.map(p => new RegExp(p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i'));
 }

package/src/index.ts

@@ -54,6 +54,7 @@ import { PDTaskService } from './core/pd-task-service.js';
 import { CentralSyncService } from './service/central-sync-service.js';
 import { ensureWorkspaceTemplates } from './core/init.js';
 import { migrateDirectoryStructure } from './core/migration.js';
+import { runMigrationIfNeeded } from './core/principle-tree-migration.js';
 import { SystemLogger } from './core/system-logger.js';
 import { createDeepReflectTool } from './tools/deep-reflect.js';
 import { PathResolver, resolveWorkspaceDirFromApi } from './core/path-resolver.js';
@@ -125,6 +126,9 @@ const plugin = {
           const workspaceDir = ctx.workspaceDir || api.resolvePath('.');
           if (!workspaceInitialized && workspaceDir) {
             migrateDirectoryStructure(api, workspaceDir);
+            // Phase 11: Migrate trainingStore principles to tree.principles
+            const { stateDir } = WorkspaceContext.fromHookContext({ workspaceDir });
+            runMigrationIfNeeded(stateDir, workspaceDir);
             ensureWorkspaceTemplates(api, workspaceDir, language);
             SystemLogger.log(workspaceDir, 'SYSTEM_BOOT', `Principles Disciple online. Language: ${language}`);
             workspaceInitialized = true;
@@ -231,7 +235,7 @@ const plugin = {
         try {
           const workspaceDir = resolveToolHookWorkspaceDir(ctx, api, 'trajectory.after_tool_call');
           TrajectoryCollector.handleAfterToolCall(event, { ...ctx, workspaceDir });
-          // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars -- Reason: catch binding intentionally unused
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars -- Reason: catch binding intentionally unused
         } catch (_err) {
           // Non-critical: don't log, just skip
         }
@@ -244,7 +248,7 @@ const plugin = {
         try {
           const workspaceDir = resolveToolHookWorkspaceDir(ctx as unknown as Record<string, unknown>, api, 'trajectory.llm_output');
           TrajectoryCollector.handleLlmOutput(event, { ...ctx, workspaceDir });
-          // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars -- Reason: catch binding intentionally unused
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars -- Reason: catch binding intentionally unused
         } catch (_err) {
           // Non-critical: don't log, just skip
         }
@@ -254,7 +258,7 @@ const plugin = {
     // ── Hook: Subagent Loop Closure ──
     api.on(
       'subagent_spawning',
-      // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars -- Reason: ctx param required by hook callback signature but not used in this handler
+       
       (event: PluginHookSubagentSpawningEvent, _ctx: PluginHookSubagentContext): void | PluginHookSubagentSpawningResult => {
         try {
           // Resolve workspace via official API, falling back to PathResolver

package/src/service/nocturnal-service.ts

@@ -1146,13 +1146,14 @@ async function executeNocturnalReflectionWithAdapter(
   // eslint-disable-next-line no-useless-assignment -- Reason: initial value unused due to immediate reassignment in all branches
   let snapshot: NocturnalSessionSnapshot | null = null;
 
-  if (options.principleIdOverride && options.snapshotOverride) {
-    // Skip Selector: use provided principleId and snapshot directly
-    selectedPrincipleId = options.principleIdOverride;
-    selectedSessionId = options.snapshotOverride.sessionId;
-    snapshot = options.snapshotOverride;
-    // Calculate violation density from snapshot stats for meaningful diagnostics
-    const snapStats = options.snapshotOverride.stats;
+      if (options.principleIdOverride && options.snapshotOverride) {
+        // Skip Selector: use provided principleId and snapshot directly
+        selectedPrincipleId = options.principleIdOverride;
+        selectedSessionId = options.snapshotOverride.sessionId;
+        snapshot = options.snapshotOverride;
+        console.log(`[nocturnal-service] Using override: principleId=${selectedPrincipleId}, sessionId=${selectedSessionId}`);
+        // Calculate violation density from snapshot stats for meaningful diagnostics
+        const snapStats = options.snapshotOverride.stats;
     const totalToolCalls = snapStats?.totalToolCalls ?? 0;
     const failureCount = snapStats?.failureCount ?? 0;
     const violationDensity = totalToolCalls > 0 ? failureCount / totalToolCalls : 0;
@@ -1177,6 +1178,7 @@ async function executeNocturnalReflectionWithAdapter(
     diagnostics.idle = { isIdle: true, mostRecentActivityAt: 0, idleForMs: 0, userActiveSessions: 0, abandonedSessionIds: [], trajectoryGuardrailConfirmsIdle: true, reason: 'selector skipped (override provided)' };
   } else {
     // Normal Selector path
+    console.log(`[nocturnal-service] Step 2/7: Target selection (normal path)`);
     const extractor = createNocturnalTrajectoryExtractor(workspaceDir, stateDir);
     const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor, {
       idleCheckOverride: options.idleCheckOverride,
@@ -1185,8 +1187,10 @@ async function executeNocturnalReflectionWithAdapter(
 
     const selection = selector.select();
     diagnostics.selection = selection;
+    console.log(`[nocturnal-service] Selector result: decision=${selection.decision}, skipReason=${selection.skipReason ?? 'none'}`);
 
     if (selection.decision === 'skip') {
+      console.warn(`[nocturnal-service] Target selection skipped: ${selection.skipReason}`);
       return {
         success: false,
         noTargetSelected: true,

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

@@ -176,8 +176,14 @@ export class NocturnalWorkflowManager implements WorkflowManager {
         // Other workflow managers (empathy, deep-reflect) have this check
         // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Reason: TrinityRuntimeAdapter interface doesn't expose api.runtime.subagent, but OpenClawTrinityRuntimeAdapter has it
         const subagent = (this.runtimeAdapter as any).api?.runtime?.subagent;
-        if (!isSubagentRuntimeAvailable(subagent)) {
-            this.logger.warn(`[PD:NocturnalWorkflow] Subagent runtime unavailable, skipping workflow`);
+        const apiAvailable = !!(this.runtimeAdapter as any).api;
+        const runtimeAvailable = !!(this.runtimeAdapter as any).api?.runtime;
+        const subagentAvailable = isSubagentRuntimeAvailable(subagent);
+        
+        this.logger.info(`[PD:NocturnalWorkflow] Subagent availability check: api=${apiAvailable}, runtime=${runtimeAvailable}, subagent=${subagentAvailable}`);
+        
+        if (!subagentAvailable) {
+            this.logger.warn(`[PD:NocturnalWorkflow] Subagent runtime unavailable (api=${apiAvailable}, runtime=${runtimeAvailable}), skipping workflow`);
             throw new Error(`NocturnalWorkflowManager: subagent runtime unavailable`);
         }
 
@@ -234,12 +240,15 @@ export class NocturnalWorkflowManager implements WorkflowManager {
         // When principleId is provided, we pass it as principleIdOverride to skip Selector.
         // When principleId is missing, Selector will choose a principle from training store.
         this.logger.info(`[PD:NocturnalWorkflow] Calling executeNocturnalReflectionAsync for full pipeline (principleId=${principleId ?? 'auto-select'})`);
+        const pipelineStart = Date.now();
 
         // #213: Wrap fire-and-forget Promise with .catch() to prevent
         // unhandled promise rejections if anything throws outside the try-catch
         // (e.g., during parameter construction or environment errors).
         Promise.resolve().then(async () => {
             try {
+                this.logger.info(`[PD:NocturnalWorkflow] [${workflowId}] Pipeline step 1/4: Starting executeNocturnalReflectionAsync`);
+                
                 const result = await executeNocturnalReflectionAsync(
                     this.workspaceDir,
                     this.stateDir,
@@ -262,20 +271,26 @@ export class NocturnalWorkflowManager implements WorkflowManager {
                     }
                 );
 
+                const pipelineDuration = Date.now() - pipelineStart;
+                this.logger.info(`[PD:NocturnalWorkflow] [${workflowId}] Pipeline completed in ${pipelineDuration}ms, success=${result.success}`);
+
                 if (result.success) {
+                    this.logger.info(`[PD:NocturnalWorkflow] [${workflowId}] Pipeline step 4/4: Completed successfully, artifactId=${result.diagnostics?.persistedPath}`);
                     this.store.recordEvent(workflowId, 'nocturnal_completed', null, 'completed', 'Full pipeline completed via executeNocturnalReflectionAsync', {
                         artifactId: result.diagnostics?.persistedPath,
                     });
                     this.completedWorkflows.set(workflowId, Date.now());
                 } else {
                     const reason = result.noTargetSelected ? 'no_target_selected' : 'validation_failed';
+                    this.logger.warn(`[PD:NocturnalWorkflow] [${workflowId}] Pipeline failed: reason=${reason}, noTargetSelected=${result.noTargetSelected}, skipReason=${result.skipReason ?? 'none'}, validationFailures=${result.validationFailures?.length ?? 0}`);
                     this.store.recordEvent(workflowId, 'nocturnal_failed', null, 'terminal_error', reason, {
                         failures: result.validationFailures,
                         skipReason: result.skipReason,
                     });
                 }
             } catch (err) {
-                this.logger.error(`[PD:NocturnalWorkflow] executeNocturnalReflectionAsync threw: ${String(err)}`);
+                const errDuration = Date.now() - pipelineStart;
+                this.logger.error(`[PD:NocturnalWorkflow] [${workflowId}] executeNocturnalReflectionAsync threw after ${errDuration}ms: ${String(err)}`);
                 this.store.recordEvent(workflowId, 'nocturnal_failed', null, 'terminal_error', String(err), { workflowId });
             }
         }).catch((err) => {

package/templates/langs/en/principles/THINKING_OS.md

@@ -61,4 +61,17 @@ LLMs are highly sensitive to XML tags; this structure is designed to boost instr
     <must>Maintain extreme digital cleanliness. The project root is SACRED. Use strict `kebab-case` for all naming. Clean up all test scripts and debug artifacts after the task.</must>
     <forbidden>Creating arbitrary temporary files (e.g., `test.txt`, `temp.md`, `debug.log`) in the project root directory.</forbidden>
   </directive>
+
+  <!-- 复杂任务分解与记忆外化 (Complex Task Decomposition & Memory Externalization) -->
+  <directive id="T-09" name="DIVIDE_AND_CONQUER">
+    <trigger>When facing a complex task with multiple interdependent steps or large-scale refactoring.</trigger>
+    <must>Break the work into smallest meaningful units. Execute in dependency order. Validate each unit before proceeding.</must>
+    <forbidden>Tackle complex tasks as a single monolithic operation. Mix unrelated changes in one edit.</forbidden>
+  </directive>
+
+  <directive id="T-10" name="MEMORY_EXTERNALIZATION">
+    <trigger>When drawing conclusions, completing analysis, or about to switch context.</trigger>
+    <must>Write conclusions to a file (plan.md, scratchpad, memory) before proceeding. Preserve reasoning for future reference.</must>
+    <forbidden>Keep important conclusions only in conversation context. Lose state between turns.</forbidden>
+  </directive>
 </thinking_os_core_directives>

package/templates/langs/zh/principles/THINKING_OS.md

@@ -61,4 +61,17 @@
     <must>保持极致的数字洁癖。项目根目录是神圣的。所有命名必须严格使用 `kebab-case`。任务结束后清理所有的测试脚本和 Debug 遗留物。</must>
     <forbidden>在项目根目录下随意创建临时文件（如 `test.txt`、`temp.md`、`debug.log`）。</forbidden>
   </directive>
+
+  <!-- 复杂任务分解与记忆外化 (Complex Task Decomposition & Memory Externalization) -->
+  <directive id="T-09" name="DIVIDE_AND_CONQUER">
+    <trigger>面对包含多个相互依赖步骤的复杂任务或大规模重构时。</trigger>
+    <must>将工作拆分为最小有意义的单元。按依赖顺序执行。在继续之前验证每个单元。</must>
+    <forbidden>将复杂任务当作单一操作处理。在一次编辑中混合不相关的变更。</forbidden>
+  </directive>
+
+  <directive id="T-10" name="MEMORY_EXTERNALIZATION">
+    <trigger>得出结论、完成分析或即将切换上下文时。</trigger>
+    <must>将结论写入文件（plan.md、scratchpad、memory）后再继续。保留推理过程供未来参考。</must>
+    <forbidden>将重要结论仅保留在对话上下文中。在会话切换后丢失状态。</forbidden>
+  </directive>
 </thinking_os_core_directives>

package/ui/src/i18n/ui.ts

@@ -225,21 +225,46 @@ export const i18n = {
     dormant: { zh: '休眠', en: 'Dormant' },
     effective: { zh: '有效', en: 'Effective' },
 
-    // Empty state
-    emptyTitle: { zh: '选择一个思维模型', en: 'Select a thinking model' },
-    emptyDesc: { zh: '点击左侧列表中的模型，查看场景分布和最近事件', en: 'Click a model from the list to inspect scenario coverage and recent events' },
+    // Charts and sections
+    coverageTrend: { zh: '覆盖率趋势', en: 'Coverage Trend' },
+    emptyCoverageTrend: { zh: '今日暂无覆盖率记录', en: 'No coverage data yet' },
+    emptyCoverageTrendDesc: { zh: '当 AI 开始执行任务后，覆盖率会自动记录。', en: 'Coverage is tracked automatically once AI starts working.' },
+    scenarioHeatmap: { zh: '场景热力图', en: 'Scenario Heatmap' },
+    emptyScenarioMatrix: { zh: '暂无场景数据', en: 'No scenario data yet' },
+    emptyScenarioMatrixDesc: { zh: '模型触发场景后会在此显示。', en: 'Scenarios will appear here when models are triggered.' },
+    emptyAllActive: { zh: '所有模型都在使用中', en: 'All models are active' },
+    emptyAllActiveDesc: { zh: '没有休眠模型。', en: 'No dormant models.' },
+    noModelsYet: { zh: '暂无思维模型数据', en: 'No thinking model data yet' },
+    noModelsYetDesc: { zh: 'AI 开始使用后，这里会显示思维模型的使用情况。', en: 'Thinking model usage will appear here once AI starts working.' },
+
+    // Recommendations
+    dormantModels: { zh: '休眠模型', en: 'Dormant Models' },
+    reinforce: { zh: '保持', en: 'Reinforce' },
+    rework: { zh: '重构', en: 'Rework' },
+    archive: { zh: '归档', en: 'Archive' },
+    filterByRec: { zh: '按推荐过滤', en: 'Filter by Rec' },
 
     // Detail sections
-    outcomeStats: { zh: '结果统计', en: 'Outcome Stats' },
-    scenarioDistribution: { zh: '场景分布', en: 'Scenario Distribution' },
-    recentEvents: { zh: '最近事件', en: 'Recent Events' },
-    noScenariosYet: { zh: '暂无场景', en: 'No scenarios yet' },
-
-    // Outcome stats
+    outcomeStats: { zh: '效果统计', en: 'Outcome Stats' },
+    usageTrend: { zh: '使用趋势', en: 'Usage Trend' },
     success: { zh: '成功', en: 'Success' },
     failure: { zh: '失败', en: 'Failure' },
     pain: { zh: '痛点', en: 'Pain' },
     correction: { zh: '纠正', en: 'Correction' },
+    scenarioDistribution: { zh: '场景分布', en: 'Scenario Distribution' },
+    recentEvents: { zh: '最近事件', en: 'Recent Events' },
+    toolContext: { zh: '工具上下文', en: 'Tool Context' },
+    painContext: { zh: '痛点上下文', en: 'Pain Context' },
+    principleContext: { zh: '原则上下文', en: 'Principle Context' },
+    trigger: { zh: '触发条件', en: 'Trigger' },
+    antiPattern: { zh: '禁止行为', en: 'Anti-Pattern' },
+    thinkingOsSource: { zh: '思维模型定义来源', en: 'Thinking Model Source' },
+
+    // Empty state
+    emptyTitle: { zh: '选择一个思维模型', en: 'Select a thinking model' },
+    emptyDesc: { zh: '点击左侧列表中的模型，查看场景分布和最近事件', en: 'Click a model from the list to inspect scenario coverage and recent events' },
+    noDataTitle: { zh: '思维模型定义', en: 'Thinking Model Definitions' },
+    noDataDesc: { zh: '以下是 10 个思维模型的定义。当 AI 开始使用后，这里会显示每个模型的使用统计。', en: 'Below are 10 thinking model definitions. Usage statistics will appear once the AI starts working.' },
 
     // Table
     hits: { zh: '命中', en: 'Hits' },

package/ui/src/pages/EvolutionPage.tsx

@@ -1,5 +1,5 @@
 import React, { useCallback, useEffect, useMemo, useState } from 'react';
-import { ChevronLeft } from 'lucide-react';
+import { ChevronLeft, Clock, Activity, Shield, Zap, BookOpen } from 'lucide-react';
 import { api } from '../api';
 import type {
   OverviewResponse,