principles-disciple 1.104.1 → 1.105.0

package/openclaw.plugin.json

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

package/package.json

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

package/src/core/init.ts

@@ -9,6 +9,7 @@ import { addPrincipleToLedger } from './principle-tree-ledger.js';
 import type { LedgerPrinciple } from './principle-tree-ledger.js';
 import { atomicWriteFileSync } from '../utils/io.js';
 import { createDefaultKeywordStore, saveKeywordStore } from './empathy-keyword-matcher.js';
+import { CORE_PRINCIPLES } from '@principles/core/runtime-v2';
 
 /**
  * Default PROFILE.json content
@@ -150,24 +151,17 @@ function copyRecursiveSync(srcDir: string, destDir: string, api: OpenClawPluginA
 
 /**
  * Core thinking model definitions (T-01 through T-10).
- * These are the built-in cognitive patterns that every workspace should have.
+ * Derived from the Core Principle Registry — the single source of truth.
  */
 export const CORE_THINKING_MODELS: Array<{
   id: string;
   name: string;
   description: string;
-}> = [
-  { id: 'T-01', name: 'Survey Before Acting', description: 'Understand the structure first before making changes.' },
-  { id: 'T-02', name: 'Respect Constraints', description: 'Trust files, not your context window. Write conclusions to files.' },
-  { id: 'T-03', name: 'Evidence Over Assumption', description: 'Use logs, code, and outputs before inferring causes.' },
-  { id: 'T-04', name: 'Reversible First', description: 'Prefer changes that are safe to roll back when risk is high.' },
-  { id: 'T-05', name: 'Safety Rails', description: 'Call out guardrails, prohibitions, and failure-prevention constraints.' },
-  { id: 'T-06', name: 'Simplicity First', description: 'Prefer the smallest understandable solution over over-engineering.' },
-  { id: 'T-07', name: 'Minimal Change Surface', description: 'Limit the blast radius and touch only what is necessary.' },
-  { id: 'T-08', name: 'Pain As Signal', description: 'Treat failures and friction as clues to step back and rethink.' },
-  { id: 'T-09', name: 'Divide And Conquer', description: 'Split the task into smaller phases before execution.' },
-  { id: 'T-10', name: 'Memory Externalization', description: 'Write intermediate conclusions to files for persistence.' },
-];
+}> = CORE_PRINCIPLES.map(p => ({
+  id: p.id,
+  name: p.name,
+  description: p.description,
+}));
 
 /**
  * Initialize core thinking models into the training store if it's empty.

package/src/core/thinking-models.ts

@@ -1,16 +1,18 @@
 /**
  * Thinking Models — Detection Engine
  *
- * THINKING_OS.md is the single source of truth for model definitions (id, name, description).
+ * 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:
- *   THINKING_OS.md (authority) → id, name, description, antiPattern
+ *   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';
 
 export interface ThinkingModelDefinition {
   id: string;
@@ -199,37 +201,15 @@ const BUILTIN_PATTERNS: BuiltinPatternEntry[] = [
 
 const BUILTIN_PATTERN_MAP = new Map(BUILTIN_PATTERNS.map((p) => [p.id, p]));
 
-// Fallback name/description lookup tables (must be defined before listThinkingModels uses them)
+// Fallback name/description lookup — delegates to Core Principle Registry
 function getFallbackName(id: string): string {
-  const names: Record<string, string> = {
-    'T-01': 'Survey Before Acting',
-    'T-02': 'Respect Constraints',
-    'T-03': 'Evidence Over Assumption',
-    'T-04': 'Reversible First',
-    'T-05': 'Safety Rails',
-    'T-06': 'Simplicity First',
-    'T-07': 'Minimal Change Surface',
-    'T-08': 'Pain As Signal',
-    'T-09': 'Divide And Conquer',
-    'T-10': 'Memory Externalization',
-  };
-  return names[id] ?? id;
+  const entry = CORE_PRINCIPLES.find(p => p.id === id);
+  return entry?.name ?? id;
 }
 
 function getFallbackDescription(id: string): string {
-  const descs: Record<string, string> = {
-    'T-01': 'Understand the structure first before making changes.',
-    'T-02': 'Trust files, not your context window. Write conclusions to files.',
-    'T-03': 'Use logs, code, and outputs before inferring causes.',
-    'T-04': 'Prefer changes that are safe to roll back when risk is high.',
-    'T-05': 'Call out guardrails, prohibitions, and failure-prevention constraints.',
-    'T-06': 'Prefer the smallest understandable solution over over-engineering.',
-    'T-07': 'Limit the blast radius and touch only what is necessary.',
-    'T-08': 'Treat failures and friction as clues to step back and rethink.',
-    'T-09': 'Split the task into smaller phases before execution.',
-    'T-10': 'Write intermediate conclusions to files for persistence.',
-  };
-  return descs[id] ?? '';
+  const entry = CORE_PRINCIPLES.find(p => p.id === id);
+  return entry?.description ?? '';
 }
 
 // ---------------------------------------------------------------------------

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

@@ -62,4 +62,16 @@ 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>
+
+  <directive id="T-09" name="DIVIDE_AND_CONQUER">
+    <trigger>When facing a complex task, multi-step change, or an operation that can be decomposed.</trigger>
+    <must>Break the task into smaller, manageable phases before execution. Execute one phase at a time and verify each phase's result before proceeding.</must>
+    <forbidden>Attempting to execute a large, complex change in a single step, or proceeding without a decomposition plan.</forbidden>
+  </directive>
+
+  <directive id="T-10" name="MEMORY_EXTERNALIZATION">
+    <trigger>When reaching a significant conclusion, making a decision, or planning next steps across sessions.</trigger>
+    <must>Write intermediate conclusions, decisions, and plans to persistent files (e.g., plan.md, scratchpad) so they survive context compression and session boundaries.</must>
+    <forbidden>Relying solely on conversation context to retain important state that will be lost when the context window shifts.</forbidden>
+  </directive>
 </thinking_os_core_directives>

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

@@ -62,4 +62,16 @@
     <must>保持极致的数字洁癖。项目根目录是神圣的。所有命名必须严格使用 `kebab-case`。任务结束后清理所有的测试脚本和 Debug 遗留物。</must>
     <forbidden>在项目根目录下随意创建临时文件（如 `test.txt`、`temp.md`、`debug.log`）。</forbidden>
   </directive>
+
+  <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），使其在上下文压缩和会话边界后仍然可用。</must>
+    <forbidden>仅依赖对话上下文来保持重要状态，这些状态在上下文窗口切换时将丢失。</forbidden>
+  </directive>
 </thinking_os_core_directives>

package/tests/core/core-principle-registry-drift.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest';
+import { listThinkingModels } from '../../src/core/thinking-models.js';
+import {
+  CORE_PRINCIPLES,
+  CORE_PRINCIPLE_IDS,
+} from '@principles/core/runtime-v2';
+
+describe('Core Principle Registry drift test', () => {
+  it('registry count matches thinking-models.ts builtin count', () => {
+    // No workspace → falls back to builtin patterns (T-01..T-10)
+    const models = listThinkingModels();
+    expect(models).toHaveLength(10);
+    expect(CORE_PRINCIPLES).toHaveLength(10);
+  });
+
+  it('registry ids match thinking-models.ts ids', () => {
+    const models = listThinkingModels();
+    const modelIds = models.map(m => m.id).sort();
+    const registryIds = CORE_PRINCIPLE_IDS.slice().sort();
+    expect(registryIds).toEqual(modelIds);
+  });
+
+  it('registry names match thinking-models.ts fallback names', () => {
+    const models = listThinkingModels();
+    for (const model of models) {
+      const registryEntry = CORE_PRINCIPLES.find(p => p.id === model.id);
+      expect(registryEntry).toBeDefined();
+      // model.name comes from getFallbackName() when no workspace
+      expect(registryEntry!.name).toBe(model.name);
+    }
+  });
+
+  it('no extra or missing ids in registry', () => {
+    const models = listThinkingModels();
+    const modelIdSet = new Set(models.map(m => m.id));
+    const registryIdSet = new Set(CORE_PRINCIPLE_IDS);
+    expect(registryIdSet).toEqual(modelIdSet);
+  });
+});