principles-disciple 1.201.0 → 1.202.0

package/dist/core/reflection/reflection-context.d.ts

@@ -0,0 +1,31 @@
+import { type LedgerPrinciple } from '../principle-tree-ledger.js';
+import type { TrajectoryDatabase } from '../trajectory.js';
+export interface ReflectionContext {
+    principle: LedgerPrinciple;
+    painEvents: Array<{
+        source: string;
+        score: number;
+        severity: string | null;
+        reason: string | null;
+        createdAt: string;
+    }>;
+    sessionSnapshot: {
+        toolCalls: Array<{
+            toolName: string;
+            outcome: string;
+            filePath: string | null;
+            errorType: string | null;
+        }>;
+    } | null;
+}
+export declare class ReflectionContextCollector {
+    private readonly stateDir;
+    private readonly trajectory;
+    constructor(stateDir: string, trajectory: TrajectoryDatabase);
+    collect(principleId: string): ReflectionContext | null;
+    collectBatch(filter?: {
+        status?: string;
+    }): ReflectionContext[];
+    private buildContext;
+    private resolvePainEvents;
+}

package/dist/core/replay-engine.d.ts

@@ -0,0 +1,12 @@
+import type { ReplayReport, ClassificationSummary, ReplayResult } from '@principles/core/runtime-v2';
+export type { ReplayReport, ClassificationSummary, ReplayResult };
+export declare class ReplayEngine {
+    private readonly workspaceDir;
+    private readonly stateDir;
+    constructor(workspaceDir: string, stateDir: string);
+    listReports(implementationId: string): ReplayReport[];
+    getLatestReport(implementationId: string): ReplayReport | null;
+    hasPassingReport(implementationId: string): boolean;
+    private _getImplementationById;
+}
+export declare function formatReplayReport(report: ReplayReport): string;

