principles-disciple 1.26.0 → 1.27.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.26.0",
+  "version": "1.27.0",
   "skills": [
     "./skills"
   ],
@@ -76,8 +76,8 @@
     }
   },
   "buildFingerprint": {
-    "gitSha": "6c8a61389b46",
-    "bundleMd5": "2803099a748622cc50286ad4c55be551",
-    "builtAt": "2026-04-13T02:02:51.311Z"
+    "gitSha": "9037c29faf9a",
+    "bundleMd5": "e7e9ebf7f67083f72f8f4328314d5670",
+    "builtAt": "2026-04-13T06:10:29.622Z"
   }
 }

package/package.json

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

package/src/core/trajectory.ts

@@ -961,6 +961,17 @@ export class TrajectoryDatabase {
       throw new SampleNotFoundError(`${sampleId} (after update)`);
     }
 
+    // #Phase2b: Emit pain event for rejected corrections
+    if (status === 'rejected') {
+      this.recordCorrectionRejectedPain({
+        session_id: record.session_id,
+        quality_score: record.quality_score,
+        diff_excerpt: record.diff_excerpt,
+        principle_ids_json: record.principle_ids_json,
+        created_at: record.created_at,
+      });
+    }
+
     return {
       sampleId: String(record.sample_id),
       sessionId: String(record.session_id),
@@ -977,6 +988,43 @@ export class TrajectoryDatabase {
     };
   }
 
