principles-disciple 1.34.0 → 1.34.2

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

@@ -0,0 +1,140 @@
+/**
+ * Keyword Optimization Service
+ *
+ * Applies LLM optimization results (ADD/UPDATE/REMOVE mutations) to the
+ * correction keyword store. Called by evolution-worker.ts after the
+ * keyword_optimization workflow completes.
+ */
+
+import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
+import type { CorrectionObserverResult } from './correction-observer-types.js';
+import type { PluginLogger } from '../openclaw-sdk.js';
+import { TrajectoryRegistry } from '../core/trajectory.js';
+
+/**
+ * Applies CorrectionObserverResult mutations to the keyword store.
+ * - ADD: calls learner.add() with new keyword
+ * - UPDATE: updates weight on existing keyword
+ * - REMOVE: removes keyword from store
+ */
+export class KeywordOptimizationService {
+  private readonly stateDir: string;
+  private readonly workspaceDir: string;
+  private readonly logger: PluginLogger;
+
+  constructor(stateDir: string, workspaceDir: string, logger: PluginLogger) {
+    this.stateDir = stateDir;
+    this.workspaceDir = workspaceDir;
+    this.logger = logger;
+  }
+
+  applyResult(result: CorrectionObserverResult): void {
+    const learner = CorrectionCueLearner.get(this.stateDir);
+
+    if (!result.updated || !result.updates) {
+      this.logger?.info?.('[KeywordOptimizationService] No updates to apply');
+      return;
+    }
+
+    for (const [term, update] of Object.entries(result.updates)) {
+      try {
+        switch (update.action) {
+          case 'add': {
+            const weight = update.weight !== undefined
+              ? Math.max(0.1, Math.min(0.9, update.weight))
+              : 0.5;
+            learner.add({ term, weight, source: 'llm' });
+            this.logger?.info?.(`[KeywordOptimizationService] ADD term="${term}" weight=${weight}`);
+            break;
+          }
+          case 'update': {
+            if (update.weight !== undefined) {
+              learner.updateWeight(term, update.weight);
+              this.logger?.info?.(`[KeywordOptimizationService] UPDATE term="${term}" weight=${update.weight}`);
+            }
+            break;
+          }
+          case 'remove': {
+            learner.remove(term);
+            this.logger?.info?.(`[KeywordOptimizationService] REMOVE term="${term}"`);
+            break;
+          }
+        }
+      } catch (opErr) {
+        // Log and skip individual operation failures — don't fail the whole batch
+        this.logger?.warn?.(`[KeywordOptimizationService] ${update.action.toUpperCase()} failed for term="${term}": ${String(opErr)}`);
+      }
+    }
+  }
+
+  /**
+   * Builds trajectory history for payload:
+   * - Calls TrajectoryDatabase.listUserTurnsForSession() for recent sessions
+   * - Filters to turns where correctionDetected=true
+   * - Returns last 50 correction events
+   */
+  async buildTrajectoryHistory(sessionIds: string[]): Promise<TrajectoryHistoryEntry[]> {
+    const history: TrajectoryHistoryEntry[] = [];
+    const db = TrajectoryRegistry.get(this.workspaceDir);
+
+    for (const sessionId of sessionIds.slice(0, 10)) { // Last 10 sessions
+      try {
+        const turns = db.listUserTurnsForSession(sessionId);
+        for (const turn of turns) {
+          if (turn.correctionDetected) {
+            history.push({
+              sessionId,
+              timestamp: turn.createdAt,
+              term: turn.correctionCue ?? 'unknown',
+              userMessage: turn.correctionCue ?? '',
+            });
+          }
+          if (history.length >= 50) break; // Cap at 50 events
+        }
+      } catch (dbErr) {
+        // Skip individual session DB errors — try remaining sessions
+        this.logger?.warn?.(`[KeywordOptimizationService] Failed to read trajectory for session ${sessionId}: ${String(dbErr)}`);
+      }
+      if (history.length >= 50) break;
+    }
+
+    return history;
+  }
+
+  // ── Singleton factory ───────────────────────────────────────────────────
+
+  private static _instance: KeywordOptimizationService | null = null;
+  private static _lastStateDir: string | null = null;
+  private static _lastWorkspaceDir: string | null = null;
+
+  static get(stateDir: string, workspaceDir: string, logger: PluginLogger): KeywordOptimizationService {
+    if (!KeywordOptimizationService._instance || KeywordOptimizationService._lastStateDir !== stateDir || KeywordOptimizationService._lastWorkspaceDir !== workspaceDir) {
+      KeywordOptimizationService._instance = new KeywordOptimizationService(stateDir, workspaceDir, logger);
+      KeywordOptimizationService._lastStateDir = stateDir;
+      KeywordOptimizationService._lastWorkspaceDir = workspaceDir;
+    }
+    return KeywordOptimizationService._instance;
+  }
+
+  static reset(): void {
+    KeywordOptimizationService._instance = null;
+    KeywordOptimizationService._lastStateDir = null;
+    KeywordOptimizationService._lastWorkspaceDir = null;
+  }
+}
+
+// ── Types ─────────────────────────────────────────────────────────────────
+
+/**
+ * Internal type mirroring the trajectoryHistory field in CorrectionObserverPayload.
+ * Exported here so buildTrajectoryHistory can reference it without a circular import.
+ */
+export type TrajectoryHistoryEntry = {
+  sessionId: string;
+  timestamp: string;
+  term: string;
+  userMessage: string;
+};
+
+/** Re-export CorrectionObserverPayload for convenience */
+export type { CorrectionObserverPayload } from './correction-observer-types.js';

