principles-disciple 1.40.0 → 1.42.0

package/src/commands/pain.ts

@@ -80,6 +80,14 @@ function formatEmpathyCard(stats: EmpathyEventStats, range: string, isZh: boolea
     return lines.join('\n');
 }
 
+/**
+ * Extended context interface that includes sessionId injected by the plugin framework.
+ * PluginCommandContext does not include sessionId in its type definition.
+ */
+interface SessionAwareCommandContext extends PluginCommandContext {
+  sessionId: string;
+}
+
 /**
  * Handles the /pd-status command
  */
@@ -89,15 +97,14 @@ export function handlePainCommand(ctx: PluginCommandContext): PluginCommandResul
     const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
     const lang = (ctx.config?.language as string) || 'en';
     const isZh = lang === 'zh';
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Reason: sessionId injected by OpenClaw plugin framework - type not available in PluginCommandContext
-    const {sessionId} = (ctx as any);
+    const { sessionId } = ctx as SessionAwareCommandContext;
 
     const args = (ctx.args || '').trim();
 
     // Handle empathy subcommand
     if (args.startsWith('empathy')) {
          
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+         
         return handleEmpathySubcommand(wctx, args, sessionId, isZh);
     }
 
@@ -138,7 +145,7 @@ export function handlePainCommand(ctx: PluginCommandContext): PluginCommandResul
     
     // Determine health status based on GFI
      
-    // eslint-disable-next-line @typescript-eslint/init-declarations
+     
     let healthLabel: string;
     let suggestionText = '';
 
@@ -218,7 +225,7 @@ export function handlePainCommand(ctx: PluginCommandContext): PluginCommandResul
  * Handle /pd-status empathy subcommand
  */
  