+  /**
+   * When a correction sample is rejected, emit a pain event to the trajectory.
+   * This feeds rejected corrections into the nocturnal pipeline as a high-fidelity
+   * violation signal (human-verified, unlike heuristic pain detection).
+   */
+  private recordCorrectionRejectedPain(record: {
+    session_id: unknown;
+    quality_score: unknown;
+    diff_excerpt: unknown;
+    principle_ids_json: unknown;
+    created_at: unknown;
+  }): void {
+    const sessionId = String(record.session_id);
+    const qualityScore = Number(record.quality_score);
+    const diffExcerpt = String(record.diff_excerpt ?? '');
+    const principleIds = String(record.principle_ids_json ?? '[]');
+    // quality_score (0-100) from correction sample → pain score (0-100), clamped
+    const painScore = Math.max(0, Math.min(100, Math.round(Number(qualityScore) || 0)));
+    const reason = `Correction rejected (quality ${qualityScore.toFixed(2)}). Principles: ${principleIds}${diffExcerpt ? ` — ${diffExcerpt.slice(0, 120)}` : ''}`;
+
+    try {
+      this.recordPainEvent({
+        sessionId,
+        source: 'correction_rejected',
+        score: painScore,
+        reason,
+        severity: painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild',
+        origin: 'system_infer',
+        text: diffExcerpt || undefined,
+        createdAt: String(record.created_at),
+      });
+    } catch (err) {
+      // Non-fatal: pain event recording should not break the review flow
+      console.warn(`[Trajectory] Failed to record correction_rejected pain event: ${String(err)}`);
+    }
+  }
+
   /**
    * Export correction samples to JSONL file.
    *
@@ -1496,6 +1544,11 @@ export class TrajectoryDatabase {
     `).get(sessionId) as Record<string, unknown> | undefined;
     if (!correctionTurn || !correctionTurn.references_assistant_turn_id) return;
 
+    // #Phase2b-fix: Tool failure is NOT required for correction samples.
+    // User corrections are the highest-fidelity signal — they indicate the agent
+    // said or did something wrong, regardless of whether tool calls succeeded.
+    // Requiring tool failure excluded the most valuable cases: "agent did something
+    // that technically worked but violated a principle or was logically wrong."
     const failedCall = this.db.prepare(`
       SELECT id, tool_name, error_type, error_message
       FROM tool_calls
@@ -1503,26 +1556,37 @@ export class TrajectoryDatabase {
       ORDER BY id DESC
       LIMIT 1
     `).get(sessionId) as Record<string, unknown> | undefined;
-    if (!failedCall) return;
 
-    const successfulCalls = this.db.prepare(`
-      SELECT id, tool_name
+    const recentCalls = this.db.prepare(`
+      SELECT id, tool_name, outcome
       FROM tool_calls
-      WHERE session_id = ? AND outcome = 'success'
+      WHERE session_id = ?
       ORDER BY id DESC
-      LIMIT 3
+      LIMIT 5
     `).all(sessionId) as Record<string, unknown>[];
-    if (successfulCalls.length === 0) return;
 
-    const sampleId = `sample_${crypto.createHash('md5').update(`${sessionId}:${correctionTurn.id}:${successfulCalls[0].id}`).digest('hex').slice(0, 12)}`;
+    const successfulCalls = recentCalls.filter(c => c.outcome === 'success');
+
+    // Generate sample ID from correction turn + first recent call (or correction id if no calls)
+    const refForHash = successfulCalls[0]?.id ?? correctionTurn.id;
+    const sampleId = `sample_${crypto.createHash('md5').update(`${sessionId}:${correctionTurn.id}:${refForHash}`).digest('hex').slice(0, 12)}`;
     const userRawText = this.restoreRawText(correctionTurn.raw_text as string | null, correctionTurn.blob_ref as string | null);
+
+    // Quality scoring: correction cue is always valuable
+    // Tool failure adds context (20pts), successful calls add context (up to 15pts)
+    // Pure conversation corrections still score 55-75 (high enough to review)
     const qualityScore = [
       correctionTurn.references_assistant_turn_id ? 35 : 0,
       correctionTurn.correction_cue ? 20 : 0,
       failedCall ? 20 : 0,
-      successfulCalls.length > 0 ? 25 : 0,
+      Math.min(successfulCalls.length, 3) * 5,
     ].reduce((sum, value) => sum + value, 0);
 
+    // Diff excerpt: prefer user correction text, fallback to error info, fallback to cue
+    const diffText = userRawText
+      || (failedCall ? String(failedCall.error_message ?? failedCall.error_type ?? failedCall.tool_name) : '')
+      || String(correctionTurn.correction_cue ?? 'user correction');
+
     this.withWrite(() => {
       this.db.prepare(`
         INSERT OR IGNORE INTO correction_samples (
@@ -1535,8 +1599,8 @@ export class TrajectoryDatabase {
         sessionId,
         Number(correctionTurn.references_assistant_turn_id),
         Number(correctionTurn.id),
-        safeJson(successfulCalls.map((call) => ({ id: call.id, toolName: call.tool_name }))),
-        summarizeForDiff(userRawText || String(failedCall.error_message ?? failedCall.error_type ?? failedCall.tool_name)),
+        safeJson(successfulCalls.map((call) => ({ id: call.id, toolName: call.tool_name, outcome: call.outcome }))),
+        summarizeForDiff(diffText),
         '[]',
         qualityScore,
         nowIso(),

package/tests/core/trajectory-correction-pain.test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { TrajectoryDatabase } from '../../src/core/trajectory.js';
+
+function safeRmDir(dir: string): void {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+}
+
+describe('Trajectory — correction_rejected pain event (Phase 2b)', () => {
+  let workspaceDir: string;
+  let trajectory: TrajectoryDatabase;
+
+  beforeEach(() => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-correction-pain-'));
+    trajectory = new TrajectoryDatabase({ workspaceDir });
+  });
+
+  afterEach(() => {
+    trajectory?.dispose();
+    safeRmDir(workspaceDir);
+  });
+
+  it('emits a pain event when a correction sample is rejected', async () => {
+    // Step 1: Create a session
+    trajectory.recordSession({
+      sessionId: 'test-session-001',
+      startedAt: new Date().toISOString(),
+    });
+
+    // Step 2: Create an assistant turn (to be referenced)
+    const assistantTurnId = trajectory.recordAssistantTurn({
+      sessionId: 'test-session-001',
+      turnIndex: 0,
+      rawText: 'Here is some code I wrote',
+      createdAt: new Date().toISOString(),
+    });
+
+    // Step 3: Create a user turn with correction_cue (triggers auto-creation)
+    trajectory.recordUserTurn({
+      sessionId: 'test-session-001',
+      turnIndex: 1,
+      rawText: 'This is wrong. Fix it properly.',
+      correctionDetected: true,
+      correctionCue: 'This is wrong. Fix it properly.',
+      referencesAssistantTurnId: assistantTurnId,
+      createdAt: new Date().toISOString(),
+    });
+
+    // Wait for async sample creation
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    // Verify sample was created as pending
+    const pendingSamples = trajectory.listCorrectionSamples('pending');
+    expect(pendingSamples.length).toBe(1);
+    const sampleId = pendingSamples[0].sampleId;
+
+    // Verify no pain events yet
+    const painEventsBefore = trajectory.listPainEventsForSession('test-session-001');
+    expect(painEventsBefore.length).toBe(0);
+
+    // Step 4: Review as rejected
+    trajectory.reviewCorrectionSample(sampleId, 'rejected', 'Does not match requirements');
+
+    // Step 5: Verify pain event was created
+    const painEventsAfter = trajectory.listPainEventsForSession('test-session-001');
+    expect(painEventsAfter.length).toBe(1);
+
+    const painEvent = painEventsAfter[0];
+    expect(painEvent.source).toBe('correction_rejected');
+    expect(painEvent.reason).toContain('Correction rejected');
+    expect(painEvent.origin).toBe('system_infer');
+  });
+
+  it('does NOT emit a pain event when a correction sample is approved', async () => {
+    // Setup: session + assistant turn + user correction turn
+    trajectory.recordSession({
+      sessionId: 'test-session-002',
+      startedAt: new Date().toISOString(),
+    });
+    const assistantTurnId = trajectory.recordAssistantTurn({
+      sessionId: 'test-session-002',
+      turnIndex: 0,
+      rawText: 'Here is some code',
+      createdAt: new Date().toISOString(),
+    });
+    trajectory.recordUserTurn({
+      sessionId: 'test-session-002',
+      turnIndex: 1,
+      rawText: 'This needs work',
+      correctionDetected: true,
+      correctionCue: 'This needs work',
+      referencesAssistantTurnId: assistantTurnId,
+      createdAt: new Date().toISOString(),
+    });
+
+    // Wait for async sample creation
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    // Get pending sample
+    const pendingSamples = trajectory.listCorrectionSamples('pending');
+    expect(pendingSamples.length).toBe(1);
+    const sampleId = pendingSamples[0].sampleId;
+
+    // Review as approved - should NOT trigger pain event
+    trajectory.reviewCorrectionSample(sampleId, 'approved', 'Looks good');
+
+    // Verify NO pain event was created (approved != rejected)
+    const painEvents = trajectory.listPainEventsForSession('test-session-002');
+    expect(painEvents.length).toBe(0);
+  });
+
+  it('maps quality_score to pain_score correctly (0-100 range)', async () => {
+    // Setup: with quality score components
+    trajectory.recordSession({
+      sessionId: 'test-session-003',
+      startedAt: new Date().toISOString(),
+    });
+    const assistantTurnId = trajectory.recordAssistantTurn({
+      sessionId: 'test-session-003',
+      turnIndex: 0,
+      rawText: 'Code here',
+      createdAt: new Date().toISOString(),
+    });
+
+    // Create user turn with correction_cue (adds 20 points)
+    trajectory.recordUserTurn({
+      sessionId: 'test-session-003',
+      turnIndex: 1,
+      rawText: 'Wrong approach. Try a different algorithm.',
+      correctionDetected: true,
+      correctionCue: 'Wrong approach. Try a different algorithm.',
+      referencesAssistantTurnId: assistantTurnId,
+      createdAt: new Date().toISOString(),
+    });
+
+    // Add a failed tool call (adds 20 points)
+    trajectory.recordToolCall({
+      sessionId: 'test-session-003',
+      turnIndex: 2,
+      toolName: 'write',
+      toolCallIndex: 0,
+      paramsJson: { path: '/tmp/test.txt', content: 'test' },
+      outcome: 'failure',
+      errorMessage: 'Permission denied',
+      errorType: 'PermissionError',
+      createdAt: new Date().toISOString(),
+    });
+
+    // Add successful calls (adds 25 points)
+    trajectory.recordToolCall({
+      sessionId: 'test-session-003',
+      turnIndex: 3,
+      toolName: 'read',
+      toolCallIndex: 1,
+      paramsJson: { path: '/tmp/test.txt' },
+      outcome: 'success',
+      resultJson: { content: 'file content' },
+      createdAt: new Date().toISOString(),
+    });
+
+    // Wait for async sample creation
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    // Get pending sample (quality_score ~65: 20 + 20 + 25)
+    const pendingSamples = trajectory.listCorrectionSamples('pending');
+    expect(pendingSamples.length).toBe(1);
+    const sampleId = pendingSamples[0].sampleId;
+
+    // Review as rejected
+    trajectory.reviewCorrectionSample(sampleId, 'rejected', 'Test rejection');
+
+    // Verify pain score is clamped to 0-100
+    const painEvents = trajectory.listPainEventsForSession('test-session-003');
+    expect(painEvents.length).toBe(1);
+    expect(painEvents[0].score).toBeGreaterThanOrEqual(0);
+    expect(painEvents[0].score).toBeLessThanOrEqual(100);
+  });
+});