create-principles-disciple 1.85.0 → 1.87.0

package/plugin/dist/core/config-health.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Conversation Access Health Check (PRI-343 / PRI-346)
+ *
+ * Pure function for checking whether OpenClaw plugin config has
+ * allowConversationAccess set to true. When missing, llm_output and
+ * trajectory hooks are silently blocked by OpenClaw, causing evidence
+ * to always be empty (PRI-338 root cause).
+ *
+ * Extracted from index.ts to avoid circular imports when trajectory-collector.ts
+ * needs to check conversation access state (PRI-346).
+ */
+/**
+ * PRI-348: Extract the full plugin entry (including hooks) from the global OpenClaw config.
+ * Unlike api.pluginConfig (which is only the entry.config sub-object), this returns
+ * the entire entry including hooks, config, enabled, etc.
+ */
+export declare function getPluginEntry(config: unknown, pluginId: string): unknown;
+export interface ConversationAccessCheckResult {
+    authorized: boolean;
+    reason?: string;
+    nextAction?: string;
+}
+/**
+ * PRI-343: Pure function — checks if pluginConfig has hooks.allowConversationAccess === true.
+ * Returns a structured result with reason and nextAction when not authorized (ERR-002).
+ */
+export declare function checkConversationAccessConfig(pluginConfig: unknown): ConversationAccessCheckResult;

package/plugin/dist/core/config-health.js

@@ -0,0 +1,60 @@
+/**
+ * Conversation Access Health Check (PRI-343 / PRI-346)
+ *
+ * Pure function for checking whether OpenClaw plugin config has
+ * allowConversationAccess set to true. When missing, llm_output and
+ * trajectory hooks are silently blocked by OpenClaw, causing evidence
+ * to always be empty (PRI-338 root cause).
+ *
+ * Extracted from index.ts to avoid circular imports when trajectory-collector.ts
+ * needs to check conversation access state (PRI-346).
+ */
+/**
+ * PRI-348: Extract the full plugin entry (including hooks) from the global OpenClaw config.
+ * Unlike api.pluginConfig (which is only the entry.config sub-object), this returns
+ * the entire entry including hooks, config, enabled, etc.
+ */
+export function getPluginEntry(config, pluginId) {
+    if (!config || typeof config !== 'object' || Array.isArray(config))
+        return undefined;
+    const plugins = config.plugins;
+    if (!plugins || typeof plugins !== 'object' || Array.isArray(plugins))
+        return undefined;
+    const entries = plugins.entries;
+    if (!entries || typeof entries !== 'object' || Array.isArray(entries))
+        return undefined;
+    return entries[pluginId];
+}
+/** Keep in sync with @principles/core CONVERSATION_ACCESS_CONFIG_KEY */
+const CONVERSATION_ACCESS_CONFIG_KEY = 'allowConversationAccess';
+const CONVERSATION_ACCESS_FIX_COMMAND = 'openclaw config set plugins.entries.principles-disciple.hooks.allowConversationAccess true --strict-json';
+/**
+ * PRI-343: Pure function — checks if pluginConfig has hooks.allowConversationAccess === true.
+ * Returns a structured result with reason and nextAction when not authorized (ERR-002).
+ */
+export function checkConversationAccessConfig(pluginConfig) {
+    if (pluginConfig === null || pluginConfig === undefined || typeof pluginConfig !== 'object' || Array.isArray(pluginConfig)) {
+        return {
+            authorized: false,
+            reason: 'pluginConfig is missing or invalid — conversation hooks cannot be registered',
+            nextAction: CONVERSATION_ACCESS_FIX_COMMAND,
+        };
+    }
+    const config = pluginConfig;
+    if (typeof config.hooks !== 'object' || config.hooks === null || Array.isArray(config.hooks)) {
+        return {
+            authorized: false,
+            reason: 'allowConversationAccess is not set to true',
+            nextAction: CONVERSATION_ACCESS_FIX_COMMAND,
+        };
+    }
+    const hooks = config.hooks;
+    if (hooks[CONVERSATION_ACCESS_CONFIG_KEY] !== true) {
+        return {
+            authorized: false,
+            reason: 'allowConversationAccess is not set to true',
+            nextAction: CONVERSATION_ACCESS_FIX_COMMAND,
+        };
+    }
+    return { authorized: true };
+}