-    // eslint-disable-next-line @typescript-eslint/max-params -- complexity 13, refactor candidate
+     
 function handleEmpathySubcommand(
     wctx: WorkspaceContext,
     args: string,

package/src/commands/promote-impl.ts

@@ -28,7 +28,7 @@ import {
 } from '../core/principle-tree-ledger.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
-import type { Implementation } from '../types/principle-tree-schema.js';
+import type { Implementation, ImplementationLifecycleState } from '../types/principle-tree-schema.js';
 import { withLock } from '../utils/file-lock.js';
 import { atomicWriteFileSync } from '../utils/io.js';
 
@@ -37,16 +37,23 @@ function getAllImplementations(stateDir: string): Implementation[] {
   return Object.values(ledger.tree.implementations);
 }
 
+/**
+ * Type predicate: true if impl has lifecycleState of 'candidate' or 'disabled'.
+ * The ledger adds lifecycleState at runtime beyond what's in the manifest interface.
+ */
+function isCandidateOrDisabled(
+  impl: Implementation
+): impl is Implementation & { lifecycleState: ImplementationLifecycleState } {
+  return impl.lifecycleState === 'candidate' || impl.lifecycleState === 'disabled';
+}
+
 function _handleListCandidates(
   stateDir: string,
   isZh: boolean,
 ): PluginCommandResult {
   const engine = new ReplayEngine('', stateDir);
   const allImpls = getAllImplementations(stateDir);
-  const candidates = allImpls.filter(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Reason: lifecycleState is a dynamic property added by the system - type not in official interface
-    (impl) => (impl as any).lifecycleState === 'candidate',
-  );
+  const candidates = allImpls.filter(isCandidateOrDisabled);
 
   if (candidates.length === 0) {
     return {
@@ -141,8 +148,7 @@ function _handlePromoteImpl(options: PromoteImplOptions): PluginCommandResult {
     };
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Reason: lifecycleState is a dynamic property added by the system - type not in official interface
-  const currentState = (candidate as any).lifecycleState || 'candidate';
+  const currentState = candidate.lifecycleState || 'candidate';
 
   if (currentState !== 'candidate' && currentState !== 'disabled') {
     return {

package/src/commands/rollback.ts

@@ -2,6 +2,14 @@ import { WorkspaceContext } from '../core/workspace-context.js';
 import { resetFriction } from '../core/session-tracker.js';
 import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
 
+/**
+ * Extended context interface that includes sessionId injected by the plugin framework.
+ * PluginCommandContext does not include sessionId in its type definition.
+ */
+interface SessionAwareCommandContext extends PluginCommandContext {
+  sessionId: string;
+}
+
 /**
  * Handles the /pd-rollback command
  * 
@@ -15,8 +23,7 @@ export function handleRollbackCommand(ctx: PluginCommandContext): PluginCommandR
     const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
     const lang = (ctx.config?.language as string) || 'en';
     const isZh = lang === 'zh';
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Reason: sessionId injected by OpenClaw plugin framework - type not available in PluginCommandContext
-    const {sessionId} = (ctx as any);
+    const { sessionId } = ctx as SessionAwareCommandContext;
 
     const args = (ctx.args || '').trim();
 
@@ -45,7 +52,7 @@ Usage:
     }
 
      
-    // eslint-disable-next-line @typescript-eslint/init-declarations
+     
     let eventId: string | null;
      
     const _triggerMethod = 'user_command' as const;

package/src/core/event-log.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 import * as fs from 'fs';
 import * as path from 'path';
 import type {
@@ -94,7 +95,7 @@ export class EventLog {
   /**
    * Clean up event files older than EVENT_LOG_RETENTION_DAYS.
    */
-  private cleanupOldEventFiles(today: string): void {
+  private cleanupOldEventFiles(_today: string): void {
     if (EVENT_LOG_RETENTION_DAYS <= 0) return;
 
     try {
@@ -110,8 +111,8 @@ export class EventLog {
           fs.unlinkSync(filePath);
         }
       }
-    } catch {
-      // Silently fail cleanup
+    } catch (err) {
+      this.logger?.debug?.(`[PD] Event file cleanup failed (non-blocking): ${String(err)}`);
     }
   }
   
@@ -220,6 +221,7 @@ export class EventLog {
     }
   }
 
+  /* eslint-disable complexity */
   private updateStats(entry: EventLogEntry): void {
     let stats = this.statsCache.get(entry.date);
     if (!stats) {
@@ -228,8 +230,6 @@ export class EventLog {
     }
 
     if (entry.type === 'tool_call') {
-       
-      const _data = entry.data as unknown as ToolCallEventData;
       stats.tools.total++;
       if (entry.category === 'success') stats.tools.success++;
       else stats.tools.failure++;
@@ -349,7 +349,8 @@ export class EventLog {
         .map((line) => {
           try {
             return JSON.parse(line) as EventLogEntry;
-          } catch {
+          } catch (err) {
+            this.logger?.warn?.(`[PD] Corrupted event line skipped: ${String(err).slice(0, 100)}`);
             return null;
           }
         })
@@ -499,6 +500,7 @@ export class EventLog {
   /**
    * Aggregate empathy stats for a specific session.
    */
+  /* eslint-disable complexity */
   private aggregateSessionEmpathy(sessionId: string, result: EmpathyEventStats): void {
     for (const entry of this.getMergedEvents()) {
       if (entry.sessionId === sessionId && entry.type === 'pain_signal') {

package/src/core/evolution-types.ts

@@ -1,6 +1,6 @@
 /**
  * Evolution Points System V2.0 - MVP
- * 
+ *
  * Core Philosophy: Growth-driven替代Penalty-driven
  * - 起点0分，只能增加，不扣分
  * - 失败记录教训，不扣分
@@ -8,6 +8,9 @@
  * - 5级成长路径：Seed → Forest
  */
 
+// V2 queue types require TaskKind/TaskPriority from trajectory-types
+import type { TaskKind, TaskPriority } from './trajectory-types.js';
+
 // ===== 等级定义 =====
 
  
@@ -464,3 +467,32 @@ export type EvolutionLoopEvent =
   | { ts: string; type: 'principle_rolled_back'; data: PrincipleRolledBackData }
   | { ts: string; type: 'circuit_breaker_opened'; data: CircuitBreakerOpenedData }
   | { ts: string; type: 'legacy_import'; data: LegacyImportData };
+
+// V2 Queue Types (moved from evolution-worker.ts for shared use)
+export type QueueStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'canceled';
+export type TaskResolution = 'marker_detected' | 'auto_completed_timeout' | 'failed_max_retries' | 'runtime_unavailable' | 'canceled' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'stub_fallback' | 'skipped_thin_violation' | 'success' | 'failure' | 'skipped';
+
+export interface EvolutionQueueItem {
+  id: string;
+  taskKind: TaskKind;
+  priority: TaskPriority;
+  source: string;
+  traceId?: string;
+  task?: string;
+  score: number;
+  reason: string;
+  timestamp: string;
+  enqueued_at?: string;
+  started_at?: string;
+  completed_at?: string;
+  assigned_session_key?: string;
+  trigger_text_preview?: string;
+  status: QueueStatus;
+  resolution?: TaskResolution;
+  session_id?: string;
+  agent_id?: string;
+  retryCount: number;
+  maxRetries: number;
+  lastError?: string;
+  resultRef?: string;
+}

package/src/core/principle-compiler/code-validator.ts

@@ -0,0 +1,120 @@
+/**
+ * Code Validator — Validates LLM-generated rule implementation code
+ *
+ * PURPOSE: Ensure generated code is safe, syntactically correct, and exports
+ * the expected shape before it is stored as a rule implementation.
+ *
+ * CHECKS:
+ * 1. Syntax: code parses without errors
+ * 2. Forbidden patterns: no require, import, fetch, eval, Function, process, globalThis
+ * 3. Export check: sandbox loads and exports evaluate + meta
+ * 4. Return shape: evaluate(mockInput) returns { matched: boolean }
+ *
+ * Reuses loadRuleImplementationModule for sandbox execution (node:vm isolation).
+ */
+
+import { nodeVm } from '../../utils/node-vm-polyfill.js';
+import { loadRuleImplementationModule } from '../rule-implementation-runtime.js';
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+
+const FORBIDDEN_PATTERNS: { pattern: RegExp; label: string }[] = [
+  { pattern: /\brequire\s*\(/, label: 'require' },
+  { pattern: /\bimport\s+/, label: 'import' },
+  { pattern: /\bfetch\s*\(/, label: 'fetch' },
+  { pattern: /\beval\s*\(/, label: 'eval' },
+  { pattern: /\bFunction\s*\(/, label: 'Function' },
+  { pattern: /\bprocess\b/, label: 'process' },
+  { pattern: /\bglobalThis\b/, label: 'globalThis' },
+  { pattern: /\bglobal\b/, label: 'global' },
+  { pattern: /\bReflect\b/, label: 'Reflect' },
+  { pattern: /\bProxy\b/, label: 'Proxy' },
+  { pattern: /\bconstructor\b/, label: 'constructor' },
+  { pattern: /\bBuffer\b/, label: 'Buffer' },
+  { pattern: /\bsetTimeout\b/, label: 'setTimeout' },
+  { pattern: /\bsetInterval\b/, label: 'setInterval' },
+  // Bracket notation access to globals
+  { pattern: /\[\s*['"](require|import|fetch|eval|process|globalThis|global|Reflect|Proxy|Buffer|Function)\s*['"]\s*\]/, label: 'bracket access to forbidden global' },
+];
+
+const MOCK_INPUT = {
+  action: {
+    toolName: 'bash',
+    normalizedPath: '/tmp/test.ts',
+    paramsSummary: { command: 'echo test' },
+  },
+  workspace: { isRiskPath: false, planStatus: 'NONE', hasPlanFile: false },
+  session: { sessionId: 'test', currentGfi: 0, recentThinking: false },
+  evolution: { epTier: 0 },
+  derived: { estimatedLineChanges: 0, bashRisk: 'safe' },
+};
+
+export function validateGeneratedCode(code: string): ValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  // --- Check 1: Syntax ---
+  // Normalize export keywords so vm.Script can parse ES module source
+  const normalized = code
+    .replace(/export\s+const\s+/g, 'const ')
+    .replace(/export\s+function\s+/g, 'function ');
+  try {
+    new nodeVm.Script(normalized, { filename: 'code-validator-syntax.js' });
+  } catch (err) {
+    errors.push(`Syntax error: ${(err as Error).message}`);
+    return { valid: false, errors, warnings };
+  }
+
+  // --- Check 2: Forbidden patterns ---
+  for (const { pattern, label } of FORBIDDEN_PATTERNS) {
+    if (pattern.test(code)) {
+      errors.push(`Forbidden pattern: ${label}`);
+    }
+  }
+
+  if (errors.length > 0) {
+    return { valid: false, errors, warnings };
+  }
+
+  // --- Check 3: Sandbox load + export check ---
+  let moduleExports: { meta?: unknown; evaluate?: unknown };
+  try {
+    moduleExports = loadRuleImplementationModule(code, 'code-validator-candidate.js');
+  } catch (err) {
+    errors.push(`Sandbox compilation error: ${(err as Error).message}`);
+    return { valid: false, errors, warnings };
+  }
+
+  if (!moduleExports.meta || typeof moduleExports.meta !== 'object') {
+    errors.push('Missing export: meta');
+  }
+
+  if (typeof moduleExports.evaluate !== 'function') {
+    errors.push('Missing export: evaluate');
+  }
+
+  if (errors.length > 0) {
+    return { valid: false, errors, warnings };
+  }
+
+  // --- Check 4: Return shape ---
+  try {
+    const result = (moduleExports.evaluate as (input: unknown) => unknown)(MOCK_INPUT);
+    if (!result || typeof result !== 'object') {
+      errors.push('evaluate must return an object');
+    } else if (typeof (result as Record<string, unknown>).matched !== 'boolean') {
+      errors.push('evaluate must return { matched: boolean }');
+    }
+  } catch (evalWarning) {
+    // evaluate throwing on mock input is acceptable — the function exists and
+    // has the right signature, it just can't handle our generic mock data.
+    // Track as a non-blocking warning so operators know the rule may be fragile.
+    warnings.push(`evaluate() threw on mock input: ${(evalWarning as Error).message}`);
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}

package/src/core/principle-compiler/compiler.ts

@@ -0,0 +1,242 @@
+/**
+ * PrincipleCompiler — Orchestrator (Task 5)
+ *
+ * Orchestrates the full compilation flow:
+ *   ReflectionContextCollector.collect() → extract patterns → generateFromTemplate()
+ *   → validateGeneratedCode() → registerCompiledRule()
+ *
+ * DESIGN DECISIONS:
+ * - extractPatterns infers toolName from pain event reasons and session tool calls
+ * - Groups by toolName into PainPattern objects
+ * - If no patterns can be extracted, returns a 'no patterns' failure
+ */
+
+import { ReflectionContextCollector } from '../reflection/reflection-context.js';
+import { validateGeneratedCode } from './code-validator.js';
+import { generateFromTemplate, type PainPattern } from './template-generator.js';
+import { registerCompiledRule } from './ledger-registrar.js';
+import { createImplementationAssetDir } from '../code-implementation-storage.js';
+import type { TrajectoryDatabase } from '../trajectory.js';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface CompileResult {
+  success: boolean;
+  principleId: string;
+  ruleId?: string;
+  implementationId?: string;
+  code?: string;
+  reason?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** Tool names to look for when scanning text for tool references */
+const KNOWN_TOOLS = ['bash', 'write', 'edit', 'read', 'grep', 'glob', 'mcp'] as const;
+
+/** Regex to extract file paths from reason text */
+const PATH_REGEX = /(?:\/[\w.-]+){2,}/;
+
+// ---------------------------------------------------------------------------
+// Pattern Extraction
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract PainPatterns from a ReflectionContext.
+ *
+ * Strategy:
+ * 1. Scan pain event reasons for known tool names
+ * 2. Extract file paths from reason text as pathRegex candidates
+ * 3. Cross-reference with sessionSnapshot toolCalls for failed tool calls
+ * 4. Group by toolName into PainPattern objects
+ */
+function extractPatterns(context: {
+  painEvents: Array<{ reason: string | null; source: string }>;
+  sessionSnapshot: {
+    toolCalls: Array<{
+      toolName: string;
+      outcome: string;
+      filePath: string | null;
+      errorType: string | null;
+    }>;
+  } | null;
+}): PainPattern[] {
+  const toolNameMap = new Map<string, PainPattern>();
+
+  // 1. Extract from pain event reasons
+  for (const pe of context.painEvents) {
+    const text = pe.reason ?? pe.source ?? '';
+    const toolName = inferToolName(text);
+    if (!toolName) continue;
+
+    const pathRegex = extractPathRegex(text);
+
+    if (!toolNameMap.has(toolName)) {
+      toolNameMap.set(toolName, { toolName });
+    }
+
+    const pattern = toolNameMap.get(toolName)!;
+    if (pathRegex && !pattern.pathRegex) {
+      pattern.pathRegex = pathRegex;
+    }
+  }
+
+  // 2. Extract from session snapshot tool calls (failed ones)
+  if (context.sessionSnapshot?.toolCalls) {
+    for (const tc of context.sessionSnapshot.toolCalls) {
+      // Focus on failed/blocked tool calls as they indicate pain
+      if (tc.outcome !== 'failure' && tc.outcome !== 'blocked') continue;
+
+      const toolName = tc.toolName;
+      if (!toolNameMap.has(toolName)) {
+        const pattern: PainPattern = { toolName };
+        if (tc.errorType) {
+          pattern.errorType = tc.errorType;
+        }
+        if (tc.filePath) {
+          pattern.pathRegex = escapeRegex(tc.filePath);
+        }
+        toolNameMap.set(toolName, pattern);
+      } else {
+        const existing = toolNameMap.get(toolName)!;
+        if (tc.errorType && !existing.errorType) {
+          existing.errorType = tc.errorType;
+        }
+        if (tc.filePath && !existing.pathRegex) {
+          existing.pathRegex = escapeRegex(tc.filePath);
+        }
+      }
+    }
+  }
+
+  return Array.from(toolNameMap.values());
+}
+
+/**
+ * Infer tool name from text by checking for known tool names.
+ * Returns the first matching known tool name, or null if none found.
+ */
+function inferToolName(text: string): string | null {
+  const lower = text.toLowerCase();
+  for (const tool of KNOWN_TOOLS) {
+    // Match as a standalone word to avoid false positives
+    // e.g., "bash" in "bash" or "bash command" but not in "ambush"
+    const regex = new RegExp(`\\b${tool}\\b`);
+    if (regex.test(lower)) {
+      return tool;
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract a file path from text and return it as an escaped regex pattern.
+ * Returns the first path found, or null.
+ */
+function extractPathRegex(text: string): string | null {
+  const match = PATH_REGEX.exec(text);
+  if (match) {
+    return escapeRegex(match[0]);
+  }
+  return null;
+}
+
+/**
+ * Escape special regex characters in a string.
+ */
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// ---------------------------------------------------------------------------
+// PrincipleCompiler
+// ---------------------------------------------------------------------------
+
+export class PrincipleCompiler {
+  private readonly stateDir: string;
+  private readonly collector: ReflectionContextCollector;
+
+  constructor(stateDir: string, trajectory: TrajectoryDatabase) {
+    this.stateDir = stateDir;
+    this.collector = new ReflectionContextCollector(stateDir, trajectory);
+  }
+
+  /**
+   * Compile a single principle into an auto-generated rule.
+   *
+   * Flow:
+   * 1. Collect reflection context
+   * 2. Extract pain patterns
+   * 3. Generate code from template
+   * 4. Validate generated code
+   * 5. Register in ledger
+   */
+  compileOne(principleId: string): CompileResult {
+    // Step 1: Collect context
+    const context = this.collector.collect(principleId);
+    if (!context) {
+      return { success: false, principleId, reason: 'no context' };
+    }
+
+    // Step 2: Extract patterns
+    const patterns = extractPatterns({
+      painEvents: context.painEvents,
+      sessionSnapshot: context.sessionSnapshot,
+    });
+
+    // Step 3: Generate code
+    const coversCondition = context.principle.triggerPattern || context.principle.text;
+    const code = generateFromTemplate(principleId, coversCondition, patterns);
+    if (!code) {
+      return { success: false, principleId, reason: 'no patterns' };
+    }
+
+    // Step 4: Validate
+    const validation = validateGeneratedCode(code);
+    if (!validation.valid) {
+      return {
+        success: false,
+        principleId,
+        reason: `validation failed: ${validation.errors.join('; ')}`,
+      };
+    }
+
+    // Step 5: Register
+    const registration = registerCompiledRule(this.stateDir, {
+      principleId,
+      codeContent: code,
+      coversCondition,
+    });
+
+    // Step 6: Persist code to disk so RuleHost can load it
+    createImplementationAssetDir(this.stateDir, registration.implementationId, '1', {
+      entrySource: code,
+    });
+
+    return {
+      success: true,
+      principleId,
+      ruleId: registration.ruleId,
+      implementationId: registration.implementationId,
+      code,
+    };
+  }
+
+  /**
+   * Compile all eligible principles (those with derivedFromPainIds).
+   */
+  compileAll(): CompileResult[] {
+    const contexts = this.collector.collectBatch();
+    return contexts.map((ctx) => {
+      try {
+        return this.compileOne(ctx.principle.id);
+      } catch (e) {
+        return { success: false, principleId: ctx.principle.id, reason: `unhandled: ${(e as Error).message}` };
+      }
+    });
+  }
+}

package/src/core/principle-compiler/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Principle Compiler — Barrel Export
+ *
+ * Re-exports all principle-compiler components for convenient importing.
+ */
+
+export { PrincipleCompiler, type CompileResult } from './compiler.js';
+export { validateGeneratedCode, type ValidationResult } from './code-validator.js';
+export { generateFromTemplate, type PainPattern } from './template-generator.js';
+export { registerCompiledRule, type RegisterInput, type RegisterResult } from './ledger-registrar.js';