principles-disciple 1.104.2 → 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.2",
+  "version": "1.105.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.104.2",
+  "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/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);
+  });
+});