principles-disciple 1.12.0 → 1.13.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.12.0",
+  "version": "1.13.0",
   "skills": [
     "./skills"
   ],
@@ -76,8 +76,8 @@
     }
   },
   "buildFingerprint": {
-    "gitSha": "a320b37a2418",
-    "bundleMd5": "6a5838169d98e4e6419e736dd034d93a",
-    "builtAt": "2026-04-09T13:57:36.081Z"
+    "gitSha": "ad52c5fcc9c5",
+    "bundleMd5": "3dc29cb961c7132e1ad419550686df6c",
+    "builtAt": "2026-04-10T01:19:54.357Z"
   }
 }

package/package.json

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

package/scripts/sync-plugin.mjs

@@ -17,7 +17,7 @@
  *   --help             Show help message
  */
 
-import { copyFileSync, cpSync, existsSync, rmSync, readFileSync, readFileSync as readFileSyncRaw, mkdirSync, writeFileSync, readdirSync } from 'fs';
+import { copyFileSync, cpSync, existsSync, rmSync, readFileSync, readFileSync as readFileSyncRaw, mkdirSync, writeFileSync, readdirSync, statSync } from 'fs';
 import { createHash } from 'crypto';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
@@ -667,6 +667,158 @@ function syncItem(item) {
     }
 }
 
+/**
+ * Sync workspace templates to all workspace directories.
+ * This ensures workspaces get the latest template files when the plugin is updated.
+ *
+ * IMPORTANT SAFETY RULES:
+ * - Core files (AGENTS.md, SOUL.md, IDENTITY.md, USER.md, etc.) are NEVER overwritten.
+ *   They are only copied on first-time workspace creation (file doesn't exist).
+ *   Users heavily customize these files — overwriting would destroy their work.
+ * - Non-core templates (pain_samples, THINKING_OS.md, workspace boilerplate) are synced
+ *   via MD5 comparison (only update if template content changed and workspace hasn't diverged).
+ *
+ * Syncs:
+ *   - templates/workspace/** → workspace root (recursive, skip core files)
+ *   - templates/langs/{lang}/core/** → workspace root (ONLY if missing)
+ *   - templates/langs/{lang}/pain/** → .state/pain_samples/
+ *   - templates/langs/{lang}/principles/THINKING_OS.md → .principles/THINKING_OS.md
+ */
+function syncWorkspaceTemplates(lang) {
+    const workspacesRoot = OPENCLAW_DIR;
+    if (!existsSync(workspacesRoot)) return;
+
+    const entries = readdirSync(workspacesRoot);
+    const workspaceDirs = entries.filter(e =>
+        e.startsWith('workspace-') || e === 'workspace'
+    );
+
+    if (workspaceDirs.length === 0) return;
+
+    // Core files that should NEVER be overwritten after creation
+    const CORE_FILES = new Set([
+        'AGENTS.md', 'SOUL.md', 'BOOT.md', 'BOOTSTRAP.md',
+        'IDENTITY.md', 'USER.md', 'TOOLS.md', 'HEARTBEAT.md',
+        'PRINCIPLES.md', 'PROFILE.json',
+    ]);
+
+    let updated = 0;
+
+    // Helper: compute MD5 of a file
+    function md5(filePath) {
+        try {
+            const content = readFileSyncRaw(filePath);
+            return createHash('md5').update(content).digest('hex');
+        } catch {
+            return null;
+        }
+    }
+
+    for (const ws of workspaceDirs) {
+        const wsDir = join(workspacesRoot, ws);
+
+        // 1. templates/workspace/** → workspace root (recursive)
+        const workspaceTemplateDir = join(SOURCE_DIR, 'templates', 'workspace');
+        if (existsSync(workspaceTemplateDir)) {
+            updated += syncDirRecursive(workspaceTemplateDir, wsDir, md5, CORE_FILES);
+        }
+
+        // 2. templates/langs/{lang}/core/** → workspace root (ONLY if file missing)
+        const coreDir = join(SOURCE_DIR, 'templates', 'langs', lang, 'core');
+        if (existsSync(coreDir)) {
+            updated += syncCoreFiles(coreDir, wsDir);
+        } else {
+            const zhCoreDir = join(SOURCE_DIR, 'templates', 'langs', 'zh', 'core');
+            if (existsSync(zhCoreDir)) {
+                updated += syncCoreFiles(zhCoreDir, wsDir);
+            }
+        }
+
+        // 3. templates/langs/{lang}/pain/** → .state/pain_samples/
+        const painSrc = join(SOURCE_DIR, 'templates', 'langs', lang, 'pain');
+        const painDest = join(wsDir, '.state', 'pain_samples');
+        if (existsSync(painSrc)) {
+            updated += syncDirRecursive(painSrc, painDest, md5, CORE_FILES);
+        }
+
+        // 4. templates/langs/{lang}/principles/THINKING_OS.md → .principles/THINKING_OS.md
+        const thinkingOsSrc = join(SOURCE_DIR, 'templates', 'langs', lang, 'principles', 'THINKING_OS.md');
+        const thinkingOsDest = join(wsDir, '.principles', 'THINKING_OS.md');
+        if (existsSync(thinkingOsSrc)) {
+            const srcMd5 = md5(thinkingOsSrc);
+            const destMd5 = existsSync(thinkingOsDest) ? md5(thinkingOsDest) : null;
+            if (srcMd5 !== destMd5) {
+                if (!existsSync(join(wsDir, '.principles'))) {
+                    mkdirSync(join(wsDir, '.principles'), { recursive: true });
+                }
+                cpSync(thinkingOsSrc, thinkingOsDest, { force: true });
+                updated++;
+            }
+        }
+    }
+
+    if (updated > 0) {
+        console.log(`   📄 Workspace templates → ${updated} file(s) synced across ${workspaceDirs.length} workspace(s)`);
+    }
+}
+
+/**
+ * Sync core files ONLY if they don't exist yet.
+ * NEVER overwrites existing core files (user customizations).
+ */
+function syncCoreFiles(srcDir, destDir) {
+    let count = 0;
+    if (!existsSync(srcDir)) return count;
+
+    const items = readdirSync(srcDir);
+    for (const item of items) {
+        const srcPath = join(srcDir, item);
+        const destPath = join(destDir, item);
+        const stat = statSync(srcPath);
+
+        if (stat.isDirectory()) continue;
+        // Core files: only copy if missing
+        if (!existsSync(destPath)) {
+            cpSync(srcPath, destPath, { force: false });
+            count++;
+        }
+    }
+    return count;
+}
+
+/**
+ * Recursively sync source dir to dest dir, skipping core files that already exist.
+ * Non-core files: only copy if missing or different (MD5).
+ */
+function syncDirRecursive(srcDir, destDir, md5Fn, coreFiles) {
+    let count = 0;
+    if (!existsSync(destDir)) {
+        mkdirSync(destDir, { recursive: true });
+    }
+
+    const items = readdirSync(srcDir);
+    for (const item of items) {
+        const srcPath = join(srcDir, item);
+        const destPath = join(destDir, item);
+        const stat = statSync(srcPath);
+
+        if (stat.isDirectory()) {
+            count += syncDirRecursive(srcPath, destPath, md5Fn, coreFiles);
+        } else {
+            // Skip core files that already exist
+            if (coreFiles.has(item) && existsSync(destPath)) continue;
+
+            const srcMd5 = md5Fn(srcPath);
+            const destMd5 = existsSync(destPath) ? md5Fn(destPath) : null;
+            if (srcMd5 !== destMd5) {
+                cpSync(srcPath, destPath, { force: true });
+                count++;
+            }
+        }
+    }
+    return count;
+}
+
 /**
  * Install production dependencies in target directory
  */
