principles-disciple 1.107.0 → 1.108.0

package/src/core/workspace-dir-service.ts

@@ -1,119 +0,0 @@
-import type { OpenClawPluginApi, PluginLogger } from '../openclaw-sdk.js';
-import { validateWorkspaceDir, type WorkspaceResolutionContext } from './workspace-dir-validation.js';
-
-export interface WorkspaceResolutionOptions {
-  source?: string;
-  required?: boolean;
-  fallbackAgentId?: string;
-  logger?: PluginLogger;
-}
-
-function buildResolutionFailureMessage(source: string, attempts: string[]): string {
-  const suffix = attempts.length > 0 ? ` Attempts: ${attempts.join(' | ')}` : '';
-  return `[PD:WorkspaceDir] ${source}: unable to resolve a valid workspace directory.${suffix}`;
-}
-
-function tryResolveFromAgent(
-  api: OpenClawPluginApi,
-  agentId: string,
-  attempts: string[],
-): string | undefined {
-  try {
-    const resolved = api.runtime?.agent?.resolveAgentWorkspaceDir?.(api.config, agentId);
-    const issue = validateWorkspaceDir(resolved);
-    if (!issue) {
-      return resolved;
-    }
-    attempts.push(`agent:${agentId} invalid (${issue})`);
-  } catch (error) {
-    attempts.push(`agent:${agentId} threw (${String(error)})`);
-  }
-
-  return undefined;
-}
-
-export function resolveWorkspaceDir(
-  api: OpenClawPluginApi,
-  ctx: WorkspaceResolutionContext,
-  options: WorkspaceResolutionOptions = {},
-): string | undefined {
-  const source = options.source ?? 'unknown';
-  const logger = options.logger ?? api.logger;
-  const attempts: string[] = [];
-
-  if (ctx.workspaceDir) {
-    const issue = validateWorkspaceDir(ctx.workspaceDir);
-    if (!issue) {
-      return ctx.workspaceDir;
-    }
-    attempts.push(`ctx.workspaceDir invalid (${issue})`);
-  } else {
-    attempts.push('ctx.workspaceDir missing');
-  }
-
-  const agentCandidates = [ctx.agentId, options.fallbackAgentId]
-    .filter((value, index, all): value is string => !!value && all.indexOf(value) === index);
-
-  for (const agentId of agentCandidates) {
-    const resolved = tryResolveFromAgent(api, agentId, attempts);
-    if (resolved) {
-      return resolved;
-    }
-  }
-
-  const message = buildResolutionFailureMessage(source, attempts);
-  if (options.required) {
-    logger.error(message);
-    throw new Error(message);
-  }
-
-  logger.warn(message);
-  return undefined;
-}
-
-export function resolveRequiredWorkspaceDir(
-  api: OpenClawPluginApi,
-  ctx: WorkspaceResolutionContext,
-  options: Omit<WorkspaceResolutionOptions, 'required'> = {},
-): string {
-  return resolveWorkspaceDir(api, ctx, { ...options, required: true }) as string;
-}
-
-// Re-export helpers that live in workspace-dir-validation.ts for API compatibility
-export { validateWorkspaceDir } from './workspace-dir-validation.js';
-export type { WorkspaceResolutionContext } from './workspace-dir-validation.js';
-
-export function resolveValidWorkspaceDir(
-  ctx: WorkspaceResolutionContext,
-  api: {
-    runtime: { agent: { resolveAgentWorkspaceDir: (config: unknown, agentId: string) => string } };
-    config: unknown;
-    logger: PluginLogger;
-  },
-  options?: { source?: string; fallbackAgentId?: string },
-): string | undefined {
-  return resolveWorkspaceDir(api as never, ctx, {
-    source: options?.source,
-    fallbackAgentId: options?.fallbackAgentId,
-    logger: api.logger,
-  });
-}
-
-export function logWorkspaceDirHealth(
-  ctx: WorkspaceResolutionContext,
-  source: string,
-  api: {
-    runtime: { agent: { resolveAgentWorkspaceDir: (config: unknown, agentId: string) => string } };
-    config: unknown;
-    logger: PluginLogger;
-  },
-): void {
-  const resolved = resolveValidWorkspaceDir(ctx, api, { source, fallbackAgentId: 'main' });
-  const issue = validateWorkspaceDir(resolved);
-
-  if (issue) {
-    api.logger.error(`[PD:health] ${source}: workspaceDir="${resolved}" - ${issue}`);
-  } else {
-    api.logger.info(`[PD:health] ${source}: workspaceDir="${resolved}" OK`);
-  }
-}

