principles-disciple 1.50.0 → 1.52.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.50.0",
+  "version": "1.52.0",
   "skills": [
     "./skills"
   ],

package/package.json

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

package/scripts/compile-principles.mjs

@@ -18,10 +18,20 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+/**
+ * Cross-platform home directory (Linux: HOME, Windows: USERPROFILE/HOMEDRIVE+HOMEPATH)
+ */
+function getHomeDir() {
+  return process.env.HOME
+    || process.env.USERPROFILE
+    || (process.env.HOMEDRIVE && process.env.HOMEPATH ? process.env.HOMEDRIVE + process.env.HOMEPATH : null)
+    || '.';
+}
+
 // Resolve workspace directory: CLI arg > env var > default
 const WORKSPACE_DIR = process.argv[2]
   || process.env.WORKSPACE_DIR
-  || join(process.env.HOME, '.openclaw', 'workspace-main');
+  || join(getHomeDir(), '.openclaw', 'workspace');
 
 const STATE_DIR = join(WORKSPACE_DIR, '.state');
 

package/scripts/sync-plugin.mjs

@@ -27,8 +27,36 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 const SOURCE_DIR = join(__dirname, '..');
-const OPENCLAW_DIR = join(process.env.HOME, '.openclaw');
+
+/**
+ * Cross-platform home directory resolution.
+ * Linux/macOS: HOME=/home/user
+ * Windows: USERPROFILE=C:\Users\user or HOMEDRIVE/HOMEPATH
+ */
+function getHomeDir() {
+  return process.env.HOME
+    || process.env.USERPROFILE
+    || (process.env.HOMEDRIVE && process.env.HOMEPATH ? process.env.HOMEDRIVE + process.env.HOMEPATH : null)
+    || '.';
+}
+
+const OPENCLAW_DIR = join(getHomeDir(), '.openclaw');
 const INSTALL_DIR = join(OPENCLAW_DIR, 'extensions', 'principles-disciple');
