principles-disciple 1.6.0 → 1.7.1

package/dist/core/paths.js

@@ -1,67 +1,75 @@
 import * as path from 'path';
+const posixJoin = (...parts) => path.posix.join(...parts);
+function isWindowsPath(input) {
+    return /^[A-Za-z]:[\\/]/.test(input) || input.startsWith('\\\\');
+}
+function joinWorkspacePath(workspaceDir, relativePath) {
+    if (isWindowsPath(workspaceDir)) {
+        return path.win32.join(workspaceDir, relativePath);
+    }
+    if (workspaceDir.startsWith('/')) {
+        return path.posix.join(workspaceDir, relativePath);
+    }
+    return path.join(workspaceDir, relativePath);
+}
 /**
  * Principles Disciple Directory Constants
  * Establishing a logical separation between Identity, State, and Memory.
  */
 export const PD_DIRS = {
-    /** 🧬 Core configuration, identity, and kernel rules (hidden) */
     IDENTITY: '.principles',
-    /** 🧠 Deep Reflection mental models */
-    MODELS: path.join('.principles', 'models'),
-    /** ⚡ Volatile operational data, queues, and task status (hidden) */
+    MODELS: posixJoin('.principles', 'models'),
     STATE: '.state',
-    /** 💾 Historical records, logs, and long-term memory */
     MEMORY: 'memory',
-    /** 🎯 Strategic objectives and focus areas */
-    OKR: path.join('memory', 'okr'),
-    /** 📁 Internal logs directory */
-    LOGS: path.join('memory', 'logs'),
-    /** 🧠 Session persistence directory */
-    SESSIONS: path.join('.state', 'sessions'),
-    /** 🩹 Semantic pain samples for L3 retrieval */
-    PAIN_SAMPLES: path.join('memory', 'pain'),
+    OKR: posixJoin('memory', 'okr'),
+    LOGS: posixJoin('memory', 'logs'),
+    SESSIONS: posixJoin('.state', 'sessions'),
+    PAIN_SAMPLES: posixJoin('memory', 'pain'),
+    LOCKS: posixJoin('memory', '.locks'),
 };
 /**
  * Standard File Path Mappings
  */
 export const PD_FILES = {
-    // Identity Layer
-    PROFILE: path.join(PD_DIRS.IDENTITY, 'PROFILE.json'),
-    PRINCIPLES: path.join(PD_DIRS.IDENTITY, 'PRINCIPLES.md'),
-    THINKING_OS: path.join(PD_DIRS.IDENTITY, 'THINKING_OS.md'),
-    KERNEL: path.join(PD_DIRS.IDENTITY, '00-kernel.md'),
-    DECISION_POLICY: path.join(PD_DIRS.IDENTITY, 'DECISION_POLICY.json'),
+    PROFILE: posixJoin(PD_DIRS.IDENTITY, 'PROFILE.json'),
+    PRINCIPLES: posixJoin(PD_DIRS.IDENTITY, 'PRINCIPLES.md'),
+    THINKING_OS: posixJoin(PD_DIRS.IDENTITY, 'THINKING_OS.md'),
+    KERNEL: posixJoin(PD_DIRS.IDENTITY, '00-kernel.md'),
+    DECISION_POLICY: posixJoin(PD_DIRS.IDENTITY, 'DECISION_POLICY.json'),
     MODELS_DIR: PD_DIRS.MODELS,
-    // State Layer
     STATE_DIR: PD_DIRS.STATE,
-    EVOLUTION_QUEUE: path.join(PD_DIRS.STATE, 'evolution_queue.json'),
-    EVOLUTION_DIRECTIVE: path.join(PD_DIRS.STATE, 'evolution_directive.json'),
-    WORKBOARD: path.join(PD_DIRS.STATE, 'WORKBOARD.json'),
-    AGENT_SCORECARD: path.join(PD_DIRS.STATE, 'AGENT_SCORECARD.json'),
-    PAIN_FLAG: path.join(PD_DIRS.STATE, '.pain_flag'),
-    SYSTEM_CAPABILITIES: path.join(PD_DIRS.STATE, 'SYSTEM_CAPABILITIES.json'),
-    PAIN_SETTINGS: path.join(PD_DIRS.STATE, 'pain_settings.json'),
-    PAIN_CANDIDATES: path.join(PD_DIRS.STATE, 'pain_candidates.json'),
-    THINKING_OS_USAGE: path.join(PD_DIRS.STATE, 'thinking_os_usage.json'),
+    EVOLUTION_QUEUE: posixJoin(PD_DIRS.STATE, 'evolution_queue.json'),
+    EVOLUTION_DIRECTIVE: posixJoin(PD_DIRS.STATE, 'evolution_directive.json'),
+    WORKBOARD: posixJoin(PD_DIRS.STATE, 'WORKBOARD.json'),
+    AGENT_SCORECARD: posixJoin(PD_DIRS.STATE, 'AGENT_SCORECARD.json'),
+    PAIN_FLAG: posixJoin(PD_DIRS.STATE, '.pain_flag'),
+    SYSTEM_CAPABILITIES: posixJoin(PD_DIRS.STATE, 'SYSTEM_CAPABILITIES.json'),
+    PAIN_SETTINGS: posixJoin(PD_DIRS.STATE, 'pain_settings.json'),
+    PAIN_CANDIDATES: posixJoin(PD_DIRS.STATE, 'pain_candidates.json'),
+    THINKING_OS_USAGE: posixJoin(PD_DIRS.STATE, 'thinking_os_usage.json'),
+    TRAJECTORY_DB: posixJoin(PD_DIRS.STATE, 'trajectory.db'),
+    TRAJECTORY_BLOBS_DIR: posixJoin(PD_DIRS.STATE, 'blobs'),
+    EXPORTS_DIR: posixJoin(PD_DIRS.STATE, 'exports'),
     SESSION_DIR: PD_DIRS.SESSIONS,
-    DICTIONARY: path.join(PD_DIRS.STATE, 'pain_dictionary.json'),
-    // Workflow Layer (Project Root)
+    DICTIONARY: posixJoin(PD_DIRS.STATE, 'pain_dictionary.json'),
+    PRINCIPLE_BLACKLIST: posixJoin(PD_DIRS.STATE, 'principle_blacklist.json'),
     PLAN: 'PLAN.md',
     MEMORY_MD: 'MEMORY.md',
     HEARTBEAT: 'HEARTBEAT.md',
-    // Memory Layer
-    SYSTEM_LOG: path.join(PD_DIRS.LOGS, 'SYSTEM.log'),
-    REFLECTION_LOG: path.join(PD_DIRS.MEMORY, 'reflection-log.md'),
-    USER_CONTEXT: path.join(PD_DIRS.MEMORY, 'USER_CONTEXT.md'),
+    SYSTEM_LOG: posixJoin(PD_DIRS.LOGS, 'SYSTEM.log'),
+    REFLECTION_LOG: posixJoin(PD_DIRS.MEMORY, 'reflection-log.md'),
+    USER_CONTEXT: posixJoin(PD_DIRS.MEMORY, 'USER_CONTEXT.md'),
     OKR_DIR: PD_DIRS.OKR,
-    CURRENT_FOCUS: path.join(PD_DIRS.OKR, 'CURRENT_FOCUS.md'),
-    WEEK_STATE: path.join(PD_DIRS.OKR, 'WEEK_STATE.json'),
-    THINKING_OS_CANDIDATES: path.join(PD_DIRS.MEMORY, 'THINKING_OS_CANDIDATES.md'),
-    SEMANTIC_PAIN: path.join(PD_DIRS.PAIN_SAMPLES, 'confusion_samples.md'),
+    CURRENT_FOCUS: posixJoin(PD_DIRS.OKR, 'CURRENT_FOCUS.md'),
+    WEEK_STATE: posixJoin(PD_DIRS.OKR, 'WEEK_STATE.json'),
+    THINKING_OS_CANDIDATES: posixJoin(PD_DIRS.MEMORY, 'THINKING_OS_CANDIDATES.md'),
+    SEMANTIC_PAIN: posixJoin(PD_DIRS.PAIN_SAMPLES, 'confusion_samples.md'),
+    EVOLUTION_STREAM: posixJoin(PD_DIRS.MEMORY, 'evolution.jsonl'),
+    EVOLUTION_LOCK: posixJoin(PD_DIRS.LOCKS, 'evolution'),
 };
 /**
  * Resolves a PD file path within a given workspace.
  */
 export function resolvePdPath(workspaceDir, fileKey) {
-    return path.join(workspaceDir, PD_FILES[fileKey]);
+    return joinWorkspacePath(workspaceDir, PD_FILES[fileKey]);
 }

