principles-disciple 1.122.0 → 1.124.0

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.122.0",
+  "version": "1.124.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.122.0",
+  "version": "1.124.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",

package/src/core/code-implementation-storage.ts

@@ -104,20 +104,6 @@ export function getImplementationAssetRoot(stateDir: string, implId: string): st
   return path.join(stateDir, 'principles', 'implementations', implId);
 }
 
-/**
- * Load manifest from disk. Returns null if not found (does not throw).
- */
-export function loadManifest(stateDir: string, implId: string): CodeImplementationManifest | null {
-  validateImplId(implId);
-  const manifestPath = path.join(getImplementationAssetRoot(stateDir, implId), MANIFEST_FILENAME);
-  if (!fs.existsSync(manifestPath)) return null;
-  try {
-    return JSON.parse(fs.readFileSync(manifestPath, 'utf-8')) as CodeImplementationManifest;
-  } catch {
-    return null;
-  }
-}
-
 /**
  * Write manifest atomically using withLock.
  */
@@ -163,23 +149,6 @@ export function deleteImplementationAssetDir(stateDir: string, implId: string):
   });
 }
 
-/**
- * Load the entry source code from disk.
- * Returns null if manifest doesn't exist or entry file is missing.
- */
-export function loadEntrySource(stateDir: string, implId: string): string | null {
-  validateImplId(implId);
-  const manifest = loadManifest(stateDir, implId);
-  if (!manifest) return null;
-  const entryPath = path.join(getImplementationAssetRoot(stateDir, implId), manifest.entryFile);
-  if (!fs.existsSync(entryPath)) return null;
-  try {
-    return fs.readFileSync(entryPath, 'utf-8');
-  } catch {
-    return null;
-  }
-}
-
 /**
  * Create the full asset directory structure for a new implementation.
  *

package/src/core/principle-tree-ledger.ts

@@ -701,19 +701,6 @@ export function transitionImplementationState(
   });
 }
 
-/**
- * Get all implementations for a specific lifecycle state across all rules.
- */
-export function listImplementationsByLifecycleState(
-  stateDir: string,
-  state: ImplementationLifecycleState
-): Implementation[] {
-  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/src/core/rule-host.ts

@@ -1,13 +1,15 @@
 /**
  * Rule Host — Constrained execution layer for active code implementations
  *
- * PURPOSE: Load active code implementations from the principle-tree ledger
- * AND from the activations table (code_tool_hook channel), 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
- *   - Optional workspaceDir enables reading code_tool_hook activations from SQLite
+ * 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,11 +24,6 @@
  *   - Never throw, never bypass downstream gates (Progressive Gate, Edit Verification)
  */
 
-import * as fs from 'fs';
-import {
-  listImplementationsByLifecycleState,
-} from './principle-tree-ledger.js';
-import { loadEntrySource } from './code-implementation-storage.js';
 import { createRuleHostHelpers } from '@principles/core/runtime-v2';
 import { mergeDecisions } from '@principles/core/runtime-v2';
 import { SqliteConnection } from '@principles/core/runtime-v2';
@@ -37,13 +34,12 @@ import type {
   RuleHostMeta,
   LoadedImplementation,
 } from '@principles/core/runtime-v2';
-import type { Implementation } from '../types/principle-tree-schema.js';
 
 import type { RuleHostLogger } from '@principles/core/runtime-v2';
 export type { RuleHostLogger } from '@principles/core/runtime-v2';
 
 export interface RuleHostOptions {
-  /** Workspace directory for SQLite access. When provided, RuleHost also loads code_tool_hook activations from the activations table. */
+  /** Workspace directory for SQLite access. Required for RuleHost to load active code_tool_hook activations. */
   workspaceDir?: string;
 }
 
@@ -84,7 +80,6 @@ export class RuleHost {
    *   - { decision: 'block', ... } when any implementation returns block (short-circuits)
    *   - { decision: 'requireApproval', ... } when any implementation returns requireApproval
    */
-     
   evaluate(input: RuleHostInput): RuleHostResult | undefined {
     try {
       const activeImpls = this._loadActiveCodeImplementations();
@@ -99,70 +94,28 @@ export class RuleHost {
   }
 
   /**
-   * Load active code implementations from the ledger AND the activations table.
+   * Load active code implementations from the SQLite activations table.
    *
-   * Sources (merged, deduplicated by implId):
-   *   1. principle-tree-ledger.json: implementations with lifecycleState='active' and type='code'
-   *   2. activations table: code_tool_hook channel activations (when workspaceDir is provided)
+   * 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.
    *
-   * This bridges the gap between RuleHostWriter (which records activation metadata in SQLite)
-   * and RuleHost enforcement (which previously only read from the ledger JSON file).
-   * See BUG-001 / ERR-011 / ERR-035.
+   * Source: activations table (code_tool_hook channel, deactivated_at IS NULL)
+   *   → JOIN pi_artifacts for content_json → extract implementationCode → compile
    */
   private _loadActiveCodeImplementations(): LoadedImplementation[] {
-    const loaded: LoadedImplementation[] = [];
-    const seenImplIds = new Set<string>();
+    if (!this.workspaceDir) {
+      return [];
+    }
 
-    // Source 1: principle-tree-ledger.json (existing path)
     try {
-      const activeAllTypes = listImplementationsByLifecycleState(
-        this.stateDir,
-        'active'
-      );
-
-      // Filter to code-type implementations only
-      const codeImpls = activeAllTypes.filter((impl) => impl.type === 'code');
-
-      for (const impl of codeImpls) {
-        try {
-          const loadedImpl = this._loadSingleImplementation(impl);
-          if (loadedImpl && !seenImplIds.has(loadedImpl.implId)) {
-            loaded.push(loadedImpl);
-            seenImplIds.add(loadedImpl.implId);
-          }
-        } catch (loadError: unknown) {
-          // Individual load failure: log and skip
-          this.logger.warn?.(
-            `[RuleHost] Failed to load implementation ${impl.id}: ${String(loadError)}`
-          );
-        }
-      }
-    } catch (ledgerError: unknown) {
-      // Ledger access failure: log and continue to activations table
+      return this._loadFromActivationsTable(this.workspaceDir);
+    } catch (activationError: unknown) {
       this.logger.warn?.(
-        `[RuleHost] Failed to access ledger: ${String(ledgerError)}`
+        `[RuleHost] Failed to load code_tool_hook activations: ${String(activationError)}`
       );
+      return [];
     }
-
-    // Source 2: activations table (code_tool_hook channel) — bridges BUG-001
-    if (this.workspaceDir) {
-      try {
-        const activationImpls = this._loadFromActivationsTable(this.workspaceDir);
-        for (const impl of activationImpls) {
-          if (!seenImplIds.has(impl.implId)) {
-            loaded.push(impl);
-            seenImplIds.add(impl.implId);
-          }
-        }
-      } catch (activationError: unknown) {
-        // Activations table access failure: log and continue with ledger-only results
-        this.logger.warn?.(
-          `[RuleHost] Failed to load code_tool_hook activations: ${String(activationError)}`
-        );
-      }
-    }
-
-    return loaded;
   }
 
   /**
@@ -170,10 +123,15 @@ export class RuleHost {
    *
    * For each activation record:
    *   1. Query the pi_artifacts table for the artifact content
-   *   2. Parse content_json to extract implementationCode
-   *   3. Compile via loadRuleImplementationModule (same vm isolation as ledger path)
+   *   2. Parse content_json to extract implementationCode (treated as unknown, EP-01)
+   *   3. Compile via loadRuleImplementationModule (isolated vm context)
    *
-   * This mirrors the PromptActivationReader pattern for SQLite access.
+   * 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(workspaceDir: string): LoadedImplementation[] {
     const sqliteConn = new SqliteConnection(workspaceDir);
@@ -195,13 +153,58 @@ export class RuleHost {
         return [];
       }
 
-      const loaded: LoadedImplementation[] = [];
-
+      // PRI-436: Group active rows by target_ref to detect duplicates.
+      // At most one active activation per rule (target_ref) is allowed.
+      // Duplicate groups are skipped entirely (zero executions) and emit
+      // structured unhealthy evidence. Non-duplicate rows proceed to compilation.
+      const rowsByTargetRef = new Map<string, Record<string, unknown>[]>();
       for (const row of rows) {
         if (!row || typeof row !== 'object') {
           continue;
         }
         const r = row as Record<string, unknown>;
+        const targetRef = typeof r['target_ref'] === 'string' ? r['target_ref'] : '';
+        const activationId = typeof r['activation_id'] === 'string' ? r['activation_id'] : '';
+        if (!targetRef) {
+          this.logger.warn?.(
+            `[RuleHost] Activation ${activationId}: missing target_ref, skipping`
+          );
+          continue;
+        }
+        const group = rowsByTargetRef.get(targetRef);
+        if (group) {
+          group.push(r);
+        } else {
+          rowsByTargetRef.set(targetRef, [r]);
+        }
+      }
+
+      // Emit structured unhealthy evidence for duplicate groups; collect valid (non-duplicate) rows.
+      const validRows: Record<string, unknown>[] = [];
+      for (const [targetRef, group] of rowsByTargetRef) {
+        if (group.length > 1) {
+          const activationIds: string[] = [];
+          const artifactIds: string[] = [];
+          for (const r of group) {
+            if (typeof r['activation_id'] === 'string') activationIds.push(r['activation_id']);
+            if (typeof r['artifact_id'] === 'string') artifactIds.push(r['artifact_id']);
+          }
+          this.logger.warn?.(
+            `[RuleHost] Duplicate active activations detected — skipping all executions for this rule. ` +
+            `targetRef=${targetRef} count=${group.length} ` +
+            `activationIds=[${activationIds.join(', ')}] ` +
+            `artifactIds=[${artifactIds.join(', ')}] ` +
+            `reason=at most one active activation per rule is allowed ` +
+            `nextAction=deactivate all but one activation for this target_ref`
+          );
+        } else {
+          validRows.push(group[0]);
+        }
+      }
+
+      const loaded: LoadedImplementation[] = [];
+
+      for (const r of validRows) {
         const activationId = typeof r['activation_id'] === 'string' ? r['activation_id'] : '';
         const artifactId = typeof r['artifact_id'] === 'string' ? r['artifact_id'] : '';
         const contentJson = typeof r['content_json'] === 'string' ? r['content_json'] : '';
@@ -290,83 +293,4 @@ export class RuleHost {
       }
     }
   }
-
-  /**
-   * Load and compile a single implementation from its code asset path.
-   *
-   * The implementation file is expected to export:
-   *   - meta: { name, version, ruleId, coversCondition }
-   *   - evaluate(input: RuleHostInput): RuleHostResult
-   *
-   * Uses the shared isolated runtime loader so candidate code does not execute
-   * in the host global realm.
-   */
-     
-  private _loadSingleImplementation(
-    impl: Implementation
-  ): LoadedImplementation | null {
-    let sourceCode = loadEntrySource(this.stateDir, impl.id);
-    if (!sourceCode) {
-      const assetPath = impl.path;
-      if (!assetPath || !fs.existsSync(assetPath)) {
-        return null;
-      }
-
-      try {
-        sourceCode = fs.readFileSync(assetPath, 'utf-8');
-      } catch {
-        return null;
-      }
-    }
-
-    try {
-      const moduleExports = loadRuleImplementationModule(sourceCode, impl.id);
-
-      if (!moduleExports || typeof moduleExports.evaluate !== 'function') {
-        return null;
-      }
-
-      const fallbackMeta: RuleHostMeta = {
-        name: impl.id,
-        version: impl.version,
-        ruleId: impl.ruleId,
-        coversCondition: impl.coversCondition,
-      };
-      const meta: RuleHostMeta =
-        moduleExports.meta && typeof moduleExports.meta === 'object'
-          ? (moduleExports.meta as RuleHostMeta)
-          : fallbackMeta;
-
-      // Return a loaded implementation that wraps the compiled evaluate
-      // with the actual helpers from the input at evaluation time
-       
-      const rawEvaluate = moduleExports.evaluate as (
-        _input: RuleHostInput,
-        _helpers: ReturnType<typeof createRuleHostHelpers>
-      ) => RuleHostResult;
-       
-
-      return {
-        implId: impl.id,
-        ruleId: impl.ruleId,
-        meta,
-        evaluate: (input: RuleHostInput): RuleHostResult => {
-          const frozenHelpers = createRuleHostHelpers(input);
-          const result = rawEvaluate(input, frozenHelpers);
-          // C: Enrich result with rule/principle IDs for observability
-          if (result.matched && (result.decision === 'block' || result.decision === 'requireApproval')) {
-            result.ruleId = impl.ruleId;
-            result.principleId = meta.ruleId ?? impl.ruleId;
-          }
-          return result;
-        },
-      };
-    } catch (compileError: unknown) {
-      // Compilation failure: log and skip
-      this.logger.warn?.(
-        `[RuleHost] Failed to compile implementation ${impl.id}: ${String(compileError)}`
-      );
-      return null;
-    }
-  }
 }

package/tests/core/code-implementation-storage.test.ts

@@ -5,9 +5,7 @@ import * as path from 'path';
 import {
   deleteImplementationAssetDir,
   getImplementationAssetRoot,
-  loadManifest,
   writeManifest,
-  loadEntrySource,
   createImplementationAssetDir,
   writeEntrySource,
   type CodeImplementationManifest,
@@ -63,47 +61,6 @@ describe('CodeImplementationStorage', () => {
     });
   });
 
-  // -------------------------------------------------------------------------
-  // loadManifest
-  // -------------------------------------------------------------------------
-
-  describe('loadManifest', () => {
-    it('returns null when no manifest file exists', () => {
-      const result = loadManifest(stateDir, 'nonexistent');
-      expect(result).toBeNull();
-    });
-
-    it('returns parsed manifest when manifest file exists', () => {
-      const implId = 'IMPL_002';
-      const manifest: CodeImplementationManifest = {
-        version: '1.0.0',
-        entryFile: 'entry.js',
-        createdAt: '2026-01-01T00:00:00.000Z',
-        updatedAt: '2026-01-01T00:00:00.000Z',
-        replaySampleRefs: [],
-        lastEvalReportRef: null,
-      };
-
-      // Write directly (bypass writeManifest to test load independently)
-      const assetRoot = getImplementationAssetRoot(stateDir, implId);
-      fs.mkdirSync(assetRoot, { recursive: true });
-      fs.writeFileSync(path.join(assetRoot, 'manifest.json'), JSON.stringify(manifest), 'utf-8');
-
-      const result = loadManifest(stateDir, implId);
-      expect(result).toEqual(manifest);
-    });
-
-    it('returns null for corrupted manifest JSON', () => {
-      const implId = 'IMPL_003';
-      const assetRoot = getImplementationAssetRoot(stateDir, implId);
-      fs.mkdirSync(assetRoot, { recursive: true });
-      fs.writeFileSync(path.join(assetRoot, 'manifest.json'), 'not-valid-json{{{', 'utf-8');
-
-      const result = loadManifest(stateDir, implId);
-      expect(result).toBeNull();
-    });
-  });
-
   // -------------------------------------------------------------------------
   // writeManifest
   // -------------------------------------------------------------------------
@@ -177,67 +134,6 @@ describe('CodeImplementationStorage', () => {
     });
   });
 