package/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/dist/core/rule-host.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Rule Host — Constrained execution layer for active code implementations
+ *
+ * PURPOSE: Load active code implementations from the SQLite activations table
+ * (code_tool_hook channel), execute them in a constrained node:vm context,
+ * and merge their decisions.
+ *
+ * ARCHITECTURE (PRI-436):
+ *   - SQLite is the SOLE production source of active RuleCode
+ *   - No filesystem ledger or implementation asset reads occur during evaluation
+ *   - Constructor takes stateDir for API compatibility (no longer used for impl loading)
+ *   - workspaceDir enables reading code_tool_hook activations from SQLite
+ *   - evaluate(input) loads active code implementations and runs them
+ *   - Each implementation executes in an isolated vm context with minimal helpers
+ *   - Decision merge: block short-circuits, requireApproval collects, allow is implicit
+ *
+ * SECURITY CONSTRAINTS (T-12-01, T-12-04):
+ *   - Candidate code loads through a dedicated vm context, not the host realm
+ *   - No importModuleDynamically callback
+ *   - Helpers are a frozen object — implementations cannot modify the helper surface
+ *
+ * CONSERVATIVE DEGRADATION (T-12-02, D-08):
+ *   - On ANY host error (load failure, eval error, vm error): return undefined
+ *   - Never throw, never bypass downstream gates (Progressive Gate, Edit Verification)
+ */
+import type { RuleHostInput, RuleHostResult } from '@principles/core/runtime-v2';
+import type { RuleHostLogger } from '@principles/core/runtime-v2';
+export type { RuleHostLogger } from '@principles/core/runtime-v2';
+export interface RuleHostOptions {
+    /** Workspace directory for SQLite access. Required for RuleHost to load active code_tool_hook activations. */
+    workspaceDir?: string;
+}
+type RuleHostActivationMode = 'shadow' | 'live';
+export interface RuleHostObservedDecision extends RuleHostResult {
+    readonly activationId: string;
+}
+/**
+ * PRI-491 — A structured record of an activation that was skipped at load
+ * time (flag-off v2, unsupported action, unsupported context version,
+ * missing target_ref, content_json not an object, no implementationCode,
+ * or duplicate active activation for target_ref).
+ *
+ * Unlike compile/load failures (which emit rulehost_unhealthy), skipped
+ * activations have a configuration/flag reason — the RuleCode itself may be
+ * valid, but the runtime chose not to execute it. Duplicate activations are
+ * a special case: they ALSO emit rulehost_unhealthy (for telemetry), but are
+ * surfaced in skippedActivations so the owner can observe and act (rc-9).
+ *
+ * ERR-002 (rc-9): every skip carries a reason + nextAction, never silent.
+ */
+export interface SkippedActivation {
+    readonly activationId: string;
+    readonly ruleId: string;
+    /**
+     * The mode the activation WOULD have had if loaded. Optional for cases
+     * where the action itself is unrecognized (neither shadow nor live).
+     */
+    readonly mode?: RuleHostActivationMode;
+    readonly reason: string;
+    readonly nextAction: string;
+}
+export interface RuleHostEvaluationReport {
+    readonly liveDecision: RuleHostResult | undefined;
+    readonly shadowDecisions: readonly RuleHostObservedDecision[];
+    /**
+     * PRI-491 — Activations that were skipped at load time. Empty when all
+     * active activations loaded successfully. Each entry carries a structured
+     * reason + nextAction so the owner can act without reading SQLite rows.
+     */
+    readonly skippedActivations: readonly SkippedActivation[];
+}
+export declare class RuleHost {
+    private readonly stateDir;
+    private logger;
+    private readonly workspaceDir;
+    private readonly implementationSources;
+    private activationFingerprint;
+    private cachedImplementations;
+    /**
+     * PRI-491: Cached skipped activations from the last load. Returned alongside
+     * cachedImplementations on fingerprint hit so evaluateDetailed can surface
+     * them without re-scanning SQLite.
+     */
+    private cachedSkipped;
+    private sqliteConnection;
+    /**
+     * R2-RH-002: Guards the "armed but empty" warn so it fires at most once per
+     * RuleHost instance. Without this, the 0-rules path (workspaceDir missing OR
+     * zero active code_tool_hook activations) returns [] silently on every
+     * evaluation — an observability gap (rc-9-no-silent-fallback). The warn is
+     * NOT a degradation fallback (RuleHost correctly has no opinion when empty);
+     * it makes the empty-armed state visible so operators can investigate why
+     * no live rules are loaded.
+     */
+    private emptyLoadWarnEmitted;
+    constructor(stateDir: string, logger?: RuleHostLogger, options?: RuleHostOptions);
+    /**
+     * Update the logger sink on a cached RuleHost instance.
+     *
+     * WorkspaceContext caches the RuleHost singleton, but each gate call may
+     * pass a request-level logger. Without this update, warn/unhealthy logs
+     * would forever go to the first logger sink, making the new path hard to
+     * debug.
+     */
+    updateLogger(logger: RuleHostLogger): void;
+    /**
+     * Evaluate the input against all active code implementations.
+     *
+     * Returns:
+     *   - undefined when no active code implementations exist (no opinion)
+     *   - undefined when all implementations return allow or matched=false
+     *   - { decision: 'block', ... } when any implementation returns block (short-circuits)
+     *   - { decision: 'requireApproval', ... } when any implementation returns requireApproval
+     */
+    evaluate(input: RuleHostInput): RuleHostResult | undefined;
+    dispose(): void;
+    evaluateDetailed(input: RuleHostInput): RuleHostEvaluationReport;
+    /**
+     * Load active code implementations from the SQLite activations table.
+     *
+     * PRI-436: SQLite is the SOLE production source. The filesystem ledger
+     * (principle-tree-ledger) and implementation asset paths have been deleted.
+     * No fallback, no dual-source, no deprecated adapter.
+     *
+     * Source: activations table (code_tool_hook channel, deactivated_at IS NULL)
+     *   → JOIN pi_artifacts for content_json → extract implementationCode → compile
+     */
+    private _loadActiveCodeImplementations;
+    /**
+     * R2-RH-002: Emit the "armed but empty" warn at most once per RuleHost
+     * instance. The warn is cached via `emptyLoadWarnEmitted` so repeated
+     * evaluations (which all hit the empty path) do not spam the log.
+     *
+     * This is an observability signal, NOT a degradation fallback — RuleHost
+     * correctly returns "no opinion" when there are no active rules. The warn
+     * makes the empty state visible so operators can distinguish "RuleHost is
+     * working but has no rules" from "RuleHost is broken" (rc-9-no-silent-fallback).
+     */
+    private _emitEmptyLoadWarn;
+    /**
+     * Load active code implementations from the activations table (code_tool_hook channel).
+     *
+     * For each activation record:
+     *   1. Query the pi_artifacts table for the artifact content
+     *   2. Parse content_json to extract implementationCode (treated as unknown, EP-01)
+     *   3. Compile via loadRuleImplementationModule (isolated vm context)
+     *
+     * PRI-436 invariant: at most one active activation per rule (target_ref).
+     * Duplicate active activations for the same target_ref are ALL skipped
+     * (zero executions) and emit structured unhealthy evidence via logger.warn
+     * (Runtime Contract Rule 9: graceful degradation includes a reason).
+     *
+     * All data from SQLite is treated as unknown and validated before use.
+     */
+    private _loadFromActivationsTable;
+    /**
+     * PRI-437: Record an unhealthy activation state to EventLog.
+     *
+     * This makes compile/load failures visible to CLI (pd runtime health) and
+     * Console API — NOT just a logger.warn that's silently skipped.
+     *
+     * ERR-002: degradation includes a reason and nextAction (not silent).
+     * Failures in EventLog recording are caught and logged (never throw).
+     */
+    private _recordUnhealthy;
+    /**
+     * PRI-491: Record a skipped activation to EventLog.
+     *
+     * Unlike _recordUnhealthy (compile/load failures), skipped activations have
+     * a configuration/flag reason — the RuleCode itself may be valid, but the
+     * runtime chose not to execute it (flag-off v2, unsupported context version,
+     * unsupported action, content_json not object, no implementationCode).
+     *
+     * ERR-002: degradation includes a reason and nextAction (rc-9-no-silent-fallback).
+     * Failures in EventLog recording are caught and logged (never throw).
+     */
+    private _recordSkipped;
+}

