principles-disciple 1.8.0 → 1.8.2

package/src/hooks/pain.ts

@@ -0,0 +1,384 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { isRisky, normalizePath } from '../utils/io.js';
+import { normalizeProfile } from '../core/profile.js';
+import { computePainScore, writePainFlag, trackPrincipleValue } from '../core/pain.js';
+import { getSession, trackFriction, resetFriction, getInjectedProbationIds, clearInjectedProbationIds } from '../core/session-tracker.js';
+import { denoiseError, computeHash } from '../utils/hashing.js';
+import { SystemLogger } from '../core/system-logger.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+import { getEvolutionLogger, createTraceId } from '../core/evolution-logger.js';
+import { recordEvolutionSuccess, recordEvolutionFailure } from '../core/evolution-engine.js';
+import type { EvolutionLoopEvent } from '../core/evolution-types.js';
+import type { PluginHookAfterToolCallEvent, PluginHookToolContext, OpenClawPluginApi } from '../openclaw-sdk.js';
+
+/**
+ * Interface for tool parameters to avoid 'any'
+ */
+interface ToolParams {
+  file_path?: string;
+  path?: string;
+  file?: string;
+  content?: string;
+  new_string?: string;
+  text?: string;
+  query?: string;
+  input?: string;
+  arguments?: string;
+}
+
+const WRITE_TOOLS = ['write', 'edit', 'apply_patch', 'write_file', 'edit_file', 'replace'];
+
+function shouldAttributePrincipleToTool(principle: { contextTags: string[]; trigger: string; }, toolName: string): boolean {
+  return principle.contextTags.includes(toolName) || principle.trigger.includes(toolName);
+}
+
+function emitPainDetectedEvent(wctx: WorkspaceContext, event: EvolutionLoopEvent): void {
+  try {
+    wctx.evolutionReducer.emitSync(event);
+  } catch (e) {
+    SystemLogger.log(wctx.workspaceDir, 'EVOLUTION_EMIT_WARN', `Failed to emit evolution event: ${String(e)}`);
+  }
+}
+
+function createPainId(sessionId: string): string {
+  return `pain_${Date.now()}_${computeHash(sessionId).slice(0, 8)}`;
+}
+
+export function handleAfterToolCall(
+  event: PluginHookAfterToolCallEvent,
+  ctx: PluginHookToolContext & { workspaceDir?: string; pluginConfig?: Record<string, unknown> },
+  api?: OpenClawPluginApi
+): void {
+  const effectiveWorkspaceDir = ctx.workspaceDir || (api as any)?.workspaceDir || api?.resolvePath?.('.');
+  if (!effectiveWorkspaceDir) {
+    return;
+  }
+
+  const wctx = WorkspaceContext.fromHookContext({ ...ctx, workspaceDir: effectiveWorkspaceDir });
+  const config = wctx.config;
+  const eventLog = wctx.eventLog;
+  const sessionId = ctx.sessionId || 'unknown';
+  const sessionState = ctx.sessionId ? getSession(ctx.sessionId) : undefined;
+  const gfiBefore = sessionState?.currentGfi ?? 0;
+  const params = event.params as ToolParams;
+
+  // ── Track A: Empirical Friction (GFI) ──
+  
+  // 0. Special Case: Manual Pain Intervention
+  if (event.toolName === 'pain' || event.toolName === 'skill:pain') {
+    const reason = params.input || params.arguments || 'Manual intervention';
+    const traceId = createTraceId();
+    trackFriction(sessionId, 100, 'manual_pain', effectiveWorkspaceDir);
+    SystemLogger.log(effectiveWorkspaceDir, 'MANUAL_PAIN', `User manually triggered pain: ${reason}`);
+    eventLog.recordPainSignal(sessionId, {
+      score: 100,
+      source: 'manual',
+      reason: `User intervention: ${reason}`,
+      isRisky: true
+    });
+    wctx.trajectory?.recordPainEvent?.({
+      sessionId,
+      source: 'manual',
+      score: 100,
+      reason: `User intervention: ${reason}`,
+      origin: 'user_manual',
+      text: reason,  // Store the intervention reason as text
+    });
+
+    // Log to EvolutionLogger
+    const evoLogger = getEvolutionLogger(effectiveWorkspaceDir, wctx.trajectory);
+    evoLogger.logPainDetected({
+      traceId,
+      source: 'manual',
+      reason: `User intervention: ${reason}`,
+      score: 100,
+      toolName: event.toolName,
+      sessionId,
+    });
+
+    emitPainDetectedEvent(wctx, {
+      ts: new Date().toISOString(),
+      type: 'pain_detected',
+      data: {
+        painId: createPainId(sessionId),
+        painType: 'user_frustration',
+        source: event.toolName,
+        reason: `User intervention: ${reason}`,
+        score: 100,
+        sessionId,
+        traceId,
+        agentId: ctx.agentId,
+      },
+    });
+    return;
+  }
+
+  // 1. Determine if this was a failure
+  const exitCode = (event.result && typeof event.result === 'object') ? (event.result as any).exitCode : 0;
+  const isFailure = !!event.error || (exitCode !== 0 && exitCode !== undefined);
+
+  if (isFailure) {
+    const errorText = event.error || (typeof event.result === 'string' ? event.result : JSON.stringify(event.result));
+    const denoised = denoiseError(errorText);
+    const hash = computeHash(denoised);
+    
+    const deltaF = config.get('scores.tool_failure_friction') || 30;
+    const updatedState = trackFriction(sessionId, deltaF, hash, effectiveWorkspaceDir);
+    
+    // ── Trust Engine: Record failure ──
+    const errorType = extractErrorType(event.error || errorText);
+    const filePath = params.file_path || params.path || params.file;
+    const relPath = typeof filePath === 'string' ? normalizePath(filePath, effectiveWorkspaceDir) : 'unknown';
+    
+    // Load profile for risk_paths check
+    const profilePath = wctx.resolve('PROFILE');
+    let profile = normalizeProfile({});
+    if (fs.existsSync(profilePath)) {
+      try {
+        profile = normalizeProfile(JSON.parse(fs.readFileSync(profilePath, 'utf8')));
+      } catch (e) {
+        SystemLogger.log(effectiveWorkspaceDir, 'PROFILE_PARSE_WARN', `Failed to parse PROFILE.json: ${String(e)}`);
+      }
+    }
+    
+    const isRisk = isRisky(relPath, profile.risk_paths);
+    
+    recordEvolutionFailure(effectiveWorkspaceDir, event.toolName, {
+        filePath: relPath,
+        reason: isRisk ? 'risky' : 'tool',
+        sessionId,
+    });
+    
+    // Record tool call failure event
+    eventLog.recordToolCall(sessionId, {
+      toolName: event.toolName,
+      filePath: typeof filePath === 'string' ? filePath : undefined,
+      error: event.error ? String(event.error).substring(0, 200) : undefined,
+      errorType,
+      gfi: updatedState.currentGfi,
+      consecutiveErrors: updatedState.consecutiveErrors,
+      exitCode,
+    });
+    wctx.trajectory?.recordToolCall?.({
+      sessionId,
+      toolName: event.toolName,
+      outcome: 'failure',
+      durationMs: event.durationMs,
+      exitCode,
+      errorType,
+      errorMessage: event.error ? String(event.error) : undefined,
+      gfiBefore,
+      gfiAfter: updatedState.currentGfi,
+      paramsJson: event.params,
+    });
+
+    const injectedProbationIds = getInjectedProbationIds(sessionId, effectiveWorkspaceDir);
+    for (const id of injectedProbationIds) {
+      const principle = wctx.evolutionReducer.getPrincipleById(id);
+      const shouldAttribute = !!principle && shouldAttributePrincipleToTool(principle, event.toolName);
+      if (shouldAttribute) {
+        wctx.evolutionReducer.recordProbationFeedback(id, false);
+      }
+    }
+    clearInjectedProbationIds(sessionId, effectiveWorkspaceDir);
+  } else {
+    // ── SUCCESS BRANCH ──
+    const resetState = resetFriction(sessionId, effectiveWorkspaceDir);
+    
+    recordEvolutionSuccess(effectiveWorkspaceDir, event.toolName, {
+        sessionId,
+        reason: 'tool_success',
+    });
+
+    const injectedProbationIds = getInjectedProbationIds(sessionId, effectiveWorkspaceDir);
+    for (const id of injectedProbationIds) {
+      const principle = wctx.evolutionReducer.getPrincipleById(id);
+      const shouldAttribute = !!principle && shouldAttributePrincipleToTool(principle, event.toolName);
+      if (shouldAttribute) {
+        wctx.evolutionReducer.recordProbationFeedback(id, true);
+      }
+    }
+    clearInjectedProbationIds(sessionId, effectiveWorkspaceDir);
+    wctx.trajectory?.recordToolCall?.({
+      sessionId,
+      toolName: event.toolName,
+      outcome: 'success',
+      durationMs: event.durationMs,
+      exitCode,
+      gfiBefore,
+      gfiAfter: resetState.currentGfi,
+      paramsJson: event.params,
+    });
+    
+    if (WRITE_TOOLS.includes(event.toolName)) {
+      const filePath = params.file_path || params.path || params.file;
+      eventLog.recordToolCall(sessionId, {
+        toolName: event.toolName,
+        filePath: typeof filePath === 'string' ? filePath : undefined,
+        gfi: 0,
+      });
+
+      // ── Hygiene Tracking: Record persistence actions ──
+      if (typeof filePath === 'string') {
+        const normalized = filePath.replace(/\\/g, '/');
+        const isMemory = /(?:^|\/)memory\//.test(normalized) || normalized.endsWith('/MEMORY.md') || normalized === 'MEMORY.md';
+        const isPlan = normalized === 'PLAN.md' || normalized.endsWith('/PLAN.md');
+        
+        if (isMemory || isPlan) {
+          const content = params.content || params.new_string || '';
+          wctx.hygiene.recordPersistence({
+            ts: new Date().toISOString(),
+            tool: event.toolName,
+            path: filePath,
+            type: isMemory ? 'memory' : 'plan',
+            contentLength: content.length,
+          });
+        }
+      }
+    }
+
+    // Special case for memory_store tool (Success only)
+    if (event.toolName === 'memory_store') {
+       const text = params.text || '';
+       wctx.hygiene.recordPersistence({
+         ts: new Date().toISOString(),
+         tool: event.toolName,
+         path: 'DATABASE',
+         type: 'memory',
+         contentLength: text.length,
+       });
+    }
+  }
+
+  // ── Legacy/Risky Write Pain Logic (Unified WRITE_TOOLS) ──
+  if (!WRITE_TOOLS.includes(event.toolName) || !isFailure) {
+    return;
+  }
+
+  const filePath = params.file_path || params.path || params.file;
+  const relPath = typeof filePath === 'string' ? normalizePath(filePath, effectiveWorkspaceDir) : 'unknown';
+
+  const profilePath = wctx.resolve('PROFILE');
+  let profile = normalizeProfile({});
+  if (fs.existsSync(profilePath)) {
+    try {
+      profile = normalizeProfile(JSON.parse(fs.readFileSync(profilePath, 'utf8')));
+    } catch (e) {
+      SystemLogger.log(effectiveWorkspaceDir, 'PROFILE_PARSE_WARN', `Failed to parse PROFILE.json: ${String(e)}`);
+    }
+  }
+
+  const isRisk = isRisky(relPath, profile.risk_paths);
+  const painScore = computePainScore(1, false, false, isRisk ? 20 : 0, effectiveWorkspaceDir);
+  const traceId = createTraceId();
+
+  const painData = {
+    score: String(painScore),
+    source: 'tool_failure',
+    time: new Date().toISOString(),
+    reason: `Tool ${event.toolName} failed on ${relPath}. Error: ${event.error ?? 'Non-zero exit code'}`,
+    is_risky: String(isRisk),
+    trace_id: traceId,
+    session_id: sessionId,
+    agent_id: ctx.agentId || '',
+  };
+
+  try {
+    writePainFlag(effectiveWorkspaceDir, painData);
+  } catch (e) {
+    SystemLogger.log(effectiveWorkspaceDir, 'WRITE_PAIN_FLAG_WARN', `Failed to write pain flag: ${String(e)}`);
+  }
+
+  // Observe: track which principles would have prevented this pain (Phase 1, observation-only)
+  try {
+    trackPrincipleValue(
+      effectiveWorkspaceDir,
+      { reason: painData.reason, source: painData.source, score: painData.score },
+      () => wctx.evolutionReducer.getActivePrinciples().map((p) => ({
+        id: p.id,
+        trigger: p.trigger,
+        valueMetrics: p.valueMetrics,
+      })),
+      (id, metrics) => {
+        const principle = wctx.evolutionReducer.getPrincipleById(id);
+        if (principle) {
+          principle.valueMetrics = metrics;
+          // Persist to training state (best-effort, non-critical)
+          try {
+            const storePath = path.join(wctx.stateDir, 'principle_training_state.json');
+            if (fs.existsSync(storePath)) {
+              const store = JSON.parse(fs.readFileSync(storePath, 'utf8'));
+              if (store[id]) {
+                store[id].valueMetrics = metrics;
+                fs.writeFileSync(storePath, JSON.stringify(store, null, 2), 'utf8');
+              }
+            }
+          } catch {
+            // Non-critical — metrics tracked in memory
+          }
+        }
+      },
+    );
+  } catch {
+    // Observation only — never disrupt the pain pipeline
+  }
+
+  eventLog.recordPainSignal(sessionId, {
+    score: painScore,
+    source: 'tool_failure',
+    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);
+  evoLogger.logPainDetected({
+    traceId,
+    source: 'tool_failure',
+    reason: `Tool ${event.toolName} failed on ${relPath}`,
+    score: painScore,
+    toolName: event.toolName,
+    filePath: relPath,
+    sessionId,
+  });
+
+  emitPainDetectedEvent(wctx, {
+    ts: new Date().toISOString(),
+    type: 'pain_detected',
+    data: {
+      painId: createPainId(sessionId),
+      painType: 'tool_failure',
+      source: event.toolName,
+      reason: `Tool ${event.toolName} failed on ${relPath}`,
+      score: painScore,
+      sessionId,
+      traceId,
+      agentId: ctx.agentId,
+    },
+  });
+}
+
+function extractErrorType(error: unknown): string {
+  if (!error) return 'Unknown';
+  const msg = String(error);
+  if (msg.includes('EACCES') || msg.includes('permission denied')) return 'EACCES';
+  if (msg.includes('ENOENT') || msg.includes('no such file')) return 'ENOENT';
+  if (msg.includes('EISDIR')) return 'EISDIR';
+  if (msg.includes('ENOSPC')) return 'ENOSPC';
+  if (msg.includes('SyntaxError')) return 'SyntaxError';
+  if (msg.includes('TypeError')) return 'TypeError';
+  if (msg.includes('ReferenceError')) return 'ReferenceError';
+  if (msg.includes('timeout') || msg.includes('ETIMEDOUT')) return 'Timeout';
+  if (msg.includes('network') || msg.includes('ECONNREFUSED')) return 'Network';
+  return 'Other';
+}

package/src/hooks/progressive-trust-gate.ts

@@ -0,0 +1,174 @@
+/**
+ * Progressive Gate Module (EP-Only Version)
+ *
+ * EP (Evolution Points) 是唯一的门控机制。
+ *
+ * **EP 门控逻辑:**
+ * - Seed (0分): 只读 + 基础文档
+ * - Sprout (50分): 单文件编辑
+ * - Sapling (200分): 多文件 + 测试 + 子智能体
+ * - Tree (500分): 重构 + 风险路径
+ * - Forest (1000分): 完全自主
+ *
+ * **风险路径控制:**
+ * - 低等级不能修改风险路径
+ * - 高等级解锁风险路径权限
+ *
+ * **不再有:**
+ * - Trust Score (30-100) 系统
+ * - Stage 1-4 分级
+ * - Plan Approval 白名单机制
+ * - 基于行数的限制
+ */
+
+import type { PluginHookBeforeToolCallEvent, PluginHookBeforeToolCallResult } from '../openclaw-sdk.js';
+import type { WorkspaceContext } from '../core/workspace-context.js';
+import { normalizePath } from '../utils/io.js';
+import { checkEvolutionGate } from '../core/evolution-engine.js';
+import { recordGateBlockAndReturn } from './gate-block-helper.js';
+
+// ═══ P-16: Core Governance Files — Exempt from all Blocking ═══
+// 这些文件是团队协作的基础，必须始终放行，不受 GFI 和 Risk Path 限制
+// 可通过 PROFILE.core_governance_files 扩展（merge 而非覆盖）
+const DEFAULT_CORE_GOVERNANCE_PATTERNS = [
+  'PLAN.md',
+  'AGENTS.md',
+  'VERSION.md',
+  '.team/',
+  'MEMORY.md',
+  'SOUL.md',
+  'IDENTITY.md',
+  'USER.md',
+  'HEARTBEAT.md',
+  'BOOTSTRAP.md',
+  'PRINCIPLES.md',
+  'TEAM_ROLE.md',
+  'REPAIR_OPERATING_PROMPT.md',
+];
+
+/**
+ * Get effective core governance patterns from PROFILE config, merged with defaults.
+ * PROFILE.core_governance_files extends (not replaces) the default list.
+ */
+function getCoreGovernancePatterns(profile?: { core_governance_files?: string[] }): string[] {
+  const base = DEFAULT_CORE_GOVERNANCE_PATTERNS;
+  const extra = profile?.core_governance_files ?? [];
+  return Array.from(new Set([...base, ...extra]));
+}
+
+/**
+ * Check if a file path matches a core governance pattern.
+ * Core governance files are exempt from all gate blocking (P-16).
+ */
+function isCoreGovernanceFile(filePath?: string, corePatterns?: string[]): boolean {
+  if (!filePath) return false;
+  const patterns = corePatterns ?? DEFAULT_CORE_GOVERNANCE_PATTERNS;
+  const normalized = filePath.replace(/\\/g, '/');
+  return patterns.some(pattern =>
+    pattern.endsWith('/')
+      ? normalized.includes(pattern)
+      : normalized.endsWith(pattern) || normalized.includes(`/${pattern}`)
+  );
+}
+
+
+
+/**
+ * Build EP gate rejection reason
+ */
+export function buildEvolutionGateReason(
+  tier: number,
+  tierName: string,
+  reason: string
+): string {
+  return `[EP Gate] Tier ${tier} (${tierName}): ${reason}`;
+}
+
+/**
+ * Internal helper to call the shared block helper with progressive-trust-gate source tag.
+ */
+function block(
+  filePath: string,
+  reason: string,
+  wctx: WorkspaceContext,
+  toolName: string,
+  logger: { warn?: (message: string) => void; error?: (message: string) => void },
+  sessionId?: string
+): PluginHookBeforeToolCallResult {
+  return recordGateBlockAndReturn(wctx, {
+    filePath,
+    reason,
+    toolName,
+    sessionId,
+    blockSource: 'progressive-trust-gate',
+  }, logger);
+}
+
+/**
+ * Check EP-based gate
+ *
+ * @param event - The tool call event
+ * @param wctx - Workspace context
+ * @param relPath - Relative path to target file
+ * @param risky - Whether the path is a risk path
+ * @param lineChanges - Estimated line changes (kept for interface compatibility, not used for gating)
+ * @param logger - Logger instance
+ * @param ctx - Hook context
+ * @param profile - Gate profile containing risk_paths config
+ * @returns PluginHookBeforeToolCallResult to block, or undefined to allow
+ */
+export function checkProgressiveTrustGate(
+  event: PluginHookBeforeToolCallEvent,
+  wctx: WorkspaceContext,
+  relPath: string,
+  risky: boolean,
+  lineChanges: number,
+  logger: { warn?: (message: string) => void; error?: (message: string) => void; info?: (message: string) => void },
+  ctx: { workspaceDir?: string; sessionId?: string },
+  profile?: { risk_paths: string[]; core_governance_files?: string[] }
+): PluginHookBeforeToolCallResult | void {
+  // P-16: Core governance files are exempt from all gate blocking
+  if (isCoreGovernanceFile(relPath, getCoreGovernancePatterns(profile))) {
+    logger.info?.(`[PD_GATE:P-16] Core governance file exempt — bypass all gates: ${relPath}`);
+    return;
+  }
+
+  // EP is the only gate now - use actual gate decision
+  if (!ctx.workspaceDir) {
+    logger.warn?.('[PD_GATE] No workspaceDir, skipping EP gate check');
+    return;
+  }
+
+  // Call EP gate - this is the actual gate, not simulation
+  const epDecision = checkEvolutionGate(ctx.workspaceDir, {
+    toolName: event.toolName,
+    isRiskPath: risky,
+  });
+
+  const currentTier = epDecision.currentTier ?? 1;
+  const tierName = getTierName(currentTier);
+
+  logger.info?.(`[PD_GATE] EP Gate: Tier ${currentTier} (${tierName}), Tool: ${event.toolName}, Risk: ${risky}, Allowed: ${epDecision.allowed}`);
+
+  if (!epDecision.allowed) {
+    const reason = buildEvolutionGateReason(currentTier, tierName, epDecision.reason ?? 'Unknown restriction');
+    return block(relPath, reason, wctx, event.toolName, logger, ctx.sessionId);
+  }
+
+  // Gate passed - allow
+  return;
+}
+
+/**
+ * Get tier name from tier number
+ */
+function getTierName(tier: number): string {
+  const names: Record<number, string> = {
+    1: 'Seed',
+    2: 'Sprout',
+    3: 'Sapling',
+    4: 'Tree',
+    5: 'Forest',
+  };
+  return names[tier] ?? 'Unknown';
+}