+function getConfiguredWorkspaceDir() {
+  const configPath = join(OPENCLAW_DIR, 'openclaw.json');
+  try {
+    const raw = readFileSync(configPath, 'utf-8');
+    const config = JSON.parse(raw);
+    const workspace = config?.agents?.defaults?.workspace;
+    if (workspace && existsSync(workspace)) {
+      return workspace;
+    }
+  } catch {
+    // Fall through to fallback
+  }
+  // Fallback: try workspace-main (legacy default)
+  return join(OPENCLAW_DIR, 'workspace-main');
+}
 
 // Files and directories to sync
 const SYNC_ITEMS = [
@@ -177,7 +205,11 @@ function checkPrerequisites() {
         // Check for global package conflicts that cause module resolution traps
         console.log('🔍 Checking for global package conflicts...');
         try {
-            const globalConflict = execSync('npm list -g principles-disciple --depth=0 2>/dev/null', { encoding: 'utf-8' });
+            // Cross-platform: use stdio: 'pipe' to capture stderr, then check output
+            const globalConflict = execSync('npm list -g principles-disciple --depth=0', {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe']  // Capture all streams
+            });
             if (globalConflict.includes('principles-disciple')) {
                 console.error('\n❌ CONFLICT DETECTED: A version of "principles-disciple" is installed globally via npm.');
                 console.error('This will block OpenClaw from loading the extension version you are trying to install.');
@@ -187,7 +219,17 @@ function checkPrerequisites() {
             }
         } catch (e) {
             // npm list returns non-zero if not found, which is what we want
-            console.log('✅ No global package conflicts detected.');
+            // Check if the error output contains the package name
+            const output = e.stdout || e.stderr || '';
+            if (!output.includes('principles-disciple')) {
+                console.log('✅ No global package conflicts detected.');
+            } else {
+                console.error('\n❌ CONFLICT DETECTED: A version of "principles-disciple" is installed globally via npm.');
+                console.error('This will block OpenClaw from loading the extension version you are trying to install.');
+                console.error('\nACTION REQUIRED: Please run the following command first:');
+                console.error('   npm uninstall -g principles-disciple\n');
+                process.exit(1);
+            }
         }
     } catch {
         console.error('❌ npm not found. Please install Node.js with npm.');
@@ -481,7 +523,7 @@ function verifyInstalledFingerprint() {
 }
 
 /**
- * Remove existing installation directory.
+ * Remove existing installation directory with Windows-friendly retry logic.
  */
 function cleanTargetDir(force) {
     if (!existsSync(INSTALL_DIR)) return;
@@ -495,7 +537,34 @@ function cleanTargetDir(force) {
     }
 
     console.log('\n🗑️  Removing existing installation...');
-    rmSync(INSTALL_DIR, { recursive: true, force: true });
+
+    // Windows often returns EPERM due to file locks, add retry logic
+    const maxRetries = isWindows() ? 3 : 1;
+    let lastError = null;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            rmSync(INSTALL_DIR, { recursive: true, force: true });
+            console.log('   ✅ Removed successfully.');
+            return;
+        } catch (err) {
+            lastError = err;
+            if (err.code === 'EPERM' && attempt < maxRetries) {
+                console.log(`   ⚠️  Attempt ${attempt}/${maxRetries} failed (EPERM), retrying in 2s...`);
+                // Synchronous sleep for retry
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 2000);
+            }
+        }
+    }
+
+    // If all retries failed on Windows, try graceful fallback
+    if (isWindows() && lastError?.code === 'EPERM') {
+        console.log('   ⚠️  Windows file lock detected, skipping removal.');
+        console.log('   📁 Will overwrite files in place.');
+        return;  // Continue with overwrite installation
+    }
+
+    throw lastError;
 }
 
 /**
@@ -573,17 +642,115 @@ function cleanStaleBackups() {
 }
 
 /**
- * Restart OpenClaw Gateway.
+ * Check if running on Windows.
+ */
+function isWindows() {
+    return process.platform === 'win32';
+}
+
+/**
+ * Get temporary directory path (cross-platform).
+ */
+function getTempDir() {
+    if (isWindows()) {
+        return process.env.TEMP || process.env.TMP || 'C:\\Windows\\Temp';
+    }
+    return '/tmp';
+}
+
+/**
+ * Restart OpenClaw Gateway (cross-platform).
  */
 function restartGateway() {
     console.log('\n🔄 Restarting OpenClaw Gateway...');
+
+    if (isWindows()) {
+        return restartGatewayWindows();
+    } else {
+        return restartGatewayLinux();
+    }
+}
+
+/**
+ * Restart Gateway on Windows using PowerShell.
+ */
+function restartGatewayWindows() {
+    const logPath = join(getTempDir(), 'openclaw-auto-restart.log');
+
     try {
+        // Step 1: Find and terminate existing gateway processes
+        console.log('   Looking for existing gateway processes...');
+        try {
+            // PowerShell command to find and kill openclaw gateway processes
+            // Note: Use single quotes inside -like pattern for proper escaping
+            const findCmd = "Get-Process -Name 'node' -ErrorAction SilentlyContinue | Where-Object { $_.CommandLine -like '*openclaw*' } | Select-Object -ExpandProperty Id";
+            const pids = execSync(`powershell -NoProfile -Command "${findCmd}"`, { encoding: 'utf-8' }).trim();
+
+            if (pids) {
+                console.log(`   Terminating existing gateway process(es): ${pids.replace(/\n/g, ', ')}...`);
+                // Kill by PID
+                const pidList = pids.split('\n').filter(p => p.trim());
+                for (const pid of pidList) {
+                    try {
+                        execSync(`taskkill /PID ${pid.trim()} /F`, { stdio: 'pipe' });
+                    } catch { /* ignore if process already gone */ }
+                }
+                // Wait a moment for process to terminate
+                execSync('timeout /t 3 /nobreak > nul', { shell: true, stdio: 'ignore' });
+            }
+        } catch { /* no existing processes */ }
+
+        // Step 2: Start new gateway process in background
+        console.log(`   Starting new gateway (logs: ${logPath})...`);
+
+        // Use openclaw CLI to start gateway (more reliable than direct node invocation)
+        const gatewayCmd = join(getHomeDir(), '.openclaw', 'gateway.cmd');
+        const startCmd = `Start-Process -FilePath 'cmd.exe' -ArgumentList '/c ${gatewayCmd}' -WindowStyle Hidden -RedirectStandardOutput '${logPath}' -RedirectStandardError '${join(getTempDir(), 'openclaw-auto-restart.err')}'`;
+        execSync(`powershell -NoProfile -Command "${startCmd}"`, { stdio: 'inherit' });
+        console.log('✅ Gateway restart triggered.');
+
+        // Step 3: Wait and verify
+        setTimeout(() => {
+            try {
+                if (existsSync(logPath)) {
+                    const logs = readFileSync(logPath, 'utf-8');
+                    if (logs.includes('Principles Disciple Plugin registered')) {
+                        console.log('✅ SUCCESS: Principles Disciple plugin registered successfully!');
+                    } else if (logs.includes('failed to load') || logs.includes('Error: Cannot find module')) {
+                        console.error('\n❌ CRITICAL: Gateway started but PD plugin FAILED to load!');
+                        console.error('   Check logs at: ' + logPath);
+                        process.exit(1);
+                    } else {
+                        console.warn('⚠️  Gateway started but PD registration not confirmed in recent logs.');
+                        console.log('   Check logs at: ' + logPath);
+                    }
+                }
+            } catch (e) {
+                console.warn(`⚠️  Post-restart verification skipped: ${e.message}`);
+            }
+        }, 8000);
+
+    } catch (error) {
+        console.error(`\n❌ Failed to restart gateway: ${error.message}`);
+        console.error('   You may need to manually restart OpenClaw Gateway.');
+        process.exit(1);
+    }
+}
+
+/**
+ * Restart Gateway on Linux using systemctl or process management.
+ */
+function restartGatewayLinux() {
+    const logPath = '/tmp/openclaw-auto-restart.log';
+
+    try {
+        // Try systemctl first (Linux systemd)
         try {
             execSync('systemctl --user is-active openclaw-gateway.service', { stdio: 'pipe' });
             console.log('   Restarting via systemctl...');
             execSync('systemctl --user restart openclaw-gateway.service', { stdio: 'inherit' });
             console.log('✅ Gateway restarted via systemctl.');
-            
+
             console.log('   Waiting for Gateway to initialize and load PD plugin (8s)...');
             setTimeout(() => {
                 try {
@@ -608,8 +775,9 @@ function restartGateway() {
                 }
             }, 8000);
             return;
-        } catch { /* ignore */ }
+        } catch { /* systemctl not available, fall through to manual restart */ }
 
+        // Manual process management
         const pids = execSync('pgrep -f "openclaw-gateway|openclaw gateway"', { encoding: 'utf-8' }).trim();
         if (pids) {
             console.log(`   Terminating existing gateway process(es)...`);
@@ -617,11 +785,10 @@ function restartGateway() {
             execSync('sleep 3');
         }
 
-        const logPath = '/tmp/openclaw-auto-restart.log';
         console.log(`   Starting new gateway (logs: ${logPath})...`);
         execSync(`nohup openclaw gateway --force > ${logPath} 2>&1 &`, { stdio: 'ignore' });
         console.log('✅ Gateway restart triggered.');
-        
+
         setTimeout(() => {
             if (existsSync(logPath)) {
                 const logs = readFileSync(logPath, 'utf-8');
@@ -699,9 +866,10 @@ function main() {
     if (existsSync(bootstrapScript)) {
         console.log('\n🧠 Synchronizing principles to active rules (Bootstrap)...');
         try {
-            const targetStateDir = join(process.env.HOME, '.openclaw', 'workspace-main', '.state');
+            const workspaceDir = getConfiguredWorkspaceDir();
+            const targetStateDir = join(workspaceDir, '.state');
             if (existsSync(targetStateDir)) {
-                execSync(`STATE_DIR=${targetStateDir} BOOTSTRAP_LIMIT=100 node scripts/bootstrap-rules.mjs`, { cwd: SOURCE_DIR, stdio: 'inherit' });
+                execSync(`node scripts/bootstrap-rules.mjs`, { cwd: SOURCE_DIR, stdio: 'inherit', env: { ...process.env, STATE_DIR: targetStateDir, BOOTSTRAP_LIMIT: '100' } });
                 console.log('✅ Principles synchronized.');
             }
         } catch (e) {
@@ -713,7 +881,8 @@ function main() {
     if (existsSync(compileScript)) {
         console.log('\n⚙️  Compiling pain-derived principles into rules...');
         try {
-            const targetWorkspaceDir = join(process.env.HOME, '.openclaw', 'workspace-main');
+            const workspaceDir = getConfiguredWorkspaceDir();
+            const targetWorkspaceDir = workspaceDir;
             if (existsSync(targetWorkspaceDir)) {
                 execSync(`node scripts/compile-principles.mjs ${targetWorkspaceDir}`, { cwd: SOURCE_DIR, stdio: 'inherit' });
                 console.log('✅ Principle compilation complete.');
@@ -732,12 +901,6 @@ function main() {
     verifyInstalledFingerprint();
     if (args.dev || args.restart) cleanStaleBackups();
 
-    try {
-        const reloadSignal = join(OPENCLAW_DIR, '.plugin_reload_signal');
-        writeFileSync(reloadSignal, new Date().toISOString(), 'utf-8');
-        console.log(`\n🔔 Reload signal sent to ${reloadSignal}`);
-    } catch { /* ignore */ }
-
     console.log('\n╔════════════════════════════════════════════════════════════╗');
     console.log('║                  ✅ Installation Complete                  ║');
     console.log('╚════════════════════════════════════════════════════════════╝');
@@ -746,6 +909,7 @@ function main() {
         restartGateway();
     } else {
         console.log('\n💡 Restart OpenClaw Gateway to load the new version.');
+        console.log('   (Plugin code changes require a full gateway restart)');
     }
 }
 

package/src/core/init.ts

@@ -6,6 +6,7 @@ import { PD_DIRS } from './paths.js';
 import { defaultContextConfig } from '../types.js';
 import { loadStore, setPrincipleState, type PrincipleTrainingState } from './principle-training-state.js';
 import { atomicWriteFileSync } from '../utils/io.js';
+import { createDefaultKeywordStore, saveKeywordStore } from './empathy-keyword-matcher.js';
 
 /**
  * Default PROFILE.json content
@@ -245,6 +246,17 @@ export function ensureStateTemplates(ctx: { logger: PluginLogger }, stateDir: st
             fs.copyFileSync(dictTemplate, dictDest);
             ctx.logger.info(`[PD] Initialized pain dictionary in stateDir: ${dictDest} (Lang: ${language})`);
         }
+
+        // 3. Initialize empathy keyword store for new users
+        // loadKeywordStore() creates the file if missing, but we call it explicitly
+        // here so the file exists before any agent/workflow tries to read it
+        const empathyFile = path.join(stateDir, 'empathy_keywords.json');
+        if (!fs.existsSync(empathyFile)) {
+            const lang = language === 'zh' || language === 'en' ? language : 'en';
+            const store = createDefaultKeywordStore(lang);
+            saveKeywordStore(stateDir, store);
+            ctx.logger.info(`[PD] Initialized empathy keyword store in stateDir: ${empathyFile}`);
+        }
     } catch (err) {
         ctx.logger.error(`[PD] Failed to initialize state templates: ${String(err)}`);
     }

package/src/core/pd-task-reconciler.ts

@@ -144,7 +144,7 @@ function diff(declared: PDTaskSpec[], actual: CronJob[]): DiffAction[] {
 function buildCronJob(
   task: PDTaskSpec,
   nowMs: number,
-   
+  workspaceDir: string,
   logger?: { info?: (_: string) => void },
 ): CronJob {
   logger?.info?.(`[PD:Reconciler] Building cron job: ${task.name} (id=${task.id}, interval=${task.schedule.everyMs}ms)`);
@@ -159,9 +159,7 @@ function buildCronJob(
     wakeMode: 'now',
     payload: {
       kind: 'agentTurn',
-       
-       
-      message: buildTaskPrompt(task, logger),
+      message: buildTaskPrompt(task, workspaceDir, logger),
       lightContext: task.execution.lightContext ?? true,
       timeoutSeconds: task.execution.timeoutSeconds ?? 120,
       toolsAllow: task.execution.toolsAllow,
@@ -180,7 +178,12 @@ function buildCronJob(
 }
 
  
-function buildTaskPrompt(task: PDTaskSpec, logger?: { info?: (_: string) => void }): string {
+function buildTaskPrompt(task: PDTaskSpec, workspaceDir: string, logger?: { info?: (_: string) => void }): string {
+  // Resolve paths dynamically from workspaceDir instead of hardcoding
+  const stateDir = path.join(workspaceDir, '.state');
+  const empathyKeywordsPath = path.join(stateDir, 'empathy_keywords.json');
+  const eventsJsonlPath = path.join(stateDir, 'logs', 'events.jsonl');
+
   if (task.id === 'empathy-optimizer') {
     logger?.info?.(`[PD:Reconciler] Building empathy optimizer prompt`);
     return `You are the Principles Disciple Empathy Keyword Optimizer.
@@ -195,7 +198,7 @@ Analyze the current empathy keyword store and recent user message logs to:
 
 ### Step 1: Read current keyword store
 Use read_file to load:
-\`~/.openclaw/workspace-main/.state/empathy_keywords.json\`
+\`${empathyKeywordsPath}\`
 
 Examine the "terms" object. For each term note:
 - weight (0.1-0.9): higher = stronger frustration signal
@@ -204,7 +207,7 @@ Examine the "terms" object. For each term note:
 
 ### Step 2: Read recent message logs
 Use search_file_content to scan:
-\`~/.openclaw/workspace-main/.state/logs/events.jsonl\`
+\`${eventsJsonlPath}\`
 
 Look for user messages containing frustration signals:
 - Negation: "不对", "错了", "不行", "重做"
@@ -214,7 +217,7 @@ Look for user messages containing frustration signals:
 
 ### Step 3: Write updated keyword store
 Use write_file to save the updated store back to:
-\`~/.openclaw/workspace-main/.state/empathy_keywords.json\`
+\`${empathyKeywordsPath}\`
 
 The file format is:
 \`\`\`json
@@ -304,7 +307,7 @@ export async function reconcilePDTasks(
       case 'CREATE':
         if (action.task) {
           if (!dryRun) {
-            const job = buildCronJob(action.task, nowMs, logger);
+            const job = buildCronJob(action.task, nowMs, workspaceDir, logger);
             cronStore.jobs.push(job);
             logger.info?.(`[PD:Reconciler] Created job: ${action.task.name}`);
           }
@@ -315,7 +318,7 @@ export async function reconcilePDTasks(
         if (action.task && action.job) {
           if (!dryRun) {
             const idx = cronStore.jobs.indexOf(action.job);
-            const newJob = buildCronJob(action.task, nowMs, logger);
+            const newJob = buildCronJob(action.task, nowMs, workspaceDir, logger);
             newJob.id = action.job.id;
             // Preserve original state — only CronService should recalculate nextRunAtMs
             newJob.state = {
@@ -449,7 +452,7 @@ export async function trigger(
     existingJob.deleteAfterRun = undefined;
   } else {
     log(`Creating new job for manual trigger: ${task.name}`);
-    const newJob = buildCronJob(task, nowMs, { info: log });
+    const newJob = buildCronJob(task, nowMs, workspaceDir, { info: log });
     newJob.enabled = true;
     newJob.state.nextRunAtMs = nowMs;
     cronStore.jobs.push(newJob);

package/src/hooks/prompt.ts

@@ -533,8 +533,11 @@ The empathy observer subagent handles pain detection independently.
 
   const empathyEnabled = wctx.config.get('empathy_engine.enabled') !== false;
   logger?.info?.(`[PD:Empathy] Conditions: enabled=${empathyEnabled}, isUser=${isUserInteraction}, sessionId=${!!sessionId}, api=${!!api}, !agentToAgent=${!isAgentToAgent}, workspaceDir=${!!workspaceDir}, hasMessage=${!!latestUserMessage}`);
+
+  // Track if we should inject behavioral constraints (will be added to appendSystemContext later)
+  let shouldInjectBehavioralConstraints = false;
   if (empathyEnabled && isUserInteraction && sessionId && api && !isAgentToAgent) {
-    prependContext = '### BEHAVIORAL_CONSTRAINTS\n' + empathySilenceConstraint + '\n\n' + prependContext;
+    shouldInjectBehavioralConstraints = true;
 
     // ── Empathy Hybrid Matching (keyword + subagent sampling) ──
     // Fast keyword scan on every turn, with strategic subagent sampling
@@ -935,9 +938,18 @@ ${taskBlocks}${processingNote}
   }
 
   // Build appendSystemContext with recency effect
-  // Content order (most important last): project_context -> working_memory -> reflection_log -> thinking_os -> principles
+  // Content order (most important last): behavioral_constraints -> project_context -> working_memory -> reflection_log -> thinking_os -> principles
   const appendParts: string[] = [];
 
+  // 0. Behavioral Constraints (empathy observer coordination)
+  // Injected here (appendSystemContext) instead of prependContext to hide from WebUI users.
+  // See: https://github.com/csuzngjh/principles/issues/XXX
+  if (shouldInjectBehavioralConstraints) {
+    appendParts.push(`<behavioral_constraints>
+${empathySilenceConstraint}
+</behavioral_constraints>`);
+  }
+
   // 1. Project Context (lowest priority, goes first)
   if (projectContextContent) {
     appendParts.push(`<project_context>\n${projectContextContent}\n</project_context>`);
@@ -1087,6 +1099,7 @@ The sections below are ordered by priority. When conflicts arise, **later sectio
 ---
 
 **【EXECUTION RULES】** (Priority: Low → High):
+- \`<behavioral_constraints>\` - Output format restrictions (hide diagnostic JSON)
 - \`<project_context>\` - Current priorities (can be overridden)
 - \`<reflection_log>\` - Past lessons (inform your approach)
 - \`<thinking_os>\` - Thinking models (guide your reasoning)

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

@@ -1,9 +1,9 @@
 /**
- * EventLog Auditor — Search and verify events across all .state directories
- * 
+ * 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);
@@ -42,7 +42,7 @@ interface AuditReport {
  */
 function findEventLogs(baseDir: string, maxDepth = 4): string[] {
   const results: string[] = [];
-  
+
   function scan(dir: string, depth: number): void {
     if (depth > maxDepth) return;
     try {
@@ -58,37 +58,50 @@ function findEventLogs(baseDir: string, maxDepth = 4): string[] {
       // 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
-  const patterns = [
+
+  // Common patterns (legacy, non-workspace paths)
+  const legacyPatterns = [
     path.join(homeDir, '.state', 'logs', 'events.jsonl'),
     path.join(homeDir, '.openclaw', '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', 'workspace-main', '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', 'workspace-builder', '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', 'workspace-pm', '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', 'workspace-hr', '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', 'workspace-repair', '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', 'workspace-research', '.state', 'logs', 'events.jsonl'),
-    path.join(homeDir, '.openclaw', 'workspace-scout', '.state', 'logs', 'events.jsonl'),
   ];
-  
-  for (const p of patterns) {
+
+  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;
 }
 
@@ -133,25 +146,25 @@ function countAllHooks(filePath: string): Record<string, number> {
 
 /**
  * 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);
@@ -165,7 +178,7 @@ export async function auditEventLogs(
         hookCounts: allCounts,
         recentEntries: recent,
       });
-      
+
       // Determine primary path (workspace-main or most recent)
       if (filePath.includes('workspace-main') || filePath.includes('workspace-main')) {
         primaryPath = filePath;
@@ -174,7 +187,7 @@ export async function auditEventLogs(
       // Skip unreadable files
     }
   }
-  
+
   // If no primary found, use most recent
   if (!primaryPath && locations.length > 0) {
     locations.sort((a, b) => {
@@ -184,21 +197,21 @@ export async function auditEventLogs(
     });
     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 => 
+
+    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,
@@ -210,37 +223,37 @@ export async function auditEventLogs(
 /**
  * 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) {
@@ -258,6 +271,6 @@ export function formatAuditReport(report: AuditReport): string {
   } else {
     lines.push('✅ No misplaced tool hook events detected.');
   }
-  
+
   return lines.join('\n');
 }