principles-disciple 1.55.0 → 1.57.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.55.0",
+  "version": "1.57.0",
   "skills": [
     "./skills"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.55.0",
+  "version": "1.57.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",
@@ -67,6 +67,7 @@
     }
   },
   "dependencies": {
+    "@principles/core": "^0.1.0",
     "@sinclair/typebox": "^0.34.48",
     "better-sqlite3": "^12.9.0",
     "lucide-react": "^1.7.0",

package/scripts/sync-plugin.mjs

@@ -17,7 +17,7 @@
  *   --help             Show help message
  */
 
-import { copyFileSync, cpSync, existsSync, rmSync, readFileSync, readFileSync as readFileSyncRaw, mkdirSync, writeFileSync, readdirSync } from 'fs';
+import { copyFileSync, cpSync, existsSync, lstatSync, rmSync, readFileSync, readFileSync as readFileSyncRaw, mkdirSync, writeFileSync, readdirSync } from 'fs';
 import { createHash } from 'crypto';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
@@ -80,7 +80,7 @@ function parseArgs() {
         skipBuild: false,
         skipDeps: false,
         force: false,
-        restart: false,
+        restart: true,
         dev: false,
         bump: false,
         help: false,
@@ -100,7 +100,8 @@ function parseArgs() {
                 args.skipDeps = true;
                 break;
             case '--restart':
-                args.restart = true;
+            case '--no-restart':
+                args.restart = !arg.startsWith('--no-');
                 break;
             case '--dev':
             case '-d':
@@ -145,7 +146,7 @@ Options:
   --lang <zh|en>     Language for skills (default: zh)
   --skip-build       Skip build step (use existing dist/)
   --skip-deps        Skip dependency installation
-  --restart          Automatically restart OpenClaw gateway after installation
+  --restart         Automatically restart OpenClaw gateway after installation (default: true, use --no-restart to skip)
   --dev, -d          Developer mode: --force + --restart + --bump + clean stale backups
   --bump, -b         Auto-bump patch version if there are uncommitted source changes
   --force, -f        Force overwrite without prompts
@@ -610,6 +611,47 @@ function syncItem(item) {
     }
 }
 
+/**
+ * Recursive directory copy (Windows-safe, no symlinks).
+ */
+function copyDir(src, dest) {
+    mkdirSync(dest, { recursive: true });
+    for (const entry of readdirSync(src)) {
+        const srcPath = join(src, entry);
+        const destPath = join(dest, entry);
+        if (lstatSync(srcPath).isDirectory()) {
+            copyDir(srcPath, destPath);
+        } else {
+            copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+/**
+ * Inject local workspace packages (monorepo) into node_modules before npm install.
+ * @principles/core is a workspace package, not published to npm — we must copy it
+ * from the monorepo's node_modules so npm install --production doesn't 404 it.
+ */
+function injectLocalWorkspacePackages() {
+    const monorepoModules = join(SOURCE_DIR, '..', '..', 'node_modules', '@principles', 'core');
+    const targetModules = join(INSTALL_DIR, 'node_modules', '@principles', 'core');
+
+    if (!existsSync(monorepoModules)) {
+        // Not in monorepo context (e.g., npm pack / CI tarball) — skip
+        return;
+    }
+
+    console.log('  📦 Injecting local workspace packages (@principles/core)...');
+    mkdirSync(dirname(targetModules), { recursive: true });
+    // cpSync creates symlinks on Windows for symlinked dirs — use cp -rL (dereference) via exec
+    try {
+        execSync(`cp -rL "${monorepoModules}" "${targetModules}"`, { stdio: 'ignore' });
+    } catch {
+        // Fallback: manual copy via node (Windows-compatible)
+        copyDir(monorepoModules, targetModules);
+    }
+}
+
 /**
  * Install production dependencies in target.
  */
@@ -844,6 +886,7 @@ function main() {
     for (const item of SYNC_ITEMS) syncItem(item);
     syncSkills(args.lang);
 
+    injectLocalWorkspacePackages();
     installTargetDependencies();
 
     console.log('\n🔍 Verifying installed plugin can load native dependencies...');

package/src/core/event-log.ts

@@ -51,6 +51,9 @@ export class EventLog {
   private currentEventsFile: string | undefined;
   private currentDate: string | undefined;
 
+  // Pain score sum per date (for avgScore calculation)
+  private readonly painScoreSums: Map<string, number> = new Map();
+
   constructor(stateDir: string, logger?: PluginLogger) {
     this.logsDir = path.join(stateDir, 'logs');
     if (!fs.existsSync(this.logsDir)) {
@@ -156,6 +159,10 @@ export class EventLog {
   recordEvolutionTask(data: EvolutionTaskEventData): void {
     this.record('evolution_task', 'enqueued', undefined, data);
   }
+
+  recordEvolutionTaskCompleted(data: EvolutionTaskEventData): void {
+    this.record('evolution_task', 'completed', undefined, data);
+  }
   
   recordDeepReflection(sessionId: string | undefined, data: DeepReflectionEventData): void {
     const category = data.passed ? 'passed' : data.timeout ? 'failure' : 'completed';
@@ -238,6 +245,18 @@ export class EventLog {
       stats.pain.signalsDetected++;
       stats.pain.maxScore = Math.max(stats.pain.maxScore, data.score);
 
+      // Track signals by source
+      if (data.source) {
+        stats.pain.signalsBySource[data.source] = (stats.pain.signalsBySource[data.source] || 0) + 1;
+      }
+
+      // Accumulate score for avg calculation
+      const currentSum = this.painScoreSums.get(entry.date) ?? 0;
+      this.painScoreSums.set(entry.date, currentSum + (data.score || 0));
+      stats.pain.avgScore = stats.pain.signalsDetected > 0
+        ? Math.round((currentSum + (data.score || 0)) / stats.pain.signalsDetected)
+        : 0;
+
       // Update empathy stats for user_empathy source
       if (data.source === 'user_empathy') {
         if (data.deduped) {
@@ -291,6 +310,20 @@ export class EventLog {
       const data = entry.data as unknown as EmpathyRollbackEventData;
       stats.empathy.rollbackCount++;
       stats.empathy.rolledBackScore += data.originalScore || 0;
+    } else if (entry.type === 'rule_match') {
+      const data = entry.data as unknown as RuleMatchEventData;
+      if (data.ruleId) {
+        stats.pain.rulesMatched[data.ruleId] = (stats.pain.rulesMatched[data.ruleId] || 0) + 1;
+      }
+    } else if (entry.type === 'rule_promotion') {
+      stats.pain.candidatesPromoted++;
+      stats.evolution.rulesPromoted++;
+    } else if (entry.type === 'evolution_task') {
+      if (entry.category === 'completed') {
+        stats.evolution.tasksCompleted++;
+      } else if (entry.category === 'enqueued') {
+        stats.evolution.tasksEnqueued++;
+      }
     }
   }
 

package/src/core/evolution-logger.ts

@@ -260,7 +260,7 @@ export class EvolutionLogger {
   logCompleted(params: {
     traceId: string;
     taskId: string;
-    resolution: 'marker_detected' | 'auto_completed_timeout' | 'manual' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'diagnostician_timeout';
+    resolution: 'marker_detected' | 'auto_completed_timeout' | 'manual' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'diagnostician_timeout' | 'noise_classified' | 'duplicate' | 'serverDuplicate';
     durationMs?: number;
     principlesGenerated?: number;
   }): void {
@@ -271,6 +271,8 @@ export class EvolutionLogger {
       summary = `任务 ${params.taskId} 完成，已生成 ${params.principlesGenerated || 0} 条原则`;
     } else if (params.resolution === 'auto_completed_timeout' || params.resolution === 'diagnostician_timeout' || params.resolution === 'late_marker_no_principle') {
       summary = `任务 ${params.taskId} 超时自动完成`;
+    } else if (params.resolution === 'noise_classified' || params.resolution === 'duplicate' || params.resolution === 'serverDuplicate') {
+      summary = `任务 ${params.taskId} 分类为噪音/重复，已过滤`;
     } else {
       summary = `任务 ${params.taskId} 已完成`;
     }

package/src/core/evolution-types.ts

@@ -470,7 +470,7 @@ export type EvolutionLoopEvent =
 
 // 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 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' | 'noise_classified';
 
 export interface EvolutionQueueItem {
   id: string;

package/src/core/observability.ts

@@ -235,7 +235,7 @@ function persistBaselines(stateDir: string, baselines: ObservabilityBaselines):
       fs.mkdirSync(dir, { recursive: true });
     }
     atomicWriteFileSync(filePath, JSON.stringify(baselines, null, 2));
-  } catch (err) {
+  } catch {
     // Baselines persistence is best-effort — don't crash the caller
     // (the SystemLogger call above already logged the values)
   }

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

@@ -26,7 +26,8 @@ export type TaskResolution =
     | 'late_marker_principle_created'
     | 'late_marker_no_principle'
     | 'stub_fallback'
-    | 'skipped_thin_violation';
+    | 'skipped_thin_violation'
+    | 'noise_classified';
 
 /**
  * Recent pain context for sleep_reflection tasks.

package/src/service/evolution-worker.ts

@@ -109,7 +109,7 @@ let timeoutId: NodeJS.Timeout | null = null;
  * Old queue items (without taskKind) are migrated to pain_diagnosis for compatibility.
  */
 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';
+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' | 'noise_classified';
 
 export interface EvolutionQueueItem {
     // Core identity
@@ -921,11 +921,27 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
             if (fs.existsSync(completeMarker)) {
                 if (logger) logger.info(`[PD:EvolutionWorker] Task ${task.id} completed - marker file detected`);
 
+                let principlesGenerated = 0;
                 // Create principle from the diagnostician's JSON report.
                 const reportPath = path.join(wctx.stateDir, `.diagnostician_report_${task.id}.json`);
                 if (fs.existsSync(reportPath)) {
                     try {
                         const reportData = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+
+                        // ── Step 3: Noise Classification Filter ──
+                        // Skip principle creation for low-value noise categories that don't represent
+                        // systemic failures or behavioral issues worth encoding as principles.
+                        const classification = reportData?.classification;
+                        const noiseCategories: Record<string, boolean> = {
+                            'development_transient': true, // CRLF drift, duplicate match, self-resolved dev issues
+                            'user_error': true,           // User mistakes, wrong file, bad input
+                        };
+                        if (classification?.category && noiseCategories[classification.category]) {
+                            if (logger) logger.info(`[PD:EvolutionWorker] Skipping principle for noise category "${classification.category}" — pain was ${classification.severity || 'low'} severity, not a systemic failure`);
+                            task.status = 'completed';
+                            task.completed_at = new Date().toISOString();
+                            task.resolution = 'noise_classified';
+                        } else {
                         // Check ALL known nesting paths — matches subagent.ts parseDiagnosticianReport
                         const principle = reportData?.principle
                             || reportData?.phases?.principle_extraction?.principle
@@ -1006,6 +1022,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                                     });
                                     if (principleId) {
                                         logger.info(`[PD:EvolutionWorker] Created principle ${principleId} from marker fallback for task ${task.id}`);
+                                        principlesGenerated = 1;
                                     } else {
                                         logger.warn(`[PD:EvolutionWorker] createPrincipleFromDiagnosis returned null for task ${task.id} (may be duplicate or blacklisted)`);
                                     }
@@ -1017,6 +1034,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                         } else {
                             logger.warn(`[PD:EvolutionWorker] Diagnostician report for task ${task.id} missing principle fields — diagnostician did not produce a principle`);
                         }
+                        }
                     } catch (err) {
                         logger.warn(`[PD:EvolutionWorker] Failed to parse diagnostician report for task ${task.id}: ${String(err)}`);
                     }
@@ -1026,7 +1044,8 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
 
                 task.status = 'completed';
                 task.completed_at = new Date().toISOString();
-                task.resolution = 'marker_detected';
+                // resolution already set by each branch (noise_classified | marker_detected)
+                if (!task.resolution) task.resolution = 'marker_detected';
                 try {
                     fs.unlinkSync(completeMarker);
                 } catch { /* marker may have been deleted already, not critical */ }
@@ -1047,22 +1066,30 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                 evoLogger.logCompleted({
                     traceId: task.traceId || task.id,
                     taskId: task.id,
-                    resolution: 'marker_detected',
+                    resolution: task.resolution as 'marker_detected' | 'auto_completed_timeout' | 'manual' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'diagnostician_timeout',
                     durationMs,
+                    principlesGenerated,
+                });
+
+                // Record task completion in event stats
+                eventLog.recordEvolutionTaskCompleted({
+                    taskId: task.id,
+                    taskType: task.source || 'unknown',
+                    reason: task.reason || '',
                 });
 
                 // Update evolution_tasks table
                 wctx.trajectory?.updateEvolutionTask?.(task.id, {
                     status: 'completed',
                     completedAt: task.completed_at,
-                    resolution: 'marker_detected',
+                    resolution: task.resolution as 'marker_detected' | 'auto_completed_timeout' | 'manual' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'diagnostician_timeout',
                 });
 
                 wctx.trajectory?.recordTaskOutcome({
                     sessionId: task.assigned_session_key || 'heartbeat:diagnostician',
                     taskId: task.id,
                     outcome: 'ok',
-                    summary: `Task ${task.id} completed - marker file detected.`
+                    summary: `Task ${task.id} completed — ${principlesGenerated} principle(s) generated (${task.resolution}).`
                 });
                 queueChanged = true;
                 continue;
@@ -1075,9 +1102,11 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                 const timeoutCompleteMarker = path.join(wctx.stateDir, `.evolution_complete_${task.id}`);
                 const timeoutReportPath = path.join(wctx.stateDir, `.diagnostician_report_${task.id}.json`);
 
+                let principlesGenerated = 0;
+
+
                 if (fs.existsSync(timeoutCompleteMarker) && fs.existsSync(timeoutReportPath)) {
                     if (logger) logger.info(`[PD:EvolutionWorker] Task ${task.id} timed out but marker found — creating principle anyway`);
-                    let principleCreated = false;
                     try {
                         const reportData = JSON.parse(fs.readFileSync(timeoutReportPath, 'utf8'));
                         const principle = reportData?.principle
@@ -1103,7 +1132,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                                     });
                                 if (principleId) {
                                     logger.info(`[PD:EvolutionWorker] Created principle ${principleId} from late marker for task ${task.id}`);
-                                    principleCreated = true;
+                                    principlesGenerated = 1;
                                 }
                             }
                         }
@@ -1116,7 +1145,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                         const lateReportPath = path.join(wctx.stateDir, `.diagnostician_report_${task.id}.json`);
                         if (fs.existsSync(lateReportPath)) fs.unlinkSync(lateReportPath);
                     } catch { /* report may not exist, not critical */ }
-                    task.resolution = principleCreated ? 'late_marker_principle_created' : 'late_marker_no_principle';
+                    task.resolution = principlesGenerated > 0 ? 'late_marker_principle_created' : 'late_marker_no_principle';
                 } else {
                     if (logger) logger.info(`[PD:EvolutionWorker] Task ${task.id} auto-completed after ${timeoutMinutes} minute timeout`);
                     // #190: Clean up diagnostician report file even on timeout (may have been written late)
@@ -1137,6 +1166,14 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                     taskId: task.id,
                     resolution: task.resolution,
                     durationMs: age,
+                    principlesGenerated,
+                });
+
+                // Record task completion in event stats (for timeout path too)
+                eventLog.recordEvolutionTaskCompleted({
+                    taskId: task.id,
+                    taskType: task.source || 'unknown',
+                    reason: task.reason || '',
                 });
 
                 // Update evolution_tasks table - use task.resolution, not hardcoded value
@@ -1150,7 +1187,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                     sessionId: task.assigned_session_key || 'heartbeat:diagnostician',
                     taskId: task.id,
                     outcome: 'timeout',
-                    summary: `Task ${task.id} auto-completed after ${timeoutMinutes} minute timeout.`
+                    summary: `Task ${task.id} completed — ${principlesGenerated} principle(s) generated (${task.resolution}).`
                 });
                 queueChanged = true;
             }

package/src/tools/write-pain-flag.ts

@@ -1,6 +1,5 @@
 import type { OpenClawPluginApi } from '../openclaw-sdk.js';
 import { Type } from '@sinclair/typebox';
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 import { buildPainFlag } from '../core/pain.js';
 import { resolveWorkspaceDirFromApi } from '../core/path-resolver.js';
 import { TrajectoryRegistry } from '../core/trajectory.js';

package/tests/core/event-log.test.ts

@@ -179,4 +179,78 @@ describe('EventLog', () => {
       expect(stats.totalPenaltyScore).toBe(12);
     });
   });
+
+  describe('Evolution and rule stats', () => {
+    it('should count evolution_task enqueued events', () => {
+      eventLog.recordEvolutionTask({ taskId: 't1', taskType: 'pain_diagnosis', reason: 'test' });
+      eventLog.recordEvolutionTask({ taskId: 't2', taskType: 'pain_diagnosis', reason: 'test' });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      expect(stats.evolution.tasksEnqueued).toBe(2);
+      expect(stats.evolution.tasksCompleted).toBe(0);
+    });
+
+    it('should count evolution_task completed events', () => {
+      // First enqueue
+      eventLog.recordEvolutionTask({ taskId: 't1', taskType: 'pain_diagnosis', reason: 'test' });
+      // Then complete
+      eventLog.recordEvolutionTaskCompleted({ taskId: 't1', taskType: 'pain_diagnosis', reason: 'test' });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      expect(stats.evolution.tasksEnqueued).toBe(1);
+      expect(stats.evolution.tasksCompleted).toBe(1);
+    });
+
+    it('should track rule_match events in rulesMatched', () => {
+      eventLog.recordRuleMatch('s1', { ruleId: 'edit-exact-match', layer: 'L2', severity: 0.8, textPreview: 'test' });
+      eventLog.recordRuleMatch('s1', { ruleId: 'edit-exact-match', layer: 'L2', severity: 0.8, textPreview: 'test' });
+      eventLog.recordRuleMatch('s1', { ruleId: 'path-traversal', layer: 'L1', severity: 0.9, textPreview: 'test2' });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      expect(stats.pain.rulesMatched['edit-exact-match']).toBe(2);
+      expect(stats.pain.rulesMatched['path-traversal']).toBe(1);
+    });
+
+    it('should track rule_promotion events', () => {
+      eventLog.recordRulePromotion({ fingerprint: 'fp1', ruleId: 'r1', phrase: 'test', sampleCount: 5, avgSimilarity: 0.9 });
+      eventLog.recordRulePromotion({ fingerprint: 'fp2', ruleId: 'r2', phrase: 'test2', sampleCount: 3, avgSimilarity: 0.8 });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      expect(stats.pain.candidatesPromoted).toBe(2);
+      expect(stats.evolution.rulesPromoted).toBe(2);
+    });
+
+    it('should track pain signals by source', () => {
+      eventLog.recordPainSignal('s1', { source: 'tool_failure', score: 50, reason: 'edit failed' });
+      eventLog.recordPainSignal('s2', { source: 'tool_failure', score: 60, reason: 'read failed' });
+      eventLog.recordPainSignal('s3', { source: 'user_empathy', score: 10, reason: 'user frustrated' });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      expect(stats.pain.signalsBySource['tool_failure']).toBe(2);
+      expect(stats.pain.signalsBySource['user_empathy']).toBe(1);
+      expect(stats.pain.signalsDetected).toBe(3);
+    });
+
+    it('should calculate avgScore for pain signals', () => {
+      eventLog.recordPainSignal('s1', { source: 'tool_failure', score: 50, reason: 'test' });
+      eventLog.recordPainSignal('s2', { source: 'tool_failure', score: 70, reason: 'test' });
+      eventLog.recordPainSignal('s3', { source: 'tool_failure', score: 60, reason: 'test' });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      expect(stats.pain.avgScore).toBe(60); // (50+70+60)/3 = 60
+      expect(stats.pain.maxScore).toBe(70);
+    });
+  });
 });

package/tests/core/pain-context-extractor.test.ts

@@ -1,8 +1,9 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 
-const TEST_AGENTS_DIR = path.join('/tmp', 'pd-test-agents-' + Date.now());
+const TEST_AGENTS_DIR = path.join(os.tmpdir(), 'pd-test-agents-' + Date.now());
 
 // Set env before module load
 process.env.PD_TEST_AGENTS_DIR = TEST_AGENTS_DIR;

package/tests/core/pain-lifecycle.test.ts

@@ -1,11 +1,12 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 import { clearPainFlag, PAIN_FLAG_FILENAME } from '../../src/core/pain-lifecycle.js';
 import { resolvePdPath } from '../../src/core/paths.js';
 
 describe('PainLifecycle', () => {
-    const workspaceDir = fs.mkdtempSync(path.join(fs.realpathSync('/tmp'), 'pain-lifecycle-test-'));
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pain-lifecycle-test-'));
     const painFlagPath = resolvePdPath(workspaceDir, 'PAIN_FLAG');
 
     beforeEach(() => {

package/tests/integration/pain-lifecycle-e2e.test.ts

@@ -1,11 +1,12 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 import { clearPainFlag } from '../../src/core/pain-lifecycle.js';
 import { resolvePdPath } from '../../src/core/paths.js';
 
 describe('Pain Lifecycle E2E', () => {
-    const workspaceDir = fs.mkdtempSync(path.join(fs.realpathSync('/tmp'), 'pain-lifecycle-e2e-'));
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pain-lifecycle-e2e-'));
     const painFlagPath = resolvePdPath(workspaceDir, 'PAIN_FLAG');
     const stateDir = path.dirname(painFlagPath);
 

package/tests/commands/evolver.test.ts

@@ -1,22 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { handleEvolveTask } from '../../src/commands/evolver';
-
-describe('Evolver Synergy Module', () => {
-  it('should handle /evolve-task command', () => {
-    const mockCtx = { 
-        workspaceDir: '/mock/workspace',
-        commandBody: '/evolve-task',
-        channel: 'cli',
-        isAuthorizedSender: true,
-        config: {} as any,
-        args: 'Fix tests'
-    };
-
-    const result = handleEvolveTask(mockCtx as any);
-
-    expect(result).toBeDefined();
-    expect(result.text).toContain('Evolver Handoff Requested');
-    expect(result.text).toContain('sessions_spawn');
-    expect(result.text).toContain('Fix tests');
-  });
-});