package/src/hooks/lifecycle-routing.ts

@@ -1,125 +0,0 @@
-/**
- * Lifecycle Routing Hook — Natural Language Intent Detection
- * ==========================================================
- *
- * PURPOSE: Detect natural language intent for promotion, disable, and rollback
- * of implementations. Supports both English and Chinese phrases.
- *
- * PATTERN: Extends the existing rollback natural language detection pattern
- * from rollback.ts.
- */
-
-// ---------------------------------------------------------------------------
-// Natural Language Patterns
-// ---------------------------------------------------------------------------
-
-const PROMOTE_PATTERNS_CN = [
-  /促[进推]/,
-  /启[用用]/,
-  /激活/,
-  /设为活动/,
-  /启用.*实现/,
-];
-
-const PROMOTE_PATTERNS_EN = [
-  /promote\s+(this|the|implementation)/i,
-  /activate\s+(this|the|implementation)/i,
-  /enable\s+(this|the|implementation)/i,
-  /set\s+(as|to)\s+active/i,
-];
-
-const DISABLE_PATTERNS_CN = [
-  /禁[用止]/,
-  /关闭.*实现/,
-  /停止.*实现/,
-  /停用/,
-];
-
-const DISABLE_PATTERNS_EN = [
-  /disable\s+(this|the|implementation)/i,
-  /turn\s+off\s+(this|the|implementation)/i,
-  /deactivate\s+(this|the|implementation)/i,
-  /stop\s+(this|the|implementation)/i,
-];
-
-const ROLLBACK_PATTERNS_CN = [
-  /回滚/,
-  /撤销.*实现/,
-  /恢复.*实现/,
-  /退回.*实现/,
-];
-
-const ROLLBACK_PATTERNS_EN = [
-  /rollback\s+(this|the|implementation)/i,
-  /revert\s+(this|the|implementation)/i,
-  /undo\s+(this|the|implementation)/i,
-  /restore\s+(previous|last|implementation)/i,
-];
-
-// ---------------------------------------------------------------------------
-// Intent Detection
-// ---------------------------------------------------------------------------
-
-export type LifecycleIntent = 'promote' | 'disable' | 'rollback' | null;
-
-/**
- * Detect implementation lifecycle intent from user message.
- * Returns the detected intent type or null.
- */
-     
-export function detectLifecycleIntent(message: string): LifecycleIntent {
-  // Check promote patterns
-  for (const p of PROMOTE_PATTERNS_EN) {
-    if (p.test(message)) return 'promote';
-  }
-  for (const p of PROMOTE_PATTERNS_CN) {
-    if (p.test(message)) return 'promote';
-  }
-
-  // Check disable patterns
-  for (const p of DISABLE_PATTERNS_EN) {
-    if (p.test(message)) return 'disable';
-  }
-  for (const p of DISABLE_PATTERNS_CN) {
-    if (p.test(message)) return 'disable';
-  }
-
-  // Check rollback patterns
-  for (const p of ROLLBACK_PATTERNS_EN) {
-    if (p.test(message)) return 'rollback';
-  }
-  for (const p of ROLLBACK_PATTERNS_CN) {
-    if (p.test(message)) return 'rollback';
-  }
-
-  return null;
-}
-
-/**
- * Route a natural language lifecycle intent to the appropriate command handler.
- * Returns command name and normalized message, or null if no intent detected.
- */
-export function routeLifecycleIntent(
-  message: string
-): { command: string; normalizedMessage: string } | null {
-  const intent = detectLifecycleIntent(message);
-  if (!intent) return null;
-
-  switch (intent) {
-    case 'promote':
-      return {
-        command: 'pd-promote-impl',
-        normalizedMessage: 'list',
-      };
-    case 'disable':
-      return {
-        command: 'pd-disable-impl',
-        normalizedMessage: 'list',
-      };
-    case 'rollback':
-      return {
-        command: 'pd-rollback-impl',
-        normalizedMessage: 'list',
-      };
-  }
-}

package/src/service/event-log-auditor.ts