package/plugin/dist/core/event-log.d.ts

@@ -1,4 +1,4 @@
-import type { EventLogEntry, DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, DiagnosisTaskEventData, HeartbeatDiagnosisEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData } from '../types/event-types.js';
+import type { EventLogEntry, DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, DiagnosisTaskEventData, HeartbeatDiagnosisEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData } from '../types/event-types.js';
 import type { PluginLogger } from '../openclaw-sdk.js';
 export declare class EventLog {
     private readonly logsDir;
@@ -43,6 +43,15 @@ export declare class EventLog {
     recordRuleHostAutoCorrectProposed(data: RuleHostAutoCorrectProposedEventData): void;
     recordRuleHostAutoCorrectApplied(data: RuleHostAutoCorrectAppliedEventData): void;
     recordRuntimeV2ActivationsInjected(data: RuntimeV2PromptActivationsInjectedEventData): void;
+    /**
+     * PRI-437: Record that an approved rule failed to compile or load.
+     *
+     * This is NOT just a logger.warn — the unhealthy state is persisted to EventLog
+     * so it's visible to CLI (pd runtime health) and Console API.
+     *
+     * ERR-002: degradation includes a reason and nextAction (not silent).
+     */
+    recordRuleHostUnhealthy(data: RuleHostUnhealthyEventData): void;
     /**
      * Redact telemetry-sensitive string values in event data before persistence.
      * Applies redactTelemetryString to known high-risk fields (filePath, command,

package/plugin/dist/core/event-log.js

@@ -143,6 +143,17 @@ export class EventLog {
     recordRuntimeV2ActivationsInjected(data) {
         this.record('runtime_v2_prompt_activations_injected', 'injected', data.sessionId, data);
     }
+    /**
+     * PRI-437: Record that an approved rule failed to compile or load.
+     *
+     * This is NOT just a logger.warn — the unhealthy state is persisted to EventLog
+     * so it's visible to CLI (pd runtime health) and Console API.
+     *
+     * ERR-002: degradation includes a reason and nextAction (not silent).
+     */
+    recordRuleHostUnhealthy(data) {
+        this.record('rulehost_unhealthy', 'failure', undefined, data);
+    }
     /**
      * Redact telemetry-sensitive string values in event data before persistence.
      * Applies redactTelemetryString to known high-risk fields (filePath, command,

package/plugin/dist/core/init.d.ts

@@ -6,7 +6,7 @@ import type { OpenClawPluginApi, PluginLogger } from '../openclaw-sdk.js';
 export declare function ensureWorkspaceTemplates(api: OpenClawPluginApi, workspaceDir: string, language?: string): void;
 /**
  * Core thinking model definitions (T-01 through T-10).
- * These are the built-in cognitive patterns that every workspace should have.
+ * Derived from the Core Principle Registry — the single source of truth.
  */
 export declare const CORE_THINKING_MODELS: Array<{
     id: string;

package/plugin/dist/core/init.js

@@ -7,6 +7,7 @@ import { loadStore, setPrincipleState } from './principle-training-state.js';
 import { addPrincipleToLedger } from './principle-tree-ledger.js';
 import { atomicWriteFileSync } from '../utils/io.js';
 import { createDefaultKeywordStore, saveKeywordStore } from './empathy-keyword-matcher.js';
+import { CORE_PRINCIPLES } from '@principles/core/runtime-v2';
 /**
  * Default PROFILE.json content
  */
@@ -133,20 +134,13 @@ function copyRecursiveSync(srcDir, destDir, api) {
 }
 /**
  * Core thinking model definitions (T-01 through T-10).
- * These are the built-in cognitive patterns that every workspace should have.
+ * Derived from the Core Principle Registry — the single source of truth.
  */
-export const CORE_THINKING_MODELS = [
-    { id: 'T-01', name: 'Survey Before Acting', description: 'Understand the structure first before making changes.' },
-    { id: 'T-02', name: 'Respect Constraints', description: 'Trust files, not your context window. Write conclusions to files.' },
-    { id: 'T-03', name: 'Evidence Over Assumption', description: 'Use logs, code, and outputs before inferring causes.' },
-    { id: 'T-04', name: 'Reversible First', description: 'Prefer changes that are safe to roll back when risk is high.' },
-    { id: 'T-05', name: 'Safety Rails', description: 'Call out guardrails, prohibitions, and failure-prevention constraints.' },
-    { id: 'T-06', name: 'Simplicity First', description: 'Prefer the smallest understandable solution over over-engineering.' },
-    { id: 'T-07', name: 'Minimal Change Surface', description: 'Limit the blast radius and touch only what is necessary.' },
-    { id: 'T-08', name: 'Pain As Signal', description: 'Treat failures and friction as clues to step back and rethink.' },
-    { id: 'T-09', name: 'Divide And Conquer', description: 'Split the task into smaller phases before execution.' },
-    { id: 'T-10', name: 'Memory Externalization', description: 'Write intermediate conclusions to files for persistence.' },
-];
+export const CORE_THINKING_MODELS = CORE_PRINCIPLES.map(p => ({
+    id: p.id,
+    name: p.name,
+    description: p.statement,
+}));
 /**
  * Initialize core thinking models into the training store if it's empty.
  * This ensures every workspace has evaluable principles for nocturnal reflection.
@@ -204,7 +198,9 @@ export function ensureCorePrinciples(stateDir, logger) {
             };
             addPrincipleToLedger(stateDir, ledgerPrinciple);
         }
-        logger.info(`[PD] Initialized ${CORE_THINKING_MODELS.length} core thinking models: T-01 through T-10`);
+        const firstId = CORE_THINKING_MODELS[0]?.id ?? 'T-01';
+        const lastId = CORE_THINKING_MODELS[CORE_THINKING_MODELS.length - 1]?.id ?? 'T-10';
+        logger.info(`[PD] Initialized ${CORE_THINKING_MODELS.length} core thinking models: ${firstId} through ${lastId}`);
         return true;
     }
     catch (err) {

package/plugin/dist/core/paths.d.ts

@@ -12,9 +12,6 @@ export declare const PD_DIRS: {
     SESSIONS: string;
     PAIN_SAMPLES: string;
     LOCKS: string;
-    NOCTURNAL_SAMPLES: string;
-    NOCTURNAL_MEMORY: string;
-    NOCTURNAL_EXPORTS: string;
     IMPL_CODE_DIR: string;
 };
 /**
@@ -43,9 +40,6 @@ export declare const PD_FILES: {
     DICTIONARY: string;
     PRINCIPLE_BLACKLIST: string;
     WORKFLOWS_YAML: string;
-    NOCTURNAL_SAMPLES_DIR: string;
-    NOCTURNAL_MEMORY_DIR: string;
-    NOCTURNAL_EXPORTS_DIR: string;
     IMPL_CODE_DIR: string;
     MEMORY_MD: string;
     HEARTBEAT: string;

package/plugin/dist/core/paths.js

@@ -26,9 +26,6 @@ export const PD_DIRS = {
     SESSIONS: posixJoin('.state', 'sessions'),
     PAIN_SAMPLES: posixJoin('memory', 'pain'),
     LOCKS: posixJoin('memory', '.locks'),
-    NOCTURNAL_SAMPLES: posixJoin('.state', 'nocturnal', 'samples'),
-    NOCTURNAL_MEMORY: posixJoin('.state', 'nocturnal', 'memory'),
-    NOCTURNAL_EXPORTS: posixJoin('.state', 'exports', 'orpo'),
     IMPL_CODE_DIR: posixJoin('.state', 'principles', 'implementations'),
 };
 /**
@@ -57,9 +54,6 @@ export const PD_FILES = {
     DICTIONARY: posixJoin(PD_DIRS.STATE, 'pain_dictionary.json'),
     PRINCIPLE_BLACKLIST: posixJoin(PD_DIRS.STATE, 'principle_blacklist.json'),
     WORKFLOWS_YAML: posixJoin(PD_DIRS.STATE, 'workflows.yaml'),
-    NOCTURNAL_SAMPLES_DIR: PD_DIRS.NOCTURNAL_SAMPLES,
-    NOCTURNAL_MEMORY_DIR: PD_DIRS.NOCTURNAL_MEMORY,
-    NOCTURNAL_EXPORTS_DIR: PD_DIRS.NOCTURNAL_EXPORTS,
     IMPL_CODE_DIR: PD_DIRS.IMPL_CODE_DIR,
     MEMORY_MD: 'MEMORY.md',
     HEARTBEAT: 'HEARTBEAT.md',

package/plugin/dist/core/principle-compiler/code-validator.js

@@ -38,7 +38,10 @@ export function validateGeneratedCode(code) {
         return { valid: false, errors, warnings };
     }
     // --- Check 2: Forbidden patterns (delegated to core) ---
-    const forbiddenLabels = checkForbiddenPatterns(code);
+    // PRI-439: checkForbiddenPatterns forbids `export` (canonical dialect is bare function).
+    // The openclaw-plugin legacy compiler still accepts `export` (the sandbox strips it),
+    // so we pass the normalized code (export keywords removed) to the checker.
+    const forbiddenLabels = checkForbiddenPatterns(normalized);
     for (const label of forbiddenLabels) {
         errors.push(`Forbidden pattern: ${label}`);
     }

package/plugin/dist/core/principle-tree-ledger.d.ts

@@ -72,10 +72,6 @@ export declare function getAllowedTransitions(from: ImplementationLifecycleState
  * Transition an implementation's lifecycle state with validation.
  * Throws on invalid transitions */
 export declare function transitionImplementationState(stateDir: string, implementationId: string, newState: ImplementationLifecycleState): Implementation;
-/**
- * Get all implementations for a specific lifecycle state across all rules.
- */
-export declare function listImplementationsByLifecycleState(stateDir: string, state: ImplementationLifecycleState): Implementation[];
 /**
  * Get implementations in a specific lifecycle state for a given rule.
  */

package/plugin/dist/core/principle-tree-ledger.js

@@ -511,13 +511,6 @@ export function transitionImplementationState(stateDir, implementationId, newSta
         return updated;
     });
 }
-/**
- * Get all implementations for a specific lifecycle state across all rules.
- */
-export function listImplementationsByLifecycleState(stateDir, state) {
-    const ledger = loadLedger(stateDir);
-    return Object.values(ledger.tree.implementations).filter((impl) => impl.lifecycleState === state);
-}
 /**
  * Get implementations in a specific lifecycle state for a given rule.
  */

package/plugin/dist/core/rule-host.d.ts

@@ -1,11 +1,15 @@
 /**
  * Rule Host — Constrained execution layer for active code implementations
  *
- * PURPOSE: Load active code implementations from the principle-tree ledger,
- * execute them in a constrained node:vm context, and merge their decisions.
+ * 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:
- *   - Constructor takes stateDir to access the principle-tree ledger
+ * 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
@@ -22,10 +26,16 @@
 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;
+}
 export declare class RuleHost {
     private readonly stateDir;
     private readonly logger;
-    constructor(stateDir: string, logger?: RuleHostLogger);
+    private readonly workspaceDir;
+    private readonly implementationSources;
+    constructor(stateDir: string, logger?: RuleHostLogger, options?: RuleHostOptions);
     /**
      * Evaluate the input against all active code implementations.
      *
@@ -37,20 +47,40 @@ export declare class RuleHost {
      */
     evaluate(input: RuleHostInput): RuleHostResult | undefined;
     /**
-     * Load active code implementations from the ledger.
-     * Filters by type=code and lifecycleState=active, then attempts to
-     * compile each implementation's code asset via node:vm.
+     * 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;
     /**
-     * Load and compile a single implementation from its code asset path.
+     * 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.
      *
-     * The implementation file is expected to export:
-     *   - meta: { name, version, ruleId, coversCondition }
-     *   - evaluate(input: RuleHostInput): RuleHostResult
+     * This makes compile/load failures visible to CLI (pd runtime health) and
+     * Console API — NOT just a logger.warn that's silently skipped.
      *
-     * Uses the shared isolated runtime loader so candidate code does not execute
-     * in the host global realm.
+     * ERR-002: degradation includes a reason and nextAction (not silent).
+     * Failures in EventLog recording are caught and logged (never throw).
      */
-    private _loadSingleImplementation;
+    private _recordUnhealthy;
 }