-  // -------------------------------------------------------------------------
-  // loadEntrySource
-  // -------------------------------------------------------------------------
-
-  describe('loadEntrySource', () => {
-    it('returns null when no manifest exists', () => {
-      const result = loadEntrySource(stateDir, 'nonexistent');
-      expect(result).toBeNull();
-    });
-
-    it('returns null when manifest exists but entry file does not', () => {
-      const implId = 'IMPL_007';
-      const assetRoot = getImplementationAssetRoot(stateDir, implId);
-      fs.mkdirSync(assetRoot, { recursive: true });
-
-      // Write manifest pointing to a non-existent entry file
-      const manifest: CodeImplementationManifest = {
-        version: '1.0.0',
-        entryFile: 'nonexistent.js',
-        createdAt: '2026-01-01T00:00:00.000Z',
-        updatedAt: '2026-01-01T00:00:00.000Z',
-        replaySampleRefs: [],
-        lastEvalReportRef: null,
-      };
-      fs.writeFileSync(
-        path.join(assetRoot, 'manifest.json'),
-        JSON.stringify(manifest),
-        'utf-8',
-      );
-
-      const result = loadEntrySource(stateDir, implId);
-      expect(result).toBeNull();
-    });
-
-    it('returns file content when entry file exists', () => {
-      const implId = 'IMPL_008';
-      const assetRoot = getImplementationAssetRoot(stateDir, implId);
-      fs.mkdirSync(assetRoot, { recursive: true });
-
-      const entryContent = 'export function evaluate() { return true; }';
-      fs.writeFileSync(path.join(assetRoot, 'entry.js'), entryContent, 'utf-8');
-
-      const manifest: CodeImplementationManifest = {
-        version: '1.0.0',
-        entryFile: 'entry.js',
-        createdAt: '2026-01-01T00:00:00.000Z',
-        updatedAt: '2026-01-01T00:00:00.000Z',
-        replaySampleRefs: [],
-        lastEvalReportRef: null,
-      };
-      fs.writeFileSync(
-        path.join(assetRoot, 'manifest.json'),
-        JSON.stringify(manifest),
-        'utf-8',
-      );
-
-      const result = loadEntrySource(stateDir, implId);
-      expect(result).toBe(entryContent);
-    });
-  });
-
   // -------------------------------------------------------------------------
   // createImplementationAssetDir
   // -------------------------------------------------------------------------
