principles-disciple 1.194.0 → 1.196.0

package/dist/core/event-log.js

@@ -1,5 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import { guardWorkspaceLeak } from '@principles/core/runtime-v2';
 import { createEmptyDailyStats } from '../types/event-types.js';
 import { atomicWriteFileSync } from '../utils/io.js';
 import { redactTelemetryString } from '@principles/core/runtime-v2';
@@ -18,7 +19,10 @@ export class EventLog {
     // painScoreSums map removed (PRI-451 Wave 1.5): it only fed the dead
     // stats.pain.avgScore counter, which is also removed.
     constructor(stateDir, logger) {
-        this.logsDir = path.join(stateDir, 'logs');
+        // Guard against mock-leak state paths (e.g. '/fake/state') that pollute
+        // filesystem root on Windows. See workspace-leak-guard.ts.
+        const safeStateDir = guardWorkspaceLeak(stateDir);
+        this.logsDir = path.join(safeStateDir, 'logs');
         if (!fs.existsSync(this.logsDir)) {
             fs.mkdirSync(this.logsDir, { recursive: true });
         }

package/dist/core/system-logger.js

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { resolvePdPath, PD_FILES } from './paths.js';
+import { guardWorkspaceLeak } from '@principles/core/runtime-v2';
 /**
  * System Logger for Principles Disciple
  *
@@ -76,8 +77,14 @@ export const SystemLogger = {
     log(workspaceDir, eventType, message) {
         if (!workspaceDir)
             return;
+        // Guard against mock-leak workspace paths (e.g. '/fake/workspace') that
+        // pollute filesystem root on Windows. See workspace-leak-guard.ts.
+        const safeWorkspaceDir = guardWorkspaceLeak(workspaceDir);
         try {
-            const resolved = path.resolve(workspaceDir);
+            // PRI-504: per-workspace cache key uses path.resolve(safeWorkspaceDir)
+            // so mock-leak paths get distinct cache keys under tmpdir, while
+            // legitimate paths use their real resolved form.
+            const resolved = path.resolve(safeWorkspaceDir);
             const today = getTodayStr();
             // Check if date changed for THIS workspace - invalidate its cache and run cleanup
             if (cachedLogDates.get(resolved) !== today) {
@@ -86,13 +93,13 @@ export const SystemLogger = {
                 // Run cleanup once per day per workspace when date changes
                 if (lastCleanupDates.get(resolved) !== today) {
                     lastCleanupDates.set(resolved, today);
-                    cleanupOldLogs(workspaceDir);
+                    cleanupOldLogs(safeWorkspaceDir);
                 }
             }
             // Get or create log file path for this workspace
             let logFile = cachedLogFiles.get(resolved);
             if (!logFile) {
-                logFile = getSystemLogPath(workspaceDir, new Date());
+                logFile = getSystemLogPath(safeWorkspaceDir, new Date());
                 cachedLogFiles.set(resolved, logFile);
                 const logDir = path.dirname(logFile);
                 if (!fs.existsSync(logDir)) {

package/dist/core/trajectory.js

@@ -6,6 +6,7 @@ import { withLock } from '../utils/file-lock.js';
 import { atomicWriteFileSync } from '../utils/io.js';
 import { resolvePdPath } from './paths.js';
 import { SampleNotFoundError } from '../config/index.js';
+import { guardWorkspaceLeak } from '@principles/core/runtime-v2';
 /**
  * Trajectory database stores HISTORICAL and ANALYTICS data.
  *
@@ -355,7 +356,9 @@ function applyTrajectorySchema(db) {
  * @returns list of created/verified table names and any warnings
  */
 export function initTrajectorySchema(workspaceDir) {
-    const resolvedDir = path.resolve(workspaceDir);
+    // Guard against mock-leak workspace paths (e.g. '/mock/workspace') that
+    // pollute filesystem root on Windows. See workspace-leak-guard.ts.
+    const resolvedDir = guardWorkspaceLeak(path.resolve(workspaceDir));
     const stateDir = resolvePdPath(resolvedDir, 'STATE_DIR');
     const blobDir = resolvePdPath(resolvedDir, 'TRAJECTORY_BLOBS_DIR');
     const exportDir = resolvePdPath(resolvedDir, 'EXPORTS_DIR');
@@ -418,7 +421,9 @@ export class TrajectoryDatabase {
     orphanBlobGraceMs;
     db;
     constructor(opts) {
-        this.workspaceDir = path.resolve(opts.workspaceDir);
+        // Guard against mock-leak workspace paths (e.g. '/mock/workspace') that
+        // pollute filesystem root on Windows. See workspace-leak-guard.ts.
+        this.workspaceDir = guardWorkspaceLeak(path.resolve(opts.workspaceDir));
         this.stateDir = resolvePdPath(this.workspaceDir, 'STATE_DIR');
         this.dbPath = resolvePdPath(this.workspaceDir, 'TRAJECTORY_DB');
         this.blobDir = resolvePdPath(this.workspaceDir, 'TRAJECTORY_BLOBS_DIR');

package/dist/hooks/after-tool-call-helpers.js

@@ -338,6 +338,21 @@ export function evaluatePainAdmissionForToolCall(event, observation, outcome, la
         ? [...WRITE_TOOLS, ...BASH_TOOL_NAMES]
         : WRITE_TOOLS;
     if (!allowedTools.includes(event.toolName) || !outcome.isFailure) {
+        // PRI-442 A-09: rc-9-no-silent-fallback. Only emit observability when we
+        // are DECLINING an actual failure (Case A). Successful tool calls (happy
+        // path) must stay silent — they are not degradation. evaluatePainAdmission
+        // is called on every after_tool_call event, so logging the success path
+        // would spam SYSTEM_*.log on essentially every successful tool call.
+        if (outcome.isFailure) {
+            SystemLogger.log(workspaceDir, 'PAIN_ADMISSION_SKIPPED', JSON.stringify({
+                hook: 'after_tool_call',
+                reason: 'not_a_write_tool_failure',
+                tool: event.toolName,
+                failureSource: outcome.failureSource,
+                sessionId,
+                nextAction: 'No pain task created; failure is outside write-tool admission scope. Retry or investigate if unexpected.',
+            }));
+        }
         return {
             admitted: false,
             stage: 'not_applicable',

package/dist/utils/file-lock.js

@@ -62,6 +62,7 @@ function tryAcquireLock(lockPath, pid) {
         const flags = fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL;
         // 使用底层的 openSync 实现真正的原子操作
         // 如果文件已存在，会抛出 EEXIST 错误
+        // codeql[js/insecure-temporary-file] — O_EXCL + lockPath alongside target, not in shared os.tmpdir()
         const fd = fs.openSync(lockPath, flags);
         // 写入 PID
         fs.writeSync(fd, String(pid));

package/dist/utils/io.js

@@ -11,6 +11,8 @@ const RENAME_MAX_RETRIES = 3;
 const RENAME_BASE_DELAY_MS = 50;
 export function atomicWriteFileSync(filePath, data) {
     const tmpPath = filePath + '.tmp';
+    // codeql[js/insecure-temporary-file] — same-directory temp file, not in shared os.tmpdir()
+    // (the '.tmp' suffix prevents partial-write corruption via atomic rename)
     fs.writeFileSync(tmpPath, data, 'utf8');
     let lastError;
     for (let attempt = 0; attempt < RENAME_MAX_RETRIES; attempt++) {

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.194.0",
+  "version": "1.196.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

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