principles-disciple 1.160.0 → 1.161.0

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

@@ -1,49 +1,19 @@
 /**
- * Thinking Models — Detection Engine
+ * Thinking Models — Plugin I/O Adapter (Stage 3 slim)
  *
- * 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.
+ * Pure logic (BUILTIN_PATTERNS, BUILTIN_PATTERN_MAP, getFallbackName,
+ * getFallbackDescription, deriveThinkingScenarios, types) lives in
+ * @principles/core/runtime-v2/thinking-models.
  *
- * Flow:
- *   Core Principle Registry (authority) → id, name, description
- *   BUILTIN_PATTERNS (engine) → detection regexes per model id
- *   THINKING_MODELS (merged) → full definitions with patterns
+ * 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.
  */
-interface ThinkingModelDefinition {
-    id: string;
-    name: string;
-    description: string;
-    antiPattern?: string;
-    patterns: RegExp[];
-    baselineScenarios: string[];
-}
-interface ThinkingModelMatch {
-    modelId: string;
-    matchedPattern: string;
-}
-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;
-    }[];
-}
+import { type ThinkingModelDefinition, type ThinkingModelMatch } from '@principles/core/runtime-v2';
+export { BUILTIN_PATTERN_MAP, getFallbackName, getFallbackDescription, } from '@principles/core/runtime-v2';
+export { deriveThinkingScenarios } from '@principles/core/runtime-v2';
+export type { ThinkingModelDefinition, ThinkingModelMatch, ThinkingScenarioContext, } from '@principles/core/runtime-v2';
 /**
  * Load thinking model definitions dynamically from THINKING_OS.md.
  * Falls back to built-in definitions if parsing fails.
@@ -51,6 +21,5 @@ interface ThinkingScenarioContext {
  * @param workspaceDir Optional. If provided, loads from that workspace's THINKING_OS.md.
  */
 export declare function listThinkingModels(workspaceDir?: string): ThinkingModelDefinition[];
+export declare function getThinkingModel(modelId: string, workspaceDir?: string): ThinkingModelDefinition | undefined;
 export declare function detectThinkingModelMatches(text: string, workspaceDir?: string): ThinkingModelMatch[];
-export declare function deriveThinkingScenarios(modelId: string, context: ThinkingScenarioContext): string[];
-export {};

package/dist/core/thinking-models.js

@@ -1,163 +1,20 @@
 /**
- * Thinking Models — Detection Engine
+ * Thinking Models — Plugin I/O Adapter (Stage 3 slim)
  *
- * 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.
+ * Pure logic (BUILTIN_PATTERNS, BUILTIN_PATTERN_MAP, getFallbackName,
+ * getFallbackDescription, deriveThinkingScenarios, types) lives in
+ * @principles/core/runtime-v2/thinking-models.
  *
- * Flow:
- *   Core Principle Registry (authority) → id, name, description
- *   BUILTIN_PATTERNS (engine) → detection regexes per model id
- *   THINKING_MODELS (merged) → full definitions with patterns
+ * 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 { 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 ?? '';
-}
+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
 // ---------------------------------------------------------------------------
@@ -200,20 +57,20 @@ export function listThinkingModels(workspaceDir) {
         }
     }
     // Fallback: built-in definitions
-    for (const bp of BUILTIN_PATTERNS) {
+    for (const [id, builtin] of BUILTIN_PATTERN_MAP) {
         models.push({
-            id: bp.id,
-            name: getFallbackName(bp.id),
-            description: getFallbackDescription(bp.id),
-            patterns: bp.patterns,
-            baselineScenarios: bp.baselineScenarios,
+            id,
+            name: getFallbackName(id),
+            description: getFallbackDescription(id),
+            patterns: builtin.patterns,
+            baselineScenarios: builtin.baselineScenarios,
         });
     }
     _cachedDefinitions = models;
     _cachedWorkspace = cacheKey;
     return models.slice();
 }
-function getThinkingModel(modelId, workspaceDir) {
+export function getThinkingModel(modelId, workspaceDir) {
     const models = listThinkingModels(workspaceDir);
     return models.find(m => m.id === modelId);
 }
@@ -235,47 +92,3 @@ export function detectThinkingModelMatches(text, workspaceDir) {
     }
     return matches;
 }
-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/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.160.0",
+  "version": "1.161.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

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