@@ -300,7 +196,9 @@ describe('CodeImplementationStorage', () => {
         artificerArtifactId: 'artifact-1',
       });
 
-      const loaded = loadManifest(stateDir, implId);
+      // Verify persisted manifest contains lineage
+      const assetRoot = getImplementationAssetRoot(stateDir, implId);
+      const loaded = JSON.parse(fs.readFileSync(path.join(assetRoot, 'manifest.json'), 'utf-8'));
       expect(loaded?.lineage).toMatchObject({
         sourcePainIds: ['pain:gate:1'],
         sourceGateBlockIds: ['gate:write:1'],
@@ -344,22 +242,23 @@ describe('CodeImplementationStorage', () => {
       expect(fs.existsSync(reportPath)).toBe(true);
     });
 
-    it('manifest is loadable via loadManifest after creation', () => {
+    it('manifest is persisted with correct version after creation', () => {
       const implId = 'IMPL_014';
       createImplementationAssetDir(stateDir, implId, '4.0.0');
 
-      const loaded = loadManifest(stateDir, implId);
+      const assetRoot = getImplementationAssetRoot(stateDir, implId);
+      const loaded = JSON.parse(fs.readFileSync(path.join(assetRoot, 'manifest.json'), 'utf-8'));
       expect(loaded).not.toBeNull();
-      expect(loaded!.version).toBe('4.0.0');
-      expect(loaded!.entryFile).toBe('entry.js');
+      expect(loaded.version).toBe('4.0.0');
+      expect(loaded.entryFile).toBe('entry.js');
     });
 
-    it('entry source is loadable via loadEntrySource after creation', () => {
+    it('entry source is persisted after creation', () => {
       const implId = 'IMPL_015';
       createImplementationAssetDir(stateDir, implId, '1.0.0');
 
-      const source = loadEntrySource(stateDir, implId);
-      expect(source).not.toBeNull();
+      const assetRoot = getImplementationAssetRoot(stateDir, implId);
+      const source = fs.readFileSync(path.join(assetRoot, 'entry.js'), 'utf-8');
       expect(source).toContain('export const meta');
       expect(source).toContain('export function evaluate');
     });
@@ -370,7 +269,8 @@ describe('CodeImplementationStorage', () => {
         entrySource: 'export const meta = { name: "x", version: "1", ruleId: "R", coversCondition: "c" }; export function evaluate() { return { decision: "allow", matched: false, reason: "ok" }; }',
       });
 
-      const source = loadEntrySource(stateDir, implId);
+      const assetRoot = getImplementationAssetRoot(stateDir, implId);
+      const source = fs.readFileSync(path.join(assetRoot, 'entry.js'), 'utf-8');
       expect(source).toContain('export const meta');
       expect(source).not.toContain('placeholder');
     });
@@ -383,7 +283,9 @@ describe('CodeImplementationStorage', () => {
 
       writeEntrySource(stateDir, implId, 'export const meta = { name: "updated", version: "1", ruleId: "R", coversCondition: "c" }; export function evaluate() { return { decision: "allow", matched: false, reason: "updated" }; }');
 
-      expect(loadEntrySource(stateDir, implId)).toContain('updated');
+      const assetRoot = getImplementationAssetRoot(stateDir, implId);
+      const source = fs.readFileSync(path.join(assetRoot, 'entry.js'), 'utf-8');
+      expect(source).toContain('updated');
     });
 
     it('removes the asset directory through deleteImplementationAssetDir', () => {