create-principles-disciple 1.95.0 → 1.97.0

package/plugin/dist/core/intent-doc-reader-adapter.d.ts

@@ -17,12 +17,20 @@
  * Architecture: this file is I/O (delegates to fs-reading safeReadIntentDoc).
  * It will be added to KNOWN_PLUGIN_CORE_FILES in architecture-regression.test.ts.
  */
-import type { IntentDocReader } from '@principles/core/runtime-v2';
+import type { IntentDocReader, IntentLang } from '@principles/core/runtime-v2';
 /**
- * Create an IntentDocReader bound to a specific workspace.
+ * Detect which language's INTENT file exists on disk.
+ * Priority: zh-CN first, then en. Defaults to zh-CN if neither exists.
  *
- * The returned reader is stateless beyond the workspace binding — each
+ * This lets hooks avoid hardcoding a single language — the Owner may have
+ * created either INTENT.zh-CN.md or INTENT.en.md.
+ */
+export declare function resolveIntentLang(workspaceDir: string): IntentLang;
+/**
+ * Create an IntentDocReader bound to a specific workspace and language.
+ *
+ * The returned reader is stateless beyond the (workspace, lang) binding — each
  * `readIntentDoc()` call delegates to `safeReadIntentDoc()`, which owns
- * the TTL+mtime cache.
+ * the TTL+mtime cache keyed by `${workspaceDir}:${lang}`.
  */
-export declare function createIntentDocReader(workspaceDir: string): IntentDocReader;
+export declare function createIntentDocReader(workspaceDir: string, lang: IntentLang): IntentDocReader;

package/plugin/dist/core/intent-doc-reader-adapter.js

@@ -17,18 +17,38 @@
  * Architecture: this file is I/O (delegates to fs-reading safeReadIntentDoc).
  * It will be added to KNOWN_PLUGIN_CORE_FILES in architecture-regression.test.ts.
  */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { safeReadIntentDoc } from './intent-doc-reader.js';
+import { getIntentFilename, } from '@principles/core/runtime-v2';
+const INTENT_DIR = '.principles';
 /**
- * Create an IntentDocReader bound to a specific workspace.
+ * Detect which language's INTENT file exists on disk.
+ * Priority: zh-CN first, then en. Defaults to zh-CN if neither exists.
  *
- * The returned reader is stateless beyond the workspace binding — each
+ * This lets hooks avoid hardcoding a single language — the Owner may have
+ * created either INTENT.zh-CN.md or INTENT.en.md.
+ */
+export function resolveIntentLang(workspaceDir) {
+    const zhPath = path.join(workspaceDir, INTENT_DIR, getIntentFilename('zh-CN'));
+    if (fs.existsSync(zhPath))
+        return 'zh-CN';
+    const enPath = path.join(workspaceDir, INTENT_DIR, getIntentFilename('en'));
+    if (fs.existsSync(enPath))
+        return 'en';
+    return 'zh-CN';
+}
+/**
+ * Create an IntentDocReader bound to a specific workspace and language.
+ *
+ * The returned reader is stateless beyond the (workspace, lang) binding — each
  * `readIntentDoc()` call delegates to `safeReadIntentDoc()`, which owns
- * the TTL+mtime cache.
+ * the TTL+mtime cache keyed by `${workspaceDir}:${lang}`.
  */