package/src/service/nocturnal-runtime.ts

@@ -321,7 +321,7 @@ export function checkWorkspaceIdle(
     }
 
      
-    // eslint-disable-next-line @typescript-eslint/init-declarations
+     
     let reason: string;
     if (mostRecentActivityAt === 0) {
         reason = 'No active sessions found — workspace is idle';
@@ -390,7 +390,7 @@ export function checkCooldown(
         if (cooldownEnd > now) {
             globalCooldownActive = true;
             globalCooldownRemainingMs = cooldownEnd - now;
-            // eslint-disable-next-line @typescript-eslint/prefer-destructuring
+             
             globalCooldownUntil = state.globalCooldownUntil;  
         }
     }
@@ -430,6 +430,33 @@ export function checkCooldown(
     };
 }
 
+/**
+ * Records a cooldown event for quota tracking (keyword_optimization etc.).
+ * Adds a timestamp to recentRunTimestamps and prunes entries outside the window.
+ * Does NOT set globalCooldownUntil — callers that need it should call recordRunStart.
+ *
+ * @param stateDir - State directory
+ * @param quotaWindowMs - Window size in ms (default: 24 hours)
+ */
+export async function recordCooldown(
+    stateDir: string,
+    quotaWindowMs: number = 24 * 60 * 60 * 1000
+): Promise<void> {
+    const state = await readState(stateDir);
+    const now = new Date().toISOString();
+
+    state.recentRunTimestamps.push(now);
+
+    // Prune old timestamps outside the window
+    const windowStart = Date.now() - quotaWindowMs;
+    state.recentRunTimestamps = state.recentRunTimestamps
+        .map(ts => new Date(ts).getTime())
+        .filter(ts => ts > windowStart)
+        .map(ts => new Date(ts).toISOString());
+
+    await writeState(stateDir, state);
+}
+
 /**
  * Record that a nocturnal run has started.
  * Updates global cooldown and quota tracking.
@@ -562,7 +589,7 @@ export interface PreflightCheckResult {
  * @param idleCheckOverride - Optional override for idle check result (for testing)
  */
  
-    // eslint-disable-next-line @typescript-eslint/max-params -- complexity 12, refactor candidate
+     
 export function checkPreflight(
     workspaceDir: string,
     stateDir: string,

package/src/service/nocturnal-service.ts

@@ -103,6 +103,15 @@ import { getPrincipleState, setPrincipleState } from '../core/principle-training
 import type { Implementation } from '../types/principle-tree-schema.js';
 import { validateNocturnalSnapshotIngress } from '../core/nocturnal-snapshot-contract.js';
 
+/**
+ * Atomic file write — write to temp then rename to prevent partial writes on crash.
+ */
+function atomicWriteFileSync(filePath: string, data: string): void {
+  const tmpPath = filePath + '.tmp';
+  fs.writeFileSync(tmpPath, data, 'utf8');
+  fs.renameSync(tmpPath, filePath);
+}
+
 // ---------------------------------------------------------------------------
 // #251: Sync trainingStore sample counts after registration
 // ---------------------------------------------------------------------------
@@ -385,10 +394,7 @@ function persistArtifact(
     fs.mkdirSync(dir, { recursive: true });
   }
 
-  // Atomic write: temp file + rename prevents corruption on crash
-  const tmpPath = artifactPath + '.tmp';
-  fs.writeFileSync(tmpPath, JSON.stringify(sampleRecord, null, 2), 'utf8');
-  fs.renameSync(tmpPath, artifactPath);
+  atomicWriteFileSync(artifactPath, JSON.stringify(sampleRecord, null, 2));
   return artifactPath;
 }
 