package/dist/core/rule-implementation-runtime.d.ts

@@ -0,0 +1,18 @@
+export interface RuleImplementationModuleExports {
+    meta?: unknown;
+    evaluate?: unknown;
+    /**
+     * Call evaluate(input, helpers) INSIDE the vm context with a time boundary.
+     *
+     * PRI-437: The evaluate() function extracted from a vm context executes in
+     * the vm realm, but a direct host-realm call has NO timeout protection —
+     * an infinite loop in RuleCode would hang the host process forever.
+     *
+     * callEvaluate runs the invocation inside the vm context via
+     * Script.runInContext({ timeout }), which terminates infinite loops.
+     *
+     * Throws on timeout, compilation error, or if evaluate is missing.
+     */
+    callEvaluate?: (input: unknown, helpers: unknown) => unknown;
+}
+export declare function loadRuleImplementationModule(sourceCode: string, filename: string): RuleImplementationModuleExports;

package/dist/core/runtime-v2-prompt-activation-reader.d.ts

@@ -0,0 +1,22 @@
+import type { ActivatedPrinciple, PromptActivationReaderResult } from '@principles/core/runtime-v2';
+export { RUNTIME_V2_PRINCIPLE_BUDGET } from '@principles/core/runtime-v2';
+export type { ActivatedPrinciple, PromptActivationReaderResult };
+export interface PromptActivationReaderDeps {
+    logger?: {
+        warn?: (msg: string) => void;
+        info?: (msg: string) => void;
+        error?: (msg: string) => void;
+    };
+}
+export declare class PromptActivationReader {
+    private readonly workspaceDir;
+    private readonly deps;
+    constructor(workspaceDir: string, deps?: PromptActivationReaderDeps);
+    readActivatedPrinciples(): Promise<PromptActivationReaderResult>;
+    private queryArtifactRow;
+    /**
+     * PRI-305/PRI-307: Load feature flags from .pd/config.yaml instead of .pd/feature-flags.yaml.
+     * Uses the shared plugin config loader for consistency.
+     */
+    private loadFeatureFlags;
+}

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

@@ -0,0 +1,119 @@
+import type { PainConfig } from './config.js';
+export interface TokenUsage {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    total?: number;
+}
+export interface SessionState {
+    sessionId: string;
+    sessionKey?: string;
+    trigger?: string;
+    workspaceDir?: string;
+    toolReadsByFile: Record<string, number>;
+    llmTurns: number;
+    blockedAttempts: number;
+    lastActivityAt: number;
+    lastControlActivityAt: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    cacheHits: number;
+    stuckLoops: number;
+    currentGfi: number;
+    gfiBySource?: Record<string, number>;
+    lastErrorSource?: string;
+    lastErrorHash: string;
+    consecutiveErrors: number;
+    lastGfiDecayAt?: number;
+    dailyToolCalls: number;
+    dailyToolFailures: number;
+    dailyPainSignals: number;
+    dailyGfiPeak: number;
+    lastThinkingTimestamp: number;
+    injectedProbationIds?: string[];
+}
+/**
+ * Initialize persistence for session state.
+ * Call this once during plugin startup.
+ */
+export declare function initPersistence(stateDir: string): void;
+/**
+ * Force persist all sessions immediately.
+ */
+export declare function flushAllSessions(): void;
+export declare function trackToolRead(sessionId: string, filePath: string, workspaceDir?: string): SessionState;
+export declare function trackLlmOutput(sessionId: string, usage: TokenUsage | undefined, config?: PainConfig, workspaceDir?: string, sessionKey?: string, trigger?: string): SessionState;
+/**
+ * Tracks physical friction based on tool execution failures.
+ * Delegates to core GFI kernel for scoring.
+ */
+export declare function trackFriction(sessionId: string, deltaF: number, hash: string, workspaceDir?: string, options?: {
+    source?: string;
+}): SessionState;
+/**
+ * Resets the friction index upon successful action.
+ * Delegates to core GFI kernel for relief computation.
+ */
+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.
+ */
+export declare function recordThinkingCheckpoint(sessionId: string, workspaceDir?: string): SessionState;
+/**
+ * Checks if deep thinking was performed recently (within the given window).
+ * @param sessionId - The session to check
+ * @param windowMs - How recent the thinking must be (default: 5 minutes)
+ * @returns true if thinking was recorded within the window
+ */
+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;
+/**
+ * Seed a session directly into SessionTracker.sessions for testing.
+ * This bypasses the normal tool-call flow to set up test data for
+ * checkWorkspaceIdle without requiring full integration test setup.
+ *
+ * @param sessionId - Session ID
+ * @param workspaceDir - Workspace directory (optional, for filtering)
+ * @param lastActivityAt - Unix timestamp in ms (default: now)
+ */
+export declare function seedSessionForTest(sessionId: string, workspaceDir?: string, lastActivityAt?: number): void;
+export declare function garbageCollectSessions(): void;
+/**
+ * Get daily statistics summary for a session.
+ */
+export declare function getDailySummary(sessionId: string): {
+    toolCalls: number;
+    toolFailures: number;
+    painSignals: number;
+    gfiPeak: number;
+} | null;
+/**
+ * Reset daily statistics (call at midnight or on new day).
+ */
+export declare function resetDailyStats(sessionId: string): void;
+/**
+ * Apply time-based decay to GFI using stage-aware linear decay.
+ * Delegates to core GFI kernel.
+ *
+ * @param sessionId - The session to decay
+ * @param elapsedMinutes - Minutes since last decay
+ * @returns Updated session state, or undefined if session not found or GFI is 0
+ */
+export declare function decayGfi(sessionId: string, elapsedMinutes: number): SessionState | undefined;
+/**
+ * Check if GFI decay should be applied and return elapsed minutes since last decay.
+ * @param sessionId - The session to check
+ * @returns Elapsed minutes since last decay, or 0 if no decay needed
+ */
+export declare function getGfiDecayElapsed(sessionId: string): number;

package/dist/core/signal-collector-host.d.ts

@@ -0,0 +1,113 @@
+/**
+ * SignalCollectorHost — plugin I/O 外壳 (design spec §4.2)
+ *
+ * 把 core 的纯逻辑 (collectSync / mapLlmResultToOutput) 接进 openclaw 运行时。
+ *
+ * 同步路径 (prompt.ts before_prompt_build 钩子调用,绝不阻塞):
+ *   - trigger 门控 (user/api/undefined 视为用户交互,其余跳过)
+ *   - Stage1 关键词快扫 (零成本)
+ *   - 写 user_turns (复用 recordUserTurn)
+ *   - 高精度短语命中 (high) → 直接走 STRONG 分流 (同步,纯内存)
+ *   - 普通歧义词 / 未命中 → 入队异步 LLM 确认 (不阻塞)
+ *
+ * 异步路径 (fire-and-forget):
+ *   - Stage2 LLM 确认 (后台,不阻塞 prompt hook)
+ *   - LLM 不可用 → 降级:丢弃 ambiguous 候选 (不触发 STRONG,避免误判泛滥)
+ *   - 按 strength 分流:STRONG → emitPainDetectedEvent (修断裂 ③);WEAK → trackFriction 累积 GFI
+ *
+ * 降级不静默 (rc-9):所有降级路径走 SystemLogger。
+ */
+import { type UnifiedKeywordStore, type SignalCollectorConfig } from '@principles/core/runtime-v2';
+import type { PluginLogger } from '../openclaw-sdk.js';
+import type { WorkspaceContext } from './workspace-context.js';
+export declare const DEFAULT_SIGNAL_CONFIG: SignalCollectorConfig;
+/**
+ * 判定 trigger 是否代表真实用户交互。
+ *
+ * `user` / `api` / `undefined` 均视为用户交互(prompt.ts 与 detectSync 共享同一判定,
+ * 避免两处门控不一致导致 api/undefined 触发的纠正信号丢失)。
+ * `heartbeat` / `cron` / `subagent` 等系统触发不视为用户交互。
+ */
+export declare function isUserInteractionTrigger(trigger: string | undefined): boolean;
+export declare function buildDefaultKeywordStore(): UnifiedKeywordStore;
+/**
+ * adapter 抽象 (Stage2 LLM 调用)。plugin 层可注入真实 adapter (LMStudio);
+ * 为 null / 不可用时 host 走纯关键词降级。
+ *
+ * 本文件不依赖具体的 PDRuntimeAdapter 实现,只依赖一个最小的分类函数,
+ * 以保持 host 可单测 (测试可注入 mock classifier)。
+ */
+export type SignalLlmClassifier = (text: string, promptTemplate: string) => Promise<{
+    is_feedback: boolean;
+    type: 'correction' | 'empathy' | 'none';
+    confidence: number;
+    reason: string;
+} | null>;
+export interface SignalCollectorHostOptions {
+    keywordStore?: UnifiedKeywordStore;
+    config?: SignalCollectorConfig;
+    /** Stage2 LLM 分类器。null/undefined → 降级纯关键词。 */
+    llmClassifier?: SignalLlmClassifier | null;
+}
+export declare class SignalCollectorHost {
+    private readonly wctx;
+    private readonly store;
+    private readonly config;
+    private readonly llmClassifier;
+    /** rate limit 状态:sessionId → STRONG 计数桶 */
+    private readonly rateLimit;
+    constructor(wctx: WorkspaceContext, options?: SignalCollectorHostOptions);
+    /**
+     * ★ 同步路径 (prompt.ts before_prompt_build 钩子里调用,绝不能阻塞)。
+     *
+     * 只做:trigger 门控 + Stage1 关键词快扫 + 写 user_turns。
+     * 高精度短语命中 (high) → 直接走 STRONG 分流 (同步,纯内存)。
+     * 普通歧义词 / 未命中 → 入队异步 LLM 确认 (不阻塞)。
+     */
+    /**
+     * 可选入参:lineage 字段(由调用方算好传入,host 不感知 trajectory 结构)。
+     * referencesAssistantTurnId 让诊断 evidence 能 JOIN 到前置 assistant turn。
+     */
+    detectSync(userMessage: string, sessionId: string, trigger: string, options?: {
+        referencesAssistantTurnId?: number | null;
+        turnIndex?: number;
+    }): void;
+    /**
+     * ★ 异步路径 (fire-and-forget)。
+     *
+     * 1. Stage2 LLM 确认 (后台,不阻塞用户)
+     * 2. LLM 不可用 → 降级:empathy ambiguous 候选作为 WEAK 信号路由(保留旧版 GFI 累积);
+     *    correction ambiguous / 未命中候选丢弃(不触发 STRONG,避免误判泛滥)
+     * 3. 按 strength 分流:STRONG → emitPainDetectedEvent;WEAK → trackFriction 累积 GFI;none → 仅记录
+     */
+    private detectAsyncAndRoute;
+    /**
+     * STRONG 分流 → emitPainDetectedEvent (修断裂 ③)。
+     * 带 STRONG rate limit 门控 (spec §7.2):单 session 每小时上限 strongRateLimitPerHour。
+     */
+    private routeStrong;
+    /**
+     * WEAK 分流 → trackFriction 累积 GFI + 写 evidence (维持现状,spec §3.2)。
+     *
+     * WEAK 是 Layer 3 弱信号,用较小的摩擦分(20)累积,过 highGfi 阈值(70)才触发诊断。
+     * 不用 strongPainScore(70),因为 WEAK 单条不该直接顶满 GFI。
+     */
+    private routeWeak;
+    /**
+     * STRONG rate limit 门控:成功消耗一个名额返回 true;超限返回 false。
+     * 窗口满一小时自动重置。
+     */
+    private tryConsumeRateLimit;
+}
+/**
+ * 从 .pd/config.yaml 的 signalCollector runtimeProfile 构造 SignalLlmClassifier。
+ * 完成配置单轨化(spec §3.3 决策3):统一走 .pd/config.yaml,移除 empathy 的 workflows.yaml 双轨。
+ *
+ * 返回 null 的情况(走纯关键词降级,rc-9 不静默):
+ * - feature flag signal_collector 关闭
+ * - runtimeProfile 未配置 / apiKeyEnv 缺失
+ * - profile 是 openclaw 类型(observer 不支持)
+ *
+ * 这是 Task 11 的最后一块:让本地 LLM(LMStudio)真正参与检测。
+ */
+export declare function createSignalLlmClassifierFromConfig(wctx: WorkspaceContext, logger?: Pick<PluginLogger, 'info' | 'warn' | 'error' | 'debug'>): SignalLlmClassifier | null;

package/dist/core/system-logger.d.ts

@@ -0,0 +1,24 @@
+export declare const SystemLogger: {
+    log(workspaceDir: string | undefined, eventType: string, message: string): void;
+    /**
+     * Force refresh of the cached log file path.
+     * Call this at midnight or when the date changes to ensure proper rotation.
+     *
+     * PRI-504: clears log-file and log-date caches for ALL workspaces (preserves
+     * the original "force refresh" semantics). Does NOT clear lastCleanupDates
+     * to avoid re-triggering cleanup for every workspace on the same day.
+     */
+    refreshCache(): void;
+};
+/**
+ * PRI-504: dispose the SystemLogger cache for a single workspace.
+ * Useful for tests and for workspace teardown in multi-workspace processes.
+ * Pattern follows evolution-engine.ts:564-570 (disposeEvolutionEngine).
+ */
+export declare function disposeSystemLogger(workspaceDir: string): void;
+/**
+ * PRI-504: dispose ALL SystemLogger caches. Call this in test afterEach
+ * hooks to prevent state leakage between tests. Pattern follows
+ * evolution-engine.ts:572-577 (disposeAllEvolutionEngines).
+ */
+export declare function disposeAllSystemLoggers(): void;

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

@@ -0,0 +1,25 @@
+/**
+ * Thinking Models — Plugin I/O Adapter (Stage 3 slim)
+ *
+ * Pure logic (BUILTIN_PATTERNS, BUILTIN_PATTERN_MAP, getFallbackName,
+ * getFallbackDescription, deriveThinkingScenarios, types) lives in
+ * @principles/core/runtime-v2/thinking-models.
+ *
+ * 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 { 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.
+ *
+ * @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[];

package/dist/core/thinking-os-parser.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Thinking OS XML Parser
+ *
+ * Parses THINKING_OS.md to extract directive definitions.
+ * THINKING_OS.md is the single source of truth for thinking models.
+ *
+ * XML structure:
+ *   <directive id="T-01" name="MAP_BEFORE_TERRITORY">
+ *     <trigger>...</trigger>
+ *     <must>...</must>
+ *     <forbidden>...</forbidden>
+ *   </directive>
+ */
+export interface ThinkingOsDirective {
+    id: string;
+    name: string;
+    trigger: string;
+    must: string;
+    forbidden: string;
+}
+/**
+ * Parse THINKING_OS.md content and extract all <directive> blocks.
+ * Returns empty array if no directives found.
+ */
+export declare function parseThinkingOsMd(content: string): ThinkingOsDirective[];
+/**
+ * Load THINKING_OS.md from the plugin templates for a given language.
+ * Falls back to the workspace THINKING_OS.md if it exists.
+ */
+export declare function loadThinkingOsFromWorkspace(workspaceDir: string, language?: string): ThinkingOsDirective[];
+/**
+ * Extract meaningful detection keywords from a trigger string.
+ * Returns an array of regex patterns.
+ */
+export declare function generateDetectionPatterns(trigger: string): RegExp[];