principles-disciple 1.159.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/dist/index.js

@@ -38,7 +38,7 @@ import { SystemLogger } from './core/system-logger.js';
 import { PathResolver } from './core/path-resolver.js';
 import { resolveCommandWorkspaceDir, resolveToolHookWorkspaceDirSafe, resolveHookWorkspaceDir } from './utils/workspace-resolver.js';
 import { validateWorkspaceDir } from './core/workspace-dir-validation.js';
-import { checkSurfaceGuard, guardHook, guardService } from './core/surface-guard.js';
+import { checkSurfaceGuard, guardHook, guardService } from '@principles/core/runtime-v2';
 // Track started workspaces — one-time init + evolution worker per workspace
 const startedWorkspaces = new Set();
 // ── Conversation Access Health Check (PRI-343) ────────────────────────────

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.159.0",
+  "version": "1.161.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

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

package/dist/core/surface-guard.d.ts

@@ -1,31 +0,0 @@
-import { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory, type PluginSurfaceEntry, type MvpCategory } from '@principles/core/runtime-v2';
-import type { OpenClawPluginService } from '../openclaw-sdk.js';
-export interface SurfaceGuardResult {
-    passed: boolean;
-    enabledCoreSurfaces: string[];
-    disabledNonCoreSurfaces: string[];
-    violations: string[];
-    warnings: string[];
-}
-type LoggerLike = {
-    info?: (msg: string) => void;
-    debug?: (msg: string) => void;
-};
-/**
- * Reset the per-process surface-guard skip log bookkeeping. Intended for tests
- * that need to assert on the first-fire log without cross-test pollution.
- * Not part of the production API surface; do not call from runtime code.
- */
-export declare function __resetSurfaceGuardSkipLogStateForTests(): void;
-export declare function checkSurfaceGuard(): SurfaceGuardResult;
-export declare function getSurfaceIdForHook(hookEvent: string, label?: string): string;
-export declare function getSurfaceIdForService(serviceName: string): string;
-export declare function isSurfaceEnabled(surfaceId: string, overrides?: Record<string, boolean>): {
-    enabled: boolean;
-    reason?: string;
-};
-export type HookHandler<E, C, R> = (event: E, ctx: C) => R | Promise<R>;
-export declare function guardHook<E, C, R>(surfaceId: string, logger: LoggerLike | undefined, handler: HookHandler<E, C, R>): HookHandler<E, C, R>;
-export declare function guardService<T extends OpenClawPluginService>(surfaceId: string, service: T, logger?: LoggerLike): T | null;
-export { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory };
-export type { PluginSurfaceEntry, MvpCategory };

package/dist/core/surface-guard.js