package/tests/service/keyword-optimization-service.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { CorrectionObserverResult } from '../../src/service/subagent-workflow/correction-observer-types.js';
+
+// Shared mock objects so tests can mutate them after vi.mock runs
+const mockLearner = { add: vi.fn(), updateWeight: vi.fn(), remove: vi.fn(), getStore: vi.fn(() => ({ keywords: [] })) };
+const mockDb = { listUserTurnsForSession: vi.fn(() => []), listRecentSessions: vi.fn(() => []) };
+
+// Mock the CorrectionCueLearner dependency
+vi.mock('../../src/core/correction-cue-learner.js', () => ({
+  CorrectionCueLearner: { get: vi.fn(() => mockLearner) },
+}));
+
+// Mock the trajectory dependency — return shared mock objects so tests can configure them
+vi.mock('../../src/core/trajectory.js', () => ({
+  TrajectoryRegistry: { get: vi.fn(() => mockDb) },
+}));
+
+import { KeywordOptimizationService } from '../../src/service/keyword-optimization-service.js';
+
+describe('KeywordOptimizationService', () => {
+  let service: KeywordOptimizationService;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    KeywordOptimizationService.reset();
+    service = KeywordOptimizationService.get('/tmp/test-state', '/tmp/test-state', {
+      info: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    } as any);
+  });
+
+  describe('applyResult()', () => {
+    it('ADD: calls learner.add() with new keyword and weight', () => {
+      const result: CorrectionObserverResult = {
+        updated: true,
+        updates: { 'test-term': { action: 'add', weight: 0.6, reasoning: 'test' } },
+      } as any;
+      service.applyResult(result);
+      expect(mockLearner.add).toHaveBeenCalledWith({ term: 'test-term', weight: 0.6, source: 'llm' });
+    });
+
+    it('UPDATE: calls learner.updateWeight() with clamped weight', () => {
+      const result: CorrectionObserverResult = {
+        updated: true,
+        updates: { 'existing-term': { action: 'update', weight: 0.85, reasoning: 'test' } },
+      } as any;
+      service.applyResult(result);
+      expect(mockLearner.updateWeight).toHaveBeenCalledWith('existing-term', 0.85);
+    });
+
+    it('REMOVE: calls learner.remove() with term', () => {
+      const result: CorrectionObserverResult = {
+        updated: true,
+        updates: { 'old-term': { action: 'remove', reasoning: 'test' } },
+      } as any;
+      service.applyResult(result);
+      expect(mockLearner.remove).toHaveBeenCalledWith('old-term');
+    });
+
+    it('skips when result.updated is false', () => {
+      const result: CorrectionObserverResult = { updated: false, updates: {}, summary: '' } as any;
+      service.applyResult(result);
+      expect(mockLearner.add).not.toHaveBeenCalled();
+    });
+
+    it('skips when result.updates is undefined', () => {
+      const result: CorrectionObserverResult = { updated: true, updates: undefined as any, summary: '' };
+      service.applyResult(result);
+      expect(mockLearner.add).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('updateWeight() clamp behavior', () => {
+    it('clamps weight to 0.1-0.9 range via CorrectionCueLearner', () => {
+      const result: CorrectionObserverResult = {
+        updated: true,
+        updates: { 'existing-term': { action: 'update', weight: 1.5, reasoning: 'test' } },
+      } as any;
+      service.applyResult(result);
+      expect(mockLearner.updateWeight).toHaveBeenCalledWith('existing-term', 1.5);
+    });
+  });
+
+  describe('buildTrajectoryHistory()', () => {
+    it('returns empty array when no sessions exist', async () => {
+      const history = await service.buildTrajectoryHistory([]);
+      expect(history).toEqual([]);
+    });
+
+    it('filters to correctionDetected=true turns only', async () => {
+      mockDb.listUserTurnsForSession = vi.fn(() => [
+        { id: 1, turnIndex: 0, correctionDetected: false, correctionCue: null, createdAt: '2024-01-01T00:00:00Z' },
+        { id: 2, turnIndex: 1, correctionDetected: true, correctionCue: 'wrong', createdAt: '2024-01-01T00:01:00Z' },
+        { id: 3, turnIndex: 2, correctionDetected: true, correctionCue: 'error', createdAt: '2024-01-01T00:02:00Z' },
+      ] as any);
+
+      const history = await service.buildTrajectoryHistory(['session-1']);
+
+      expect(history).toHaveLength(2);
+      expect(history[0].term).toBe('wrong');
+      expect(history[1].term).toBe('error');
+    });
+
+    it('caps at 50 events', async () => {
+      const manyTurns = Array.from({ length: 60 }, (_, i) => ({
+        id: i,
+        turnIndex: i,
+        correctionDetected: true,
+        correctionCue: `term-${i}`,
+        createdAt: new Date(i * 1000).toISOString(),
+      }));
+      mockDb.listUserTurnsForSession = vi.fn(() => manyTurns as any);
+
+      const history = await service.buildTrajectoryHistory(['session-1']);
+
+      expect(history).toHaveLength(50);
+    });
+  });
+});