principles-disciple 1.44.0 → 1.46.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.44.0",
+  "version": "1.46.0",
   "skills": [
     "./skills"
   ],
@@ -76,8 +76,8 @@
     }
   },
   "buildFingerprint": {
-    "gitSha": "cab0dbd8e6e7",
-    "bundleMd5": "1505a7119addd2ee24059f2473cdb1ca",
-    "builtAt": "2026-04-14T10:58:07.896Z"
+    "gitSha": "9ae5cc1407da",
+    "bundleMd5": "68bc85f0121a780b83931b7ed5491b97",
+    "builtAt": "2026-04-16T02:19:50.219Z"
   }
 }

package/package.json

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

package/src/core/evolution-reducer.ts

@@ -21,7 +21,7 @@ import type {
   PrincipleSuggestedRule,
 } from './evolution-types.js';
 import { isCompleteDetectorMetadata } from './evolution-types.js';
-import { updateTrainingStore } from './principle-tree-ledger.js';
+import { updateTrainingStore, addPrincipleToLedger, type LedgerPrinciple } from './principle-tree-ledger.js';
 
  
 export interface EvolutionReducer {
@@ -381,6 +381,50 @@ export class EvolutionReducerImpl implements EvolutionReducer {
       SystemLogger.log(this.workspaceDir, 'PRINCIPLE_SYNC_WARN', `Principle ${principleId} created in memory but failed to sync to PRINCIPLES.md — manual file check required`);
     }
 
+    // Add to ledger tree so the compiler can find this principle.
+    // Without this, newly diagnosed principles are invisible to the compiler
+    // (which reads tree.principles, not trainingStore or PRINCIPLES.md).
+    if (this.stateDir) {
+      try {
+        // Build a LedgerPrinciple (tree schema) from the evolution-types Principle.
+        // Tree schema Principle does NOT have: source, guardrails, contextTags, validation,
+        // feedbackScore, usageCount, activatedAt, abstractedPrinciple, valueMetrics.
+        // Pain source info is stored via derivedFromPainIds (which the compiler uses).
+        const ledgerPrinciple: LedgerPrinciple = {
+          id: principle.id,
+          version: principle.version,
+          text: principle.text,
+          triggerPattern: principle.trigger,
+          action: principle.action,
+          status: principle.status,
+          evaluability: principle.evaluability,
+          coreAxiomId: principle.coreAxiomId,
+          priority: principle.priority ?? 'P1',
+          scope: principle.scope ?? 'general',
+          domain: principle.domain,
+          suggestedRules: principle.suggestedRules?.map((r) => r.name),
+          detectorMetadata: principle.detectorMetadata,
+          deprecatedAt: principle.deprecatedAt,
+          deprecatedReason: undefined,
+          createdAt: principle.createdAt,
+          updatedAt: now,
+          // Ledger-only fields (derived from evolution-types Principle where applicable):
+          valueScore: 0,
+          adherenceRate: 0,
+          painPreventedCount: 0,
+          lastPainPreventedAt: undefined,
+          derivedFromPainIds: [params.painId],
+          ruleIds: [],
+          conflictsWithPrincipleIds: [],
+          supersedesPrincipleId: undefined,
+        };
+        addPrincipleToLedger(this.stateDir, ledgerPrinciple);
+        SystemLogger.log(this.workspaceDir, 'LEDGER_PRINCIPLE_ADDED', `Principle ${principleId} added to ledger tree`);
+      } catch (err) {
+        SystemLogger.log(this.workspaceDir, 'LEDGER_PRINCIPLE_ADD_FAILED', `Failed to add ${principleId} to ledger tree: ${String(err)}`);
+      }
+    }
+
     // #204: Write to training store so listEvaluablePrinciples() can find this principle
     if (this.stateDir) {
       try {

package/src/core/pain.ts

@@ -32,9 +32,11 @@ export interface PainFlagData {
   /** Whether this involves risky operation ('true' / 'false') */
   is_risky: string;
   /** Correlation trace ID (for linking events across the pipeline) */
-  trace_id?: string;
-  /** Short preview of text that triggered this pain signal */
-  trigger_text_preview?: string;
+  trace_id: string;
+  /** Preview of the text that triggered this pain */
+  trigger_text_preview: string;
+  /** Trajectory pain_events row ID (set by recordPainEvent) */
+  pain_event_id?: string;
 }
 
 export interface PainFlagContractResult {
@@ -65,6 +67,7 @@ export function buildPainFlag(input: {
   is_risky?: boolean;
   trace_id?: string;
   trigger_text_preview?: string;
+  pain_event_id?: string;
 }): PainFlagData {
   // Omit optional fields when not provided — prevents writing empty lines to disk
   // which causes agent confusion (SKILL.md vs reality drift)
@@ -78,6 +81,7 @@ export function buildPainFlag(input: {
     is_risky: input.is_risky ? 'true' : 'false',
     trace_id: input.trace_id ?? '',
     trigger_text_preview: input.trigger_text_preview ?? '',
+    pain_event_id: input.pain_event_id,
   };
 }
 

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

@@ -368,7 +368,7 @@ export async function saveLedgerAsync(stateDir: string, store: HybridLedgerStore
 
 export function updateTrainingStore(
   stateDir: string,
-   
+
   mutate: (store: LegacyPrincipleTrainingStore) => void,
 ): void {
   mutateLedger(stateDir, (store) => {
@@ -376,6 +376,24 @@ export function updateTrainingStore(
   });
 }
 
+/**
+ * Add a new principle directly to the ledger tree.
+ * This is the companion to updatePrinciple() — use this when creating a NEW
+ * principle so the compiler can find it in tree.principles.
+ *
+ * Idempotent: if the principle already exists, overwrites (update semantics).
+ */
+export function addPrincipleToLedger(
+  stateDir: string,
+  principle: LedgerPrinciple,
+): LedgerPrinciple {
+  return mutateLedger(stateDir, (store) => {
+    store.tree.principles[principle.id] = principle;
+    store.tree.lastUpdated = new Date().toISOString();
+    return principle;
+  });
+}
+
 export function createRule(stateDir: string, rule: LedgerRule): LedgerRule {
   return mutateLedger(stateDir, (store) => {
     const principle = store.tree.principles[rule.principleId];

package/src/core/trajectory.ts

@@ -237,10 +237,11 @@ export class TrajectoryDatabase {
     return rowId;
   }
 
-  recordPainEvent(input: TrajectoryPainEventInput): void {
+  recordPainEvent(input: TrajectoryPainEventInput): number {
     this.recordSession({ sessionId: input.sessionId, startedAt: input.createdAt });
+    let insertedId = -1;
     this.withWrite(() => {
-      this.db.prepare(`
+      const runResult = this.db.prepare(`
         INSERT INTO pain_events (
           session_id, source, score, reason, severity, origin, confidence, text, created_at
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -255,15 +256,22 @@ export class TrajectoryDatabase {
         input.text ?? null,
         input.createdAt ?? nowIso(),
       );
-
-      // Maintain FTS5 index: insert text into pain_events_fts if text is provided (MEM-03, MEM-04)
-      if (input.text) {
-        const lastId = this.db.prepare('SELECT last_insert_rowid() as id').get() as { id: number };
+      insertedId = runResult.lastInsertRowid as number;
+    });
+    // FTS indexing is best-effort — run outside the transaction so it cannot
+    // roll back the committed pain event row (MEM-03, MEM-04).
+    if (input.text && insertedId > 0) {
+      try {
         this.db.prepare(`
           INSERT INTO pain_events_fts (text, pain_event_id) VALUES (?, ?)
-        `).run(input.text, lastId.id);
+        `).run(input.text, insertedId);
+      } catch (err) {
+        // Non-fatal: FTS index is for search convenience, not correctness.
+        // Log but do not re-throw — the pain event itself is already committed.
+        console.warn(`[trajectory] FTS index insert failed for pain_event ${insertedId}: ${String(err)}`);
       }
-    });
+    }
+    return insertedId;
   }
 
   /**

package/src/hooks/pain.ts

@@ -295,6 +295,19 @@ export function handleAfterToolCall(
   const painScore = computePainScore(1, false, false, isRisk ? 20 : 0, effectiveWorkspaceDir);
   const traceId = createTraceId();
 
+  // Record to trajectory FIRST so we get the real auto-increment ID.
+  // This ID propagates through the pain flag → evolution task → principle,
+  // so the compiler can later resolve derivedFromPainIds correctly.
+  const trajectoryPainId = wctx.trajectory?.recordPainEvent({
+    sessionId,
+    source: 'tool_failure',
+    score: painScore,
+    reason: `Tool ${event.toolName} failed on ${relPath}`,
+    severity: painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild',
+    origin: 'system_infer',
+    text: params.text ?? params.content ?? undefined,
+  });
+
   const painData = buildPainFlag({
     source: 'tool_failure',
     score: String(painScore),
@@ -303,6 +316,7 @@ export function handleAfterToolCall(
     trace_id: traceId,
     session_id: sessionId,
     agent_id: ctx.agentId || '',
+    pain_event_id: trajectoryPainId !== undefined && trajectoryPainId >= 0 ? String(trajectoryPainId) : undefined,
   });
 
   try {
@@ -355,15 +369,6 @@ export function handleAfterToolCall(
     reason: `Tool ${event.toolName} failed on ${relPath}`,
     isRisky: isRisk,
   });
-    wctx.trajectory?.recordPainEvent?.({
-      sessionId,
-      source: 'tool_failure',
-      score: painScore,
-      reason: `Tool ${event.toolName} failed on ${relPath}`,
-      severity: painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild',
-      origin: 'system_infer',
-      text: params.text ?? params.content ?? undefined,  // Store original text/content that failed
-    });
 
   // Log to EvolutionLogger
   const evoLogger = getEvolutionLogger(effectiveWorkspaceDir, wctx.trajectory);

package/src/hooks/prompt.ts

@@ -402,9 +402,10 @@ export async function handleBeforePromptBuild(
             learner.flush();
           }
         }
-      } catch {
-        // Fallback to hardcoded detection if learner fails
+      } catch (learnerErr) {
+        // Fallback to hardcoded detection if learner fails — log for observability
         correctionCue = detectCorrectionCue(userText);
+        logger?.warn?.(`[PD:Prompt] CorrectionCueLearner.match() failed (${String(learnerErr)}), fallback=${correctionCue ? `matched="${correctionCue}"` : 'no-match'}`);
       }
       let referencesAssistantTurnId: number | null = null;
       const hasPriorAssistant = event.messages

package/src/service/evolution-worker.ts

@@ -141,6 +141,9 @@ export interface EvolutionQueueItem {
     // Attaches explicit recent pain signal without merging task kinds.
     // Used by target selector for ranking bias and context enrichment.
     recentPainContext?: RecentPainContext;
+
+    /** Trajectory pain_events row ID — set when pain flag includes pain_event_id */
+    painEventId?: number;
 }
 
 // ── Queue Migration (extracted to queue-migration.ts) ────────────────────────
@@ -305,6 +308,7 @@ export function hasEquivalentPromotedRule(dictionary: { getAllRules(): Record<st
 interface ParsedPainValues {
     score: number; source: string; reason: string; preview: string;
     traceId: string; sessionId: string; agentId: string;
+    painEventId?: number;
 }
 
  
@@ -352,6 +356,7 @@ async function doEnqueuePainTask(
             status: 'pending', session_id: v.sessionId || undefined,
             agent_id: v.agentId || undefined, traceId: effectiveTraceId,
             retryCount: 0, maxRetries: 3,
+            painEventId: v.painEventId,
         });
 
         saveEvolutionQueue(queuePath, queue);
@@ -400,6 +405,8 @@ async function checkPainFlag(wctx: WorkspaceContext, logger: PluginLogger): Prom
             const traceId = contract.data.trace_id ?? '';
             const sessionId = contract.data.session_id ?? '';
             const agentId = contract.data.agent_id ?? '';
+            const painEventIdRaw = contract.data.pain_event_id;
+            const painEventId = painEventIdRaw ? parseInt(painEventIdRaw, 10) : undefined;
 
             result.exists = true;
             result.score = score;
@@ -414,7 +421,7 @@ async function checkPainFlag(wctx: WorkspaceContext, logger: PluginLogger): Prom
 
             if (logger) logger.info(`[PD:EvolutionWorker] Detected pain flag (score: ${score}, source: ${source}). Enqueueing evolution task.`);
             return doEnqueuePainTask(wctx, logger, painFlagPath, result, {
-                score, source, reason, preview, traceId, sessionId, agentId,
+                score, source, reason, preview, traceId, sessionId, agentId, painEventId,
             });
         }
 
@@ -470,6 +477,7 @@ async function checkPainFlag(wctx: WorkspaceContext, logger: PluginLogger): Prom
                     preview: jsonPreview, traceId: '',
                     sessionId: jsonPain.session_id || '',
                     agentId: jsonPain.agent_id || '',
+                    painEventId: jsonPain.pain_event_id ? parseInt(jsonPain.pain_event_id, 10) : undefined,
                 });
             }
         } catch { /* Not JSON — fall through to KV/Markdown parsing */ }
@@ -492,6 +500,7 @@ async function checkPainFlag(wctx: WorkspaceContext, logger: PluginLogger): Prom
         let traceId = '';
         let sessionId = '';
         let agentId = '';
+        let painEventId: number | undefined;
 
         for (const line of lines) {
             // KV format: "key: value"
@@ -503,6 +512,10 @@ async function checkPainFlag(wctx: WorkspaceContext, logger: PluginLogger): Prom
             if (line.startsWith('trace_id:')) traceId = line.split(':', 2)[1].trim();
             if (line.startsWith('session_id:')) sessionId = line.slice('session_id:'.length).trim();
             if (line.startsWith('agent_id:')) agentId = line.slice('agent_id:'.length).trim();
+            if (line.startsWith('pain_event_id:')) {
+                const raw = line.slice('pain_event_id:'.length).trim();
+                painEventId = parseInt(raw, 10) || undefined;
+            }
 
             // Key=Value fallback format: "key=value" (pain skill manual output)
             // Handles both uppercase (Source=X) and lowercase (source=x) variants
@@ -544,7 +557,7 @@ async function checkPainFlag(wctx: WorkspaceContext, logger: PluginLogger): Prom
 
         return doEnqueuePainTask(wctx, logger, painFlagPath, result, {
             score, source, reason, preview,
-            traceId, sessionId, agentId,
+            traceId, sessionId, agentId, painEventId,
         });
 
     } catch (err) {

package/src/service/keyword-optimization-service.ts

@@ -31,12 +31,13 @@ export class KeywordOptimizationService {
   applyResult(result: CorrectionObserverResult): void {
     const learner = CorrectionCueLearner.get(this.stateDir);
 
-    if (!result.updated || !result.updates) {
+    const updates = result.updates ?? {};
+    if (!result.updated || Object.keys(updates).length === 0) {
       this.logger?.info?.('[KeywordOptimizationService] No updates to apply');
       return;
     }
 
-    for (const [term, update] of Object.entries(result.updates)) {
+    for (const [term, update] of Object.entries(updates)) {
       try {
         switch (update.action) {
           case 'add': {
@@ -74,6 +75,27 @@ export class KeywordOptimizationService {
         this.logger?.warn?.(`[KeywordOptimizationService] ${update.action.toUpperCase()} failed for term="${term}": ${String(opErr)}`);
       }
     }
+
+    // H-1: Record confirmed false positives — terms where correctionDetected fired
+    // but trajectory analysis shows user wasn't actually expressing frustration.
+    if (result.fpAnalysisStatus === 'completed' && result.fpTerms && result.fpTerms.length > 0) {
+      // Normalize: trim, lowercase, dedupe, sanity cap
+      const MAX_FP_TERMS = 20;
+      const normalizedFpTerms = [...new Set(
+        result.fpTerms
+          .map(t => t.trim().toLowerCase())
+          .filter(t => t.length > 0)
+      )].slice(0, MAX_FP_TERMS);
+
+      for (const term of normalizedFpTerms) {
+        try {
+          learner.recordFalsePositive(term);
+          this.logger?.info?.(`[KeywordOptimizationService] FP recorded for term="${term}" (weight x0.8)`);
+        } catch (fpErr) {
+          this.logger?.warn?.(`[KeywordOptimizationService} recordFalsePositive failed for term="${term}": ${String(fpErr)}`);
+        }
+      }
+    }
   }
 
   /**

package/src/service/queue-io.ts

@@ -68,6 +68,8 @@ export interface RecentPainContext {
         reason: string;
         timestamp: string;
         sessionId: string;
+        /** Trajectory pain_events row ID — set when pain flag includes pain_event_id */
+        painEventId?: number;
     } | null;
     recentPainCount: number;
     recentMaxPainScore: number;
@@ -150,10 +152,12 @@ export function readRecentPainContext(wctx: WorkspaceContext): RecentPainContext
         const reason = contract.data.reason ?? '';
         const timestamp = contract.data.time ?? '';
         const sessionId = contract.data.session_id ?? '';
+        const painEventIdRaw = contract.data.pain_event_id;
+        const painEventId = painEventIdRaw ? parseInt(painEventIdRaw, 10) : undefined;
 
         if (score > 0) {
             return {
-                mostRecent: { score, source, reason, timestamp, sessionId },
+                mostRecent: { score, source, reason, timestamp, sessionId, painEventId },
                 recentPainCount: 1,
                 recentMaxPainScore: score,
             };

package/src/service/subagent-workflow/correction-observer-types.ts

@@ -55,6 +55,19 @@ export interface CorrectionObserverResult {
     falsePositiveRate?: number;
     reasoning: string;
   }>;
+  /**
+   * Terms identified as false positives — user message didn't actually indicate
+   * frustration/correction despite correctionDetected firing for these terms.
+   * CORR-10 / H-1: Calling recordFalsePositive() decays weight by x0.8 per term.
+   * Only meaningful when fpAnalysisStatus='completed'.
+   */
+  fpTerms?: string[];
+  /**
+   * Whether FP analysis was performed. 'skipped' means the LLM did not run
+   * trajectory analysis (e.g., trajectory was empty). 'completed' means fpTerms
+   * contains the LLM's FP findings (may be empty if no FPs were found).
+   */
+  fpAnalysisStatus?: 'completed' | 'skipped';
   /** Human-readable summary */
   summary: string;
 }

package/src/service/subagent-workflow/correction-observer-workflow-manager.ts

@@ -115,6 +115,7 @@ export const correctionObserverWorkflowSpec: SubagentWorkflowSpec<CorrectionObse
             '## TASK',
             'Analyze the current correction keyword store and recent user messages.',
             'Recommend ADD/UPDATE/REMOVE actions to improve correction cue accuracy.',
+            'Also identify terms that triggered false positives (correctionDetected fired but user message doesn\'t indicate actual frustration).',
             '',
             '## Current Keyword Store (' + keywordStoreSummary.totalKeywords + ' terms):',
             termsList,
@@ -129,11 +130,14 @@ export const correctionObserverWorkflowSpec: SubagentWorkflowSpec<CorrectionObse
             '- ADD: If a correction pattern is detected in messages but not in store',
             '- UPDATE: If a term\'s weight should change based on TP/FP ratio',
             '- REMOVE: If a term has 0 hits after many uses AND high false positive rate (>0.3)',
+            '- FALSE POSITIVE: If a term appears in trajectory but the user message doesn\'t actually express frustration (e.g., user said "wrong" but in a factual context, not emotional)',
+            '- fpAnalysisStatus: set to "completed" if you performed trajectory analysis (even if no FPs found), or "skipped" if trajectory was empty/unavailable',
             '- Keep reasoning concise (max 100 chars)',
             '- Weight range: 0.1-0.9',
             '',
             'Return strict JSON (no markdown):',
-            '{"updated": boolean, "updates": {...}, "summary": string}',
+            '{"updated": boolean, "updates": {...}, "fpTerms": ["term1", ...], "fpAnalysisStatus": "completed" | "skipped", "summary": string}',
+            'Note: fpTerms is optional — only include if you identified clear false positives.',
         ].join('\n');
     },
 

package/tests/core/model-deployment-registry.test.ts

@@ -378,8 +378,15 @@ describe('ModelDeploymentRegistry getDeployment / listDeployments', () => {
 
     const deployments = listDeployments(tmpDir);
     expect(deployments).toHaveLength(2);
-    // Most recently updated is last in the list (sorted asc by updatedAt in memory)
-    expect(deployments[0].workerProfile).toBe('local-editor'); // bound second
+    // Verify sort order is descending by updatedAt (most recent first)
+    const [first, second] = deployments;
+    const firstUpdated = new Date(first.updatedAt).getTime();
+    const secondUpdated = new Date(second.updatedAt).getTime();
+    expect(firstUpdated).toBeGreaterThanOrEqual(secondUpdated);
+    // Also verify both expected profiles are present (order-independent)
+    const profiles = deployments.map(d => d.workerProfile);
+    expect(profiles).toContain('local-reader');
+    expect(profiles).toContain('local-editor');
   });
 
   it('listDeployments filters by workerProfile', () => {