package/dist/core/profile.js

@@ -51,7 +51,7 @@ export const PROFILE_DEFAULTS = {
     thinking_checkpoint: {
         enabled: false, // Default OFF to avoid blocking new users
         window_ms: 5 * 60 * 1000, // 5 minute window
-        high_risk_tools: ['run_shell_command', 'delete_file', 'move_file', 'pd_spawn_agent'],
+        high_risk_tools: ['run_shell_command', 'delete_file', 'move_file', 'pd_run_worker'],
     },
     custom_guards: [],
 };

package/dist/core/session-tracker.d.ts

@@ -18,6 +18,8 @@ export interface SessionState {
     cacheHits: number;
     stuckLoops: number;
     currentGfi: number;
+    gfiBySource?: Record<string, number>;
+    lastErrorSource?: string;
     lastErrorHash: string;
     consecutiveErrors: number;
     dailyToolCalls: number;
@@ -25,6 +27,7 @@ export interface SessionState {
     dailyPainSignals: number;
     dailyGfiPeak: number;
     lastThinkingTimestamp: number;
+    injectedProbationIds?: string[];
 }
 /**
  * Initialize persistence for session state.
@@ -40,11 +43,16 @@ export declare function trackLlmOutput(sessionId: string, usage: TokenUsage | un
 /**
  * Tracks physical friction based on tool execution failures.
  */
-export declare function trackFriction(sessionId: string, deltaF: number, hash: string, workspaceDir?: string): SessionState;
+export declare function trackFriction(sessionId: string, deltaF: number, hash: string, workspaceDir?: string, options?: {
+    source?: string;
+}): SessionState;
 /**
  * Resets the friction index upon successful action.
  */
-export declare function resetFriction(sessionId: string, workspaceDir?: string): SessionState;
+export declare function resetFriction(sessionId: string, workspaceDir?: string, options?: {
+    source?: string;
+    amount?: number;
+}): SessionState;
 /**
  * Records that deep thinking (Thinking OS) was performed in this session.
  * Used by the Thinking OS checkpoint to allow high-risk operations.
@@ -58,7 +66,11 @@ export declare function recordThinkingCheckpoint(sessionId: string, workspaceDir
  */
 export declare function hasRecentThinking(sessionId: string, windowMs?: number): boolean;
 export declare function trackBlock(sessionId: string): SessionState;
+export declare function setInjectedProbationIds(sessionId: string, ids: string[], workspaceDir?: string): SessionState;
+export declare function getInjectedProbationIds(sessionId: string, workspaceDir?: string): string[];
+export declare function clearInjectedProbationIds(sessionId: string, workspaceDir?: string): SessionState;
 export declare function getSession(sessionId: string): SessionState | undefined;
+export declare function listSessions(workspaceDir?: string): SessionState[];
 export declare function clearSession(sessionId: string): void;
 export declare function garbageCollectSessions(): void;
 /**

package/dist/core/session-tracker.js

@@ -6,6 +6,11 @@ const sessions = new Map();
 let persistDir = null;
 /** Debounce timer for persistence */
 let persistTimer = null;
+function logSessionTrackerWarning(message, error) {
+    const detail = error instanceof Error ? error.message : error ? String(error) : '';
+    const suffix = detail ? `: ${detail}` : '';
+    console.warn(`[PD:SessionTracker] ${message}${suffix}`);
+}
 /**
  * Initialize persistence for session state.
  * Call this once during plugin startup.
@@ -48,13 +53,13 @@ function loadAllSessions() {
                 }
                 sessions.set(state.sessionId, state);
             }
-            catch {
-                // Ignore corrupted files
+            catch (error) {
+                logSessionTrackerWarning(`Failed to load session snapshot ${file}`, error);
             }
         }
     }
     catch (err) {
-        // Ignore errors during load
+        logSessionTrackerWarning('Failed to load persisted sessions', err);
     }
 }
 /**
@@ -69,8 +74,8 @@ function persistSession(state) {
     try {
         fs.writeFileSync(sessionPath, JSON.stringify(state, null, 2), 'utf-8');
     }
-    catch {
-        // Ignore persistence errors
+    catch (error) {
+        logSessionTrackerWarning(`Failed to persist session ${state.sessionId}`, error);
     }
 }
 /**
@@ -108,6 +113,8 @@ function getOrCreateSession(sessionId, workspaceDir) {
             cacheHits: 0,
             stuckLoops: 0,
             currentGfi: 0,
+            gfiBySource: {},
+            lastErrorSource: '',
             lastErrorHash: '',
             consecutiveErrors: 0,
             dailyToolCalls: 0,
@@ -115,6 +122,7 @@ function getOrCreateSession(sessionId, workspaceDir) {
             dailyPainSignals: 0,
             dailyGfiPeak: 0,
             lastThinkingTimestamp: 0,
+            injectedProbationIds: [],
         };
         sessions.set(sessionId, state);
     }
@@ -123,6 +131,12 @@ function getOrCreateSession(sessionId, workspaceDir) {
     }
     return state;
 }
+function ensureGfiLedger(state) {
+    if (!state.gfiBySource || typeof state.gfiBySource !== 'object') {
+        state.gfiBySource = {};
+    }
+    return state.gfiBySource;
+}
 export function trackToolRead(sessionId, filePath, workspaceDir) {
     const state = getOrCreateSession(sessionId, workspaceDir);
     const normalizedPath = path.posix.normalize(filePath.replace(/\\/g, '/'));
@@ -164,12 +178,14 @@ export function trackLlmOutput(sessionId, usage, config, workspaceDir) {
 /**
  * Tracks physical friction based on tool execution failures.
  */
-export function trackFriction(sessionId, deltaF, hash, workspaceDir) {
+export function trackFriction(sessionId, deltaF, hash, workspaceDir, options) {
     const state = getOrCreateSession(sessionId, workspaceDir);
+    const ledger = ensureGfiLedger(state);
     if (hash && hash === state.lastErrorHash) {
         state.consecutiveErrors++;
     }
     else {
+        state.lastErrorSource = options?.source || (hash ? `unattributed:${hash}` : 'unattributed:unknown');
         state.lastErrorHash = hash;
         state.consecutiveErrors = 1;
     }
@@ -177,6 +193,8 @@ export function trackFriction(sessionId, deltaF, hash, workspaceDir) {
     const multiplier = Math.pow(1.5, state.consecutiveErrors - 1);
     const addedFriction = deltaF * multiplier;
     state.currentGfi = (state.currentGfi || 0) + addedFriction;
+    const sourceKey = options?.source || (hash ? `unattributed:${hash}` : 'unattributed:unknown');
+    ledger[sourceKey] = (ledger[sourceKey] || 0) + addedFriction;
     state.lastActivityAt = Date.now();
     SystemLogger.log(state.workspaceDir, 'GFI_INC', `Friction added: +${addedFriction.toFixed(1)} (Base: ${deltaF}, Mult: ${multiplier.toFixed(2)}). Total GFI: ${state.currentGfi.toFixed(1)}`);
     // Update daily stats
@@ -189,12 +207,36 @@ export function trackFriction(sessionId, deltaF, hash, workspaceDir) {
 /**
  * Resets the friction index upon successful action.
  */
-export function resetFriction(sessionId, workspaceDir) {
+export function resetFriction(sessionId, workspaceDir, options) {
     const state = getOrCreateSession(sessionId, workspaceDir);
+    const ledger = ensureGfiLedger(state);
+    if (options?.source) {
+        const sourceKey = options.source;
+        const currentSource = ledger[sourceKey] || 0;
+        const requestedAmount = Number.isFinite(options.amount) ? Number(options.amount) : currentSource;
+        const amountToRemove = Math.max(0, Math.min(currentSource, requestedAmount));
+        if (amountToRemove > 0) {
+            ledger[sourceKey] = Math.max(0, currentSource - amountToRemove);
+            if (ledger[sourceKey] === 0) {
+                delete ledger[sourceKey];
+            }
+            state.currentGfi = Math.max(0, (state.currentGfi || 0) - amountToRemove);
+            SystemLogger.log(state.workspaceDir, 'GFI_SLICE_RESET', `Friction slice reset for ${sourceKey}: -${amountToRemove.toFixed(1)}. Total GFI: ${state.currentGfi.toFixed(1)}`);
+            if (state.lastErrorSource === sourceKey) {
+                state.consecutiveErrors = 0;
+                state.lastErrorHash = '';
+                state.lastErrorSource = '';
+            }
+        }
+        schedulePersistence(state);
+        return state;
+    }
     if (state.currentGfi > 0) {
         SystemLogger.log(state.workspaceDir, 'GFI_RESET', `Friction reset to 0 (Was: ${state.currentGfi.toFixed(1)}). Action successful.`);
     }
     state.currentGfi = 0;
+    state.gfiBySource = {};
+    state.lastErrorSource = '';
     state.consecutiveErrors = 0;
     state.lastErrorHash = '';
     // Schedule persistence
@@ -230,9 +272,33 @@ export function trackBlock(sessionId) {
     state.lastActivityAt = Date.now();
     return state;
 }
+export function setInjectedProbationIds(sessionId, ids, workspaceDir) {
+    const state = getOrCreateSession(sessionId, workspaceDir);
+    state.injectedProbationIds = [...ids];
+    state.lastActivityAt = Date.now();
+    schedulePersistence(state);
+    return state;
+}
+export function getInjectedProbationIds(sessionId, workspaceDir) {
+    const state = getOrCreateSession(sessionId, workspaceDir);
+    return [...(state.injectedProbationIds || [])];
+}
+export function clearInjectedProbationIds(sessionId, workspaceDir) {
+    return setInjectedProbationIds(sessionId, [], workspaceDir);
+}
 export function getSession(sessionId) {
     return sessions.get(sessionId);
 }
+export function listSessions(workspaceDir) {
+    return [...sessions.values()]
+        .filter((state) => !workspaceDir || !state.workspaceDir || state.workspaceDir === workspaceDir)
+        .map((state) => ({
+        ...state,
+        toolReadsByFile: { ...state.toolReadsByFile },
+        gfiBySource: state.gfiBySource ? { ...state.gfiBySource } : undefined,
+        injectedProbationIds: state.injectedProbationIds ? [...state.injectedProbationIds] : undefined,
+    }));
+}
 export function clearSession(sessionId) {
     sessions.delete(sessionId);
 }
@@ -249,8 +315,8 @@ export function garbageCollectSessions() {
                     try {
                         fs.unlinkSync(sessionPath);
                     }
-                    catch {
-                        // Ignore deletion errors
+                    catch (error) {
+                        logSessionTrackerWarning(`Failed to delete session snapshot for ${id}`, error);
                     }
                 }
             }

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

@@ -0,0 +1,38 @@
+export interface ThinkingModelDefinition {
+    id: string;
+    name: string;
+    description: string;
+    patterns: RegExp[];
+    baselineScenarios: string[];
+}
+export interface ThinkingModelMatch {
+    modelId: string;
+    matchedPattern: string;
+}
+export interface ThinkingScenarioContext {
+    recentToolCalls?: Array<{
+        toolName: string;
+        outcome: 'success' | 'failure' | 'blocked';
+        errorType?: string | null;
+    }>;
+    recentPainEvents?: Array<{
+        source: string;
+        score: number;
+    }>;
+    recentGateBlocks?: Array<{
+        toolName: string;
+        reason: string;
+    }>;
+    recentUserCorrections?: Array<{
+        correctionCue?: string | null;
+    }>;
+    recentPrincipleEvents?: Array<{
+        eventType: string;
+        principleId?: string | null;
+    }>;
+}
+export declare const THINKING_MODEL_MAP: Map<string, ThinkingModelDefinition>;
+export declare function listThinkingModels(): ThinkingModelDefinition[];
+export declare function getThinkingModel(modelId: string): ThinkingModelDefinition | undefined;
+export declare function detectThinkingModelMatches(text: string): ThinkingModelMatch[];
+export declare function deriveThinkingScenarios(modelId: string, context: ThinkingScenarioContext): string[];

package/dist/core/thinking-models.js

@@ -0,0 +1,170 @@
+const THINKING_MODELS = [
+    {
+        id: 'T-01',
+        name: 'Survey Before Acting',
+        description: 'Understand the structure first before making changes.',
+        baselineScenarios: ['exploration', 'discovery'],
+        patterns: [
+            /let me (first )?(understand|map|outline|survey|review the (structure|architecture|dependencies))/i,
+            /before (changing|editing|touching) anything/i,
+            /让我先(梳理|理解|看看|盘点).*(结构|架构|依赖|全貌)/i,
+        ],
+    },
+    {
+        id: 'T-02',
+        name: 'Respect Constraints',
+        description: 'Explicitly reason about contracts, tests, schemas, and requirements.',
+        baselineScenarios: ['constraint-check', 'contract-verification'],
+        patterns: [
+            /(type|test|contract|schema|interface) (constraint|requirement|check|validation)/i,
+            /we (must|need to) (respect|follow|adhere to) the/i,
+            /(必须|需要).*(遵守|符合|满足).*(类型|测试|契约|接口|规范)/i,
+        ],
+    },
+    {
+        id: 'T-03',
+        name: 'Evidence Over Assumption',
+        description: 'Use logs, code, and outputs before inferring causes.',
+        baselineScenarios: ['evidence-gathering', 'verification'],
+        patterns: [
+            /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,
+        ],
+    },
+    {
+        id: 'T-04',
+        name: 'Reversible First',
+        description: 'Prefer changes that are safe to roll back when risk is high.',
+        baselineScenarios: ['risk-management', 'reversibility'],
+        patterns: [
+            /this (is|would be) (irreversible|destructive|permanent|not easily undone)/i,
+            /(reversible|can be undone|safely roll back)/i,
+            /(不可逆|破坏性|无法回滚|可以回滚|安全撤销)/i,
+        ],
+    },
+    {
+        id: 'T-05',
+        name: 'Safety Rails',
+        description: 'Call out guardrails, prohibitions, and failure-prevention constraints.',
+        baselineScenarios: ['guardrails', 'safety-rails'],
+        patterns: [
+            /we (must|should) (not|never|avoid|prevent|ensure we don't)/i,
+            /(critical|important) (not to|that we don't|to avoid)/i,
+            /(绝不能|必须避免|不可|禁止|确保不会)/i,
+        ],
+    },
+    {
+        id: 'T-06',
+        name: 'Simplicity First',
+        description: 'Prefer the smallest understandable solution over over-engineering.',
+        baselineScenarios: ['simplification', 'pragmatism'],
+        patterns: [
+            /(simpl(er|est|ify)|minimal|straightforward|lean) (approach|solution|fix|implementation)/i,
+            /(simple is better|keep it simple|no need to over)/i,
+            /(最简|更简单|精简|没必要过度设计)/i,
+        ],
+    },
+    {
+        id: 'T-07',
+        name: 'Minimal Change Surface',
+        description: 'Limit the blast radius and touch only what is necessary.',
+        baselineScenarios: ['minimal-diff', 'blast-radius-control'],
+        patterns: [
+            /(minimal|smallest|narrowest|least) (change|diff|modification|impact)/i,
+            /only (change|modify|touch|edit) (the |what)/i,
+            /(最小改动|最小变更|只改|只动必要部分)/i,
+        ],
+    },
+    {
+        id: 'T-08',
+        name: 'Pain As Signal',
+        description: 'Treat failures and friction as clues to step back and rethink.',
+        baselineScenarios: ['reflection', 'pain-response'],
+        patterns: [
+            /this (error|failure|issue) (tells us|indicates|signals|suggests|means)/i,
+            /let me (stop|pause|step back|reconsider|rethink)/i,
+            /这个(错误|失败|问题).*(说明|意味着|提示)/i,
+            /让我(停下|暂停|退一步|重新考虑|重新审视)/i,
+        ],
+    },
+    {
+        id: 'T-09',
+        name: 'Divide And Conquer',
+        description: 'Split the task into smaller phases before execution.',
+        baselineScenarios: ['decomposition', 'phased-execution'],
+        patterns: [
+            /(break|split|decompose|divide) (this |the task |it )?(into|down)/i,
+            /(step 1|first,? (we|i|let's)|phase 1)/i,
+            /(拆分|分解|分步|分阶段|第一步)/i,
+        ],
+    },
+];
+export const THINKING_MODEL_MAP = new Map(THINKING_MODELS.map((model) => [model.id, model]));
+export function listThinkingModels() {
+    return THINKING_MODELS.slice();
+}
+export function getThinkingModel(modelId) {
+    return THINKING_MODEL_MAP.get(modelId);
+}
+export function detectThinkingModelMatches(text) {
+    if (!text)
+        return [];
+    const matches = [];
+    for (const model of THINKING_MODELS) {
+        for (const pattern of model.patterns) {
+            if (pattern.test(text)) {
+                matches.push({
+                    modelId: model.id,
+                    matchedPattern: pattern.source,
+                });
+                break;
+            }
+        }
+    }
+    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);
+}