-export function createIntentDocReader(workspaceDir) {
+export function createIntentDocReader(workspaceDir, lang) {
     return {
         readIntentDoc() {
-            const result = safeReadIntentDoc(workspaceDir);
+            const result = safeReadIntentDoc(workspaceDir, lang);
             if (result.ok && result.doc) {
                 const doc = result.doc;
                 const reference = {

package/plugin/dist/core/intent-doc-reader.d.ts

@@ -21,7 +21,7 @@
  * Architecture: this file is I/O (fs, path). It is whitelisted in
  * architecture-regression.test.ts KNOWN_PLUGIN_CORE_FILES.
  */
-import { type IntentDocSections, type IntentDocWarning } from '@principles/core/runtime-v2';
+import { type IntentDocSections, type IntentDocWarning, type IntentLang } from '@principles/core/runtime-v2';
 export type SafeReadIntentDocReason = 'flag_disabled' | 'not_found' | 'oversized' | 'read_error';
 export interface IntentDoc {
     /** Raw INTENT.md content (unescaped — caller escapes for prompt injection). */
@@ -55,9 +55,17 @@ export interface SafeReadIntentDocResult {
 }
 /**
  * Reset the intent doc cache for test isolation.
- * Call in beforeEach() to ensure tests don't pollute each other.
+ *
+ * - No args: clear the whole cache.
+ * - workspaceDir only: delete all entries for that workspace (any lang).
+ *   Keys are formatted as `${workspaceDir}:${lang}`, so we match by prefix.
+ * - workspaceDir + lang: delete the single `${workspaceDir}:${lang}` entry.
+ *
+ * Note: prompt.ts resetPromptStateForTest passes workspaceDir only — the
+ * previous signature treated it as a literal cache key, which never matched
+ * the `${workspaceDir}:${lang}` format and silently left entries behind.
  */
-export declare function resetIntentDocCacheForTest(workspaceDir?: string): void;
+export declare function resetIntentDocCacheForTest(workspaceDir?: string, lang?: IntentLang): void;
 /**
  * Safely read INTENT.md for prompt injection.
  *
@@ -69,10 +77,11 @@ export declare function resetIntentDocCacheForTest(workspaceDir?: string): void;
  * 4. Never throws — all errors return structured reason + nextAction.
  *
  * @param workspaceDir - Absolute path to the workspace root
+ * @param lang - Mandatory language code ('zh-CN' | 'en'); selects INTENT.${lang}.md
  * @param options - Optional logger for debug-level diagnostics
  * @returns SafeReadIntentDocResult (never throws)
  */
-export declare function safeReadIntentDoc(workspaceDir: string, options?: {
+export declare function safeReadIntentDoc(workspaceDir: string, lang: IntentLang, options?: {
     logger?: {
         debug?: (msg: string) => void;
         warn?: (msg: string) => void;

package/plugin/dist/core/intent-doc-reader.js

@@ -23,29 +23,48 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { INTENT_MAX_BYTES, parseIntentDocSections, computeIntentContentHash, validateIntentDocSections, } from '@principles/core/runtime-v2';
+import { INTENT_MAX_BYTES, getIntentFilename, parseIntentDocSections, computeIntentContentHash, validateIntentDocSections, } from '@principles/core/runtime-v2';
 import { loadFeatureFlagFromConfig } from './pd-config-loader.js';
 // ── Constants ────────────────────────────────────────────────────────────────
-const INTENT_FILENAME = 'INTENT.md';
 const INTENT_DIR = '.principles';
 const INTENT_CACHE_TTL_MS = 60_000; // 1 minute (SPEC §12.1)
 // ── Module-level cache (per-workspace) ───────────────────────────────────────
 const _intentDocCache = new Map();
 /**
  * Reset the intent doc cache for test isolation.
- * Call in beforeEach() to ensure tests don't pollute each other.
+ *
+ * - No args: clear the whole cache.
+ * - workspaceDir only: delete all entries for that workspace (any lang).
+ *   Keys are formatted as `${workspaceDir}:${lang}`, so we match by prefix.
+ * - workspaceDir + lang: delete the single `${workspaceDir}:${lang}` entry.
+ *
+ * Note: prompt.ts resetPromptStateForTest passes workspaceDir only — the
+ * previous signature treated it as a literal cache key, which never matched
+ * the `${workspaceDir}:${lang}` format and silently left entries behind.
  */
-export function resetIntentDocCacheForTest(workspaceDir) {
-    if (workspaceDir) {
-        _intentDocCache.delete(workspaceDir);
-    }
-    else {
+export function resetIntentDocCacheForTest(workspaceDir, lang) {
+    if (workspaceDir === undefined) {
         _intentDocCache.clear();
+        return;
+    }
+    if (lang !== undefined) {
+        _intentDocCache.delete(`${workspaceDir}:${lang}`);
+        return;
+    }
+    // workspaceDir only — clear all langs for this workspace by prefix.
+    const prefix = `${workspaceDir}:`;
+    for (const key of _intentDocCache.keys()) {
+        if (key.startsWith(prefix)) {
+            _intentDocCache.delete(key);
+        }
     }
 }
 // ── Helpers ──────────────────────────────────────────────────────────────────
-function getIntentFilePath(workspaceDir) {
-    return path.join(workspaceDir, INTENT_DIR, INTENT_FILENAME);
+function getIntentFilePath(workspaceDir, lang) {
+    return path.join(workspaceDir, INTENT_DIR, getIntentFilename(lang));
+}
+function getCacheKey(workspaceDir, lang) {
+    return `${workspaceDir}:${lang}`;
 }
 function buildDocFromRaw(raw, filePath, readAt) {
     const sections = parseIntentDocSections(raw);
@@ -72,10 +91,11 @@ function buildDocFromRaw(raw, filePath, readAt) {
  * 4. Never throws — all errors return structured reason + nextAction.
  *
  * @param workspaceDir - Absolute path to the workspace root
+ * @param lang - Mandatory language code ('zh-CN' | 'en'); selects INTENT.${lang}.md
  * @param options - Optional logger for debug-level diagnostics
  * @returns SafeReadIntentDocResult (never throws)
  */
-export function safeReadIntentDoc(workspaceDir, options) {
+export function safeReadIntentDoc(workspaceDir, lang, options) {
     // SPEC §12 — Flag check FIRST. Flag off → no fs access, no cache access.
     const flagResult = loadFeatureFlagFromConfig(workspaceDir, 'intent_engineering', options?.logger);
     if (!flagResult.enabled) {
@@ -84,14 +104,15 @@ export function safeReadIntentDoc(workspaceDir, options) {
             found: false,
             flagEnabled: false,
             reason: 'flag_disabled',
-            nextAction: 'Enable the intent_engineering feature flag in .pd/config.yaml to read INTENT.md.',
+            nextAction: `Enable the intent_engineering feature flag in .pd/config.yaml to read ${getIntentFilename(lang)}.`,
             warnings: [],
         };
     }
-    const filePath = getIntentFilePath(workspaceDir);
+    const cacheKey = getCacheKey(workspaceDir, lang);
+    const filePath = getIntentFilePath(workspaceDir, lang);
     const now = Date.now();
     // Check cache freshness (TTL + mtime)
-    const cached = _intentDocCache.get(workspaceDir);
+    const cached = _intentDocCache.get(cacheKey);
     if (cached && (now - cached.loadedAt) < INTENT_CACHE_TTL_MS) {
         // Cache is within TTL. Verify mtime hasn't changed.
         try {
@@ -117,26 +138,26 @@ export function safeReadIntentDoc(workspaceDir, options) {
         // Check existence first
         if (!fs.existsSync(filePath)) {
             // Invalidate stale cache entry if any
-            _intentDocCache.delete(workspaceDir);
+            _intentDocCache.delete(cacheKey);
             return {
                 ok: false,
                 found: false,
                 flagEnabled: true,
                 reason: 'not_found',
-                nextAction: 'Create .principles/INTENT.md using "pd intent init".',
+                nextAction: `Create .principles/${getIntentFilename(lang)} using "pd intent init".`,
                 warnings: [],
             };
         }
         const stat = fs.statSync(filePath);
         // SPEC §12 — 32KB size cap
         if (stat.size > INTENT_MAX_BYTES) {
-            _intentDocCache.delete(workspaceDir);
+            _intentDocCache.delete(cacheKey);
             return {
                 ok: false,
                 found: true,
                 flagEnabled: true,
                 reason: 'oversized',
-                nextAction: `INTENT.md exceeds ${INTENT_MAX_BYTES} bytes (${stat.size} bytes). Reduce content.`,
+                nextAction: `${getIntentFilename(lang)} exceeds ${INTENT_MAX_BYTES} bytes (${stat.size} bytes). Reduce content.`,
                 warnings: [],
             };
         }
@@ -147,19 +168,19 @@ export function safeReadIntentDoc(workspaceDir, options) {
         // an oversized file would enter parse/hash/cache as ok:true.
         const actualBytes = Buffer.byteLength(raw, 'utf8');
         if (actualBytes > INTENT_MAX_BYTES) {
-            _intentDocCache.delete(workspaceDir);
+            _intentDocCache.delete(cacheKey);
             return {
                 ok: false,
                 found: true,
                 flagEnabled: true,
                 reason: 'oversized',
-                nextAction: `INTENT.md exceeds ${INTENT_MAX_BYTES} bytes (${actualBytes} bytes after read). Reduce content.`,
+                nextAction: `${getIntentFilename(lang)} exceeds ${INTENT_MAX_BYTES} bytes (${actualBytes} bytes after read). Reduce content.`,
                 warnings: [],
             };
         }
         const doc = buildDocFromRaw(raw, filePath, new Date(now).toISOString());
         // Update cache
-        _intentDocCache.set(workspaceDir, {
+        _intentDocCache.set(cacheKey, {
             doc,
             mtime: stat.mtimeMs,
             loadedAt: now,
@@ -174,15 +195,15 @@ export function safeReadIntentDoc(workspaceDir, options) {
     }
     catch (err) {
         // ERR-002 — graceful degradation with reason + nextAction
-        _intentDocCache.delete(workspaceDir);
+        _intentDocCache.delete(cacheKey);
         const message = err instanceof Error ? err.message : String(err);
-        options?.logger?.warn?.(`[PD:Intent] safeReadIntentDoc failed: workspace=${workspaceDir}, error=${message}`);
+        options?.logger?.warn?.(`[PD:Intent] safeReadIntentDoc failed: workspace=${workspaceDir}, lang=${lang}, error=${message}`);
         return {
             ok: false,
             found: false,
             flagEnabled: true,
             reason: 'read_error',
-            nextAction: 'Check filesystem permissions for .principles/INTENT.md.',
+            nextAction: `Check filesystem permissions for .principles/${getIntentFilename(lang)}.`,
             warnings: [],
         };
     }

package/plugin/dist/core/rule-context-assembler.d.ts

@@ -0,0 +1,45 @@
+/**
+ * PRI-482 Phase 3 — Production RuleContext v2 assembler
+ *
+ * Converts raw TrajectoryDatabase rows into a validated RuleHistoryWindow,
+ * and provides buildProductionRuleContext for gate integration.
+ *
+ * ERR prevention:
+ *   - ERR-001: every row field is validated as unknown. No `as` bypass on
+ *     parsed params_json or outcome.
+ *   - ERR-024: buildProductionRuleContext fail-soft — query failure returns
+ *     unavailable, never throws.
+ *   - ERR-025: callers use recordToolCall → getRuleHostContextRows → this
+ *     assembler, covering the full production chain.
+ *
+ * Spec: docs/superpowers/specs/2026-06-27-rulecode-context-vision-design.md §5.
+ */
+import type { RuleContextV2, RuleHistoryWindow } from '@principles/core/runtime-v2';
+import type { RuleHostContextResult, RuleHostContextRow } from './trajectory-types.js';
+/**
+ * Minimal interface for the data source that TrajectoryDatabase satisfies.
+ * Allows testing buildProductionRuleContext without a real DB.
+ */
+export interface RuleContextDataSource {
+    getRuleHostContextRows(sessionId: string, limit: number): RuleHostContextResult;
+}
+/**
+ * Convert raw DB rows into a validated RuleHistoryWindow.
+ *
+ * If ANY row is malformed (bad params_json, invalid outcome, empty tool_name),
+ * the entire window is marked unavailable (fail loud, spec §5.2).
+ *
+ * ERR-001: row fields are validated as unknown. params_json is JSON.parsed
+ * then structurally checked (must be a non-array object). No `as` bypass.
+ */
+export declare function assembleHistoryFromRows(rows: readonly RuleHostContextRow[], truncated: boolean, projectDir: string): RuleHistoryWindow;
+/**
+ * Build a RuleContextV2 from the production data source (TrajectoryDatabase).
+ *
+ * ERR-024: if the query or assembly fails, returns an unavailable context
+ * (fail-soft). Never throws.
+ *
+ * sameActionBlockCount is always null in this version (spec §5.4:
+ * session-tracker.blockedAttempts is a session total, not per-action).
+ */
+export declare function buildProductionRuleContext(sessionId: string | null | undefined, targetPath: string | null, source: RuleContextDataSource, projectDir: string, limit?: number): RuleContextV2;

package/plugin/dist/core/rule-context-assembler.js

@@ -0,0 +1,148 @@
+/**
+ * PRI-482 Phase 3 — Production RuleContext v2 assembler
+ *
+ * Converts raw TrajectoryDatabase rows into a validated RuleHistoryWindow,
+ * and provides buildProductionRuleContext for gate integration.
+ *
+ * ERR prevention:
+ *   - ERR-001: every row field is validated as unknown. No `as` bypass on
+ *     parsed params_json or outcome.
+ *   - ERR-024: buildProductionRuleContext fail-soft — query failure returns
+ *     unavailable, never throws.
+ *   - ERR-025: callers use recordToolCall → getRuleHostContextRows → this
+ *     assembler, covering the full production chain.
+ *
+ * Spec: docs/superpowers/specs/2026-06-27-rulecode-context-vision-design.md §5.
+ */
+import { canonicalizeToolKind, computeBehaviorFacts, extractFilePathFromParams, normalizePathPure, UNAVAILABLE_RULE_CONTEXT, } from '@principles/core/runtime-v2';
+// ── internal constants ─────────────────────────────────────────────────────
+const VALID_OUTCOMES = new Set([
+    'success',
+    'failure',
+    'blocked',
+]);
+const DEFAULT_HISTORY_LIMIT = 20;
+// ── type guards (rc-2: no `as` bypass) ─────────────────────────────────────
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isRuleToolOutcome(value) {
+    return typeof value === 'string' && VALID_OUTCOMES.has(value);
+}
+// ── assembleHistoryFromRows ────────────────────────────────────────────────
+/**
+ * Convert raw DB rows into a validated RuleHistoryWindow.
+ *
+ * If ANY row is malformed (bad params_json, invalid outcome, empty tool_name),
+ * the entire window is marked unavailable (fail loud, spec §5.2).
+ *
+ * ERR-001: row fields are validated as unknown. params_json is JSON.parsed
+ * then structurally checked (must be a non-array object). No `as` bypass.
+ */
+export function assembleHistoryFromRows(rows, truncated, projectDir) {
+    const records = [];
+    for (const row of rows) {
+        // ── validate tool_name (ERR-001: unknown) ──
+        const toolName = row.toolName;
+        if (typeof toolName !== 'string' || toolName.length === 0) {
+            return unavailable(`row id=${row.id}: tool_name must be a non-empty string`);
+        }
+        // ── validate outcome (ERR-001: unknown, enum check) ──
+        const outcome = row.outcome;
+        if (!isRuleToolOutcome(outcome)) {
+            return unavailable(`row id=${row.id}: outcome "${row.outcome}" is not a valid RuleToolOutcome`);
+        }
+        // ── validate & parse params_json (ERR-001: unknown) ──
+        const paramsJsonStr = row.paramsJson;
+        if (typeof paramsJsonStr !== 'string') {
+            return unavailable(`row id=${row.id}: params_json must be a string`);
+        }
+        let parsedParams;
+        try {
+            parsedParams = JSON.parse(paramsJsonStr);
+        }
+        catch {
+            return unavailable(`row id=${row.id}: params_json is not valid JSON`);
+        }
+        // Must be a non-array object (spec §5.2)
+        if (!isPlainObject(parsedParams)) {
+            return unavailable(`row id=${row.id}: params_json must parse to a non-array object`);
+        }
+        // ── build RuleToolCallRecord ──
+        const canonicalKind = canonicalizeToolKind(toolName);
+        // Extract normalized path using the same pure logic as buildRuleHostAction
+        // (avoids production/replay drift, spec §4.4)
+        const rawPath = extractFilePathFromParams(parsedParams, {
+            isBashTool: canonicalKind === 'execute',
+            isWriteTool: canonicalKind === 'write',
+            toolName,
+        });
+        const normalizedPath = normalizePathPure(rawPath, projectDir);
+        records.push({
+            sequenceId: row.id,
+            toolName,
+            canonicalKind,
+            normalizedPath: normalizedPath === '' ? null : normalizedPath,
+            paramsSummary: parsedParams,
+            outcome,
+        });
+    }
+    return {
+        status: 'available',
+        truncated,
+        calls: records,
+    };
+}
+// ── buildProductionRuleContext ─────────────────────────────────────────────
+/**
+ * Build a RuleContextV2 from the production data source (TrajectoryDatabase).
+ *
+ * ERR-024: if the query or assembly fails, returns an unavailable context
+ * (fail-soft). Never throws.
+ *
+ * sameActionBlockCount is always null in this version (spec §5.4:
+ * session-tracker.blockedAttempts is a session total, not per-action).
+ */
+export function buildProductionRuleContext(sessionId, targetPath, source, projectDir, limit = DEFAULT_HISTORY_LIMIT) {
+    // Guard: no session → no context
+    if (!sessionId || typeof sessionId !== 'string' || sessionId.length === 0) {
+        return UNAVAILABLE_RULE_CONTEXT;
+    }
+    try {
+        const result = source.getRuleHostContextRows(sessionId, limit);
+        const history = assembleHistoryFromRows(result.rows, result.truncated, projectDir);
+        // sameActionBlockCount = null (spec §5.4 — no reliable per-action source)
+        const facts = computeBehaviorFacts(history, targetPath, null);
+        return {
+            version: 2,
+            history,
+            facts,
+        };
+    }
+    catch {
+        // ERR-024: fail-soft — never let a DB error propagate to the rule host
+        return unavailableContext('query or assembly failed');
+    }
+}
+// ── internal helpers ───────────────────────────────────────────────────────
+function unavailable(reason) {
+    return {
+        status: 'unavailable',
+        unavailableReason: reason,
+        truncated: false,
+        calls: [],
+    };
+}
+function unavailableContext(reason) {
+    return {
+        version: 2,
+        history: unavailable(reason),
+        facts: {
+            priorReadOfTarget: 'unknown',
+            readCount: null,
+            writeCount: null,
+            uniqueWritePathCount: null,
+            sameActionBlockCount: null,
+        },
+    };
+}

package/plugin/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.
  */
-export interface ThinkingModelDefinition {
-    id: string;
-    name: string;
-    description: string;
-    antiPattern?: string;
-    patterns: RegExp[];
-    baselineScenarios: string[];
-}
-export interface ThinkingModelMatch {
-    modelId: string;
-    matchedPattern: string;
-}
-export 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,20 +21,5 @@ export interface ThinkingScenarioContext {
  * @param workspaceDir Optional. If provided, loads from that workspace's THINKING_OS.md.
  */
 export declare function listThinkingModels(workspaceDir?: string): ThinkingModelDefinition[];
-/**
- * Clear the cached model definitions.
- * Call this when THINKING_OS.md changes.
- */
-export declare function clearThinkingModelCache(): void;
 export declare function getThinkingModel(modelId: string, workspaceDir?: string): ThinkingModelDefinition | undefined;
 export declare function detectThinkingModelMatches(text: string, workspaceDir?: string): ThinkingModelMatch[];
-/**
- * Get all model definitions for display purposes (no patterns).
- */
-export declare function getThinkingModelDefinitions(workspaceDir?: string): {
-    modelId: string;
-    name: string;
-    description: string;
-    antiPattern?: string;
-}[];
-export declare function deriveThinkingScenarios(modelId: string, context: ThinkingScenarioContext): string[];