@@ -1,284 +0,0 @@
-/**
- * EventLog Auditor - Search and verify events across all .state directories
- *
- * This tool addresses a common debugging issue where hook events may be
- * written to the wrong .state directory due to workspaceDir resolution bugs.
- *
- * Usage:
- *   const report = await auditEventLogs(openclawDir, ['after_tool_call', 'before_tool_call']);
- *   console.log(report.summary);
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-interface EventLogEntry {
-  ts: string;
-  date: string;
-  type: string;
-  category: string;
-  sessionId?: string;
-  data: Record<string, unknown>;
-}
-
-interface LocationReport {
-  path: string;
-  lastModified: Date | null;
-  totalEntries: number;
-  hookCounts: Record<string, number>;
-  recentEntries: EventLogEntry[];
-}
-
-interface AuditReport {
-  searchedPaths: string[];
-  locations: LocationReport[];
-  primaryPath: string | null;
-  misplacedEvents: { path: string; entries: EventLogEntry[] }[];
-}
-
-/**
- * Find all events.jsonl files under a directory tree.
- */
-function findEventLogs(baseDir: string, maxDepth = 4): string[] {
-  const results: string[] = [];
-
-  function scan(dir: string, depth: number): void {
-    if (depth > maxDepth) return;
-    try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.name === 'events.jsonl') {
-          results.push(path.join(dir, entry.name));
-        } else if (entry.isDirectory() && !entry.name.startsWith('.')) {
-          scan(path.join(dir, entry.name), depth + 1);
-        }
-      }
-    } catch {
-      // Permission denied or directory doesn't exist
-    }
-  }
-
-  scan(baseDir, 0);
-  return results;
-}
-
-/**
- * Find events.jsonl in well-known locations.
- * Dynamically discovers workspace directories instead of hardcoding names.
- */
-function findKnownEventLogPaths(): string[] {
-  const homeDir = os.homedir();
-  const candidates: string[] = [];
-
-  // Common patterns (legacy, non-workspace paths)
-  const legacyPatterns = [
-    path.join(homeDir, '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', '.state', 'logs', 'events.jsonl'),
-  ];
-
-  for (const p of legacyPatterns) {
-    if (fs.existsSync(p)) {
-      candidates.push(p);
-    }
-  }
-
-  // Dynamically discover workspace directories under ~/.openclaw/
-  const openclawDir = path.join(homeDir, '.openclaw');
-  if (fs.existsSync(openclawDir)) {
-    try {
-      const entries = fs.readdirSync(openclawDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        // Skip known non-workspace directories
-        if (entry.name.startsWith('.') || entry.name === 'extensions' || entry.name === 'memory') continue;
-        const eventLogPath = path.join(openclawDir, entry.name, '.state', 'logs', 'events.jsonl');
-        if (fs.existsSync(eventLogPath)) {
-          candidates.push(eventLogPath);
-        }
-      }
-    } catch {
-      // Directory read failed, skip dynamic discovery
-    }
-  }
-
-  return candidates;
-}
-
-/**
- * Read the last N entries from an events.jsonl file.
- */
-function readRecentEntries(filePath: string, count = 50): EventLogEntry[] {
-  try {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    const lines = content.trim().split('\n').filter(Boolean);
-    const recent = lines.slice(-count);
-    return recent.map(line => JSON.parse(line));
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Count all hooks in the entire file (for summary).
- */
-function countAllHooks(filePath: string): Record<string, number> {
-  const counts: Record<string, number> = {};
-  try {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    const lines = content.trim().split('\n').filter(Boolean);
-    for (const line of lines) {
-      try {
-        const entry = JSON.parse(line) as EventLogEntry;
-        if (entry.type === 'hook_execution' && entry.data?.hook) {
-          const hook = entry.data.hook as string;
-          counts[hook] = (counts[hook] || 0) + 1;
-        }
-      } catch {
-        // Skip malformed lines
-      }
-    }
-  } catch {
-    // File doesn't exist or can't be read
-  }
-  return counts;
-}
-
-/**
- * Audit all events.jsonl files.
- *
- * @param openclawDir - Base OpenClaw directory (e.g., ~/.openclaw)
- * @param expectedToolHooks - Hook names that should appear in the primary workspace
- */
-
-export async function auditEventLogs(
-  openclawDir: string,
-  expectedToolHooks: string[] = ['before_tool_call', 'after_tool_call'],
-): Promise<AuditReport> {
-  const homeDir = os.homedir();
-
-  // Find all event logs
-  const knownPaths = findKnownEventLogPaths();
-  const scannedPaths = findEventLogs(homeDir, 4);
-  const allPaths = [...new Set([...knownPaths, ...scannedPaths])];
-
-  const locations: LocationReport[] = [];
-  let primaryPath: string | null = null;
-
-  for (const filePath of allPaths) {
-    try {
-      const stat = fs.statSync(filePath);
-      const allCounts = countAllHooks(filePath);
-      const recent = readRecentEntries(filePath, 30);
-
-      locations.push({
-        path: filePath,
-        lastModified: stat.mtime,
-        totalEntries: Object.values(allCounts).reduce((a, b) => a + b, 0),
-        hookCounts: allCounts,
-        recentEntries: recent,
-      });
-
-      // Determine primary path - prefer configured workspace over workspace-main
-      // The configured workspace path is {openclawDir}/workspace (without -main suffix)
-      const workspaceDir = path.join(openclawDir, 'workspace') + path.sep;
-      const workspaceMainDir = path.join(openclawDir, 'workspace-main') + path.sep;
-      
-      if (filePath.startsWith(workspaceDir)) {
-        // Configured workspace (e.g., ~/.openclaw/workspace/) takes priority
-        primaryPath = filePath;
-      } else if (!primaryPath && filePath.startsWith(workspaceMainDir)) {
-        // Fallback to workspace-main only if no configured workspace found yet
-        primaryPath = filePath;
-      }
-    } catch {
-      // Skip unreadable files
-    }
-  }
-
-  // If no primary found, use most recent
-  if (!primaryPath && locations.length > 0) {
-    locations.sort((a, b) => {
-      if (!a.lastModified) return 1;
-      if (!b.lastModified) return -1;
-      return b.lastModified.getTime() - a.lastModified.getTime();
-    });
-    primaryPath = locations[0].path;
-  }
-
-  // Detect misplaced tool hook events
-  const misplacedEvents: { path: string; entries: EventLogEntry[] }[] = [];
-  for (const loc of locations) {
-    if (loc.path === primaryPath) continue;
-
-    const toolHookEntries = loc.recentEntries.filter(e =>
-      e.type === 'hook_execution' && expectedToolHooks.includes(e.data?.hook as string)
-    );
-
-    if (toolHookEntries.length > 0) {
-      misplacedEvents.push({ path: loc.path, entries: toolHookEntries });
-    }
-  }
-
-  return {
-    searchedPaths: allPaths,
-    locations,
-    primaryPath,
-    misplacedEvents,
-  };
-}
-
-/**
- * Format audit report for display.
- */
-
-export function formatAuditReport(report: AuditReport): string {
-  const lines: string[] = [];
-
-  lines.push('=== Event Log Audit Report ===\n');
-
-  lines.push(`Searched ${report.searchedPaths.length} paths:\n`);
-  for (const p of report.searchedPaths) {
-    lines.push(`  ${p}`);
-  }
-  lines.push('');
-
-  lines.push(`Primary: ${report.primaryPath ?? 'NOT FOUND'}\n`);
-
-  for (const loc of report.locations) {
-    const isPrimary = loc.path === report.primaryPath;
-    lines.push(`─── ${isPrimary ? '[PRIMARY]' : '[OTHER]   '}${loc.path}`);
-    lines.push(`    Last modified: ${loc.lastModified?.toISOString() ?? 'never'}`);
-    lines.push(`    Hook counts:`);
-
-    const hooks = Object.entries(loc.hookCounts).sort((a, b) => b[1] - a[1]);
-    for (const [hook, count] of hooks) {
-      lines.push(`      ${hook}: ${count}`);
-    }
-
-    if (hooks.length === 0) {
-      lines.push(`      (no hooks recorded)`);
-    }
-    lines.push('');
-  }
-
-  if (report.misplacedEvents.length > 0) {
-    lines.push('⚠️  MISPLACED tool hook events detected:');
-    for (const me of report.misplacedEvents) {
-      lines.push(`\n  ${me.path}:`);
-      for (const entry of me.entries.slice(0, 5)) {
-        lines.push(`    ${entry.ts} - ${entry.data.hook}`);
-      }
-      if (me.entries.length > 5) {
-        lines.push(`    ... and ${me.entries.length - 5} more`);
-      }
-    }
-    lines.push('');
-    lines.push('This means tool hooks are writing events to the wrong .state directory.');
-    lines.push('Check workspaceDir resolution in the hook handler.');
-  } else {
-    lines.push('✅ No misplaced tool hook events detected.');
-  }
-
-  return lines.join('\n');
-}

package/src/service/evolution-queue-lock.ts

@@ -1,47 +0,0 @@
-/**
- * Evolution Queue Lock Utilities
- *
- * File locking for safe concurrent queue access.
- * Extracted from evolution-worker.ts.
- */
-
-import { acquireLockAsync, releaseLock as releaseImportedLock, type LockContext } from '../utils/file-lock.js';
-import { LockUnavailableError } from '../config/index.js';
-
-export const EVOLUTION_QUEUE_LOCK_SUFFIX = '.lock';
-export const LOCK_MAX_RETRIES = 50;
-export const LOCK_RETRY_DELAY_MS = 50;
-export const LOCK_STALE_MS = 30_000;
-
-export async function acquireQueueLock(
-    resourcePath: string,
-    logger: { warn?: (message: string) => void; info?: (message: string) => void } | undefined,
-    lockSuffix: string = EVOLUTION_QUEUE_LOCK_SUFFIX,
-): Promise<() => void> {
-    try {
-        const ctx: LockContext = await acquireLockAsync(resourcePath, {
-            lockSuffix,
-            maxRetries: LOCK_MAX_RETRIES,
-            baseRetryDelayMs: LOCK_RETRY_DELAY_MS,
-            lockStaleMs: LOCK_STALE_MS,
-        });
-        return () => releaseImportedLock(ctx);
-    } catch (error: unknown) {
-        const warn = logger?.warn;
-        warn?.(`[PD:EvolutionWorker] Failed to acquire lock for ${resourcePath}: ${String(error)}`);
-        throw error;
-    }
-}
-
-export async function requireQueueLock(
-    resourcePath: string,
-    logger: { warn?: (message: string) => void; info?: (message: string) => void } | undefined,
-    scope: string,
-    lockSuffix: string = EVOLUTION_QUEUE_LOCK_SUFFIX,
-): Promise<() => void> {
-    try {
-        return await acquireQueueLock(resourcePath, logger, lockSuffix);
-    } catch (err) {
-        throw new LockUnavailableError(resourcePath, scope, { cause: err });
-    }
-}

package/src/service/failure-classifier.ts

@@ -1,79 +0,0 @@
-/**
- * Failure Classifier -- Pure stateless classification of task failure patterns
- * ===========================================================
- *
- * Classifies consecutive task failures from the evolution queue as transient
- * or persistent. This module is pure (no file I/O) and testable in isolation.
- *
- * The classifier reads the evolution queue to count consecutive failures per
- * task kind. When the count reaches the configured threshold (default 3),
- * the pattern is classified as "persistent" and the cooldown strategy should
- * be invoked.
- *
- * IMPORTANT: Only `status === 'failed'` counts as a failure.
- * `status === 'completed'` (including stub_fallback and skipped_thin_violation
- * resolutions) counts as a success and breaks the consecutive failure chain.
- */
-
-import type { EvolutionQueueItem } from './evolution-worker.js';
-
-/** Task kinds subject to failure classification.
- *  Only sleep_reflection and keyword_optimization have outcome handling in
- *  evolution-worker.ts. pain_diagnosis and model_eval are excluded. */
-export type ClassifiableTaskKind = 'sleep_reflection' | 'keyword_optimization';
-
-export interface FailureClassificationResult {
-    /** Whether the failure pattern is transient or persistent */
-    classification: 'transient' | 'persistent';
-    /** Number of consecutive failures for this task kind */
-    consecutiveFailures: number;
-    /** The task kind that was analyzed */
-    taskKind: ClassifiableTaskKind;
-}
-
-/**
- * Classify the failure pattern for a given task kind based on recent task
- * outcomes in the evolution queue.
- *
- * Algorithm:
- * 1. Filter queue to tasks of the specified taskKind with status 'completed' or 'failed'
- * 2. Sort by completed_at (or timestamp fallback) descending (newest first)
- * 3. Count consecutive 'failed' tasks from the top
- * 4. First non-'failed' task (i.e., 'completed') breaks the chain
- * 5. If consecutive count >= threshold, classify as 'persistent'
- *
- * @param queue - Current evolution queue (array of EvolutionQueueItem)
- * @param taskKind - Task kind to classify
- * @param threshold - Consecutive failure threshold for "persistent" (default: 3)
- * @returns FailureClassificationResult
- */
-export function classifyFailure(
-    queue: EvolutionQueueItem[],
-    taskKind: ClassifiableTaskKind,
-    threshold: number = 3,
-): FailureClassificationResult {
-    // Filter to this task kind, only terminal states (completed or failed)
-    const relevantTasks = queue
-        .filter(t => t.taskKind === taskKind)
-        .filter(t => t.status === 'completed' || t.status === 'failed')
-        .sort((a, b) => {
-            const aTime = new Date(a.completed_at || a.timestamp).getTime();
-            const bTime = new Date(b.completed_at || b.timestamp).getTime();
-            return bTime - aTime; // newest first
-        });
-
-    let consecutive = 0;
-    for (const task of relevantTasks) {
-        if (task.status === 'failed') {
-            consecutive++;
-        } else {
-            break; // completed (any resolution including stub_fallback) breaks the chain
-        }
-    }
-
-    return {
-        classification: consecutive >= threshold ? 'persistent' : 'transient',
-        consecutiveFailures: consecutive,
-        taskKind,
-    };
-}