@@ -1,131 +0,0 @@
-import { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory, } from '@principles/core/runtime-v2';
-// Surface-level once-only log state (PRI-298).
-// The first time a quiet/non-core surface guard actually fires in this
-// process, the disabled reason is emitted once. Subsequent fires for the
-// same surfaceId are still observable (the no-op handler preserves
-// behaviour) but no longer flood the log. Fresh processes start with an
-// empty set, so each plugin load gets one observable skip per surface.
-//
-// The Set is only updated when the log was actually emitted, so passing
-// `undefined` for the logger on a quiet first fire does NOT consume the
-// one-shot slot — a later registration that supplies a logger still gets
-// the first-fire reason (PRI-298 / ERR-002).
-const loggedSkipSurfaces = new Set();
-/**
- * Emit the disabled-reason log line for `surfaceId` at most once per
- * process. Returns true if the log was emitted, false if it was suppressed
- * (already logged, or no logger available). Only marks the surface as
- * logged when the log was actually written, so a missing logger on first
- * call does not consume the one-shot slot.
- */
-function logSkipOnce(surfaceId, logger, message) {
-    if (loggedSkipSurfaces.has(surfaceId)) {
-        return false;
-    }
-    if (!logger?.info) {
-        return false;
-    }
-    loggedSkipSurfaces.add(surfaceId);
-    logger.info(message);
-    return true;
-}
-/**
- * Reset the per-process surface-guard skip log bookkeeping. Intended for tests
- * that need to assert on the first-fire log without cross-test pollution.
- * Not part of the production API surface; do not call from runtime code.
- */
-export function __resetSurfaceGuardSkipLogStateForTests() {
-    loggedSkipSurfaces.clear();
-}
-export function checkSurfaceGuard() {
-    const validation = validateSurfaceRegistry(PLUGIN_SURFACE_REGISTRY);
-    const violations = [];
-    const warnings = [...validation.warnings];
-    const coreSurfaces = getSurfacesByCategory(PLUGIN_SURFACE_REGISTRY, 'core');
-    const enabledCore = coreSurfaces.filter(s => s.enabledByDefault);
-    const nonCoreEnabled = PLUGIN_SURFACE_REGISTRY.filter(s => s.category !== 'core' && s.enabledByDefault);
-    if (nonCoreEnabled.length > 0) {
-        for (const surface of nonCoreEnabled) {
-            violations.push(`non-core surface '${surface.id}' (${surface.category}) is enabledByDefault=true — must be false per ADR-0014`);
-        }
-    }
-    if (!validation.valid) {
-        violations.push(...validation.errors);
-    }
-    return {
-        passed: violations.length === 0,
-        enabledCoreSurfaces: enabledCore.map(s => s.id),
-        disabledNonCoreSurfaces: PLUGIN_SURFACE_REGISTRY
-            .filter(s => s.category !== 'core' && !s.enabledByDefault)
-            .map(s => s.id),
-        violations,
-        warnings,
-    };
-}
-export function getSurfaceIdForHook(hookEvent, label) {
-    if (label) {
-        return `hook:${hookEvent}.${label}`;
-    }
-    return `hook:${hookEvent}`;
-}
-export function getSurfaceIdForService(serviceName) {
-    return `service:${serviceName}`;
-}
-export function isSurfaceEnabled(surfaceId, overrides = {}) {
-    const entry = PLUGIN_SURFACE_REGISTRY.find(s => s.id === surfaceId);
-    if (!entry) {
-        return {
-            enabled: false,
-            reason: `surface '${surfaceId}' not found in registry — classify before enabling (PRI-289)`,
-        };
-    }
-    if (Object.hasOwn(overrides, surfaceId)) {
-        const override = overrides[surfaceId];
-        if (typeof override !== 'boolean') {
-            return { enabled: entry.enabledByDefault, reason: `override for '${surfaceId}' is not boolean, using default` };
-        }
-        if (entry.category === 'gone') {
-            return { enabled: false, reason: `surface '${surfaceId}' is gone and cannot be re-enabled` };
-        }
-        if (entry.category === 'core' && !override) {
-            return { enabled: true, reason: `surface '${surfaceId}' is core and cannot be disabled` };
-        }
-        return { enabled: override };
-    }
-    if (!entry.enabledByDefault && entry.disabledReason) {
-        return { enabled: false, reason: entry.disabledReason };
-    }
-    return { enabled: entry.enabledByDefault };
-}
-export function guardHook(surfaceId, logger, handler) {
-    const check = isSurfaceEnabled(surfaceId);
-    if (check.enabled) {
-        return handler;
-    }
-    const reason = check.reason ?? 'surface not enabled';
-    // Log on the first ACTUAL no-op invocation, not at construction time
-    // (PRI-298). Construction-time logging would emit a `SKIP` line at
-    // plugin startup for every registered quiet hook, regardless of
-    // whether the hook ever fires — which is exactly the startup log
-    // noise this change is meant to prevent. The one-shot is consumed only
-    // when the log was actually written, so `undefined` logger on first
-    // call does not eat the slot.
-    return (_event, _ctx) => {
-        logSkipOnce(surfaceId, logger, `[PD:surface-guard] SKIP ${surfaceId}: ${reason}`);
-        return undefined;
-    };
-}
-export function guardService(surfaceId, service, logger) {
-    const check = isSurfaceEnabled(surfaceId);
-    if (check.enabled) {
-        return service;
-    }
-    const reason = check.reason ?? 'surface not enabled';
-    // guardService is called once per service during plugin registration,
-    // so the once-only check fires on the registration call itself. The
-    // shared helper makes the consumption rule identical to guardHook:
-    // a missing logger on first call does not consume the one-shot.
-    logSkipOnce(surfaceId, logger, `[PD:surface-guard] SKIP service ${surfaceId}: ${reason}`);
-    return null;
-}
-export { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory };