principles-disciple 1.201.0 → 1.202.0

package/dist/hooks/prompt.d.ts

@@ -0,0 +1,22 @@
+import type { PluginHookBeforePromptBuildEvent, PluginHookAgentContext, PluginHookBeforePromptBuildResult } from '../openclaw-sdk.js';
+import type { ContextInjectionConfig } from '../types.js';
+import type { PromptHookApi } from './prompt-types.js';
+/**
+ * Reset all module-level prompt state for a workspace.
+ * Intended for test isolation — call in beforeEach().
+ */
+export declare function resetPromptStateForTest(workspaceDir?: string): void;
+/**
+ * OpenClaw API Prompt Hook
+ * Constructs the system prompt injected into LLM context for Principles Disciple
+ */
+/**
+ * Loads context injection config from .pd/config.yaml via loadPdConfigForPlugin.
+ * The resolved config is computed by the core config layer (pd-config-effective.ts),
+ * which merges user partial input with DEFAULT_CONTEXT_INJECTION defaults.
+ * @internal Used by evolution engine for context settings
+ */
+export declare function loadContextInjectionConfig(workspaceDir: string): ContextInjectionConfig;
+export declare function handleBeforePromptBuild(event: PluginHookBeforePromptBuildEvent, ctx: PluginHookAgentContext & {
+    api?: PromptHookApi;
+}): Promise<PluginHookBeforePromptBuildResult | void>;

package/dist/hooks/raw-observation-adapter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Raw Observation Adapter — PRI-362 / PRI-446
+ *
+ * The source-kind resolution logic and RawObservation builders have been
+ * migrated to principles-core (runtime-v2/evidence-triage/observation-resolver.ts).
+ *
+ * This file is now a thin re-export adapter. It preserves the original export
+ * names (resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation,
+ * RawObservation) so all existing import sites and the source-string
+ * characterization tests keep working without changes.
+ *
+ * ERR checklist:
+ * - ERR-011: re-export adapter, not a local re-definition of migrated logic.
+ */
+export { resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation, buildEmpathyObservation, buildManualPainObservation, } from '@principles/core/runtime-v2';
+export type { RawObservation } from './raw-observation-types.js';

package/dist/hooks/raw-observation-types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Raw Observation Types — PRI-362 / PRI-446
+ *
+ * The RawObservation type has been migrated to principles-core
+ * (runtime-v2/evidence-triage/observation-resolver.ts). This file re-exports it
+ * so existing plugin import sites keep working unchanged.
+ *
+ * ERR checklist:
+ * - ERR-011: this is a re-export adapter, not a local re-definition.
+ */
+export type { RawObservation } from '@principles/core/runtime-v2';

package/dist/hooks/trajectory-collector.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Trajectory Collector - message write trajectory recording
+ *
+ * Fallback trajectory collection when llm_output is blocked by missing
+ * allowConversationAccess. before_message_write is NOT in
+ * CONVERSATION_HOOK_NAMES so OpenClaw always delivers it.
+ *
+ * SQLite writes are enqueued to an async queue because before_message_write is
+ * a SYNCHRONOUS OpenClaw hook — the handler must return immediately. better-sqlite3
+ * is synchronous, so calling it directly would block the message-write main path.
+ * Trade-off: in degradation mode the last few queued writes may be lost on
+ * process exit; this is acceptable because degradation mode is already caused
+ * by a config problem (missing allowConversationAccess), and the primary
+ * llm_output path is authoritative when authorized.
+ *
+ * JSONL writing was removed (no consumers — verified zero readers across the
+ * codebase; PRI-347 already removed tool_call/llm_output JSONL writers).
+ *
+ * ERR-002: fallback errors are logged, never silent.
+ * ERR-001/005: content is sanitized before persisting.
+ */
+import type { PluginHookAgentContext, PluginHookBeforeMessageWriteEvent } from '../openclaw-sdk.js';
+/**
+ * PRI-346: Message write hook with SQLite fallback trajectory recording.
+ *
+ * When allowConversationAccess is NOT set (unauthorized), llm_output is silently
+ * blocked by OpenClaw and trajectory.db has no data. This hook is NOT in
+ * CONVERSATION_HOOK_NAMES, so it always fires — making it the natural fallback.
+ *
+ * De-duplication: only writes to SQLite when llm_output is blocked (unauthorized).
+ * When llm_output is working (authorized), this hook is a no-op.
+ *
+ * SQLite writes are async-queued (see file header) to avoid blocking the sync hook.
+ *
+ * ERR-002: structured observability when fallback fires.
+ * ERR-001/005: content is sanitized before persisting.
+ */
+export declare function handleBeforeMessageWrite(event: PluginHookBeforeMessageWriteEvent, ctx: PluginHookAgentContext & {
+    workspaceDir?: string;
+    pluginConfig?: unknown;
+}): void;

package/dist/hooks/trajectory-evidence.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Trajectory Evidence Builder — PRI-326
+ *
+ * Extracted from pain.ts to avoid circular imports between
+ * pain.ts and after-tool-call-helpers.ts.
+ *
+ * Pure data extraction — reads from trajectory DB, sanitizes, returns evidence entries.
+ */
+import type { PainEvidenceEntry } from '@principles/core/runtime-v2';
+import type { WorkspaceContext } from '../core/workspace-context.js';
+export declare function buildTrajectoryEvidence(wctx: WorkspaceContext, sessionId: string): PainEvidenceEntry[];

package/dist/hooks/triage-adapter.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Triage Adapter — PEAT-B1
+ *
+ * Plugin-side adapter that maps OpenClaw hook context to evidence triage input.
+ * Calls the pure triage policy from principles-core.
+ *
+ * This file lives in openclaw-plugin because it:
+ * - Maps hook-specific context (source strings, session state) to SourceKind
+ * - Wraps evaluatePainDiagnosticGate as a compatibility sub-policy
+ * - Knows about OpenClaw hook conventions (sessionId, toolName, etc.)
+ *
+ * It does NOT expose evaluatePainDiagnosticGate to core.
+ * Core only sees SourceKind and TriageResult.
+ *
+ * ERR checklist:
+ * - ERR-001: Source kind derived from runtime values with guards, not `as` casts.
+ * - ERR-002: Every triage result carries reason + nextAction.
+ * - ERR-024/025/048: Production-path tests cover this adapter.
+ */
+import { type TriageResult, type SourceKind } from '@principles/core/runtime-v2';
+/**
+ * Map RawObservation to SourceKind.
+ *
+ * This is the unified entry point for source-kind classification.
+ * It replaces the scattered resolveSourceKindFrom* functions.
+ *
+ * PRI-360 S1: All source-kind resolution now goes through this single entry point.
+ */
+export { resolveSourceKind, buildToolFailureObservation, buildLlmDetectionObservation, type RawObservation } from './raw-observation-adapter.js';
+/**
+ * Evaluate evidence triage for a given source kind and context.
+ *
+ * This is the main entry point for hooks. It calls the pure triage policy
+ * from principles-core and returns the result.
+ *
+ * The caller (hook) is responsible for:
+ * - Checking the painEvidenceAdmission feature flag
+ * - Acting on the triage result (proceed to diagnosis, store evidence, etc.)
+ * - Falling back to existing behavior when the flag is off
+ */
+export declare function evaluateEvidenceTriage(sourceKind: SourceKind, score: number, options?: {
+    isUnsafeHighConfidence?: boolean;
+    provenance?: 'openclaw_context_bound' | 'owner_reported_no_host_trace' | 'automatic_hook';
+    consecutiveErrors?: number;
+    isRisky?: boolean;
+}): TriageResult;
+/**
+ * Determine if a gate-blocked action is a high-confidence unsafe action.
+ *
+ * This is a heuristic that the plugin adapter owns. Core does not know about
+ * these heuristics — it only receives the boolean flag.
+ *
+ * Criteria for high-confidence unsafe:
+ * - Score >= 70 (high severity)
+ * - Tool is in the risky write set
+ * - Action would be irreversible (file deletion, force push, etc.)
+ */
+export declare function isHighConfidenceUnsafeAction(score: number, isRisky: boolean): boolean;

package/dist/hooks/trigger-cooldown-tracker.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Trigger Cooldown Tracker — PRI-363
+ *
+ * Manages cooldown state for trigger controller decisions.
+ *
+ * This is a plugin-layer concern because:
+ * - Core (trigger-controller) is stateless and pure
+ * - Cooldown state needs to persist across tool calls
+ * - The map is scoped to the plugin's lifecycle
+ *
+ * EP-05: Loop State Freshness — each check reads fresh state from the map.
+ * ERR-001: No `as` casts on map access.
+ * ERR-002: Every rejected decision includes reason + nextAction.
+ */
+/**
+ * Check whether cooldown is currently active for a given episode.
+ */
+export declare function isCooldownActive(source: string, sessionId: string | undefined, errorHash: string | undefined, cooldownMap: ReadonlyMap<string, number>): boolean;
+/**
+ * Mark an episode as diagnosed (set cooldown timestamp).
+ */
+export declare function markEpisodeAsDiagnosed(source: string, sessionId: string | undefined, errorHash: string | undefined, cooldownMap: Map<string, number>): void;
+/**
+ * Clear all cooldown state (for tests).
+ */
+export declare function clearCooldownState(cooldownMap: Map<string, number>): void;
+/**
+ * Get the cooldown timestamp for a given episode (for tests).
+ */
+export declare function getCooldownTimestamp(source: string, sessionId: string | undefined, errorHash: string | undefined, cooldownMap: ReadonlyMap<string, number>): number | undefined;
+/**
+ * Check whether cooldown is currently active using the shared Map.
+ */
+export declare function isSharedCooldownActive(source: string, sessionId: string | undefined, errorHash: string | undefined): boolean;
+/**
+ * Mark an episode as diagnosed using the shared Map.
+ */
+export declare function markSharedEpisodeAsDiagnosed(source: string, sessionId: string | undefined, errorHash: string | undefined): void;
+/**
+ * Clear all shared cooldown state (for tests).
+ */
+export declare function resetSharedCooldownForTest(): void;

package/dist/i18n/commands.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Command internationalization module.
+ * Provides localized descriptions for all plugin commands.
+ */
+export type SupportedLanguage = 'zh' | 'en';
+/**
+ * Normalize language code to supported language.
+ * Handles variants like zh-CN, zh-TW, en-US, etc.
+ * @param lang - Language code (e.g., 'zh-CN', 'en-US', 'zh', 'en')
+ * @returns Normalized language ('zh' or 'en')
+ */
+export declare function normalizeLanguage(lang: string): SupportedLanguage;
+export declare const commandDescriptions: Record<string, Record<SupportedLanguage, string>>;
+/**
+ * Get localized command description.
+ * @param name - Command name (e.g., 'pd-init')
+ * @param lang - Language code (e.g., 'zh-CN', 'en-US', 'zh', 'en')
+ * @returns Localized description or fallback to English then command name
+ */
+export declare function getCommandDescription(name: string, lang: string): string;
+/**
+ * Get all command descriptions for a language.
+ * @param lang - Language code (e.g., 'zh-CN', 'en-US', 'zh', 'en')
+ * @returns Object mapping command names to descriptions
+ */
+export declare function getAllCommandDescriptions(lang: string): Record<string, string>;

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+import type { OpenClawPluginApi } from './openclaw-sdk.js';
+export { checkConversationAccessConfig, getPluginEntry, ensureConversationAccessInConfig } from './core/config-health.js';
+export type { ConversationAccessCheckResult } from './core/config-health.js';
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * PRI-305/PRI-307: Load feature flag from .pd/config.yaml instead of .pd/feature-flags.yaml.
+ * Delegates to the shared plugin config loader for consistency.
+ */
+declare function loadFeatureFlagFromWorkspace(workspaceDir: string, flagId: string, logger?: {
+    warn?: (msg: string) => void;
+    info?: (msg: string) => void;
+}): {
+    enabled: boolean;
+    source: string;
+};
+export interface EvolutionWorkerGateResult {
+    shouldStart: boolean;
+    flagSource: string;
+    disabledInfo: string | null;
+}
+export declare function shouldStartEvolutionWorker(workspaceDir: string, logger: {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+}): EvolutionWorkerGateResult;
+export interface CorrectionObserverGateResult {
+    shouldStart: boolean;
+    flagSource: string;
+    disabledInfo: string | null;
+}
+export declare function shouldStartCorrectionObserver(workspaceDir: string, logger: {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+}): CorrectionObserverGateResult;
+export interface InternalizationAutoConsumerGateResult {
+    shouldStart: boolean;
+    flagSource: string;
+    disabledInfo: string | null;
+}
+export declare function shouldStartInternalizationAutoConsumer(workspaceDir: string, logger: {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+}): InternalizationAutoConsumerGateResult;
+declare const plugin: {
+    name: string;
+    description: string;
+    register(api: OpenClawPluginApi): void;
+};
+export { PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
+export { loadFeatureFlagFromWorkspace, isRecord };
+export { initTrajectorySchema } from './core/trajectory.js';
+export { initWorkflowSchema } from './service/subagent-workflow/workflow-store.js';
+export default plugin;

package/dist/openclaw-sdk.d.ts

@@ -0,0 +1,338 @@
+export interface TokenUsage {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    total?: number;
+}
+export interface PluginLogger {
+    debug: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+export interface AgentTool {
+    name: string;
+    description?: string;
+    parameters?: unknown;
+    result?: unknown;
+}
+export interface SubagentRunParams {
+    agentId: string;
+    prompt: string;
+    context?: Record<string, unknown>;
+}
+export interface SubagentRunResult {
+    runId: string;
+}
+export interface SubagentWaitResult {
+    status: 'ok' | 'error' | 'timeout';
+    error?: string;
+}
+export interface SubagentGetSessionMessagesResult {
+    messages: unknown[];
+    assistantTexts?: string[];
+}
+export interface PluginRuntime {
+    state: Record<string, unknown>;
+    config?: Record<string, unknown>;
+}
+export interface PluginCommandContext {
+    sessionId: string;
+    sessionKey: string;
+    agentId?: string;
+    workspaceDir?: string;
+    config?: Record<string, unknown>;
+    args?: string | string[];
+    [key: string]: unknown;
+}
+export interface PluginCommandResult {
+    text?: string;
+    content?: string;
+    [key: string]: unknown;
+}
+export interface PluginCommandDefinition {
+    name: string;
+    description: string;
+    acceptsArgs?: boolean;
+    requireAuth?: boolean;
+    handler: (ctx: PluginCommandContext) => PluginCommandResult | Promise<PluginCommandResult>;
+}
+export interface OpenClawPluginService {
+    id: string;
+    start?: (ctx: OpenClawPluginServiceContext) => void | Promise<void>;
+    stop?: (ctx: OpenClawPluginServiceContext) => void | Promise<void>;
+}
+export interface OpenClawPluginApi {
+    id: string;
+    rootDir?: string;
+    pluginConfig?: Record<string, unknown>;
+    logger: PluginLogger;
+    config?: Record<string, unknown>;
+    runtime?: {
+        agent?: {
+            run?: (opts: {
+                sessionKey: string;
+                message: string;
+                lane?: string;
+                deliver?: boolean;
+                idempotencyKey?: string;
+                expectsCompletionMessage?: boolean;
+                extraSystemPrompt?: string;
+            }) => Promise<SubagentRunResult>;
+            resolveAgentWorkspaceDir?: (config: unknown, agentId: string) => string;
+            runEmbeddedPiAgent?: (_opts: {
+                sessionId: string;
+                sessionFile: string;
+                prompt: string;
+                extraSystemPrompt?: string;
+                config?: unknown;
+                provider?: string;
+                model?: string;
+                timeoutMs: number;
+                runId: string;
+                disableTools?: boolean;
+            }) => Promise<unknown>;
+            session?: {
+                resolveStorePath: () => string;
+                /** Row-scoped read (replaces deprecated loadSessionStore whole-store reads). */
+                getSessionEntry?: (params: {
+                    sessionKey: string;
+                    agentId?: string;
+                    storePath?: string;
+                }) => Record<string, unknown> | undefined;
+                /** Row-scoped write (replaces deprecated saveSessionStore whole-store writes). */
+                patchSessionEntry?: (params: {
+                    sessionKey: string;
+                    agentId?: string;
+                    storePath?: string;
+                    replaceEntry?: boolean;
+                    preserveActivity?: boolean;
+                    update: (entry: Record<string, unknown>, context: {
+                        existingEntry?: Record<string, unknown>;
+                    }) => Promise<Partial<Record<string, unknown>> | null> | Partial<Record<string, unknown>> | null;
+                }) => Promise<Record<string, unknown> | null>;
+                /** Row-scoped upsert (replaces deprecated saveSessionStore whole-store writes). */
+                upsertSessionEntry?: (params: {
+                    sessionKey: string;
+                    agentId?: string;
+                    storePath?: string;
+                    entry: Record<string, unknown>;
+                }) => Promise<void>;
+                /** @deprecated Use getSessionEntry for reads. Kept for compat with older OpenClaw hosts. */
+                loadSessionStore: (storePath: string, opts?: {
+                    skipCache?: boolean;
+                }) => Record<string, unknown>;
+                /** @deprecated Use patchSessionEntry/upsertSessionEntry for writes. Kept for compat with older OpenClaw hosts. */
+                saveSessionStore: (storePath: string, store: Record<string, unknown>) => Promise<void>;
+                resolveSessionFilePath: (sessionKey: string) => string;
+                config?: unknown;
+            };
+        };
+        subagent?: {
+            run: (params: {
+                sessionKey: string;
+                message: string;
+                lane?: string;
+                deliver?: boolean;
+                idempotencyKey?: string;
+                expectsCompletionMessage?: boolean;
+                extraSystemPrompt?: string;
+            }) => Promise<SubagentRunResult>;
+            waitForRun: (params: {
+                runId: string;
+                timeoutMs?: number;
+            }) => Promise<SubagentWaitResult>;
+            getSessionMessages: (params: {
+                sessionKey: string;
+                limit?: number;
+            }) => Promise<SubagentGetSessionMessagesResult>;
+            deleteSession: (params: {
+                sessionKey: string;
+                deleteTranscript?: boolean;
+            }) => Promise<void>;
+        };
+        system?: {
+            runHeartbeatOnce?: (opts?: {
+                reason?: string;
+            }) => Promise<{
+                status: 'ran' | 'skipped' | 'failed';
+                durationMs?: number;
+                reason?: string;
+            }>;
+        };
+    };
+    registerCommand: (cmd: PluginCommandDefinition) => void;
+    registerService: (service: OpenClawPluginService) => void;
+    registerTool: (tool: AgentTool) => void;
+    registerHttpRoute: (route: {
+        path: string;
+        auth?: 'plugin' | 'gateway';
+        match?: 'prefix' | 'exact';
+        handler: (req: unknown, res: {
+            json: (data: unknown) => void;
+            status: (code: number) => {
+                json: (data: unknown) => void;
+            };
+            text: (content: string, code?: number) => void;
+        }) => boolean | Promise<boolean>;
+    }) => void;
+    on: (event: string, handler: (...args: any[]) => unknown, opts?: {
+        priority?: number;
+        timeoutMs?: number;
+    }) => void;
+}
+export interface PluginHookBeforePromptBuildEvent {
+    prompt: string;
+    messages: unknown[];
+}
+export interface PluginHookBeforePromptBuildResult {
+    systemPrompt?: string;
+    prependContext?: string;
+    appendContext?: string;
+    prependSystemContext?: string;
+    appendSystemContext?: string;
+}
+export interface PluginHookBeforeToolCallEvent {
+    toolName: string;
+    params?: Record<string, unknown>;
+    toolArgs?: Record<string, unknown>;
+    agentId?: string;
+    sessionId?: string;
+    [key: string]: unknown;
+}
+export interface PluginHookBeforeToolCallResult {
+    toolArgs?: Record<string, unknown>;
+    skipToolCall?: boolean;
+    [key: string]: unknown;
+}
+export interface PluginHookToolContext {
+    agentId?: string;
+    sessionId?: string;
+    workspaceDir?: string;
+    logger?: Partial<PluginLogger>;
+    [key: string]: unknown;
+}
+export interface PluginHookAfterToolCallEvent {
+    toolName: string;
+    toolArgs?: Record<string, unknown>;
+    result?: unknown;
+    error?: unknown;
+    agentId?: string;
+    sessionId?: string;
+    durationMs?: number;
+    [key: string]: unknown;
+}
+export interface PluginHookBeforeResetEvent {
+    agentId?: string;
+    sessionId?: string;
+    messages?: unknown[];
+    reason?: string;
+    [key: string]: unknown;
+}
+export interface PluginHookBeforeCompactionEvent {
+    agentId?: string;
+    sessionId?: string;
+    [key: string]: unknown;
+}
+export interface PluginHookAfterCompactionEvent {
+    agentId?: string;
+    sessionId?: string;
+    sessionFile?: string;
+    messageCount?: number;
+    [key: string]: unknown;
+}
+export interface PluginHookSubagentEndedEvent {
+    targetSessionKey: string;
+    outcome: 'ok' | 'error' | 'timeout' | 'escalated' | 'deleted' | 'killed' | 'reset';
+    agentId?: string;
+    sessionId?: string;
+    [key: string]: unknown;
+}
+export interface PluginHookLlmOutputEvent {
+    output: string;
+    agentId?: string;
+    sessionId?: string;
+    runId?: string;
+    provider?: string;
+    model?: string;
+    usage?: TokenUsage;
+    assistantTexts?: string[];
+    trigger?: string;
+    lastAssistant?: unknown;
+    [key: string]: unknown;
+}
+export interface PluginHookSubagentSpawningEvent {
+    agentId: string;
+    childSessionKey: string;
+    sessionId?: string;
+    [key: string]: unknown;
+}
+export interface PluginHookSubagentSpawningResult {
+    status: 'ok' | 'error';
+    [key: string]: unknown;
+}
+export interface PluginHookSubagentContext {
+    agentId?: string;
+    sessionId?: string;
+    [key: string]: unknown;
+}
+export interface PluginHookAgentContext {
+    runId?: string;
+    jobId?: string;
+    trace?: unknown;
+    agentId?: string;
+    sessionKey?: string;
+    sessionId?: string;
+    workspaceDir?: string;
+    modelProviderId?: string;
+    modelId?: string;
+    messageProvider?: string;
+    channel?: string;
+    chatId?: string;
+    senderId?: string;
+    trigger?: string;
+    channelId?: string;
+    contextTokenBudget?: number;
+    contextWindowSource?: 'model' | 'config';
+    contextWindowReferenceTokens?: number;
+    senderExternalId?: string;
+    channelContext?: unknown;
+    logger?: Partial<PluginLogger>;
+}
+export interface PluginHookBeforeMessageWriteEvent {
+    message: {
+        role?: string;
+        content?: unknown;
+    };
+    agentId?: string;
+    sessionId?: string;
+    [key: string]: unknown;
+}
+export interface PluginHookBeforeMessageWriteResult {
+    message?: {
+        role?: string;
+        content?: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface OpenClawPluginHttpRouteParams {
+    path: string;
+    auth?: 'plugin' | 'gateway';
+    match?: 'prefix' | 'exact';
+    handler: (req: unknown, res: {
+        json: (data: unknown) => void;
+        status: (code: number) => {
+            json: (data: unknown) => void;
+        };
+        text: (content: string, code?: number) => void;
+    }) => boolean | Promise<boolean>;
+}
+export interface OpenClawPluginServiceContext {
+    api?: OpenClawPluginApi;
+    workspaceDir?: string;
+    logger?: PluginLogger;
+    config?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export {};

package/dist/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Turn repeated Agent corrections into Owner-approved, observable, reversible behavior principles. Stop correcting the same AI behavior across sessions.",
-  "version": "1.201.0",
+  "version": "1.202.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/dist/rulehost-evidence.d.ts

@@ -0,0 +1,4 @@
+/** Side-effect-free public boundary for RuleHost evidence assembly. */
+export { BehaviorExamplePackAssembler } from './core/behavior-example-pack-assembler.js';
+export type { BehaviorExamplePackAssemblerInput, BehaviorExamplePackAssemblerOptions, } from './core/behavior-example-pack-assembler.js';
+export { TrajectoryRegistry as RuleHostEvidenceRegistry } from './core/trajectory.js';

package/dist/service/correction-observer-service.d.ts

@@ -0,0 +1,19 @@
+import type { OpenClawPluginServiceContext, PluginLogger } from '../openclaw-sdk.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+import { CorrectionObserver } from '@principles/core/runtime-v2';
+export interface CorrectionObserverServiceShape {
+    id: string;
+    start: (ctx: OpenClawPluginServiceContext) => void;
+    stop?: (ctx: OpenClawPluginServiceContext) => void;
+}
+/**
+ * PRI-307: Resolve CorrectionObserver from .pd/config.yaml.
+ *
+ * States:
+ * - disabled: feature flag off → return null, no noisy logs
+ * - needs_setup: enabled but missing API key or profile → return null with structured reason
+ * - ready/not_ready: enabled and configured → return observer instance
+ */
+export declare function resolveCorrectionObserver(wctx: WorkspaceContext, logger?: Pick<PluginLogger, 'info' | 'warn' | 'error' | 'debug'>): CorrectionObserver | null;
+export declare function runCorrectionObserverCycle(wctx: WorkspaceContext, logger: PluginLogger): Promise<void>;
+export declare const CorrectionObserverService: CorrectionObserverServiceShape;