@@ -825,6 +977,9 @@ function main() {
     // Step 7: Sync skills
     syncSkills(args.lang);
 
+    // Step 7.5: Sync THINKING_OS.md to all workspace .principles/ directories
+    syncWorkspaceTemplates(args.lang);
+
     // Step 8: Install production dependencies in target (ALWAYS — cleanTargetDir wiped node_modules)
     // --skip-deps only applies to SOURCE directory deps, not the installed plugin.
     installTargetDependencies();

package/src/commands/nocturnal-train.ts

@@ -270,12 +270,12 @@ Hardware tiers:
       // This closes the gap in the create-experiment -> trainer -> import-result chain.
       // NOTE: This blocks until training completes (could be minutes).
       if (runNow) {
-        // eslint-disable-next-line @typescript-eslint/no-shadow -- Reason: shadowing is intentional - inner block scoping for trainer execution
+         
         const {spec} = createResult;
         const baseDir = TRAINER_SCRIPTS_DIR;
         const scriptPath = path.join(baseDir, 'main.py');
         const specPath = path.join(baseDir, `experiment-${spec.experimentId}.json`);
-        // eslint-disable-next-line @typescript-eslint/no-shadow -- Reason: shadowing is intentional - inner block scoping for trainer output directory
+         
         const {outputDir} = spec;
         const resultFilePath = path.join(outputDir, `result-${spec.experimentId}.json`);
 
@@ -286,7 +286,7 @@ Hardware tiers:
         }
         fs.writeFileSync(specPath, JSON.stringify(spec, null, 2), 'utf-8');
 
-        // eslint-disable-next-line @typescript-eslint/init-declarations, @typescript-eslint/consistent-type-imports -- Reason: type assertion required - trainer result type from external contract module
+         
         let trainerResult!: import('../core/external-training-contract.js').TrainingExperimentResult;
 
         try {
@@ -394,7 +394,7 @@ Hardware tiers:
 
         // Process trainer result (register checkpoint)
         // dry_run returns null (no checkpoint); other statuses throw on error
-        // eslint-disable-next-line @typescript-eslint/init-declarations -- Reason: assigned in try block immediately after declaration
+         
         let processed: { checkpointId: string; checkpointRef: string } | null;
         try {
           processed = program.processResult({
@@ -536,7 +536,7 @@ Next steps:
         }
       }
 
-      // eslint-disable-next-line @typescript-eslint/init-declarations, @typescript-eslint/no-explicit-any -- Reason: JSON.parse returns dynamic JSON - type unknown at parse time, narrowed via type narrowing below
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Reason: JSON.parse returns dynamic JSON - type unknown at parse time, narrowed via type narrowing below
       let result: any;
       try {
         result = JSON.parse(resultJson);
@@ -567,7 +567,7 @@ Next steps:
 
       // Process the result
       const program = new TrainingProgram(workspaceDir);
-      // eslint-disable-next-line @typescript-eslint/init-declarations -- Reason: assigned in try block immediately after declaration
+       
       let processed: { checkpointId: string; checkpointRef: string } | null;
       try {
         processed = program.processResult({
@@ -754,12 +754,11 @@ Next steps:
           };
         }
 
-        // Destructure benchmark result - delta property contains the actual delta value
-        delta = benchmarkResult.delta.delta;
-        baselineScore = benchmarkResult.delta.baselineScore;
-        candidateScore = benchmarkResult.delta.candidateScore;
-        benchmarkId = benchmarkResult.benchmarkId;
-        verdict = benchmarkResult.verdict;
+        ({
+          delta: { delta, baselineScore, candidateScore },
+          benchmarkId,
+          verdict,
+        } = benchmarkResult);
       } else {
         // Manual mode: require explicit delta and verdict
         if (!deltaArg || !verdictArg) {

package/src/core/evolution-reducer.ts

@@ -20,9 +20,10 @@ import type {
   PrincipleSuggestedRule,
 } from './evolution-types.js';
 import { isCompleteDetectorMetadata } from './evolution-types.js';
-import { updateTrainingStore } from './principle-tree-ledger.js';
+import { updateTrainingStore, createPrinciple } from './principle-tree-ledger.js';
+import type { LedgerPrinciple } from './principle-tree-ledger.js';
 
-/* eslint-disable no-unused-vars -- Reason: interface method params are type signatures, implementations use actual values */
+ 
 export interface EvolutionReducer {
 
   emit(_event: EvolutionLoopEvent): void;
@@ -72,7 +73,7 @@ export interface EvolutionReducer {
     lastPromotedAt: string | null;
   };
 }
-/* eslint-enable no-unused-vars */
+ 
 
 const PROBATION_SUCCESS_THRESHOLD = 3;
 const CIRCUIT_BREAKER_THRESHOLD = 3;
@@ -381,6 +382,7 @@ export class EvolutionReducerImpl implements EvolutionReducer {
     }
 
     // #204: Write to training store so listEvaluablePrinciples() can find this principle
+    // Phase 11: Also write to tree.principles for Rule/Implementation layer support
     if (this.stateDir) {
       try {
         // Determine initial internalization status based on evaluability:
@@ -404,6 +406,31 @@ export class EvolutionReducerImpl implements EvolutionReducer {
           };
         });
         SystemLogger.log(this.workspaceDir, 'TRAINING_STORE_UPDATED', `Principle ${principleId} added to training store with evaluability=${evaluability}, internalizationStatus=${initialStatus}`);
+
+        // Phase 11: Also create principle in tree.principles for Rule/Implementation layer
+        const treePrinciple: LedgerPrinciple = {
+          id: principleId,
+          version: 1,
+          text: principle.text,
+          coreAxiomId: principle.coreAxiomId,
+          triggerPattern: params.triggerPattern,
+          action: params.action,
+          status: principle.status,
+          priority: principle.priority ?? 'P1',
+          scope: principle.scope ?? 'general',
+          domain: principle.domain,
+          evaluability,
+          valueScore: 0,
+          adherenceRate: 0,
+          painPreventedCount: 0,
+          derivedFromPainIds: [params.painId],
+          ruleIds: [],
+          conflictsWithPrincipleIds: [],
+          createdAt: now,
+          updatedAt: now,
+        };
+        createPrinciple(this.stateDir, treePrinciple);
+        SystemLogger.log(this.workspaceDir, 'TREE_PRINCIPLE_CREATED', `Principle ${principleId} added to tree.principles`);
       } catch (err) {
         SystemLogger.log(this.workspaceDir, 'TRAINING_STORE_UPDATE_FAILED', `Failed to update training store for ${principleId}: ${String(err)}`);
       }
@@ -663,7 +690,7 @@ export class EvolutionReducerImpl implements EvolutionReducer {
     });
   }
 
-  // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars -- Reason: event timestamp intentionally unused, only data payload matters
+   
   private onPainDetected(data: PainDetectedData, _eventTs: string): void {
     const trigger = String(data.reason ?? data.source ?? 'unknown trigger');
 

package/src/core/nocturnal-trinity.ts

@@ -1360,14 +1360,19 @@ export async function runTrinityAsync(options: RunTrinityOptions): Promise<Trini
 
   try {
     // Step 1: Dreamer — generate candidates via real subagent
+    const dreamerStart = Date.now();
+    console.log(`[Trinity] Step 1/3: Invoking Dreamer (principleId=${principleId}, maxCandidates=${config.maxCandidates})`);
     const dreamerOutput = await adapter.invokeDreamer(snapshot, principleId, config.maxCandidates);
+    console.log(`[Trinity] Dreamer completed in ${Date.now() - dreamerStart}ms, valid=${dreamerOutput.valid}, candidates=${dreamerOutput.candidates?.length ?? 0}`);
 
     if (!dreamerOutput.valid || dreamerOutput.candidates.length === 0) {
+      const reason = dreamerOutput.reason ?? 'No valid candidates generated';
+      console.warn(`[Trinity] Dreamer failed: ${reason}`);
       failures.push({
         stage: 'dreamer',
-        reason: dreamerOutput.reason ?? 'No valid candidates generated',
+        reason,
       });
-      telemetry.stageFailures.push(`Dreamer: ${dreamerOutput.reason ?? 'failed'}`);
+      telemetry.stageFailures.push(`Dreamer: ${reason}`);
       return { success: false, telemetry, failures, fallbackOccurred: false };
     }
 
@@ -1375,20 +1380,27 @@ export async function runTrinityAsync(options: RunTrinityOptions): Promise<Trini
     telemetry.candidateCount = dreamerOutput.candidates.length;
 
     // Step 2: Philosopher — rank candidates via real subagent
+    const philosopherStart = Date.now();
+    console.log(`[Trinity] Step 2/3: Invoking Philosopher (${dreamerOutput.candidates.length} candidates)`);
     const philosopherOutput = await adapter.invokePhilosopher(dreamerOutput, principleId);
+    console.log(`[Trinity] Philosopher completed in ${Date.now() - philosopherStart}ms, valid=${philosopherOutput.valid}, judgments=${philosopherOutput.judgments?.length ?? 0}`);
 
     if (!philosopherOutput.valid || philosopherOutput.judgments.length === 0) {
+      const reason = philosopherOutput.reason ?? 'No judgments produced';
+      console.warn(`[Trinity] Philosopher failed: ${reason}`);
       failures.push({
         stage: 'philosopher',
-        reason: philosopherOutput.reason ?? 'No judgments produced',
+        reason,
       });
-      telemetry.stageFailures.push(`Philosopher: ${philosopherOutput.reason ?? 'failed'}`);
+      telemetry.stageFailures.push(`Philosopher: ${reason}`);
       return { success: false, telemetry, failures, fallbackOccurred: false };
     }
 
     telemetry.philosopherPassed = true;
 
     // Step 3: Scribe — synthesize final artifact via real subagent
+    const scribeStart = Date.now();
+    console.log(`[Trinity] Step 3/3: Invoking Scribe (synthesizing artifact)`);
     const draftArtifact = await adapter.invokeScribe(
       dreamerOutput,
       philosopherOutput,
@@ -1397,8 +1409,10 @@ export async function runTrinityAsync(options: RunTrinityOptions): Promise<Trini
       telemetry,
       config
     );
+    console.log(`[Trinity] Scribe completed in ${Date.now() - scribeStart}ms, artifact=${!!draftArtifact}`);
 
     if (!draftArtifact) {
+      console.warn(`[Trinity] Scribe failed: Failed to synthesize artifact from candidates`);
       failures.push({ stage: 'scribe', reason: 'Failed to synthesize artifact from candidates' });
       telemetry.stageFailures.push('Scribe: synthesis failed');
       return { success: false, telemetry, failures, fallbackOccurred: false };
@@ -1406,6 +1420,7 @@ export async function runTrinityAsync(options: RunTrinityOptions): Promise<Trini
 
     telemetry.scribePassed = true;
     telemetry.selectedCandidateIndex = draftArtifact.selectedCandidateIndex;
+    console.log(`[Trinity] Trinity chain completed successfully: selectedCandidateIndex=${draftArtifact.selectedCandidateIndex}`);
 
     if (draftArtifact.telemetry) {
       telemetry.tournamentTrace = draftArtifact.telemetry.tournamentTrace;

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

@@ -77,7 +77,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
-/* eslint-disable @typescript-eslint/max-params -- Reason: Clamp function requires all parameters for safe numeric conversion */
+ 
 function clampFloat(value: unknown, min: number, max: number, fallback: number): number {
   if (typeof value !== 'number' || !Number.isFinite(value)) {
     return fallback;
@@ -85,7 +85,7 @@ function clampFloat(value: unknown, min: number, max: number, fallback: number):
   return Math.max(min, Math.min(max, value));
 }
 
-/* eslint-disable @typescript-eslint/max-params -- Reason: Clamp function requires all parameters for safe numeric conversion */
+ 
 function clampInt(value: unknown, min: number, max: number, fallback: number): number {
   if (typeof value !== 'number' || !Number.isFinite(value)) {
     return fallback;
@@ -315,9 +315,9 @@ function writeLedgerUnlocked(filePath: string, store: HybridLedgerStore): void {
   fs.writeFileSync(filePath, serializeLedger(store), 'utf-8');
 }
 
-/* eslint-disable no-unused-vars -- Reason: callback parameter used via closure in inner function */
+ 
 function mutateLedger<T>(stateDir: string, mutate: (store: HybridLedgerStore) => T): T {
-  // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: function is defined later but called in this helper for consistency
+   
   const filePath = getLedgerFilePath(stateDir);
   return withLock(filePath, () => {
     const store = readLedgerFromFile(filePath);
@@ -327,9 +327,9 @@ function mutateLedger<T>(stateDir: string, mutate: (store: HybridLedgerStore) =>
   });
 }
 
-/* eslint-disable no-unused-vars -- Reason: callback parameter used via closure in inner function */
+ 
 async function mutateLedgerAsync<T>(stateDir: string, mutate: (store: HybridLedgerStore) => Promise<T>): Promise<T> {
-  // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: function is defined later but called in this helper for consistency
+   
   const filePath = getLedgerFilePath(stateDir);
   return withLockAsync(filePath, async () => {
     const store = readLedgerFromFile(filePath);
@@ -363,7 +363,7 @@ export async function saveLedgerAsync(stateDir: string, store: HybridLedgerStore
 
 export function updateTrainingStore(
   stateDir: string,
-  /* eslint-disable no-unused-vars -- Reason: callback parameter is forwarded to mutateLedger callback */
+   
   mutate: (store: LegacyPrincipleTrainingStore) => void,
 ): void {
   mutateLedger(stateDir, (store) => {
@@ -371,6 +371,26 @@ export function updateTrainingStore(
   });
 }
 
+export function createPrinciple(stateDir: string, principle: LedgerPrinciple): LedgerPrinciple {
+  return mutateLedger(stateDir, (store) => {
+    const existing = store.tree.principles[principle.id];
+    if (existing) {
+      // Principle already exists, return existing (idempotent)
+      return existing;
+    }
+
+    const nextPrinciple: LedgerPrinciple = {
+      ...principle,
+      ruleIds: uniqueStrings(principle.ruleIds ?? []),
+      conflictsWithPrincipleIds: uniqueStrings(principle.conflictsWithPrincipleIds ?? []),
+      derivedFromPainIds: uniqueStrings(principle.derivedFromPainIds ?? []),
+    };
+
+    store.tree.principles[principle.id] = nextPrinciple;
+    return nextPrinciple;
+  });
+}
+
 export function createRule(stateDir: string, rule: LedgerRule): LedgerRule {
   return mutateLedger(stateDir, (store) => {
     const principle = store.tree.principles[rule.principleId];